warn if bindings/return-types reference regions

This is a step towards fixing #32330. The full fix would be a breaking
change, so we begin by issuing warnings for scenarios that will break.

Author: nikomatsakis

src/librustc/lint/builtin.rs

@@ -167,6 +167,13 @@ declare_lint! {
     "transmute from function item type to pointer-sized type erroneously allowed"
 }
 
+declare_lint! {
+    pub HR_LIFETIME_IN_ASSOC_TYPE,
+    Warn,
+    "binding for associated type references higher-ranked lifetime \
+     that does not appear in the trait input types"
+}
+
 declare_lint! {
     pub OVERLAPPING_INHERENT_IMPLS,
     Warn,
@@ -213,7 +220,8 @@ impl LintPass for HardwiredLints {
             RAW_POINTER_DERIVE,
             TRANSMUTE_FROM_FN_ITEM_TYPES,
             OVERLAPPING_INHERENT_IMPLS,
-            RENAMED_AND_REMOVED_LINTS
+            RENAMED_AND_REMOVED_LINTS,
+            HR_LIFETIME_IN_ASSOC_TYPE
         )
     }
 }

src/librustc_lint/lib.rs

@@ -188,6 +188,10 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
             id: LintId::of(ILLEGAL_STRUCT_OR_ENUM_CONSTANT_PATTERN),
             reference: "RFC 1445 <https://github.com/rust-lang/rfcs/pull/1445>",
         },
+        FutureIncompatibleInfo {
+            id: LintId::of(HR_LIFETIME_IN_ASSOC_TYPE),
+            reference: "issue #32330 <https://github.com/rust-lang/rust/issues/32330>",
+        },
         ]);
 
     // We have one lint pass defined specially

src/librustc_typeck/astconv.rs

@@ -63,20 +63,18 @@ use require_c_abi_if_variadic;
 use rscope::{self, UnelidableRscope, RegionScope, ElidableRscope,
              ObjectLifetimeDefaultRscope, ShiftedRscope, BindingRscope,
              ElisionFailureInfo, ElidedLifetime};
-use util::common::{ErrorReported, FN_OUTPUT_NAME};
-use util::nodemap::FnvHashSet;
-
+use rustc::lint;
+use rustc_back::slice;
 use rustc_const_math::ConstInt;
-
+use rustc_front::print::pprust;
+use rustc_front::hir;
 use syntax::{abi, ast};
 use syntax::codemap::{Span, Pos};
 use syntax::errors::DiagnosticBuilder;
 use syntax::feature_gate::{GateIssue, emit_feature_err};
 use syntax::parse::token;
-
-use rustc_front::print::pprust;
-use rustc_front::hir;
-use rustc_back::slice;
+use util::common::{ErrorReported, FN_OUTPUT_NAME};
+use util::nodemap::FnvHashSet;
 
 pub trait AstConv<'tcx> {
     fn tcx<'a>(&'a self) -> &'a TyCtxt<'tcx>;
@@ -690,6 +688,7 @@ pub fn instantiate_poly_trait_ref<'tcx>(
                                PathParamMode::Explicit,
                                trait_def_id,
                                self_ty,
+                               trait_ref.ref_id,
                                trait_ref.path.segments.last().unwrap(),
                                poly_projections)
 }
@@ -737,6 +736,7 @@ fn object_path_to_poly_trait_ref<'a,'tcx>(
     span: Span,
     param_mode: PathParamMode,
     trait_def_id: DefId,
+    trait_path_ref_id: ast::NodeId,
     trait_segment: &hir::PathSegment,
     mut projections: &mut Vec<ty::PolyProjectionPredicate<'tcx>>)
     -> ty::PolyTraitRef<'tcx>
@@ -747,6 +747,7 @@ fn object_path_to_poly_trait_ref<'a,'tcx>(
                                param_mode,
                                trait_def_id,
                                None,
+                               trait_path_ref_id,
                                trait_segment,
                                projections)
 }
@@ -758,6 +759,7 @@ fn ast_path_to_poly_trait_ref<'a,'tcx>(
     param_mode: PathParamMode,
     trait_def_id: DefId,
     self_ty: Option<Ty<'tcx>>,
+    path_id: ast::NodeId,
     trait_segment: &hir::PathSegment,
     poly_projections: &mut Vec<ty::PolyProjectionPredicate<'tcx>>)
     -> ty::PolyTraitRef<'tcx>
@@ -788,6 +790,7 @@ fn ast_path_to_poly_trait_ref<'a,'tcx>(
                 // specify type to assert that error was already reported in Err case:
                 let predicate: Result<_, ErrorReported> =
                     ast_type_binding_to_poly_projection_predicate(this,
+                                                                  path_id,
                                                                   poly_trait_ref.clone(),
                                                                   self_ty,
                                                                   binding);
@@ -884,6 +887,7 @@ fn create_substs_for_ast_trait_ref<'a,'tcx>(this: &AstConv<'tcx>,
 
 fn ast_type_binding_to_poly_projection_predicate<'tcx>(
     this: &AstConv<'tcx>,
+    path_id: ast::NodeId,
     mut trait_ref: ty::PolyTraitRef<'tcx>,
     self_ty: Option<Ty<'tcx>>,
     binding: &ConvertedBinding<'tcx>)
@@ -932,11 +936,13 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>(
                              br));
             }
         };
