---

yaml
---
r: 146342
b: refs/heads/try2
c: f27272d
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 1bbd4afb4ae5503bc04a7f500bc8ade6e1db0854
+refs/heads/try2: f27272d60f193c6d27cc283f48c5be0e41562814
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -401,9 +401,9 @@ valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 valopt libdir "${CFG_PREFIX}/lib" "install libraries" 
 
 #Deprecated opts to keep compatibility
-valopt build-triple "${CFG_BUILD}" "LLVM build triple"
-valopt host-triples "${CFG_HOST}" "LLVM host triples"
-valopt target-triples "${CFG_TARGET}" "LLVM target triples"
+valopt build-triple "${DEFAULT_BUILD}" "LLVM build triple"
+valopt host-triples "${CFG_BUILD}" "LLVM host triples"
+valopt target-triples "${CFG_HOST}" "LLVM target triples"
 
 # Validate Options
 step_msg "validating $CFG_SELF args"

branches/try2/doc/rust.md

@@ -568,7 +568,6 @@ This requirement most often affects name-designator pairs when they occur at the
 * `log_syntax!` : print out the arguments at compile time
 * `trace_macros!` : supply `true` or `false` to enable or disable macro expansion logging
 * `stringify!` : turn the identifier argument into a string literal
-* `concat!` : concatenates a comma-separated list of literals
 * `concat_idents!` : create a new identifier by concatenating the arguments
 
 # Crates and source files

branches/try2/doc/tutorial.md

@@ -1142,7 +1142,7 @@ For a more in-depth explanation of borrowed pointers, read the
 
 ## Freezing
 
-Lending an immutable pointer to an object freezes it and prevents mutation.
+Borrowing an immutable pointer to an object freezes it and prevents mutation.
 `Owned` objects have freezing enforced statically at compile-time.
 
 ~~~~

branches/try2/src/librustc/front/feature_gate.rs

@@ -140,12 +140,12 @@ impl Visitor<()> for Context {
 
             },
             ast::ty_box(_) => {
-                self.gate_feature("managed_boxes", t.span,
-                                  "The managed box syntax will be replaced \
-                                  by a library type, and a garbage \
-                                  collector is not yet implemented. \
-                                  Consider using the `std::rc::Rc` type \
-                                  for reference counted pointers.");
+                self.gate_feature("managed_boxes", t.span, "The managed box syntax may be replaced \
+                                                            by a library type, and a garbage \
+                                                            collector is not yet implemented. \
+                                                            Consider using the `std::rc` module \
+                                                            as it performs much better as a \
+                                                            reference counting implementation.");
             }
             _ => {}
         }

branches/try2/src/librustc/util/ppaux.rs

@@ -308,10 +308,11 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
                       ident: Option<ast::Ident>,
                       sig: &ty::FnSig)
                       -> ~str {
-        let mut s = ~"extern ";
-
-        s.push_str(abis.to_str());
-        s.push_char(' ');
+        let mut s = if abis.is_rust() {
+            ~""
+        } else {
+            format!("extern {} ", abis.to_str())
+        };
 
         match purity {
             ast::impure_fn => {}
@@ -331,16 +332,16 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
           _ => { }
         }
 
-        push_sig_to_str(cx, &mut s, sig);
+        push_sig_to_str(cx, &mut s, '(', ')', sig);
 
         return s;
     }
-    fn closure_to_str(cx: ctxt, cty: &ty::ClosureTy) -> ~str
-    {
+    fn closure_to_str(cx: ctxt, cty: &ty::ClosureTy) -> ~str {
         let is_proc =
             (cty.sigil, cty.onceness) == (ast::OwnedSigil, ast::Once);
+        let is_borrowed_closure = cty.sigil == ast::BorrowedSigil;
 
-        let mut s = if is_proc {
+        let mut s = if is_proc || is_borrowed_closure {
             ~""
         } else {
             cty.sigil.to_str()
@@ -374,23 +375,42 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
                 }
             };
 
-            s.push_str("fn");
+            if !is_borrowed_closure {
+                s.push_str("fn");
+            }
         }
 
-        if !cty.bounds.is_empty() {
-            s.push_str(":");
-        }
-        s.push_str(cty.bounds.repr(cx));
+        if !is_borrowed_closure {
+            // Print bounds before `fn` if this is not a borrowed closure.
+            if !cty.bounds.is_empty() {
+                s.push_str(":");
+                s.push_str(cty.bounds.repr(cx));
+            }
+
+            push_sig_to_str(cx, &mut s, '(', ')', &cty.sig);
+        } else {
+            // Print bounds after the signature if this is a borrowed closure.
+            push_sig_to_str(cx, &mut s, '|', '|', &cty.sig);
 
-        push_sig_to_str(cx, &mut s, &cty.sig);
+            if is_borrowed_closure {
+                if !cty.bounds.is_empty() {
+                    s.push_str(":");
+                    s.push_str(cty.bounds.repr(cx));
+                }
+            }
+        }
 
         return s;
     }
