---

yaml
---
r: 44742
b: refs/heads/master
c: 194f29c
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 88f8868158c71b4bf2a563f2f77152c8696d2c87
+refs/heads/master: 194f29c20fb86fa163f35e9cd0540ae2b0d41b9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/etc/emacs/rust-mode.el

@@ -66,17 +66,22 @@
                     "trait" "struct" "fn" "enum"
                     "impl"))
       (puthash word 'def table))
-    (dolist (word '("as" "break"
-                    "copy" "do" "drop" "else"
-                    "extern" "for" "if" "let" "log"
-                    "loop" "once" "priv" "pub" "pure"
-                    "ref" "return" "static" "unsafe" "use"
-                    "while" "while"
-                    "assert"
-                    "mut"))
+    (dolist (word '("again" "assert"
+                    "break"
+                    "copy"
+                    "do" "drop"
+                    "else" "export" "extern"
+                    "fail" "for"
+                    "if" "use"
+                    "let" "log" "loop"
+                    "move" "new"
+                    "pure" "pub" "priv"
+                    "ref" "return" "static"
+                    "unchecked" "unsafe"
+                    "while"))
       (puthash word t table))
     (puthash "match" 'alt table)
-    (dolist (word '("self" "true" "false")) (puthash word 'atom table))
+    (dolist (word '("true" "false")) (puthash word 'atom table))
     table))
 ;; FIXME type-context keywords
 

trunk/src/etc/x86.supp

@@ -422,13 +422,6 @@
    ...
 }
 