-        this.tcx().sess.span_err(
+        this.tcx().sess.add_lint(
+            lint::builtin::HR_LIFETIME_IN_ASSOC_TYPE,
+            path_id,
             binding.span,
-            &format!("binding for associated type `{}` references lifetime `{}`, \
-                      which does not appear in the trait input types",
-                     binding.item_name, br_name));
+            format!("binding for associated type `{}` references lifetime `{}`, \
+                     which does not appear in the trait input types",
+                    binding.item_name, br_name));
     }
 
     // Simple case: X is defined in the current trait.
@@ -1069,6 +1075,7 @@ fn ast_ty_to_trait_ref<'tcx>(this: &AstConv<'tcx>,
                                                                   path.span,
                                                                   PathParamMode::Explicit,
                                                                   trait_def_id,
+                                                                  ty.id,
                                                                   path.segments.last().unwrap(),
                                                                   &mut projection_bounds);
                     Ok((trait_ref, projection_bounds))
@@ -1479,6 +1486,7 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx>,
                         param_mode: PathParamMode,
                         def: &Def,
                         opt_self_ty: Option<Ty<'tcx>>,
+                        base_path_ref_id: ast::NodeId,
                         base_segments: &[hir::PathSegment])
                         -> Ty<'tcx> {
     let tcx = this.tcx();
@@ -1494,6 +1502,7 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx>,
                                                           span,
                                                           param_mode,
                                                           trait_def_id,
+                                                          base_path_ref_id,
                                                           base_segments.last().unwrap(),
                                                           &mut projection_bounds);
 
@@ -1583,6 +1592,7 @@ pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx>,
                                         param_mode: PathParamMode,
                                         def: &Def,
                                         opt_self_ty: Option<Ty<'tcx>>,
+                                        base_path_ref_id: ast::NodeId,
                                         base_segments: &[hir::PathSegment],
                                         assoc_segments: &[hir::PathSegment])
                                         -> Ty<'tcx> {
@@ -1592,6 +1602,7 @@ pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx>,
                                 param_mode,
                                 def,
                                 opt_self_ty,
+                                base_path_ref_id,
                                 base_segments);
     let mut def = *def;
     // If any associated type segments remain, attempt to resolve them.
@@ -1671,7 +1682,50 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
         }
         hir::TyBareFn(ref bf) => {
             require_c_abi_if_variadic(tcx, &bf.decl, bf.abi, ast_ty.span);
-            tcx.mk_fn_ptr(ty_of_bare_fn(this, bf.unsafety, bf.abi, &bf.decl))
+            let bare_fn_ty = ty_of_bare_fn(this,
+                                           bf.unsafety,
+                                           bf.abi,
+                                           &bf.decl);
+
+            // Find any late-bound regions declared in return type that do
+            // not appear in the arguments. These are not wellformed.
+            //
+            // Example:
+            //
+            //     for<'a> fn() -> &'a str <-- 'a is bad
+            //     for<'a> fn(&'a String) -> &'a str <-- 'a is ok
+            //
+            // Note that we do this check **here** and not in
+            // `ty_of_bare_fn` because the latter is also used to make
+            // the types for fn items, and we do not want to issue a
+            // warning then. (Once we fix #32330, the regions we are
+            // checking for here would be considered early bound
+            // anyway.)
+            let inputs = bare_fn_ty.sig.inputs();
+            let late_bound_in_args = this.tcx().collect_late_bound_regions(&inputs);
+            let output = bare_fn_ty.sig.output();
+            let late_bound_in_ret = this.tcx().collect_late_bound_regions(&output);
+            for br in late_bound_in_ret.difference(&late_bound_in_args) {
+                let br_name = match *br {
+                    ty::BrNamed(_, name) => name,
+                    _ => {
+                        this.tcx().sess.span_bug(
+                            bf.decl.output.span(),
+                            &format!("anonymous bound region {:?} in \
+                                      return but not args",
+                                     br));
+                    }
+                };
+                this.tcx().sess.add_lint(
+                    lint::builtin::HR_LIFETIME_IN_ASSOC_TYPE,
+                    ast_ty.id,
+                    bf.decl.output.span(),
+                    format!("return type references lifetime `{}`, \
+                             which does not appear in the argument types",
+                            br_name));
+            }
+
+            tcx.mk_fn_ptr(bare_fn_ty)
         }
         hir::TyPolyTraitRef(ref bounds) => {
             conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds)
@@ -1699,6 +1753,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
                                                 PathParamMode::Explicit,
                                                 &def,
                                                 opt_self_ty,
+                                                ast_ty.id,
                                                 &path.segments[..base_ty_end],
                                                 &path.segments[base_ty_end..]);
 
