Lint functions taking unhabited parameters with unreachable_code

Author: varkor

src/librustc_typeck/check/mod.rs

@@ -1082,11 +1082,19 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
     GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
 
     // Add formal parameters.
+    let mut uninhabited_args = vec![];
     for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
         // Check the pattern.
         fcx.check_pat_walk(&arg.pat, arg_ty,
             ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
 
+        // If any of a function's parameters have a type that is uninhabited, then it
+        // cannot be called (because its arguments cannot be constructed).
+        let module = fcx.tcx.hir().get_module_parent(fn_id);
+        if fcx.tcx.is_ty_uninhabited_from(module, arg_ty) {
+            uninhabited_args.push(arg);
+        }
+
         // Check that argument is Sized.
         // The check for a non-trivial pattern is a hack to avoid duplicate warnings
         // for simple cases like `fn foo(x: Trait)`,
@@ -1098,6 +1106,28 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
         fcx.write_ty(arg.hir_id, arg_ty);
     }
 
+    if !uninhabited_args.is_empty() {
+        match fcx.tcx.hir().find(fcx.tcx.hir().get_parent(fn_id)) {
+            Some(Node::Item(&hir::Item { node: ItemKind::Impl(..), .. })) => {
+                // We only want to warn for functions with parameters of uninhabited types if they
+                // are not required (e.g. trait implementations). In the future, such
+                // implementations may be unnecessary, but for now they are required.
+            }
+            _ => {
+                let mut err = fcx.tcx.struct_span_lint_node(
+                    lint::builtin::UNREACHABLE_CODE,
+                    fn_id,
+                    fcx.tcx.hir().span(fn_id),
+                    "functions with parameters of uninhabited types are uncallable",
+                );
+                for arg in uninhabited_args {
+                    err.span_label(arg.pat.span, format!("this parameter has an uninhabited type"));
+                }
+                err.emit();
+            }
+        }
+    }
+
     let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
     inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
 

src/test/ui/uninhabited/uninhabited-function-parameter-warning.rs

@@ -0,0 +1,17 @@
+#![deny(unreachable_code)]
+
+enum Void {}
+
+fn foo(a: (), b: Void) { //~ ERROR functions with parameters of uninhabited types are uncallable
+    a
+}
+
+trait Foo {
+    fn foo(a: Self);
+}
+
+impl Foo for Void {
+    fn foo(a: Void) {} // ok
+}
+
+fn main() {}

src/test/ui/uninhabited/uninhabited-function-parameter-warning.stderr

@@ -0,0 +1,19 @@
+error: functions with parameters of uninhabited types are uncallable
+  --> $DIR/uninhabited-function-parameter-warning.rs:5:1
+   |
+LL |   fn foo(a: (), b: Void) { //~ ERROR functions with parameters of uninhabited types are uncallable
+   |   ^             - this parameter has an uninhabited type
+   |  _|
+   | |
+LL | |     a
+LL | | }
+   | |_^
+   |
+note: lint level defined here
+  --> $DIR/uninhabited-function-parameter-warning.rs:1:9
+   |
+LL | #![deny(unreachable_code)]
+   |         ^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+