---

yaml
---
r: 170735
b: refs/heads/try
c: 8a6d7a6
h: refs/heads/master
i:
  170733: eabb228
  170731: ecfab05
  170727: 9c6b74e
  170719: 9b940d2
v: v3

Author: Jorge Aparicio

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 73a25f55ad748b4d3516417c711b99ce446591af
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 5b3cd3900ceda838f5798c30ab96ceb41f962534
-refs/heads/try: 4e9c50e081f92cbf45df7f8ecbff3b05e26abf36
+refs/heads/try: 8a6d7a68b17542f67086d014720d13e3dc320d51
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/librustc/metadata/tydecode.rs

@@ -506,9 +506,6 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
         st.pos = st.pos + 1u;
         return ty::mk_tup(tcx, params);
       }
-      'f' => {
-        return ty::mk_closure(tcx, parse_closure_ty_(st, conv));
-      }
       'F' => {
           let def_id = parse_def_(st, NominalType, conv);
           return ty::mk_bare_fn(tcx, Some(def_id),

branches/try/src/librustc/middle/ty.rs

@@ -2738,10 +2738,6 @@ pub fn mk_nil<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> {
     mk_tup(cx, Vec::new())
 }
 
-pub fn mk_closure<'tcx>(cx: &ctxt<'tcx>, fty: ClosureTy<'tcx>) -> Ty<'tcx> {
-    panic!("stub");
-}
-
 pub fn mk_bare_fn<'tcx>(cx: &ctxt<'tcx>,
                         opt_def_id: Option<ast::DefId>,
                         fty: &'tcx BareFnTy<'tcx>) -> Ty<'tcx> {

branches/try/src/librustc_driver/test.rs

@@ -277,26 +277,6 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
         ty::mk_tup(self.infcx.tcx, vec![ty1, ty2])
     }
 
-    pub fn t_closure(&self,
-                     input_tys: &[Ty<'tcx>],
-                     output_ty: Ty<'tcx>,
-                     region_bound: ty::Region)
-                     -> Ty<'tcx>
-    {
-        ty::mk_closure(self.infcx.tcx, ty::ClosureTy {
-            unsafety: ast::Unsafety::Normal,
-            onceness: ast::Many,
-            store: ty::RegionTraitStore(region_bound, ast::MutMutable),
-            bounds: ty::region_existential_bound(region_bound),
-            sig: ty::Binder(ty::FnSig {
-                inputs: input_tys.to_vec(),
-                output: ty::FnConverging(output_ty),
-                variadic: false,
-            }),
-            abi: abi::Rust,
-        })
-    }
-
     pub fn t_param(&self, space: subst::ParamSpace, index: u32) -> Ty<'tcx> {
         let name = format!("T{}", index);
         ty::mk_param(self.infcx.tcx, space, index, token::intern(name[]))
@@ -780,19 +760,6 @@ fn escaping() {
         assert!(!ty::type_has_escaping_regions(t_param));
         let t_fn = env.t_fn(&[t_param], env.t_nil());
         assert!(!ty::type_has_escaping_regions(t_fn));
-
-        // t_fn = |&int|+'a
-        let t_fn = env.t_closure(&[t_rptr_bound1], env.t_nil(), env.re_free(0, 1));
-        assert!(!ty::type_has_escaping_regions(t_fn));
-
-        // t_fn = |&int|+'a (where &int has depth 2)
-        let t_fn = env.t_closure(&[t_rptr_bound2], env.t_nil(), env.re_free(0, 1));
-        assert!(ty::type_has_escaping_regions(t_fn));
-
-        // t_fn = |&int|+&int
-        let t_fn = env.t_closure(&[t_rptr_bound1], env.t_nil(),
-                                 env.re_late_bound_with_debruijn(1, ty::DebruijnIndex::new(1)));
-        assert!(ty::type_has_escaping_regions(t_fn));
     })
 }
 

branches/try/src/librustc_trans/trans/closure.rs

@@ -530,7 +530,6 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
     // of the closure expression.
     let typer = NormalizingUnboxedClosureTyper::new(bcx.tcx());
     let function_type = typer.unboxed_closure_type(closure_id, bcx.fcx.param_substs);
-    let function_type = ty::mk_closure(bcx.tcx(), function_type);
 
     let freevars: Vec<ty::Freevar> =
         ty::with_freevars(bcx.tcx(), id, |fv| fv.iter().map(|&fv| fv).collect());
@@ -543,8 +542,8 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
                   bcx.fcx.param_substs,
                   id,
                   &[],
-                  ty::ty_fn_ret(function_type),
-                  ty::ty_fn_abi(function_type),
+                  function_type.sig.0.output,
+                  function_type.abi,
                   ClosureEnv::new(freevars[],
                                   UnboxedClosure(freevar_mode)));
 

branches/try/src/librustc_typeck/check/closure.rs

@@ -316,7 +316,7 @@ fn check_boxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
                                        abi::Rust,
                                        expected_sig);
     let fn_sig = fn_ty.sig.clone();
-    let fty = ty::mk_closure(tcx, fn_ty);
+    let fty = panic!("stub");
     debug!("check_expr_fn fty={}", fcx.infcx().ty_to_string(fty));
 
     fcx.write_ty(expr.id, fty);