Remove some global state from the lowering pass

oli-obk · oli-obk · commit 953da9d4ae69 · 2018-06-19T13:47:53.000+02:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -109,13 +109,6 @@ pub struct LoweringContext<'a> {
     /// written at all (e.g., `&T` or `std::cell::Ref<T>`).
     anonymous_lifetime_mode: AnonymousLifetimeMode,
 
-    // This is a list of in-band type definitions being generated by
-    // Argument-position `impl Trait`.
-    // When traversing a signature such as `fn foo(x: impl Trait)`,
-    // we record `impl Trait` as a new type parameter, then later
-    // add it on to `foo`s generics.
-    in_band_ty_params: Vec<hir::TyParam>,
-
     // Used to create lifetime definitions from in-band lifetime usages.
     // e.g. `fn foo(x: &'x u8) -> &'x u8` to `fn foo<'x>(x: &'x u8) -> &'x u8`
     // When a named lifetime is encountered in a function or impl header and
@@ -170,26 +163,41 @@ pub trait Resolver {
     ) -> hir::Path;
 }
 
-#[derive(Clone, Copy, Debug)]
-enum ImplTraitContext {
+#[derive(Debug)]
+enum ImplTraitContext<'a> {
     /// Treat `impl Trait` as shorthand for a new universal generic parameter.
     /// Example: `fn foo(x: impl Debug)`, where `impl Debug` is conceptually
     /// equivalent to a fresh universal parameter like `fn foo<T: Debug>(x: T)`.
     ///
     /// We store a DefId here so we can look up necessary information later
-    Universal(DefId),
+    ///
+    /// Newly generated parameters should be inserted into the given `Vec`
+    Universal(DefId, &'a mut Vec<hir::TyParam>),
 
     /// Treat `impl Trait` as shorthand for a new universal existential parameter.
     /// Example: `fn foo() -> impl Debug`, where `impl Debug` is conceptually
     /// equivalent to a fresh existential parameter like `abstract type T; fn foo() -> T`.
     ///
     /// We store a DefId here so we can look up necessary information later
-    Existential(DefId),
+    ///
+    /// All generics of the surrounding function must go into the generated existential type
+    Existential(DefId, &'a [hir::TyParam]),
 
     /// `impl Trait` is not accepted in this position.
     Disallowed,
 }
 
+impl<'a> ImplTraitContext<'a> {
+    fn reborrow(&'b mut self) -> ImplTraitContext<'b> {
+        use self::ImplTraitContext::*;
+        match self {
+            Universal(did, params) => Universal(*did, params),
+            Existential(did, params) => Existential(*did, params),
+            Disallowed => Disallowed,
+        }
+    }
+}
+
 pub fn lower_crate(
     sess: &Session,
     cstore: &CrateStore,
@@ -225,7 +233,6 @@ pub fn lower_crate(
         node_id_to_hir_id: IndexVec::new(),
         is_generator: false,
         is_in_trait_impl: false,
-        in_band_ty_params: Vec::new(),
         lifetimes_to_define: Vec::new(),
         is_collecting_in_band_lifetimes: false,
         in_scope_lifetimes: Vec::new(),
@@ -645,7 +652,7 @@ impl<'a> LoweringContext<'a> {
         f: F,
     ) -> (Vec<hir::GenericParam>, T)
     where
-        F: FnOnce(&mut LoweringContext) -> T,
+        F: FnOnce(&mut LoweringContext) -> (Vec<hir::TyParam>, T),
     {
         assert!(!self.is_collecting_in_band_lifetimes);
         assert!(self.lifetimes_to_define.is_empty());
@@ -656,13 +663,11 @@ impl<'a> LoweringContext<'a> {
             self.anonymous_lifetime_mode = anonymous_lifetime_mode;
         }
 
-        assert!(self.in_band_ty_params.is_empty());
-        let res = f(self);
+        let (in_band_ty_params, res) = f(self);
 
         self.is_collecting_in_band_lifetimes = false;
         self.anonymous_lifetime_mode = old_anonymous_lifetime_mode;
 
-        let in_band_ty_params = self.in_band_ty_params.split_off(0);
         let lifetimes_to_define = self.lifetimes_to_define.split_off(0);
 
         let params = lifetimes_to_define
@@ -804,17 +809,22 @@ impl<'a> LoweringContext<'a> {
         f: F,
     ) -> (hir::Generics, T)
     where
-        F: FnOnce(&mut LoweringContext) -> T,
+        F: FnOnce(&mut LoweringContext, &mut Vec<hir::TyParam>) -> T,
     {
         let (in_band_defs, (mut lowered_generics, res)) = self.with_in_scope_lifetime_defs(
             generics.params.iter().filter_map(|p| match p {
                 GenericParam::Lifetime(ld) => Some(ld),
                 _ => None,
             }),
             |this| {
-                let itctx = ImplTraitContext::Universal(parent_id);
                 this.collect_in_band_defs(parent_id, anonymous_lifetime_mode, |this| {
-                    (this.lower_generics(generics, itctx), f(this))
+                    let mut params = Vec::new();
+                    let generics = this.lower_generics(
+                        generics,
+                        ImplTraitContext::Universal(parent_id, &mut params),
+                    );
+                    let res = f(this, &mut params);
+                    (params, (generics, res))
                 })
             },
         );
@@ -1037,7 +1047,7 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> P<hir::Ty> {
+    fn lower_ty(&mut self, t: &Ty, mut itctx: ImplTraitContext) -> P<hir::Ty> {
         let kind = match t.node {
             TyKind::Infer => hir::TyInfer,
             TyKind::Err => hir::TyErr,
@@ -1077,7 +1087,7 @@ impl<'a> LoweringContext<'a> {
             ),
             TyKind::Never => hir::TyNever,
             TyKind::Tup(ref tys) => {
-                hir::TyTup(tys.iter().map(|ty| self.lower_ty(ty, itctx)).collect())
+                hir::TyTup(tys.iter().map(|ty| self.lower_ty(ty, itctx.reborrow())).collect())
             }
             TyKind::Paren(ref ty) => {
                 return self.lower_ty(ty, itctx);
@@ -1111,7 +1121,7 @@ impl<'a> LoweringContext<'a> {
                     .iter()
                     .filter_map(|bound| match *bound {
                         TraitTyParamBound(ref ty, TraitBoundModifier::None) => {
-                            Some(self.lower_poly_trait_ref(ty, itctx))
+                            Some(self.lower_poly_trait_ref(ty, itctx.reborrow()))
                         }
                         TraitTyParamBound(_, TraitBoundModifier::Maybe) => None,
                         RegionTyParamBound(ref lifetime) => {
@@ -1132,7 +1142,7 @@ impl<'a> LoweringContext<'a> {
             TyKind::ImplTrait(exist_ty_node_id, ref bounds) => {
                 let span = t.span;
                 match itctx {
-                    ImplTraitContext::Existential(fn_def_id) => {
+                    ImplTraitContext::Existential(fn_def_id, _) => {
                         // Make sure we know that some funky desugaring has been going on here.
                         // This is a first: there is code in other places like for loop
                         // desugaring that explicitly states that we don't want to track that.
@@ -1214,7 +1224,7 @@ impl<'a> LoweringContext<'a> {
                             )
                         })
                     }
-                    ImplTraitContext::Universal(def_id) => {
+                    ImplTraitContext::Universal(def_id, in_band_ty_params) => {
                         let def_node_id = self.next_id().node_id;
 
                         // Add a definition for the in-band TyParam
@@ -1227,10 +1237,13 @@ impl<'a> LoweringContext<'a> {
                             span,
                         );
 
-                        let hir_bounds = self.lower_bounds(bounds, itctx);
+                        let hir_bounds = self.lower_bounds(
+                            bounds,
+                            ImplTraitContext::Universal(def_id, in_band_ty_params),
+                        );
                         // Set the name to `impl Bound1 + Bound2`
                         let name = Symbol::intern(&pprust::ty_to_string(t));
-                        self.in_band_ty_params.push(hir::TyParam {
+                        in_band_ty_params.push(hir::TyParam {
                             name,
                             id: def_node_id,
                             bounds: hir_bounds,
@@ -1472,10 +1485,10 @@ impl<'a> LoweringContext<'a> {
         qself: &Option<QSelf>,
         p: &Path,
         param_mode: ParamMode,
-        itctx: ImplTraitContext,
+        mut itctx: ImplTraitContext,
     ) -> hir::QPath {
         let qself_position = qself.as_ref().map(|q| q.position);
-        let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
+        let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx.reborrow()));
 
         let resolution = self.resolver
             .get_resolution(id)
@@ -1562,7 +1575,7 @@ impl<'a> LoweringContext<'a> {
                         param_mode,
                         num_lifetimes,
                         parenthesized_generic_args,
-                        itctx,
+                        itctx.reborrow(),
                     )
                 })
                 .collect(),
@@ -1605,7 +1618,7 @@ impl<'a> LoweringContext<'a> {
                 param_mode,
                 0,
                 ParenthesizedGenericArgs::Warn,
-                itctx,
+                itctx.reborrow(),
             ));
             let qpath = hir::QPath::TypeRelative(ty, segment);
 
@@ -1713,7 +1726,7 @@ impl<'a> LoweringContext<'a> {
         &mut self,
         data: &AngleBracketedParameterData,
         param_mode: ParamMode,
-        itctx: ImplTraitContext,
+        mut itctx: ImplTraitContext,
     ) -> (hir::PathParameters, bool) {
         let &AngleBracketedParameterData {
             ref lifetimes,
@@ -1724,10 +1737,10 @@ impl<'a> LoweringContext<'a> {
         (
             hir::PathParameters {
                 lifetimes: self.lower_lifetimes(lifetimes),
-                types: types.iter().map(|ty| self.lower_ty(ty, itctx)).collect(),
+                types: types.iter().map(|ty| self.lower_ty(ty, itctx.reborrow())).collect(),
                 bindings: bindings
                     .iter()
-                    .map(|b| self.lower_ty_binding(b, itctx))
+                    .map(|b| self.lower_ty_binding(b, itctx.reborrow()))
                     .collect(),
                 parenthesized: false,
             },
@@ -1835,7 +1848,7 @@ impl<'a> LoweringContext<'a> {
     fn lower_fn_decl(
         &mut self,
         decl: &FnDecl,
-        fn_def_id: Option<DefId>,
+        mut in_band_ty_params: Option<(DefId, &mut Vec<hir::TyParam>)>,
         impl_trait_return_allow: bool,
     ) -> P<hir::FnDecl> {
         // NOTE: The two last parameters here have to do with impl Trait. If fn_def_id is Some,
@@ -1849,17 +1862,17 @@ impl<'a> LoweringContext<'a> {
             inputs: decl.inputs
                 .iter()
                 .map(|arg| {
-                    if let Some(def_id) = fn_def_id {
-                        self.lower_ty(&arg.ty, ImplTraitContext::Universal(def_id))
+                    if let Some((def_id, ibty)) = in_band_ty_params.as_mut() {
+                        self.lower_ty(&arg.ty, ImplTraitContext::Universal(*def_id, ibty))
                     } else {
                         self.lower_ty(&arg.ty, ImplTraitContext::Disallowed)
                     }
                 })
                 .collect(),
             output: match decl.output {
-                FunctionRetTy::Ty(ref ty) => match fn_def_id {
-                    Some(def_id) if impl_trait_return_allow => {
-                        hir::Return(self.lower_ty(ty, ImplTraitContext::Existential(def_id)))
+                FunctionRetTy::Ty(ref ty) => match in_band_ty_params {
+                    Some((def_id, ref mut ibty)) if impl_trait_return_allow => {
+                        hir::Return(self.lower_ty(ty, ImplTraitContext::Existential(def_id, ibty)))
                     }
                     _ => hir::Return(self.lower_ty(ty, ImplTraitContext::Disallowed)),
                 },
@@ -1894,7 +1907,7 @@ impl<'a> LoweringContext<'a> {
         &mut self,
         tp: &TyParam,
         add_bounds: &[TyParamBound],
-        itctx: ImplTraitContext,
+        mut itctx: ImplTraitContext,
     ) -> hir::TyParam {
         let mut name = self.lower_ident(tp.ident);
 
@@ -1905,11 +1918,11 @@ impl<'a> LoweringContext<'a> {
             name = Symbol::gensym("Self");
         }
 
-        let mut bounds = self.lower_bounds(&tp.bounds, itctx);
+        let mut bounds = self.lower_bounds(&tp.bounds, itctx.reborrow());
         if !add_bounds.is_empty() {
             bounds = bounds
                 .into_iter()
-                .chain(self.lower_bounds(add_bounds, itctx).into_iter())
+                .chain(self.lower_bounds(add_bounds, itctx.reborrow()).into_iter())
                 .collect();
         }
 
@@ -1984,7 +1997,7 @@ impl<'a> LoweringContext<'a> {
         &mut self,
         params: &Vec<GenericParam>,
         add_bounds: &NodeMap<Vec<TyParamBound>>,
-        itctx: ImplTraitContext,
+        mut itctx: ImplTraitContext,
     ) -> hir::HirVec<hir::GenericParam> {
         params
             .iter()
@@ -1995,7 +2008,7 @@ impl<'a> LoweringContext<'a> {
                 GenericParam::Type(ref ty_param) => hir::GenericParam::Type(self.lower_ty_param(
                     ty_param,
                     add_bounds.get(&ty_param.id).map_or(&[][..], |x| &x),
-                    itctx,
+                    itctx.reborrow(),
                 )),
             })
             .collect()
@@ -2170,10 +2183,10 @@ impl<'a> LoweringContext<'a> {
     fn lower_poly_trait_ref(
         &mut self,
         p: &PolyTraitRef,
-        itctx: ImplTraitContext,
+        mut itctx: ImplTraitContext,
     ) -> hir::PolyTraitRef {
         let bound_generic_params =
-            self.lower_generic_params(&p.bound_generic_params, &NodeMap(), itctx);
+            self.lower_generic_params(&p.bound_generic_params, &NodeMap(), itctx.reborrow());
         let trait_ref = self.with_parent_impl_lifetime_defs(
             &bound_generic_params
                 .iter()
@@ -2227,11 +2240,11 @@ impl<'a> LoweringContext<'a> {
     fn lower_bounds(
         &mut self,
         bounds: &[TyParamBound],
-        itctx: ImplTraitContext,
+        mut itctx: ImplTraitContext,
     ) -> hir::TyParamBounds {
         bounds
             .iter()
-            .map(|bound| self.lower_ty_param_bound(bound, itctx))
+            .map(|bound| self.lower_ty_param_bound(bound, itctx.reborrow()))
             .collect()
     }
 
@@ -2308,7 +2321,7 @@ impl<'a> LoweringContext<'a> {
                         generics,
                         fn_def_id,
                         AnonymousLifetimeMode::PassThrough,
-                        |this| this.lower_fn_decl(decl, Some(fn_def_id), true),
+                        |this, idty| this.lower_fn_decl(decl, Some((fn_def_id, idty)), true),
                     );
 
                     hir::ItemFn(
@@ -2380,7 +2393,7 @@ impl<'a> LoweringContext<'a> {
                     ast_generics,
                     def_id,
                     AnonymousLifetimeMode::CreateParameter,
-                    |this| {
+                    |this, _| {
                         let trait_ref = trait_ref.as_ref().map(|trait_ref| {
                             this.lower_trait_ref(trait_ref, ImplTraitContext::Disallowed)
                         });
@@ -2878,7 +2891,7 @@ impl<'a> LoweringContext<'a> {
                         generics,
                         def_id,
                         AnonymousLifetimeMode::PassThrough,
-                        |this| {
+                        |this, _| {
                             (
                                 // Disallow impl Trait in foreign items
                                 this.lower_fn_decl(fdec, None, false),
@@ -2913,7 +2926,11 @@ impl<'a> LoweringContext<'a> {
             generics,
             fn_def_id,
             AnonymousLifetimeMode::PassThrough,
-            |this| this.lower_fn_decl(&sig.decl, Some(fn_def_id), impl_trait_return_allow),
+            |this, idty| this.lower_fn_decl(
+                &sig.decl,
+                Some((fn_def_id, idty)),
+                impl_trait_return_allow,
+            ),
         );
         (
             generics,
