---

yaml
---
r: 161053
b: refs/heads/try
c: 6f422c4
h: refs/heads/master
i:
  161051: 364a758
v: v3

Author: barosl

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4eb72d268f337a8f117c86a2ac1b98336cab9e9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c9f6d696420107f82304b992cf623b806995fe18
-refs/heads/try: c8d6e3b2c2a780eff92299da5d1c02e081617088
+refs/heads/try: 6f422c4c05f4d108ba6429a174aa0c2ef3b183fa
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/reference.md

@@ -2513,6 +2513,11 @@ The currently implemented features of the reference compiler are:
                closure as `once` is unlikely to be supported going forward. So
                they are hidden behind this feature until they are to be removed.
 
+* `overloaded_calls` - Allow implementing the `Fn*` family of traits on user
+                       types, allowing overloading the call operator (`()`).
+                       This feature may still undergo changes before being
+                       stabilized.
+
 * `phase` - Usage of the `#[phase]` attribute allows loading compiler plugins
             for custom lints or syntax extensions. The implementation is
             considered unwholesome and in need of overhaul, and it is not clear
@@ -2555,8 +2560,11 @@ The currently implemented features of the reference compiler are:
 * `trace_macros` - Allows use of the `trace_macros` macro, which is a nasty
                    hack that will certainly be removed.
 
-* `unboxed_closures` - Rust's new closure design, which is currently a work in
-                       progress feature with many known bugs.
+* `unboxed_closure_sugar` - Allows using `|Foo| -> Bar` as a trait bound
+                            meaning one of the `Fn` traits. Still
+                            experimental.
+
+* `unboxed_closures` - A work in progress feature with many known bugs.
 
 * `unsafe_destructor` - Allows use of the `#[unsafe_destructor]` attribute,
                         which is considered wildly unsafe and will be

branches/try/src/librustc/diagnostics.rs

@@ -144,6 +144,5 @@ register_diagnostics!(
     E0165,
     E0166,
     E0167,
-    E0168,
-    E0169
+    E0168
 )

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

@@ -219,7 +219,7 @@ pub fn rust_path() -> Vec<Path> {
         }
         None => Vec::new()
     };