-{
-   enum-instruction-scheduling-9
-   Memcheck:Cond
-   fun:*get_authority*
-   ...
-}
-
 {  
    llvm-user-new-leak
    Memcheck:Leak

trunk/src/libcore/iter.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -69,7 +69,7 @@ pub trait CopyableNonstrictIter<A:Copy> {
     pure fn each_val(&const self, f: &fn(A) -> bool);
 }
 
-// A trait for sequences that can be built by imperatively pushing elements
+// A trait for sequences that can be by imperatively pushing elements
 // onto them.
 pub trait Buildable<A> {
     /**
@@ -198,7 +198,7 @@ pub pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
 }
 
 // note: 'rposition' would only make sense to provide with a bidirectional
-// iter interface, such as would provide "reach" in addition to "each". As is,
+// iter interface, such as would provide "reach" in addition to "each". as is,
 // it would have to be implemented with foldr, which is too inefficient.
 
 #[inline(always)]
@@ -269,13 +269,13 @@ pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(A)))
 
 /**
  * Builds a sequence by calling a provided function with an argument
- * function that pushes an element to the back of the sequence.
+ * function that pushes an element to the back of a sequence.
  * This version takes an initial size for the sequence.
  *
  * # Arguments
  *
  * * size - An option, maybe containing initial size of the sequence
- *          to reserve.
+ *          to reserve
  * * builder - A function that will construct the sequence. It receives
  *             as an argument a function that will push an element
  *             onto the sequence being constructed.
@@ -290,7 +290,7 @@ pub pure fn build_sized_opt<A,B: Buildable<A>>(
 
 // Functions that combine iteration and building
 
-/// Applies a function to each element of an iterable and returns the results.
+/// Apply a function to each element of an iterable and return the results
 #[inline(always)]
 pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U)
     -> BU {
@@ -302,7 +302,7 @@ pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U)
 }
 
 /**
- * Creates and initializes a generic sequence from a function.
+ * Creates and initializes a generic sequence from a function
  *
  * Creates a generic sequence of size `n_elts` and initializes the elements
  * to the value returned by the function `op`.
@@ -317,7 +317,7 @@ pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint,
 }
 
 /**
- * Creates and initializes a generic sequence with some elements.
+ * Creates and initializes a generic sequence with some element
  *
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value `t`.
@@ -331,7 +331,7 @@ pub pure fn from_elem<T:Copy,BT:Buildable<T>>(n_elts: uint,
     }
 }
 
-/// Appends two generic sequences.
+/// Appending two generic sequences
 #[inline(always)]
 pub pure fn append<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>(
     lhs: &IT, rhs: &IT) -> BT {

trunk/src/libfuzzer/fuzzer.rc

@@ -134,7 +134,7 @@ pub pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool {
 
 pub fn safe_to_steal_ty(t: @ast::Ty, tm: test_mode) -> bool {
     // Restrictions happen to be the same.
-    safe_to_replace_ty(t.node, tm)
+    safe_to_replace_ty(&t.node, tm)
 }
 
 // Not type-parameterized: https://github.com/mozilla/rust/issues/898 (FIXED)
@@ -175,8 +175,8 @@ pub fn steal(crate: ast::crate, tm: test_mode) -> StolenStuff {
 }
 
 
-pub fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
-    match e {
+pub fn safe_to_replace_expr(e: &ast::expr_, _tm: test_mode) -> bool {
+    match *e {
       // https://github.com/mozilla/rust/issues/652
       ast::expr_if(*) => { false }
       ast::expr_block(_) => { false }
@@ -188,8 +188,8 @@ pub fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
     }
 }
 
-pub fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool {
-    match t {
+pub fn safe_to_replace_ty(t: &ast::ty_, _tm: test_mode) -> bool {
+    match *t {
       ast::ty_infer => { false } // always implicit, always top level
       ast::ty_bot => { false }   // in source, can only appear
                               // as the out type of a function
@@ -204,7 +204,7 @@ pub fn replace_expr_in_crate(crate: ast::crate, i: uint,
    ast::crate {
     let j: @mut uint = @mut 0u;
     fn fold_expr_rep(j_: @mut uint, i_: uint, newexpr_: ast::expr_,
-                     original: ast::expr_, fld: fold::ast_fold,
+                     original: &ast::expr_, fld: fold::ast_fold,
                      tm_: test_mode) ->
        ast::expr_ {
         *j_ += 1u;
@@ -221,7 +221,7 @@ pub fn replace_expr_in_crate(crate: ast::crate, i: uint,
         .. *fold::default_ast_fold()
     };
     let af = fold::make_fold(afp);
-    let crate2: @ast::crate = @af.fold_crate(crate);
+    let crate2: @ast::crate = @af.fold_crate(&crate);
     *crate2
 }
 
@@ -231,7 +231,7 @@ pub fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::Ty,
                            tm: test_mode) -> ast::crate {
     let j: @mut uint = @mut 0u;
     fn fold_ty_rep(j_: @mut uint, i_: uint, newty_: ast::ty_,
-                   original: ast::ty_, fld: fold::ast_fold,
+                   original: &ast::ty_, fld: fold::ast_fold,
                    tm_: test_mode) ->
        ast::ty_ {
         *j_ += 1u;
@@ -244,7 +244,7 @@ pub fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::Ty,
         .. *fold::default_ast_fold()
     };
     let af = fold::make_fold(afp);
-    let crate2: @ast::crate = @af.fold_crate(crate);
+    let crate2: @ast::crate = @af.fold_crate(&crate);
     *crate2
 }
 

trunk/src/librustc/driver/driver.rs

@@ -396,7 +396,7 @@ pub fn pretty_print_input(sess: Session, +cfg: ast::crate_cfg, input: input,
           pprust::node_block(s, ref blk) => {
             pp::space(s.s);
             pprust::synth_comment(
-                s, ~"block " + int::to_str((*blk).node.id));
+                s, ~"block " + int::to_str(blk.node.id));
           }
           pprust::node_expr(s, expr) => {
             pp::space(s.s);

trunk/src/librustc/driver/session.rs

@@ -358,7 +358,7 @@ pub mod test {
     pub fn make_crate_type_attr(+t: ~str) -> ast::attribute {
         codemap::respan(codemap::dummy_sp(), ast::attribute_ {
             style: ast::attr_outer,
-            value: codemap::respan(codemap::dummy_sp(),
+            value: @codemap::respan(codemap::dummy_sp(),
                 ast::meta_name_value(
                     @~"crate_type",
                     codemap::respan(codemap::dummy_sp(),

trunk/src/librustc/front/config.rs

@@ -45,7 +45,7 @@ pub fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
           .. *fold::default_ast_fold()};
 
     let fold = fold::make_fold(precursor);
-    let res = @fold.fold_crate(*crate);
+    let res = @fold.fold_crate(&*crate);
     return res;
 }
 
@@ -63,7 +63,7 @@ fn filter_view_item(cx: @Context, &&view_item: @ast::view_item
     }
 }
 
-fn fold_mod(cx: @Context, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
+fn fold_mod(cx: @Context, m: &ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     let filtered_items =
         m.items.filter_mapped(|a| filter_item(cx, *a));
     let filtered_view_items =
@@ -83,7 +83,7 @@ fn filter_foreign_item(cx: @Context, &&item: @ast::foreign_item) ->
 
 fn fold_foreign_mod(
     cx: @Context,
-    nm: ast::foreign_mod,
+    nm: &ast::foreign_mod,
     fld: fold::ast_fold
 ) -> ast::foreign_mod {
     let filtered_items =
@@ -98,21 +98,21 @@ fn fold_foreign_mod(
     }
 }
 
-fn fold_item_underscore(cx: @Context, +item: ast::item_,
+fn fold_item_underscore(cx: @Context, item: &ast::item_,
                         fld: fold::ast_fold) -> ast::item_ {
-    let item = match item {
-        ast::item_impl(a, b, c, methods) => {
+    let item = match *item {
+        ast::item_impl(ref a, b, c, ref methods) => {
             let methods = methods.filtered(|m| method_in_cfg(cx, *m) );
-            ast::item_impl(a, b, c, methods)
+            ast::item_impl(/*bad*/ copy *a, b, c, methods)
         }
         ast::item_trait(ref a, ref b, ref methods) => {
             let methods = methods.filtered(|m| trait_method_in_cfg(cx, m) );
             ast::item_trait(/*bad*/copy *a, /*bad*/copy *b, methods)
         }
