Handle locals in closures properly.

Author: Alexander Regueiro

src/librustc/hir/def_id.rs

@@ -215,7 +215,7 @@ impl DefIndexAddressSpace {
     }
 }
 
-/// A DefId identifies a particular *definition*, by combining a crate
+/// A `DefId` identifies a particular *definition*, by combining a crate
 /// index and a def index.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
 pub struct DefId {

src/librustc/hir/lowering.rs

@@ -139,7 +139,6 @@ pub struct LoweringContext<'a> {
     type_def_lifetime_params: DefIdMap<usize>,
 
     current_hir_id_owner: Vec<(DefIndex, u32)>,
-    current_impl_trait_owner: Vec<DefId>,
     item_local_id_counters: NodeMap<u32>,
     node_id_to_hir_id: IndexVec<NodeId, hir::HirId>,
 }
@@ -233,7 +232,6 @@ pub fn lower_crate(
         anonymous_lifetime_mode: AnonymousLifetimeMode::PassThrough,
         type_def_lifetime_params: DefIdMap(),
         current_hir_id_owner: vec![(CRATE_DEF_INDEX, 0)],
-        current_impl_trait_owner: vec![],
         item_local_id_counters: NodeMap(),
         node_id_to_hir_id: IndexVec::new(),
         is_generator: false,
@@ -392,17 +390,6 @@ impl<'a> LoweringContext<'a> {
         }
 
         impl<'lcx, 'interner> ItemLowerer<'lcx, 'interner> {
-            fn with_impl_trait_owner<F, T>(&mut self, def_id: DefId, f: F) -> T
-            where
-                F: FnOnce(&mut Self) -> T,
-            {
-                self.lctx.current_impl_trait_owner.push(def_id);
-                let ret = f(self);
-                self.lctx.current_impl_trait_owner.pop();
-
-                ret
-            }
-
             fn with_trait_impl_ref<F>(&mut self, trait_impl_ref: &Option<TraitRef>, f: F)
             where
                 F: FnOnce(&mut Self),
@@ -440,12 +427,7 @@ impl<'a> LoweringContext<'a> {
 
                     self.lctx.with_parent_impl_lifetime_defs(&item_generics, |this| {
                         let this = &mut ItemLowerer { lctx: this };
-                        if let ItemKind::Fn(..) = item.node {
-                            let fn_def_id = this.lctx.resolver.definitions().local_def_id(item.id);
-                            this.with_impl_trait_owner(fn_def_id, |this| {
-                                visit::walk_item(this, item)
-                            });
-                        } else if let ItemKind::Impl(.., ref opt_trait_ref, _, _) = item.node {
+                        if let ItemKind::Impl(.., ref opt_trait_ref, _, _) = item.node {
                             this.with_trait_impl_ref(opt_trait_ref, |this| {
                                 visit::walk_item(this, item)
                             });
@@ -573,17 +555,6 @@ impl<'a> LoweringContext<'a> {
         ret
     }
 
-    fn with_impl_trait_owner<F, T>(&mut self, def_id: DefId, f: F) -> T
-    where
-        F: FnOnce(&mut LoweringContext) -> T,
-    {
-        self.current_impl_trait_owner.push(def_id);
-        let ret = f(self);
-        self.current_impl_trait_owner.pop();
-
-        ret
-    }
-
     /// This method allocates a new HirId for the given NodeId and stores it in
     /// the LoweringContext's NodeId => HirId map.
     /// Take care not to call this method if the resulting HirId is then not
@@ -1939,15 +1910,15 @@ impl<'a> LoweringContext<'a> {
                 visitor.visit_ty(ty);
             }
         }
-        let impl_trait_owner_id = self.current_impl_trait_owner.last().map(|id| *id);
+        let parent_def_id = DefId::local(self.current_hir_id_owner.last().unwrap().0);
         (P(hir::Local {
             id: node_id,
             hir_id,
             ty: l.ty
                 .as_ref()
                 .map(|t| self.lower_ty(t,
                     if self.sess.features_untracked().impl_trait_in_bindings {
-                        ImplTraitContext::Existential(impl_trait_owner_id)
+                        ImplTraitContext::Existential(Some(parent_def_id))
                     } else {
                         ImplTraitContext::Disallowed
                     }
@@ -2213,8 +2184,7 @@ impl<'a> LoweringContext<'a> {
             span, Some(fn_def_id), return_impl_trait_id, |this| {
             let output_ty = match output {
                 FunctionRetTy::Ty(ty) => {
-                    let impl_trait_owner_id = *this.current_impl_trait_owner.last().unwrap();
-                    this.lower_ty(ty, ImplTraitContext::Existential(Some(impl_trait_owner_id)))
+                    this.lower_ty(ty, ImplTraitContext::Existential(Some(fn_def_id)))
                 }
                 FunctionRetTy::Default(span) => {
                     let LoweredNodeId { node_id, hir_id } = this.next_id();
@@ -2738,33 +2708,31 @@ impl<'a> LoweringContext<'a> {
             }
             ItemKind::Fn(ref decl, header, ref generics, ref body) => {
                 let fn_def_id = self.resolver.definitions().local_def_id(id);
-                self.with_impl_trait_owner(fn_def_id, |this| {
-                    this.with_new_scopes(|this| {
-                        // Note: we don't need to change the return type from `T` to
-                        // `impl Future<Output = T>` here because lower_body
-                        // only cares about the input argument patterns in the function
-                        // declaration (decl), not the return types.
-                        let body_id = this.lower_async_body(decl, header.asyncness, body);
-
-                        let (generics, fn_decl) = this.add_in_band_defs(
-                            generics,
-                            fn_def_id,
-                            AnonymousLifetimeMode::PassThrough,
-                            |this, idty| this.lower_fn_decl(
-                                decl,
-                                Some((fn_def_id, idty)),
-                                true,
-                                header.asyncness.opt_return_id()
-                            ),
-                        );
+                self.with_new_scopes(|this| {
+                    // Note: we don't need to change the return type from `T` to
+                    // `impl Future<Output = T>` here because lower_body
+                    // only cares about the input argument patterns in the function
+                    // declaration (decl), not the return types.
+                    let body_id = this.lower_async_body(decl, header.asyncness, body);
+
+                    let (generics, fn_decl) = this.add_in_band_defs(
+                        generics,
+                        fn_def_id,
+                        AnonymousLifetimeMode::PassThrough,
+                        |this, idty| this.lower_fn_decl(
+                            decl,
+                            Some((fn_def_id, idty)),
+                            true,
+                            header.asyncness.opt_return_id()
+                        ),
+                    );
 
-                        hir::ItemKind::Fn(
-                            fn_decl,
-                            this.lower_fn_header(header),
-                            generics,
-                            body_id,
-                        )
-                    })
+                    hir::ItemKind::Fn(
+                        fn_decl,
+                        this.lower_fn_header(header),
+                        generics,
+                        body_id,
+                    )
                 })
             }
             ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),
@@ -3083,33 +3051,29 @@ impl<'a> LoweringContext<'a> {
                 ),
             ),
             TraitItemKind::Method(ref sig, None) => {
-                self.with_impl_trait_owner(trait_item_def_id, |this| {
-                    let names = this.lower_fn_args_to_names(&sig.decl);
-                    let (generics, sig) = this.lower_method_sig(
-                        &i.generics,
-                        sig,
-                        trait_item_def_id,
-                        false,
-                        None,
-                    );
-                    (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Required(names)))
-                })
+                let names = self.lower_fn_args_to_names(&sig.decl);
+                let (generics, sig) = self.lower_method_sig(
+                    &i.generics,
+                    sig,
+                    trait_item_def_id,
+                    false,
+                    None,
+                );
+                (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Required(names)))
             }
             TraitItemKind::Method(ref sig, Some(ref body)) => {
-                self.with_impl_trait_owner(trait_item_def_id, |this| {
-                    let body_id = this.lower_body(Some(&sig.decl), |this| {
-                        let body = this.lower_block(body, false);
-                        this.expr_block(body, ThinVec::new())
-                    });
-                    let (generics, sig) = this.lower_method_sig(
-                        &i.generics,
-                        sig,
-                        trait_item_def_id,
-                        false,
-                        None,
-                    );
-                    (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Provided(body_id)))
-                })
+                let body_id = self.lower_body(Some(&sig.decl), |this| {
+                    let body = this.lower_block(body, false);
+                    this.expr_block(body, ThinVec::new())
+                });
+                let (generics, sig) = self.lower_method_sig(
+                    &i.generics,
+                    sig,
+                    trait_item_def_id,
+                    false,
+                    None,
+                );
+                (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Provided(body_id)))
             }
             TraitItemKind::Type(ref bounds, ref default) => (
                 self.lower_generics(&i.generics, ImplTraitContext::Disallowed),
@@ -3175,18 +3139,16 @@ impl<'a> LoweringContext<'a> {
                 )
             }
             ImplItemKind::Method(ref sig, ref body) => {
-                self.with_impl_trait_owner(impl_item_def_id, |this| {
-                    let body_id = this.lower_async_body(&sig.decl, sig.header.asyncness, body);
-                    let impl_trait_return_allow = !this.is_in_trait_impl;
-                    let (generics, sig) = this.lower_method_sig(
-                        &i.generics,
-                        sig,
-                        impl_item_def_id,
-                        impl_trait_return_allow,
-                        sig.header.asyncness.opt_return_id(),
-                    );
-                    (generics, hir::ImplItemKind::Method(sig, body_id))
-                })
+                let body_id = self.lower_async_body(&sig.decl, sig.header.asyncness, body);
+                let impl_trait_return_allow = !self.is_in_trait_impl;
+                let (generics, sig) = self.lower_method_sig(
+                    &i.generics,
+                    sig,
+                    impl_item_def_id,
+                    impl_trait_return_allow,
+                    sig.header.asyncness.opt_return_id(),
+                );
+                (generics, hir::ImplItemKind::Method(sig, body_id))
             }
             ImplItemKind::Type(ref ty) => (
                 self.lower_generics(&i.generics, ImplTraitContext::Disallowed),

src/librustc/infer/opaque_types/mod.rs

@@ -98,9 +98,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     ///
     /// # Parameters
     ///
-    /// - `parent_def_id` -- we will only instantiate opaque types
-    ///   with this parent. This is typically the def-id of the function
-    ///   in whose return type opaque types are being instantiated.
+    /// - `parent_def_id` -- the def-id of the function in which the opaque type
+    ///   is defined
     /// - `body_id` -- the body-id with which the resulting obligations should
     ///   be associated
     /// - `param_env` -- the in-scope parameter environment to be used for
@@ -113,11 +112,9 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         value: &T,
     ) -> InferOk<'tcx, (T, OpaqueTypeMap<'tcx>)> {
-        debug!(
-            "instantiate_opaque_types(value={:?},
-            parent_def_id={:?}, body_id={:?},
-            param_env={:?})",
-            value, parent_def_id, body_id, param_env,
+        debug!("instantiate_opaque_types(value={:?}, parent_def_id={:?}, body_id={:?}, \
+                param_env={:?})",
+               value, parent_def_id, body_id, param_env,
         );
         let mut instantiator = Instantiator {
             infcx: self,

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -898,7 +898,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         locations: Locations,
         category: ConstraintCategory,
     ) -> Fallible<()> {
-        if let Err(terr) = self.sub_types(sub, sup, locations) {
+        if let Err(terr) = self.sub_types(sub, sup, locations, category) {
             if let TyKind::Opaque(..) = sup.sty {
                 return self.eq_opaque_type_and_type(sub, sup, locations, category);
             } else {
@@ -954,18 +954,19 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         let infcx = self.infcx;
         let tcx = infcx.tcx;
         let param_env = self.param_env;
-        let mir_def_id = self.mir_def_id;
+        let parent_def_id = infcx.tcx.closure_base_def_id(self.mir_def_id);
         let opaque_type_map =
             self.fully_perform_op(
                 locations,
+                category,
                 CustomTypeOp::new(
                     |infcx| {
                         let mut obligations = ObligationAccumulator::default();
 
                         let dummy_body_id = ObligationCause::dummy().body_id;
                         let (output_ty, opaque_type_map) =
                             obligations.add(infcx.instantiate_opaque_types(
-                                mir_def_id,
+                                parent_def_id,
                                 dummy_body_id,
                                 param_env,
                                 &anon_ty,
@@ -1028,7 +1029,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
             for (opaque_def_id, opaque_decl) in opaque_type_map {
                 self.fully_perform_op(
                     locations,
-                    category,
+                    ConstraintCategory::OpaqueType,
                     CustomTypeOp::new(
                         |_cx| {
                             infcx.constrain_opaque_type(

src/librustc_typeck/check/mod.rs

@@ -821,8 +821,8 @@ fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                              def_id: DefId)
-                              -> Lrc<DefIdSet> {
+                                def_id: DefId)
+                                -> Lrc<DefIdSet> {
     tcx.typeck_tables_of(def_id).used_trait_imports.clone()
 }
 
@@ -870,7 +870,6 @@ fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
 
             let revealed_ty = if tcx.features().impl_trait_in_bindings {
-                fcx.require_type_is_sized(expected_type, body.value.span, traits::SizedReturnType);
                 fcx.instantiate_opaque_types_from_value(
                     id,
                     &expected_type
@@ -965,7 +964,6 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
         let local_ty = match local.ty {
             Some(ref ty) => {
                 let o_ty = self.fcx.to_ty(&ty);
-                debug!("visit_local: ty.hir_id={:?} o_ty={:?} c_ty={:?}", ty.hir_id, o_ty, 1);
 
                 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
                     self.fcx.instantiate_opaque_types_from_value(
@@ -977,6 +975,8 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
                 };
 
                 let c_ty = self.fcx.inh.infcx.canonicalize_response(&revealed_ty);
+                debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
+                       ty.hir_id, o_ty, revealed_ty, c_ty);
                 self.fcx.tables.borrow_mut().user_provided_tys_mut().insert(ty.hir_id, c_ty);
 
                 Some(LocalTy { decl_ty: o_ty, revealed_ty })
@@ -1074,7 +1074,9 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
         fcx.yield_ty = Some(yield_ty);
     }
 
-    GatherLocalsVisitor { fcx: &fcx, parent_id: fn_id, }.visit_body(body);
+    let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir.local_def_id(fn_id));
+    let outer_node_id = fcx.tcx.hir.as_local_node_id(outer_def_id).unwrap();
+    GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_id, }.visit_body(body);
 
     // Add formal parameters.
     for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
@@ -2265,19 +2267,17 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     /// `InferCtxt::instantiate_opaque_types` for more details.
     fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
         &self,
-        fn_id: ast::NodeId,
+        parent_id: ast::NodeId,
         value: &T,
     ) -> T {
-        let fn_def_id = self.tcx.hir.local_def_id(fn_id);
-        debug!(
-            "instantiate_opaque_types_from_value(fn_def_id={:?}, value={:?})",
-            fn_def_id,
-            value
-        );
+        let parent_def_id = self.tcx.hir.local_def_id(parent_id);
+        debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
+               parent_def_id,
+               value);
 
         let (value, opaque_type_map) = self.register_infer_ok_obligations(
             self.instantiate_opaque_types(
-                fn_def_id,
+                parent_def_id,
                 self.body_id,
                 self.param_env,
                 value,