---

yaml
---
r: 112219
b: refs/heads/try
c: 829c00c
h: refs/heads/master
i:
  112217: 6a63165
  112215: 4102975
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a692e9b1234ff6573b0cfbc39394d9222eb38f81
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b5dd3f05fe95168b5569d0f519636149479eb6ac
-refs/heads/try: 72655677b173c5f77118b2535b22acaa94076f17
+refs/heads/try: 829c00cb09ac093307a6edc5bbca92c4ad9dbda2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/compiletest/header.rs

@@ -17,6 +17,8 @@ pub struct TestProps {
     pub error_patterns: Vec<~str> ,
     // Extra flags to pass to the compiler
     pub compile_flags: Option<~str>,
+    // Extra flags to pass when the compiled code is run (such as --bench)
+    pub run_flags: Option<~str>,
     // If present, the name of a file that this test should match when
     // pretty-printed
     pub pp_exact: Option<Path>,
@@ -42,6 +44,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut aux_builds = Vec::new();
     let mut exec_env = Vec::new();
     let mut compile_flags = None;
+    let mut run_flags = None;
     let mut pp_exact = None;
     let mut debugger_cmds = Vec::new();
     let mut check_lines = Vec::new();
@@ -58,6 +61,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
             compile_flags = parse_compile_flags(ln);
         }
 
+        if run_flags.is_none() {
+            run_flags = parse_run_flags(ln);
+        }
+
         if pp_exact.is_none() {
             pp_exact = parse_pp_exact(ln, testfile);
         }
@@ -96,9 +103,11 @@ pub fn load_props(testfile: &Path) -> TestProps {
 
         true
     });
-    return TestProps {
+
+    TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
+        run_flags: run_flags,
         pp_exact: pp_exact,
         aux_builds: aux_builds,
         exec_env: exec_env,
@@ -107,7 +116,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         force_host: force_host,
         check_stdout: check_stdout,
         no_prefer_dynamic: no_prefer_dynamic,
-    };
+    }
 }
 
 pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
@@ -160,6 +169,10 @@ fn parse_compile_flags(line: &str) -> Option<~str> {
     parse_name_value_directive(line, "compile-flags".to_owned())
 }
 
+fn parse_run_flags(line: &str) -> Option<~str> {
+    parse_name_value_directive(line, ~"run-flags")
+}
+
 fn parse_debugger_cmd(line: &str) -> Option<~str> {
     parse_name_value_directive(line, "debugger".to_owned())
 }

branches/try/src/compiletest/runtest.rs

@@ -835,14 +835,19 @@ fn make_exe_name(config: &config, testfile: &Path) -> Path {
     f
 }
 
-fn make_run_args(config: &config, _props: &TestProps, testfile: &Path) ->
+fn make_run_args(config: &config, props: &TestProps, testfile: &Path) ->
    ProcArgs {
     // If we've got another tool to run under (valgrind),
     // then split apart its command
     let mut args = split_maybe_args(&config.runtool);
     let exe_file = make_exe_name(config, testfile);
+
     // FIXME (#9639): This needs to handle non-utf8 paths
     args.push(exe_file.as_str().unwrap().to_owned());
+
+    // Add the arguments in the run_flags directive
+    args.push_all_move(split_maybe_args(&props.run_flags));
+
     let prog = args.shift().unwrap();
     return ProcArgs {prog: prog, args: args};
 }

branches/try/src/doc/tutorial.md