-        item => item
+        ref item => /*bad*/ copy *item
     };
 
-    fold::noop_fold_item_underscore(item, fld)
+    fold::noop_fold_item_underscore(&item, fld)
 }
 
 fn filter_stmt(cx: @Context, &&stmt: @ast::stmt) ->
@@ -134,7 +134,7 @@ fn filter_stmt(cx: @Context, &&stmt: @ast::stmt) ->
 
 fn fold_block(
     cx: @Context,
-    b: ast::blk_,
+    b: &ast::blk_,
     fld: fold::ast_fold
 ) -> ast::blk_ {
     let filtered_stmts =

trunk/src/librustc/front/core_inject.rs

@@ -50,7 +50,7 @@ fn inject_libcore_ref(sess: Session,
                 attrs: ~[
                     spanned(ast::attribute_ {
                         style: ast::attr_inner,
-                        value: spanned(ast::meta_name_value(
+                        value: @spanned(ast::meta_name_value(
                             @~"vers",
                             spanned(ast::lit_str(@CORE_VERSION.to_str()))
                         )),
@@ -66,10 +66,13 @@ fn inject_libcore_ref(sess: Session,
                 view_items: vis,
                 ../*bad*/copy crate.module
             };
-            new_module = fld.fold_mod(new_module);
+            new_module = fld.fold_mod(&new_module);
 
             // FIXME #2543: Bad copy.
-            let new_crate = ast::crate_ { module: new_module, ..copy crate };
+            let new_crate = ast::crate_ {
+                module: new_module,
+                ..copy *crate
+            };
             (new_crate, span)
         },
         fold_mod: |module, fld| {
@@ -95,12 +98,15 @@ fn inject_libcore_ref(sess: Session,
             let vis = vec::append(~[vi2], module.view_items);
 
             // FIXME #2543: Bad copy.
-            let new_module = ast::_mod { view_items: vis, ..copy module };
-            fold::noop_fold_mod(new_module, fld)
+            let new_module = ast::_mod {
+                view_items: vis,
+                ..copy *module
+            };
+            fold::noop_fold_mod(&new_module, fld)
         },
         ..*fold::default_ast_fold()
     };
 
     let fold = fold::make_fold(precursor);
-    @fold.fold_crate(*crate)
+    @fold.fold_crate(crate)
 }

trunk/src/librustc/front/test.rs

@@ -91,7 +91,7 @@ fn generate_test_harness(sess: session::Session,
         fold_mod: |a,b| fold_mod(cx, a, b),.. *fold::default_ast_fold()};
 
     let fold = fold::make_fold(precursor);
-    let res = @fold.fold_crate(*crate);
+    let res = @fold.fold_crate(&*crate);
     cx.ext_cx.bt_pop();
     return res;
 }
@@ -106,7 +106,7 @@ fn strip_test_functions(crate: @ast::crate) -> @ast::crate {
 }
 
 fn fold_mod(cx: @mut TestCtxt,
-            m: ast::_mod,
+            m: &ast::_mod,
             fld: fold::ast_fold)
          -> ast::_mod {
     // Remove any #[main] from the AST so it doesn't clash with
@@ -125,19 +125,21 @@ fn fold_mod(cx: @mut TestCtxt,
         items: vec::map(m.items, |i| nomain(cx, *i)),
     };
 
-    fold::noop_fold_mod(mod_nomain, fld)
+    fold::noop_fold_mod(&mod_nomain, fld)
 }
 
 fn fold_crate(cx: @mut TestCtxt,
-              c: ast::crate_,
+              c: &ast::crate_,
               fld: fold::ast_fold)
            -> ast::crate_ {
     let folded = fold::noop_fold_crate(c, fld);
 
     // Add a special __test module to the crate that will contain code
     // generated for the test harness
-    ast::crate_ { module: add_test_module(cx, /*bad*/copy folded.module),
-                  .. folded }
+    ast::crate_ {
+        module: add_test_module(cx, &folded.module),
+        .. folded
+    }
 }
 
 
@@ -238,11 +240,11 @@ fn should_fail(i: @ast::item) -> bool {
     vec::len(attr::find_attrs_by_name(i.attrs, ~"should_fail")) > 0u
 }
 
-fn add_test_module(cx: &TestCtxt, +m: ast::_mod) -> ast::_mod {
+fn add_test_module(cx: &TestCtxt, m: &ast::_mod) -> ast::_mod {
     let testmod = mk_test_module(cx);
     ast::_mod {
         items: vec::append_one(/*bad*/copy m.items, testmod),
-        .. m
+        .. /*bad*/ copy *m
     }
 }