Use impl Trait lifetime bounds in regionck

If the user explicitly provides lifetime bounds on
an impl Trait return type, it's not necessary to
search for or require a least region. This change
uses the required region bounds of the impl Trait
predicates to directly apply lifetime bounds and
skip least region searching where possible.

Author: cramertj

src/librustc_typeck/check/mod.rs

@@ -255,6 +255,10 @@ struct AnonTypeDecl<'tcx> {
     /// other words, `?C` should not include `'b`, even though it's a
     /// lifetime parameter on `foo`.)
     concrete_ty: Ty<'tcx>,
+
+    /// A list of all required region bounds on the impl Trait type,
+    /// e.g. `'a` and `'b` in `fn foo<'a, 'b, 'c>() -> impl Trait<'c> + 'a + 'b`.
+    required_region_bounds: Vec<ty::Region<'tcx>>,
 }
 
 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
@@ -1983,16 +1987,23 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 }
                 let span = self.tcx.def_span(def_id);
                 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
-                self.anon_types.borrow_mut().insert(def_id, AnonTypeDecl {
-                    substs: substs,
-                    concrete_ty: ty_var
-                });
-                debug!("instantiate_anon_types: ty_var={:?}", ty_var);
 
                 let predicates_of = self.tcx.predicates_of(def_id);
                 debug!("instantiate_anon_types: predicates_of={:?}", predicates_of);
                 let bounds = predicates_of.instantiate(self.tcx, substs);
 
+                let required_region_bounds =
+                    self.tcx.required_region_bounds(ty, bounds.predicates.clone());
+                debug!("instantiate_anon_types: required_region_bounds={:?}",
+                       required_region_bounds);
+
+                self.anon_types.borrow_mut().insert(def_id, AnonTypeDecl {
+                    substs,
+                    concrete_ty: ty_var,
+                    required_region_bounds,
+                });
+                debug!("instantiate_anon_types: ty_var={:?}", ty_var);
+
                 for predicate in bounds.predicates {
                     // Change the predicate to refer to the type variable,
                     // which will be the concrete type, instead of the TyAnon.

src/librustc_typeck/check/regionck.rs

@@ -153,14 +153,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         let node_id = body.value.id;
         let mut rcx = RegionCtxt::new(self, RepeatingScope(node_id), node_id, Subject(subject));
 
+        rcx.free_region_map.relate_free_regions_from_predicates(
+            &self.param_env.caller_bounds);
+
         if self.err_count_since_creation() == 0 {
             // regionck assumes typeck succeeded
             rcx.visit_fn_body(fn_id, body, self.tcx.hir.span(fn_id));
         }
 
-        rcx.free_region_map.relate_free_regions_from_predicates(
-            &self.param_env.caller_bounds);
-
         rcx.resolve_regions_and_report_errors();
 
         // In this mode, we also copy the free-region-map into the
@@ -475,6 +475,15 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
 
             let span = self.tcx.def_span(def_id);
 
+            // If there are required region bounds, we can just skip
+            // ahead.  There will already be a registered region
+            // obligation related `concrete_ty` to those regions.
+            if anon_defn.required_region_bounds.len() != 0 {
+                continue;
+            }
+
+            // There were no `required_region_bounds`,
+            // so we have to search for a `least_region`.
             // Go through all the regions used as arguments to the
             // abstract type. These are the parameters to the abstract
             // type; so in our example above, `substs` would contain
@@ -503,13 +512,6 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
                             // There are two regions (`lr` and
                             // `subst_arg`) which are not relatable. We can't
                             // find a best choice.
-
-                            // FIXME We don't need to issue an error
-                            // if there is a lifetime bound in the
-                            // `impl Trait` already (e.g., `impl Foo +
-                            // 'a`). `required_region_bounds` could be
-                            // applied during the instantiation phase
-                            // to find this, I suspect.
                             self.tcx
                                 .sess
                                 .struct_span_err(span, "ambiguous lifetime bound in `impl Trait`")