@@ -1883,8 +1883,8 @@ impl Shape {
 
 let s = Circle(Point { x: 1.0, y: 2.0 }, 3.0);
 
-(~s).draw_owned();
 (&s).draw_reference();
+(~s).draw_owned();
 s.draw_value();
 ~~~
 

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

@@ -16,7 +16,7 @@
 //! enabled.
 //!
 //! Features are enabled in programs via the crate-level attributes of
-//! #[feature(...)] with a comma-separated list of features.
+//! #![feature(...)] with a comma-separated list of features.
 
 use middle::lint;
 
@@ -324,7 +324,7 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
         match attr.meta_item_list() {
             None => {
                 sess.span_err(attr.span, "malformed feature attribute, \
-                                          expected #[feature(...)]");
+                                          expected #![feature(...)]");
             }
             Some(list) => {
                 for &mi in list.iter() {

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

@@ -137,8 +137,7 @@ pub fn parse_substs_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx:
     parse_substs(&mut st, conv)
 }
 
-fn parse_vstore<M>(st: &mut PState, conv: conv_did,
-                   parse_mut: |&mut PState| -> M) -> ty::Vstore<M> {
+fn parse_vstore(st: &mut PState, conv: conv_did) -> ty::Vstore {
     assert_eq!(next(st), '/');
 
     let c = peek(st);
@@ -150,11 +149,24 @@ fn parse_vstore<M>(st: &mut PState, conv: conv_did,
 
     match next(st) {
         '~' => ty::VstoreUniq,
-        '&' => ty::VstoreSlice(parse_region(st, conv), parse_mut(st)),
+        '&' => ty::VstoreSlice(parse_region(st, conv)),
         c => st.tcx.sess.bug(format!("parse_vstore(): bad input '{}'", c))
     }
 }
 
+fn parse_size(st: &mut PState) -> Option<uint> {
+    assert_eq!(next(st), '/');
+
+    if peek(st) == '|' {
+        assert_eq!(next(st), '|');
+        None
+    } else {
+        let n = parse_uint(st);
+        assert_eq!(next(st), '|');
+        Some(n)
+    }
+}
+
 fn parse_trait_store(st: &mut PState, conv: conv_did) -> ty::TraitStore {
     match next(st) {
         '~' => ty::UniqTraitStore,
@@ -342,12 +354,12 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         return ty::mk_rptr(st.tcx, r, mt);
       }
       'V' => {
-        let ty = parse_ty(st, |x,y| conv(x,y));
-        let v = parse_vstore(st, |x,y| conv(x,y), parse_mutability);
-        return ty::mk_vec(st.tcx, ty, v);
+        let mt = parse_mt(st, |x,y| conv(x,y));
+        let sz = parse_size(st);
+        return ty::mk_vec(st.tcx, mt, sz);
       }
       'v' => {
-        let v = parse_vstore(st, |x,y| conv(x,y), |_| ());
+        let v = parse_vstore(st, |x,y| conv(x,y));
         return ty::mk_str(st.tcx, v);
       }
       'T' => {
@@ -396,7 +408,7 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
           assert_eq!(next(st), ']');
           return ty::mk_struct(st.tcx, did, substs);
       }
-      c => { error!("unexpected char in type string: {}", c); fail!();}
+      c => { fail!("unexpected char in type string: {}", c);}
     }
 }
 

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

@@ -204,17 +204,17 @@ fn enc_bound_region(w: &mut MemWriter, cx: &ctxt, br: ty::BoundRegion) {
     }
 }
 
-pub fn enc_vstore<M>(w: &mut MemWriter, cx: &ctxt,
-                     v: ty::Vstore<M>,
-                     enc_mut: |&mut MemWriter, M|) {
+pub fn enc_vstore(w: &mut MemWriter, cx: &ctxt,
+                  v: ty::Vstore,
+                  enc_mut: |&mut MemWriter|) {
     mywrite!(w, "/");
     match v {
         ty::VstoreFixed(u) => mywrite!(w, "{}|", u),
         ty::VstoreUniq => mywrite!(w, "~"),
-        ty::VstoreSlice(r, m) => {
+        ty::VstoreSlice(r) => {
             mywrite!(w, "&");
             enc_region(w, cx, r);
-            enc_mut(w, m);
+            enc_mut(w);
         }
     }
 }
@@ -292,14 +292,18 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
             enc_region(w, cx, r);
             enc_mt(w, cx, mt);
         }
-        ty::ty_vec(ty, v) => {
+        ty::ty_vec(mt, sz) => {
             mywrite!(w, "V");
-            enc_ty(w, cx, ty);
-            enc_vstore(w, cx, v, enc_mutability);
+            enc_mt(w, cx, mt);
+            mywrite!(w, "/");
+            match sz {
+                Some(n) => mywrite!(w, "{}|", n),
+                None => mywrite!(w, "|"),
+            }
         }
         ty::ty_str(v) => {
             mywrite!(w, "v");
-            enc_vstore(w, cx, v, |_, ()| {});
+            enc_vstore(w, cx, v, |_| {});
         }
         ty::ty_closure(ref f) => {
             mywrite!(w, "f");