@@ -1791,8 +1846,11 @@ pub fn ty_of_method<'tcx>(this: &AstConv<'tcx>,
     (bare_fn_ty, optional_explicit_self_category.unwrap())
 }
 
-pub fn ty_of_bare_fn<'tcx>(this: &AstConv<'tcx>, unsafety: hir::Unsafety, abi: abi::Abi,
-                                              decl: &hir::FnDecl) -> ty::BareFnTy<'tcx> {
+pub fn ty_of_bare_fn<'tcx>(this: &AstConv<'tcx>,
+                           unsafety: hir::Unsafety,
+                           abi: abi::Abi,
+                           decl: &hir::FnDecl)
+                           -> ty::BareFnTy<'tcx> {
     let (bare_fn_ty, _) = ty_of_method_or_bare_fn(this, unsafety, abi, None, decl);
     bare_fn_ty
 }

src/librustc_typeck/check/mod.rs

@@ -3749,6 +3749,7 @@ pub fn resolve_ty_and_def_ufcs<'a, 'b, 'tcx>(fcx: &FnCtxt<'b, 'tcx>,
                                                      PathParamMode::Optional,
                                                      &mut def,
                                                      opt_self_ty,
+                                                     node_id,
                                                      &ty_segments[..base_ty_end],
                                                      &ty_segments[base_ty_end..]);
         let item_segment = path.segments.last().unwrap();

src/librustc_typeck/collect.rs

@@ -545,7 +545,8 @@ fn convert_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
 
     let (fty, explicit_self_category) =
         astconv::ty_of_method(&ccx.icx(&(rcvr_ty_predicates, &sig.generics)),
-                              sig, untransformed_rcvr_ty);
+                              sig,
+                              untransformed_rcvr_ty);
 
     let def_id = ccx.tcx.map.local_def_id(id);
     let substs = ccx.tcx.mk_substs(mk_item_substs(ccx, &ty_generics));
@@ -1457,7 +1458,10 @@ fn compute_type_scheme_of_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>,
         }
         hir::ItemFn(ref decl, unsafety, _, abi, ref generics, _) => {
             let ty_generics = ty_generics_for_fn(ccx, generics, &ty::Generics::empty());
-            let tofd = astconv::ty_of_bare_fn(&ccx.icx(generics), unsafety, abi, &decl);
+            let tofd = astconv::ty_of_bare_fn(&ccx.icx(generics),
+                                              unsafety,
+                                              abi,
+                                              &decl);
             let def_id = ccx.tcx.map.local_def_id(it.id);
             let substs = tcx.mk_substs(mk_item_substs(ccx, &ty_generics));
             let ty = tcx.mk_fn_def(def_id, substs, tofd);

src/test/compile-fail/associated-types-eq-hr.rs

@@ -40,6 +40,17 @@ impl<'a> TheTrait<&'a isize> for UintStruct {
     }
 }
 
+struct Tuple {
+}
+
+impl<'a> TheTrait<(&'a isize, &'a isize)> for Tuple {
+    type A = &'a isize;
+
+    fn get(&self, t: (&'a isize, &'a isize)) -> &'a isize {
+        t.0
+    }
+}
+
 fn foo<T>()
     where T : for<'x> TheTrait<&'x isize, A = &'x isize>
 {
@@ -52,10 +63,28 @@ fn bar<T>()
     // ok for UintStruct, but not IntStruct
 }
 
-fn baz<T>()
-    where T : for<'x,'y> TheTrait<&'x isize, A = &'y isize>
+fn tuple_one<T>()
+    where T : for<'x,'y> TheTrait<(&'x isize, &'y isize), A = &'x isize>
+{
+    // not ok for tuple, two lifetimes and we pick first
+}
+
+fn tuple_two<T>()
+    where T : for<'x,'y> TheTrait<(&'x isize, &'y isize), A = &'y isize>
 {
-    // not ok for either struct, due to the use of two lifetimes
+    // not ok for tuple, two lifetimes and we pick second
+}
+
+fn tuple_three<T>()
+    where T : for<'x> TheTrait<(&'x isize, &'x isize), A = &'x isize>
+{
+    // ok for tuple
+}
+
+fn tuple_four<T>()
+    where T : for<'x,'y> TheTrait<(&'x isize, &'y isize)>
+{
+    // not ok for tuple, two lifetimes, and lifetime matching is invariant
 }
 
 pub fn main() {
@@ -65,6 +94,16 @@ pub fn main() {
     bar::<IntStruct>(); //~ ERROR type mismatch
     bar::<UintStruct>();
 
-    baz::<IntStruct>(); //~ ERROR type mismatch
-    baz::<UintStruct>(); //~ ERROR type mismatch
+    tuple_one::<Tuple>();
+    //~^ ERROR E0277
+    //~| ERROR type mismatch
+
+    tuple_two::<Tuple>();
+    //~^ ERROR E0277
+    //~| ERROR type mismatch
+
+    tuple_three::<Tuple>();
+
+    tuple_four::<Tuple>();
+    //~^ ERROR E0277
 }