Add more tests and map regions in writeback

Author: cramertj

src/librustc/hir/lowering.rs

@@ -788,12 +788,18 @@ impl<'a> LoweringContext<'a> {
                 let old_len = self.currently_bound_lifetimes.len();
 
                 // Record the introduction of 'a in `for<'a> ...`
-                self.currently_bound_lifetimes
-                    .extend(polytr.bound_lifetimes.iter().filter_map(|lt_def|
-                        if let hir::LifetimeName::Name(name) = lt_def.lifetime.name {
-                            Some(name)
-                        } else { None }
-                    ));
+                for lt_def in &polytr.bound_lifetimes {
+                    // Introduce lifetimes one at a time so that we can handle
+                    // cases like `fn foo<'d>() -> impl for<'a, 'b: 'a, 'c: 'b + 'd> ...`
+                    if let hir::LifetimeName::Name(name) = lt_def.lifetime.name {
+                        self.currently_bound_lifetimes.push(name);
+                    }
+
+                    // Visit the lifetime bounds
+                    for lt_bound in &lt_def.bounds {
+                        self.visit_lifetime(&lt_bound);
+                    }
+                }
 
                 hir::intravisit::walk_trait_ref(self, &polytr.trait_ref);
 

src/librustc_typeck/check/mod.rs

@@ -212,7 +212,7 @@ pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     // associated fresh inference variable. Writeback resolves these
     // variables to get the concrete type, which can be used to
     // deanonymize TyAnon, after typeck is done with all functions.
-    anon_types: RefCell<NodeMap<Ty<'tcx>>>,
+    anon_types: RefCell<DefIdMap<(&'tcx Substs<'tcx>, Ty<'tcx>)>>,
 
     /// Each type parameter has an implicit region bound that
     /// indicates it must outlive at least the function body (the user
@@ -621,7 +621,7 @@ impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
             deferred_call_resolutions: RefCell::new(DefIdMap()),
             deferred_cast_checks: RefCell::new(Vec::new()),
             deferred_generator_interiors: RefCell::new(Vec::new()),
-            anon_types: RefCell::new(NodeMap()),
+            anon_types: RefCell::new(DefIdMap()),
             implicit_region_bound,
             body_id,
         }
@@ -1943,13 +1943,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 
                 // Use the same type variable if the exact same TyAnon appears more
                 // than once in the return type (e.g. if it's passed to a type alias).
-                let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
-                if let Some(ty_var) = self.anon_types.borrow().get(&id) {
+                if let Some(&(_substs, ty_var)) = self.anon_types.borrow().get(&def_id) {
                     return ty_var;
                 }
                 let span = self.tcx.def_span(def_id);
                 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
-                self.anon_types.borrow_mut().insert(id, ty_var);
+                self.anon_types.borrow_mut().insert(def_id, (substs, ty_var));
                 debug!("instantiate_anon_types: ty_var={:?}", ty_var);
 
                 let predicates_of = self.tcx.predicates_of(def_id);

src/librustc_typeck/check/writeback.rs

@@ -19,7 +19,8 @@ use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
 use rustc::infer::{InferCtxt};
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::ty::fold::{TypeFolder,TypeFoldable};
-use rustc::util::nodemap::DefIdSet;
+use rustc::ty::subst::{Kind, Substs};
+use rustc::util::nodemap::{DefIdSet, FxHashMap};
 use syntax::ast;
 use syntax_pos::Span;
 use std::mem;
@@ -285,35 +286,43 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
 
     fn visit_anon_types(&mut self) {
         let gcx = self.tcx().global_tcx();
-        for (&node_id, &concrete_ty) in self.fcx.anon_types.borrow().iter() {
+        for (&def_id, &(substs, concrete_ty)) in self.fcx.anon_types.borrow().iter() {
+            let node_id = gcx.hir.as_local_node_id(def_id).unwrap();
             let inside_ty = self.resolve(&concrete_ty, &node_id);
 
+            // Use substs to build up a reverse map from regions
+            // to their identity mappings.
+            // This is necessary because of `impl Trait` lifetimes
+            // are computed by replacing existing lifetimes with 'static
+            // and remapping only those used in the `impl Trait` return type,
+            // resulting in the parameters shifting.
+            let id_substs = Substs::identity_for_item(gcx, def_id);
+            let map: FxHashMap<Kind, Kind> =
+                substs.iter().enumerate()
+                    .map(|(index, subst)| (*subst, id_substs[index]))
+                    .collect();
+
             // Convert the type from the function into a type valid outside
             // the function, by replacing invalid regions with 'static,
             // after producing an error for each of them.
             let outside_ty = gcx.fold_regions(&inside_ty, &mut false, |r, _| {
                 match *r {
                     // 'static and early-bound regions are valid.
                     ty::ReStatic |
-                    ty::ReEarlyBound(_) |
                     ty::ReEmpty => r,
 
-                    ty::ReFree(_) |
-                    ty::ReLateBound(..) |
-                    ty::ReScope(_) |
-                    ty::ReSkolemized(..) => {
-                        let span = node_id.to_span(&self.fcx.tcx);
-                        span_err!(self.tcx().sess, span, E0564,
-                                  "only named lifetimes are allowed in `impl Trait`, \
-                                   but `{}` was found in the type `{}`", r, inside_ty);
-                        gcx.types.re_static
-                    }
-
-                    ty::ReVar(_) |
-                    ty::ReErased => {
-                        let span = node_id.to_span(&self.fcx.tcx);
-                        span_bug!(span, "invalid region in impl Trait: {:?}", r);
-                    }
+                    // All other regions, we map them appropriately to their adjusted
+                    // indices, erroring if we find any lifetimes that were not mapped
+                    // into the new set.
+                    _ => if let Some(r1) =
+                            map.get(&Kind::from(r)).and_then(|k| k.as_region()) { r1 } else
+                        {
+                            let span = node_id.to_span(&self.fcx.tcx);
+                            span_err!(self.tcx().sess, span, E0564,
+                                      "only named lifetimes are allowed in `impl Trait`, \
+                                       but `{}` was found in the type `{}`", r, inside_ty);
+                            gcx.types.re_static
+                        },
                 }
             });
 

src/test/compile-fail/impl-trait/more_lifetimes.rs

@@ -20,7 +20,20 @@ fn foo_not_static() -> impl Debug + 'static {
     let mut x = 5;
     x += 5;
     foo(&x)
-    //~^ ERROR cannot infer an appropriate lifetime
+    //~^ ERROR `x` does not live long enough
+}
+
+trait Any {}
+impl<T> Any for T {}
+
+// Check that type parameters are captured and not considered 'static
+fn whatever<T>(x: T) -> impl Any + 'static {
+    x
+    //~^ ERROR the parameter type `T` may not live long enough
+}
+
+fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32) {
+    move |_| println!("{}", y)
 }
 
 fn main() {}

src/test/run-pass/impl-trait/lifetimes.rs

@@ -0,0 +1,38 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(conservative_impl_trait)]
+
+use std::fmt::Debug;
+
+fn any_lifetime<'a>() -> &'a u32 { &5 }
+
+fn static_lifetime() -> &'static u32 { &5 }
+
+fn any_lifetime_as_static_impl_trait() -> impl Debug {
+    any_lifetime()
+}
+
+fn lifetimes_as_static_impl_trait() -> impl Debug {
+        static_lifetime()
+}
+
+trait Foo<'a> {}
+impl<'a> Foo<'a> for u32 {}
+
+fn foo<'b>() -> impl for<'a> Foo<'a> { 5 }
+
+fn closure_hrtb() -> impl for<'a> Fn(&'a u32) { |_| () }
+
+fn mixed_lifetimes<'a>() -> impl for<'b: 'a> Fn(&'b u32) { |_| () }
+
+fn mixed_as_static() -> impl Fn(&'static u32) { mixed_lifetimes() }
+
+fn main() {}