introduce a Vec<Ty> to TyClosure for storing upvar types

nikomatsakis · nikomatsakis · commit 69d62e04e524 · 2015-07-24T04:50:45.000-04:00
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
@@ -564,8 +564,13 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
           assert_eq!(next(st), '[');
           let did = parse_def_(st, ClosureSource, conv);
           let substs = parse_substs_(st, conv);
+          let mut tys = vec![];
+          while peek(st) != '.' {
+              tys.push(parse_ty_(st, conv));
+          }
+          assert_eq!(next(st), '.');
           assert_eq!(next(st), ']');
-          return st.tcx.mk_closure(did, st.tcx.mk_substs(substs));
+          return st.tcx.mk_closure(did, st.tcx.mk_substs(substs), tys);
       }
       'P' => {
           assert_eq!(next(st), '[');
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
@@ -143,9 +143,13 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::TyClosure(def, substs) => {
+        ty::TyClosure(def, substs, ref tys) => {
             mywrite!(w, "k[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
+            for ty in tys {
+                enc_ty(w, cx, ty);
+            }
+            mywrite!(w, ".");
             mywrite!(w, "]");
         }
         ty::TyProjection(ref data) => {
diff --git a/src/librustc/middle/fast_reject.rs b/src/librustc/middle/fast_reject.rs
@@ -76,7 +76,7 @@ pub fn simplify_type(tcx: &ty::ctxt,
                 Err(msg) => tcx.sess.fatal(&msg),
             }
         }
-        ty::TyClosure(def_id, _) => {
+        ty::TyClosure(def_id, _, _) => {
             Some(ClosureSimplifiedType(def_id))
         }
         ty::TyTuple(ref tys) => {
diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs
@@ -96,7 +96,8 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
                 // No borrowed content reachable here.
             }
 
-            ty::TyClosure(def_id, substs) => {
+            ty::TyClosure(def_id, substs, _) => {
+                // TODO remove RegionSubClosure
                 let &(r_a, opt_ty) = self.stack.last().unwrap();
                 self.out.push(Implication::RegionSubClosure(opt_ty, r_a, def_id, substs));
             }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -1493,7 +1493,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
     fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> {
         let fn_ty = self.ir.tcx.node_id_to_type(id);
         match fn_ty.sty {
-            ty::TyClosure(closure_def_id, substs) =>
+            ty::TyClosure(closure_def_id, substs, _) =>
                 self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),
             _ => fn_ty.fn_ret()
         }
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
@@ -584,7 +584,7 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> {
           def::DefUpvar(var_id, fn_node_id) => {
               let ty = try!(self.node_ty(fn_node_id));
               match ty.sty {
-                  ty::TyClosure(closure_id, _) => {
+                  ty::TyClosure(closure_id, _, _) => {
                       match self.typer.closure_kind(closure_id) {
                           Some(kind) => {
                               self.cat_upvar(id, span, var_id, fn_node_id, kind)
diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs
@@ -271,6 +271,7 @@ pub struct VtableImplData<'tcx, N> {
 pub struct VtableClosureData<'tcx, N> {
     pub closure_def_id: ast::DefId,
     pub substs: subst::Substs<'tcx>,
+    pub upvar_tys: Vec<Ty<'tcx>>,
     /// Nested obligations. This can be non-empty if the closure
     /// signature contains associated types.
     pub nested: Vec<N>
@@ -548,7 +549,8 @@ impl<'tcx, N> Vtable<'tcx, N> {
             VtableClosure(c) => VtableClosure(VtableClosureData {
                 closure_def_id: c.closure_def_id,
                 substs: c.substs,
-                nested: c.nested.into_iter().map(f).collect()
+                nested: c.nested.into_iter().map(f).collect(),
+                upvar_tys: c.upvar_tys,
             })
         }
     }
diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs
@@ -154,7 +154,7 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext
     debug!("consider_unification_despite_ambiguity: self_ty.sty={:?}",
            self_ty.sty);
     match self_ty.sty {
-        ty::TyClosure(closure_def_id, substs) => {
+        ty::TyClosure(closure_def_id, substs, _) => {
             let closure_typer = selcx.closure_typer();
             let closure_type = closure_typer.closure_type(closure_def_id, substs);
             let ty::Binder((_, ret_type)) =
diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs
@@ -201,7 +201,7 @@ enum SelectionCandidate<'tcx> {
 
     /// Implementation of a `Fn`-family trait by one of the
     /// anonymous types generated for a `||` expression.
-    ClosureCandidate(/* closure */ ast::DefId, Substs<'tcx>),
+    ClosureCandidate(/* closure */ ast::DefId, &'tcx Substs<'tcx>, &'tcx Vec<Ty<'tcx>>),
 
     /// Implementation of a `Fn`-family trait by one of the anonymous
     /// types generated for a fn pointer type (e.g., `fn(int)->int`)
@@ -348,7 +348,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // lifetimes can appear inside the self-type.
         let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
         let (closure_def_id, substs) = match self_ty.sty {
-            ty::TyClosure(id, ref substs) => (id, substs.clone()),
+            ty::TyClosure(id, ref substs, _) => (id, substs.clone()),
             _ => { return; }
         };
         assert!(!substs.has_escaping_regions());
@@ -1142,8 +1142,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // touch bound regions, they just capture the in-scope
         // type/region parameters
         let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
-        let (closure_def_id, substs) = match self_ty.sty {
-            ty::TyClosure(id, substs) => (id, substs),
+        let (closure_def_id, substs, upvar_tys) = match self_ty.sty {
+            ty::TyClosure(id, substs, ref upvar_tys) => (id, substs, upvar_tys),
             ty::TyInfer(ty::TyVar(_)) => {
                 debug!("assemble_unboxed_closure_candidates: ambiguous self-type");
                 candidates.ambiguous = true;
@@ -1161,8 +1161,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             Some(closure_kind) => {
                 debug!("assemble_unboxed_candidates: closure_kind = {:?}", closure_kind);
                 if closure_kind.extends(kind) {
-                    candidates.vec.push(ClosureCandidate(closure_def_id,
-                                                         substs.clone()));
+                    candidates.vec.push(ClosureCandidate(closure_def_id, substs, upvar_tys));
                 }
             }
             None => {
@@ -1704,7 +1703,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
             ty::TyTuple(ref tys) => ok_if(tys.clone()),
 
-            ty::TyClosure(def_id, substs) => {
+            ty::TyClosure(def_id, substs, _) => {
                 // FIXME -- This case is tricky. In the case of by-ref
                 // closures particularly, we need the results of
                 // inference to decide how to reflect the type of each
@@ -1730,6 +1729,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     return ok_if(Vec::new());
                 }
 
+                // TODO
                 match self.infcx.closure_upvars(def_id, substs) {
                     Some(upvars) => ok_if(upvars.iter().map(|c| c.ty).collect()),
                     None => {
@@ -1865,9 +1865,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Some(tys.clone())
             }
 
-            ty::TyClosure(def_id, substs) => {
+            ty::TyClosure(def_id, substs, _) => {
                 assert_eq!(def_id.krate, ast::LOCAL_CRATE);
 
+                // TODO
                 match self.infcx.closure_upvars(def_id, substs) {
                     Some(upvars) => {
                         Some(upvars.iter().map(|c| c.ty).collect())
@@ -2014,9 +2015,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Ok(VtableImpl(vtable_impl))
             }
 
-            ClosureCandidate(closure_def_id, substs) => {
+            ClosureCandidate(closure_def_id, substs, upvar_tys) => {
                 let vtable_closure =
-                    try!(self.confirm_closure_candidate(obligation, closure_def_id, &substs));
+                    try!(self.confirm_closure_candidate(obligation, closure_def_id,
+                                                        &substs, upvar_tys));
                 Ok(VtableClosure(vtable_closure))
             }
 
@@ -2365,7 +2367,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     fn confirm_closure_candidate(&mut self,
                                  obligation: &TraitObligation<'tcx>,
                                  closure_def_id: ast::DefId,
-                                 substs: &Substs<'tcx>)
+                                 substs: &Substs<'tcx>,
+                                 upvar_tys: &'tcx Vec<Ty<'tcx>>)
                                  -> Result<VtableClosureData<'tcx, PredicateObligation<'tcx>>,
                                            SelectionError<'tcx>>
     {
@@ -2391,6 +2394,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         Ok(VtableClosureData {
             closure_def_id: closure_def_id,
             substs: substs.clone(),
+            upvar_tys: upvar_tys.clone(),
             nested: obligations
         })
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -1767,7 +1767,7 @@ pub enum TypeVariants<'tcx> {
 
     /// The anonymous type of a closure. Used to represent the type of
     /// `|a| a`.
-    TyClosure(DefId, &'tcx Substs<'tcx>),
+    TyClosure(DefId, &'tcx Substs<'tcx>, Vec<Ty<'tcx>>),
 
     /// A tuple type.  For example, `(i32, bool)`.
     TyTuple(Vec<Ty<'tcx>>),
@@ -3214,10 +3214,11 @@ impl FlagComputation {
                 }
             }
 
-            &TyClosure(_, substs) => {
+            &TyClosure(_, substs, ref tys) => {
                 self.add_flags(TypeFlags::HAS_TY_CLOSURE);
                 self.add_flags(TypeFlags::HAS_LOCAL_NAMES);
                 self.add_substs(substs);
+                self.add_tys(tys);
             }
 
             &TyInfer(_) => {
@@ -3659,9 +3660,12 @@ impl<'tcx> ctxt<'tcx> {
         self.mk_ty(TyStruct(struct_id, substs))
     }
 
-    pub fn mk_closure(&self, closure_id: ast::DefId, substs: &'tcx Substs<'tcx>)
+    pub fn mk_closure(&self,
+                      closure_id: ast::DefId,
+                      substs: &'tcx Substs<'tcx>,
+                      tys: Vec<Ty<'tcx>>)
                       -> Ty<'tcx> {
-        self.mk_ty(TyClosure(closure_id, substs))
+        self.mk_ty(TyClosure(closure_id, substs, tys))
     }
 
     pub fn mk_var(&self, v: TyVid) -> Ty<'tcx> {
@@ -3928,7 +3932,7 @@ impl<'tcx> TyS<'tcx> {
             TyTrait(ref tt) => Some(tt.principal_def_id()),
             TyStruct(id, _) |
             TyEnum(id, _) |
-            TyClosure(id, _) => Some(id),
+            TyClosure(id, _, _) => Some(id),
             _ => None
         }
     }
@@ -4146,7 +4150,7 @@ impl<'tcx> TyS<'tcx> {
                     apply_lang_items(cx, did, res)
                 }
 
-                TyClosure(did, substs) => {
+                TyClosure(did, substs, _) => {
                     let param_env = cx.empty_parameter_environment();
                     let infcx = infer::new_infer_ctxt(cx, &cx.tables, Some(param_env), false);
                     let upvars = infcx.closure_upvars(did, substs).unwrap();
@@ -6378,7 +6382,7 @@ impl<'tcx> ctxt<'tcx> {
                     }
                     TyInfer(_) => unreachable!(),
                     TyError => byte!(21),
-                    TyClosure(d, _) => {
+                    TyClosure(d, _, _) => {
                         byte!(22);
                         did(state, d);
                     }
diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs
@@ -450,6 +450,7 @@ impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableClosureDa
             closure_def_id: self.closure_def_id,
             substs: self.substs.fold_with(folder),
             nested: self.nested.fold_with(folder),
+            upvar_tys: self.upvar_tys.fold_with(folder),
         }
     }
 }
@@ -602,9 +603,10 @@ pub fn super_fold_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
             let substs = substs.fold_with(this);
             ty::TyStruct(did, this.tcx().mk_substs(substs))
         }
-        ty::TyClosure(did, ref substs) => {
+        ty::TyClosure(did, ref substs, ref tys) => {
             let s = substs.fold_with(this);
-            ty::TyClosure(did, this.tcx().mk_substs(s))
+            let tys = tys.fold_with(this);
+            ty::TyClosure(did, this.tcx().mk_substs(s), tys)
         }
         ty::TyProjection(ref data) => {
             ty::TyProjection(data.fold_with(this))
diff --git a/src/librustc/middle/ty_relate/mod.rs b/src/librustc/middle/ty_relate/mod.rs
@@ -48,6 +48,12 @@ pub trait TypeRelation<'a,'tcx> : Sized {
         Relate::relate(self, a, b)
     }
 
+    /// Relete elements of two slices pairwise.
+    fn relate_zip<T:Relate<'a,'tcx>>(&mut self, a: &[T], b: &[T]) -> RelateResult<'tcx, Vec<T>> {
+        assert_eq!(a.len(), b.len());
+        a.iter().zip(b).map(|(a, b)| self.relate(a, b)).collect()
+    }
+
     /// Switch variance for the purpose of relating `a` and `b`.
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                variance: ty::Variance,
@@ -500,15 +506,16 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R,
             Ok(tcx.mk_struct(a_id, tcx.mk_substs(substs)))
         }
 
-        (&ty::TyClosure(a_id, a_substs),
-         &ty::TyClosure(b_id, b_substs))
+        (&ty::TyClosure(a_id, a_substs, ref a_tys),
+         &ty::TyClosure(b_id, b_substs, ref b_tys))
             if a_id == b_id =>
         {
             // All TyClosure types with the same id represent
             // the (anonymous) type of the same closure expression. So
             // all of their regions should be equated.
             let substs = try!(relate_substs(relation, None, a_substs, b_substs));
-            Ok(tcx.mk_closure(a_id, tcx.mk_substs(substs)))
+            let tys = try!(relation.relate_zip(a_tys, b_tys));
+            Ok(tcx.mk_closure(a_id, tcx.mk_substs(substs), tys))
         }
 
         (&ty::TyBox(a_inner), &ty::TyBox(b_inner)) =>
diff --git a/src/librustc/middle/ty_walk.rs b/src/librustc/middle/ty_walk.rs
@@ -88,10 +88,13 @@ fn push_subtypes<'tcx>(stack: &mut Vec<Ty<'tcx>>, parent_ty: Ty<'tcx>) {
             }).collect::<Vec<_>>());
         }
         ty::TyEnum(_, ref substs) |
-        ty::TyStruct(_, ref substs) |
-        ty::TyClosure(_, ref substs) => {
+        ty::TyStruct(_, ref substs) => {
             push_reversed(stack, substs.types.as_slice());
         }
+        ty::TyClosure(_, ref substs, ref tys) => {
+            push_reversed(stack, substs.types.as_slice());
+            push_reversed(stack, tys);
+        }
         ty::TyTuple(ref ts) => {
             push_reversed(stack, ts);
         }
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -662,7 +662,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> {
             TyTrait(ref data) => write!(f, "{}", data),
             ty::TyProjection(ref data) => write!(f, "{}", data),
             TyStr => write!(f, "str"),
-            TyClosure(ref did, substs) => ty::tls::with(|tcx| {
+            TyClosure(ref did, substs, _) => ty::tls::with(|tcx| {
                 try!(write!(f, "[closure"));
                 let closure_tys = &tcx.tables.borrow().closure_tys;
                 try!(closure_tys.get(did).map(|cty| &cty.sig).and_then(|sig| {
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -2529,7 +2529,7 @@ impl LintPass for DropWithReprExtern {
             match dtor_self_type.sty {
                 ty::TyEnum(self_type_did, _) |
                 ty::TyStruct(self_type_did, _) |
-                ty::TyClosure(self_type_did, _) => {
+                ty::TyClosure(self_type_did, _, _) => {
                     let hints = ctx.tcx.lookup_repr_hints(self_type_did);
                     if hints.iter().any(|attr| *attr == attr::ReprExtern) &&
                         ctx.tcx.ty_dtor(self_type_did).has_drop_flag() {
diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs
@@ -221,9 +221,9 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
             Univariant(mk_struct(cx, &ftys[..], packed, t), dtor_to_init_u8(dtor))
         }
-        ty::TyClosure(def_id, substs) => {
+        ty::TyClosure(def_id, substs, _) => {
             let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
-            let upvars = infcx.closure_upvars(def_id, substs).unwrap();
+            let upvars = infcx.closure_upvars(def_id, substs).unwrap(); // TODO
             let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
             Univariant(mk_struct(cx, &upvar_types[..], false, t), 0)
         }
@@ -441,9 +441,9 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>,
 
         // Perhaps one of the upvars of this struct is non-zero
         // Let's recurse and find out!
-        ty::TyClosure(def_id, substs) => {
+        ty::TyClosure(def_id, substs, _) => {
             let infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables);
-            let upvars = infcx.closure_upvars(def_id, substs).unwrap();
+            let upvars = infcx.closure_upvars(def_id, substs).unwrap(); // TODO
             let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
 
             for (j, &ty) in upvar_types.iter().enumerate() {
diff --git a/src/librustc_trans/trans/attributes.rs b/src/librustc_trans/trans/attributes.rs
@@ -145,7 +145,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx
     let function_type;
     let (fn_sig, abi, env_ty) = match fn_type.sty {
         ty::TyBareFn(_, ref f) => (&f.sig, f.abi, None),
-        ty::TyClosure(closure_did, substs) => {
+        ty::TyClosure(closure_did, substs, _) => {
             let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
             function_type = infcx.closure_type(closure_did, substs);
             let self_type = base::self_type_for_closure(ccx, closure_did, fn_type);
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
@@ -470,7 +470,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
               }
           })
       }
-      ty::TyClosure(def_id, substs) => {
+      ty::TyClosure(def_id, substs, _) => { // TODO
           let repr = adt::represent_type(cx.ccx(), t);
           let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
           let upvars = infcx.closure_upvars(def_id, substs).unwrap();
diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs
diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs
diff --git a/src/librustc_trans/trans/declare.rs b/src/librustc_trans/trans/declare.rs
diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs
diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ pub fn simplify_type(tcx: &ty::ctxt,`
`76`	`76`	`Err(msg) => tcx.sess.fatal(&msg),`
`77`	`77`	`}`
`78`	`78`	`}`
`79`		`- ty::TyClosure(def_id, _) => {`
	`79`	`+ ty::TyClosure(def_id, _, _) => {`
`80`	`80`	`Some(ClosureSimplifiedType(def_id))`
`81`	`81`	`}`
`82`	`82`	`ty::TyTuple(ref tys) => {`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,8 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {`
`96`	`96`	`// No borrowed content reachable here.`
`97`	`97`	`}`
`98`	`98`
`99`		`- ty::TyClosure(def_id, substs) => {`
	`99`	`+ ty::TyClosure(def_id, substs, _) => {`
	`100`	`+ // TODO remove RegionSubClosure`
`100`	`101`	`let &(r_a, opt_ty) = self.stack.last().unwrap();`
`101`	`102`	`self.out.push(Implication::RegionSubClosure(opt_ty, r_a, def_id, substs));`
`102`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1493,7 +1493,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {`
`1493`	`1493`	`fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> {`
`1494`	`1494`	`let fn_ty = self.ir.tcx.node_id_to_type(id);`
`1495`	`1495`	`match fn_ty.sty {`
`1496`		`- ty::TyClosure(closure_def_id, substs) =>`
	`1496`	`+ ty::TyClosure(closure_def_id, substs, _) =>`
`1497`	`1497`	`self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),`
`1498`	`1498`	`_ => fn_ty.fn_ret()`
`1499`	`1499`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1767,7 +1767,7 @@ pub enum TypeVariants<'tcx> {`
`1767`	`1767`
`1768`	`1768`	`/// The anonymous type of a closure. Used to represent the type of`
`1769`	`1769`	/// `\|a\| a`.
`1770`		`- TyClosure(DefId, &'tcx Substs<'tcx>),`
	`1770`	`+ TyClosure(DefId, &'tcx Substs<'tcx>, Vec<Ty<'tcx>>),`
`1771`	`1771`
`1772`	`1772`	/// A tuple type. For example, `(i32, bool)`.
`1773`	`1773`	`TyTuple(Vec<Ty<'tcx>>),`
`@@ -3214,10 +3214,11 @@ impl FlagComputation {`
`3214`	`3214`	`}`
`3215`	`3215`	`}`
`3216`	`3216`
`3217`		`- &TyClosure(_, substs) => {`
	`3217`	`+ &TyClosure(_, substs, ref tys) => {`
`3218`	`3218`	`self.add_flags(TypeFlags::HAS_TY_CLOSURE);`
`3219`	`3219`	`self.add_flags(TypeFlags::HAS_LOCAL_NAMES);`
`3220`	`3220`	`self.add_substs(substs);`
	`3221`	`+ self.add_tys(tys);`
`3221`	`3222`	`}`
`3222`	`3223`
`3223`	`3224`	`&TyInfer(_) => {`
`@@ -3659,9 +3660,12 @@ impl<'tcx> ctxt<'tcx> {`
`3659`	`3660`	`self.mk_ty(TyStruct(struct_id, substs))`
`3660`	`3661`	`}`
`3661`	`3662`
`3662`		`- pub fn mk_closure(&self, closure_id: ast::DefId, substs: &'tcx Substs<'tcx>)`
	`3663`	`+ pub fn mk_closure(&self,`
	`3664`	`+ closure_id: ast::DefId,`
	`3665`	`+ substs: &'tcx Substs<'tcx>,`
	`3666`	`+ tys: Vec<Ty<'tcx>>)`
`3663`	`3667`	`-> Ty<'tcx> {`
`3664`		`- self.mk_ty(TyClosure(closure_id, substs))`
	`3668`	`+ self.mk_ty(TyClosure(closure_id, substs, tys))`
`3665`	`3669`	`}`
`3666`	`3670`
`3667`	`3671`	`pub fn mk_var(&self, v: TyVid) -> Ty<'tcx> {`
`@@ -3928,7 +3932,7 @@ impl<'tcx> TyS<'tcx> {`
`3928`	`3932`	`TyTrait(ref tt) => Some(tt.principal_def_id()),`
`3929`	`3933`	`TyStruct(id, _) \|`
`3930`	`3934`	`TyEnum(id, _) \|`
`3931`		`- TyClosure(id, _) => Some(id),`
	`3935`	`+ TyClosure(id, _, _) => Some(id),`
`3932`	`3936`	`_ => None`
`3933`	`3937`	`}`
`3934`	`3938`	`}`
`@@ -4146,7 +4150,7 @@ impl<'tcx> TyS<'tcx> {`
`4146`	`4150`	`apply_lang_items(cx, did, res)`
`4147`	`4151`	`}`
`4148`	`4152`
`4149`		`- TyClosure(did, substs) => {`
	`4153`	`+ TyClosure(did, substs, _) => {`
`4150`	`4154`	`let param_env = cx.empty_parameter_environment();`
`4151`	`4155`	`let infcx = infer::new_infer_ctxt(cx, &cx.tables, Some(param_env), false);`
`4152`	`4156`	`let upvars = infcx.closure_upvars(did, substs).unwrap();`
`@@ -6378,7 +6382,7 @@ impl<'tcx> ctxt<'tcx> {`
`6378`	`6382`	`}`
`6379`	`6383`	`TyInfer(_) => unreachable!(),`
`6380`	`6384`	`TyError => byte!(21),`
`6381`		`- TyClosure(d, _) => {`
	`6385`	`+ TyClosure(d, _, _) => {`
`6382`	`6386`	`byte!(22);`
`6383`	`6387`	`did(state, d);`
`6384`	`6388`	`}`