---

yaml
---
r: 146067
b: refs/heads/try2
c: ebb9b46
h: refs/heads/master
i:
  146065: a2f9f75
  146063: 88f761c
v: v3

Author: bors

[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: 45334326127285e9442ae1c3e9f4ba9c428ec3c6
+refs/heads/try2: ebb9b461914347950592f9a2d4e53e324f2f1238
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -34,6 +34,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("macro_rules", Active),
     ("struct_variant", Active),
     ("once_fns", Active),
+    ("asm", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -108,26 +109,29 @@ impl Visitor<()> for Context {
                 }
             }
 
-            ast::item_mac(ref mac) => {
-                match mac.node {
-                    ast::mac_invoc_tt(ref path, _, _) => {
-                        let rules = self.sess.ident_of("macro_rules");
-                        if path.segments.last().identifier == rules {
-                            self.gate_feature("macro_rules", i.span,
-                                              "macro definitions are not \
-                                               stable enough for use and are \
-                                               subject to change");
-                        }
-                    }
-                }
-            }
-
             _ => {}
         }
 
         visit::walk_item(self, i, ());
     }
 
+    fn visit_mac(&mut self, macro: &ast::mac, _: ()) {
+        let ast::mac_invoc_tt(ref path, _, _) = macro.node;
+
+        if path.segments.last().identifier == self.sess.ident_of("macro_rules") {
+            self.gate_feature("macro_rules", path.span, "macro definitions are \
+                not stable enough for use and are subject to change");
+        }
+
+        else if path.segments.last().identifier == self.sess.ident_of("asm") {
+            // NOTE: remove the false once the ASM feature is in the next snapshot
+            if false {
+                self.gate_feature("asm", path.span, "inline assembly is not \
+                    stable enough for use and is subject to change");
+            }
+        }
+    }
+
     fn visit_ty(&mut self, t: &ast::Ty, _: ()) {
         match t.node {
             ast::ty_closure(closure) if closure.onceness == ast::Once => {

branches/try2/src/libstd/rt/io/stdio.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use fmt;
 use libc;
 use option::{Option, Some, None};
 use result::{Ok, Err};
@@ -56,7 +57,9 @@ pub fn stderr() -> StdWriter {
 pub fn print(s: &str) {
     // XXX: need to see if not caching stdin() is the cause of performance
     //      issues, it should be possible to cache a stdout handle in each Task
-    //      and then re-use that across calls to print/println
+    //      and then re-use that across calls to print/println. Note that the
+    //      resolution of this comment will affect all of the prints below as
+    //      well.
     stdout().write(s.as_bytes());
 }
 
@@ -68,6 +71,20 @@ pub fn println(s: &str) {
     out.write(['\n' as u8]);
 }
 
+/// Similar to `print`, but takes a `fmt::Arguments` structure to be compatible
+/// with the `format_args!` macro.
+pub fn print_args(fmt: &fmt::Arguments) {
+    let mut out = stdout();
+    fmt::write(&mut out as &mut Writer, fmt);
+}
+
+/// Similar to `println`, but takes a `fmt::Arguments` structure to be
+/// compatible with the `format_args!` macro.
+pub fn println_args(fmt: &fmt::Arguments) {
+    let mut out = stdout();
+    fmt::writeln(&mut out as &mut Writer, fmt);
+}
+
 /// Representation of a reader of a standard input stream
 pub struct StdReader {
     priv inner: ~RtioFileStream

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

@@ -999,16 +999,11 @@ pub fn std_macros() -> @str {
     macro_rules! writeln(($dst:expr, $($arg:tt)*) => (
         format_args!(|args| { ::std::fmt::writeln($dst, args) }, $($arg)*)
     ))
-    // FIXME(#6846) once stdio is redesigned, this shouldn't perform an
-    //              allocation but should rather delegate to an invocation of
-    //              write! instead of format!
     macro_rules! print (
-        ($($arg:tt)*) => (::std::io::print(format!($($arg)*)))
+        ($($arg:tt)*) => (format_args!(::std::rt::io::stdio::print_args, $($arg)*))
     )
-    // FIXME(#6846) once stdio is redesigned, this shouldn't perform an
-    //              allocation but should rather delegate to an io::Writer
     macro_rules! println (
-        ($($arg:tt)*) => (::std::io::println(format!($($arg)*)))
+        ($($arg:tt)*) => (format_args!(::std::rt::io::stdio::println_args, $($arg)*))
     )
 
     macro_rules! local_data_key (

branches/try2/src/libsyntax/visit.rs

@@ -90,6 +90,7 @@ pub trait Visitor<E:Clone> {
         walk_struct_def(self, s, i, g, n, e)
     }
     fn visit_struct_field(&mut self, s:@struct_field, e:E) { walk_struct_field(self, s, e) }
+    fn visit_mac(&mut self, m:&mac, e:E) { walk_mac(self, m, e); }
 }
 
 impl<E:Clone> Visitor<E> for @mut Visitor<E> {
@@ -150,6 +151,9 @@ impl<E:Clone> Visitor<E> for @mut Visitor<E> {
     fn visit_struct_field(&mut self, a:@struct_field, e:E) {
         (*self).visit_struct_field(a, e)
     }
+    fn visit_mac(&mut self, macro:&mac, e:E) {
+        (*self).visit_mac(macro, e);
+    }
 }
 
 pub fn walk_crate<E:Clone, V:Visitor<E>>(visitor: &mut V, crate: &Crate, env: E) {
@@ -247,7 +251,7 @@ pub fn walk_item<E:Clone, V:Visitor<E>>(visitor: &mut V, item: &item, env: E) {
                 visitor.visit_trait_method(method, env.clone())
             }
         }
-        item_mac(ref macro) => walk_mac(visitor, macro, env),
+        item_mac(ref macro) => visitor.visit_mac(macro, env),
     }
 }
 
@@ -507,7 +511,7 @@ pub fn walk_stmt<E:Clone, V:Visitor<E>>(visitor: &mut V, statement: &Stmt, env:
         StmtExpr(expression, _) | StmtSemi(expression, _) => {
             visitor.visit_expr(expression, env)
         }
-        StmtMac(ref macro, _) => walk_mac(visitor, macro, env),
+        StmtMac(ref macro, _) => visitor.visit_mac(macro, env),
     }
 }
 
@@ -644,7 +648,7 @@ pub fn walk_expr<E:Clone, V:Visitor<E>>(visitor: &mut V, expression: @Expr, env:
             walk_expr_opt(visitor, optional_expression, env.clone())
         }
         ExprLogLevel => {}
-        ExprMac(ref macro) => walk_mac(visitor, macro, env.clone()),
+        ExprMac(ref macro) => visitor.visit_mac(macro, env.clone()),
         ExprParen(subexpression) => {
             visitor.visit_expr(subexpression, env.clone())
         }

branches/try2/src/test/compile-fail/asm-gated.rs

@@ -0,0 +1,17 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-test
+
+fn main() {
+    unsafe {
+        asm!(""); //~ ERROR inline assembly is not stable enough
+    }
+}