-    fn push_sig_to_str(cx: ctxt, s: &mut ~str, sig: &ty::FnSig) {
-        s.push_char('(');
+    fn push_sig_to_str(cx: ctxt,
+                       s: &mut ~str,
+                       bra: char,
+                       ket: char,
+                       sig: &ty::FnSig) {
+        s.push_char(bra);
         let strs = sig.inputs.map(|a| fn_input_to_str(cx, *a));
         s.push_str(strs.connect(", "));
-        s.push_char(')');
+        s.push_char(ket);
         if ty::get(sig.output).sty != ty_nil {
             s.push_str(" -> ");
             if ty::type_is_bot(sig.output) {

branches/try2/src/libsyntax/ext/base.rs

@@ -14,7 +14,6 @@ use codemap;
 use codemap::{CodeMap, Span, ExpnInfo};
 use diagnostic::span_handler;
 use ext;
-use ext::expand;
 use parse;
 use parse::token;
 use parse::token::{ident_to_str, intern, str_to_ident};
@@ -247,9 +246,6 @@ pub fn syntax_expander_table() -> SyntaxEnv {
     syntax_expanders.insert(intern("concat_idents"),
                             builtin_normal_tt_no_ctxt(
                                     ext::concat_idents::expand_syntax_ext));
-    syntax_expanders.insert(intern("concat"),
-                            builtin_normal_tt_no_ctxt(
-                                    ext::concat::expand_syntax_ext));
     syntax_expanders.insert(intern(&"log_syntax"),
                             builtin_normal_tt_no_ctxt(
                                     ext::log_syntax::expand_syntax_ext));
@@ -342,22 +338,6 @@ impl ExtCtxt {
         }
     }
 
-    pub fn expand_expr(@self, mut e: @ast::Expr) -> @ast::Expr {
-        loop {
-            match e.node {
-                ast::ExprMac(*) => {
-                    let extsbox = @mut syntax_expander_table();
-                    let expander = expand::MacroExpander {
-                        extsbox: extsbox,
-                        cx: self,
-                    };
-                    e = expand::expand_expr(extsbox, self, e, &expander);
-                }
-                _ => return e
-            }
-        }
-    }
-
     pub fn codemap(&self) -> @CodeMap { self.parse_sess.cm }
     pub fn parse_sess(&self) -> @mut parse::ParseSess { self.parse_sess }
     pub fn cfg(&self) -> ast::CrateConfig { self.cfg.clone() }

branches/try2/src/libsyntax/ext/concat.rs

@@ -1083,7 +1083,7 @@ struct NoOpFolder {
 
 impl ast_fold for NoOpFolder {}
 
-pub struct MacroExpander {
+struct MacroExpander {
     extsbox: @mut SyntaxEnv,
     cx: @ExtCtxt,
 }

branches/try2/src/libsyntax/ext/expand.rs

@@ -735,10 +735,8 @@ pub fn expand_args(ecx: @ExtCtxt, sp: Span,
         (_, None) => { return MRExpr(ecx.expr_uint(sp, 2)); }
     };
     cx.fmtsp = efmt.span;
-    // Be sure to recursively expand macros just in case the format string uses
-    // a macro to build the format expression.
-    let (fmt, _) = expr_to_str(ecx, ecx.expand_expr(efmt),
-                               "format argument must be a string literal.");
+    let (fmt, _fmt_str_style) = expr_to_str(ecx, efmt,
+                                            "format argument must be a string literal.");
 
     let mut err = false;
     do parse::parse_error::cond.trap(|m| {