-    let mut cwd = os::getcwd();
+    let mut cwd = os::getcwd().unwrap();
     // now add in default entries
     let cwd_dot_rust = cwd.join(".rust");
     if !env_rust_path.contains(&cwd_dot_rust) {

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

@@ -294,7 +294,7 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region {
     match next(st) {
       'b' => {
         assert_eq!(next(st), '[');
-        let id = ty::DebruijnIndex::new(parse_uint(st));
+        let id = parse_uint(st) as ast::NodeId;
         assert_eq!(next(st), '|');
         let br = parse_bound_region(st, |x,y| conv(x,y));
         assert_eq!(next(st), ']');
@@ -579,6 +579,8 @@ fn parse_bare_fn_ty(st: &mut PState, conv: conv_did) -> ty::BareFnTy {
 
 fn parse_sig(st: &mut PState, conv: conv_did) -> ty::FnSig {
     assert_eq!(next(st), '[');
+    let id = parse_uint(st) as ast::NodeId;
+    assert_eq!(next(st), '|');
     let mut inputs = Vec::new();
     while peek(st) != ']' {
         inputs.push(parse_ty(st, |x,y| conv(x,y)));
@@ -596,7 +598,8 @@ fn parse_sig(st: &mut PState, conv: conv_did) -> ty::FnSig {
         }
         _ => ty::FnConverging(parse_ty(st, |x,y| conv(x,y)))
     };
-    ty::FnSig {inputs: inputs,
+    ty::FnSig {binder_id: id,
+               inputs: inputs,
                output: output,
                variadic: variadic}
 }

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

@@ -130,7 +130,7 @@ fn enc_region_substs(w: &mut SeekableMemWriter, cx: &ctxt, substs: &subst::Regio
 pub fn enc_region(w: &mut SeekableMemWriter, cx: &ctxt, r: ty::Region) {
     match r {
         ty::ReLateBound(id, br) => {
-            mywrite!(w, "b[{}|", id.depth);
+            mywrite!(w, "b[{}|", id);
             enc_bound_region(w, cx, br);
             mywrite!(w, "]");
         }
@@ -331,7 +331,7 @@ pub fn enc_closure_ty(w: &mut SeekableMemWriter, cx: &ctxt, ft: &ty::ClosureTy)
 }
 
 fn enc_fn_sig(w: &mut SeekableMemWriter, cx: &ctxt, fsig: &ty::FnSig) {
-    mywrite!(w, "[");
+    mywrite!(w, "[{}|", fsig.binder_id);
     for ty in fsig.inputs.iter() {
         enc_ty(w, cx, *ty);
     }

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

@@ -483,8 +483,8 @@ impl tr for def::Def {
 impl tr for ty::Region {
     fn tr(&self, dcx: &DecodeContext) -> ty::Region {
         match *self {
-            ty::ReLateBound(debruijn, br) => {
-                ty::ReLateBound(debruijn, br.tr(dcx))
+            ty::ReLateBound(id, br) => {
+                ty::ReLateBound(dcx.tr_id(id), br.tr(dcx))
             }
             ty::ReEarlyBound(id, space, index, ident) => {
                 ty::ReEarlyBound(dcx.tr_id(id), space, index, ident)

branches/try/src/librustc/middle/borrowck/mod.rs

@@ -65,8 +65,8 @@ pub type LoanDataFlow<'a, 'tcx> = DataFlowContext<'a, 'tcx, LoanDataFlowOperator
 
 impl<'a, 'tcx, 'v> Visitor<'v> for BorrowckCtxt<'a, 'tcx> {
     fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
-                b: &'v Block, s: Span, id: ast::NodeId) {
-        borrowck_fn(self, fk, fd, b, s, id);
+                b: &'v Block, s: Span, n: NodeId) {
+        borrowck_fn(self, fk, fd, b, s, n);
     }
 
     fn visit_item(&mut self, item: &ast::Item) {

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

@@ -139,8 +139,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MatchCheckCtxt<'a, 'tcx> {
         check_local(self, l);
     }
     fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
-                b: &'v Block, s: Span, n: NodeId) {
-        check_fn(self, fk, fd, b, s, n);
+                b: &'v Block, s: Span, _: NodeId) {
+        check_fn(self, fk, fd, b, s);
     }
 }
 
@@ -920,8 +920,7 @@ fn check_fn(cx: &mut MatchCheckCtxt,
             kind: FnKind,
             decl: &FnDecl,
             body: &Block,
-            sp: Span,
-            _: NodeId) {
+            sp: Span) {
     visit::walk_fn(cx, kind, decl, body, sp);
     for input in decl.inputs.iter() {
         is_refutable(cx, &*input.pat, |pat| {

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

@@ -187,8 +187,9 @@ fn live_node_kind_to_string(lnk: LiveNodeKind, cx: &ty::ctxt) -> String {
 }
 
 impl<'a, 'tcx, 'v> Visitor<'v> for IrMaps<'a, 'tcx> {
-    fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, id: ast::NodeId) {
-        visit_fn(self, fk, fd, b, s, id);
+    fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+                b: &'v Block, s: Span, n: NodeId) {
+        visit_fn(self, fk, fd, b, s, n);
     }
     fn visit_local(&mut self, l: &ast::Local) { visit_local(self, l); }
     fn visit_expr(&mut self, ex: &Expr) { visit_expr(self, ex); }
@@ -373,8 +374,9 @@ fn visit_fn(ir: &mut IrMaps,
             decl: &FnDecl,
             body: &Block,
             sp: Span,
-            id: ast::NodeId) {
-    debug!("visit_fn");
+            id: NodeId) {
+    debug!("visit_fn: id={}", id);
+    let _i = ::util::common::indenter();
 
     // swap in a new set of IR maps for this function body:
     let mut fn_maps = IrMaps::new(ir.tcx);

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

@@ -5038,10 +5038,10 @@ impl<'a> Resolver<'a> {
                 visit::walk_ty(self, ty);
             }
 
-            TyPolyTraitRef(ref bounds) => {
-                self.resolve_type_parameter_bounds(
+            TyPolyTraitRef(ref poly_trait_ref) => {
+                self.resolve_poly_trait_reference(
                     ty.id,
-                    bounds,
+                    &**poly_trait_ref,
                     TraitObject);
                 visit::walk_ty(self, ty);
             }