---

yaml
---
r: 47868
b: refs/heads/incoming
c: 9dae4cf
h: refs/heads/master
v: v3

Author: bblum

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 48c1c3cfc076bf155c1e54afa41ec560b343f52d
+refs/heads/incoming: 9dae4cf1f0f2fd82ee653d89abc46d349b6e6caa
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/compiletest/common.rs

@@ -21,7 +21,7 @@ pub enum mode {
     mode_debug_info,
 }
 
-pub struct config {
+pub type config = {
     // The library paths required for running the compiler
     compile_lib_path: ~str,
 
@@ -68,4 +68,4 @@ pub struct config {
     // Explain what's going on
     verbose: bool
 
-}
+};

branches/incoming/src/compiletest/compiletest.rc

@@ -11,6 +11,7 @@
 #[crate_type = "bin"];
 
 #[no_core];
+#[legacy_records];
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
@@ -76,28 +77,26 @@ pub fn parse_config(args: ~[~str]) -> config {
         Path(getopts::opt_str(m, nm))
     }
 
-    config {
-        compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
-        run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
-        rustc_path: opt_path(matches, ~"rustc-path"),
-        src_base: opt_path(matches, ~"src-base"),
-        build_base: opt_path(matches, ~"build-base"),
-        aux_base: opt_path(matches, ~"aux-base"),
-        stage_id: getopts::opt_str(matches, ~"stage-id"),
-        mode: str_mode(getopts::opt_str(matches, ~"mode")),
-        run_ignored: getopts::opt_present(matches, ~"ignored"),
-        filter:
+    return {compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
+         run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
+         rustc_path: opt_path(matches, ~"rustc-path"),
+         src_base: opt_path(matches, ~"src-base"),
+         build_base: opt_path(matches, ~"build-base"),
+         aux_base: opt_path(matches, ~"aux-base"),
+         stage_id: getopts::opt_str(matches, ~"stage-id"),
+         mode: str_mode(getopts::opt_str(matches, ~"mode")),
+         run_ignored: getopts::opt_present(matches, ~"ignored"),
+         filter:
              if vec::len(matches.free) > 0u {
                  option::Some(matches.free[0])
              } else { option::None },
-        logfile: option::map(&getopts::opt_maybe_str(matches,
+         logfile: option::map(&getopts::opt_maybe_str(matches,
                                                      ~"logfile"),
-                             |s| Path(*s)),
-        runtool: getopts::opt_maybe_str(matches, ~"runtool"),
-        rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
-        jit: getopts::opt_present(matches, ~"jit"),
-        verbose: getopts::opt_present(matches, ~"verbose")
-    }
+                              |s| Path(*s)),
+         runtool: getopts::opt_maybe_str(matches, ~"runtool"),
+         rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
+         jit: getopts::opt_present(matches, ~"jit"),
+         verbose: getopts::opt_present(matches, ~"verbose")};
 }
 
 pub fn log_config(config: config) {

branches/incoming/src/libcore/private.rs

@@ -493,7 +493,7 @@ pub mod tests {
         res.recv();
     }
 
-    #[test] #[should_fail] #[ignore(reason = "random red")]
+    #[test] #[should_fail] #[ignore(cfg(windows))]
     pub fn exclusive_unwrap_conflict() {
         let x = exclusive(~~"hello");
         let x2 = ~mut Some(x.clone());
@@ -505,7 +505,8 @@ pub mod tests {
         }
         assert unwrap_exclusive(x) == ~~"hello";
         let res = option::swap_unwrap(&mut res);
-        res.recv();
+        // See #4689 for why this can't be just "res.recv()".
+        assert res.recv() == task::Success;
     }
 
     #[test] #[ignore(cfg(windows))]

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

@@ -1278,13 +1278,13 @@ fn test_simplification() {
     let item_in = ast::ii_item(quote_item!(
         fn new_int_alist<B:Copy>() -> alist<int, B> {
             fn eq_int(&&a: int, &&b: int) -> bool { a == b }
-            return alist {eq_fn: eq_int, data: ~[]};
+            return {eq_fn: eq_int, data: ~[]};
         }
     ).get());
     let item_out = simplify_ast(item_in);
     let item_exp = ast::ii_item(quote_item!(
         fn new_int_alist<B:Copy>() -> alist<int, B> {
-            return alist {eq_fn: eq_int, data: ~[]};
+            return {eq_fn: eq_int, data: ~[]};
         }
     ).get());
     match (item_out, item_exp) {

branches/incoming/src/librustc/middle/lint.rs

@@ -706,21 +706,23 @@ fn check_item_deprecated_self(cx: ty::ctxt, item: @ast::item) {
 }
 
 fn check_item_structural_records(cx: ty::ctxt, it: @ast::item) {
-    let visit = item_stopping_visitor(
-        visit::mk_simple_visitor(@visit::SimpleVisitor {
-            visit_expr: |e: @ast::expr| {
-                match e.node {
-                    ast::expr_rec(*) =>
-                        cx.sess.span_lint(
-                            structural_records, e.id, it.id,
-                            e.span,
-                            ~"structural records are deprecated"),
-                    _ => ()
-                }
-            },
-            .. *visit::default_simple_visitor()
-        }));
-    visit::visit_item(it, (), visit);
+    if !cx.legacy_records {
+        let visit = item_stopping_visitor(
+            visit::mk_simple_visitor(@visit::SimpleVisitor {
+                visit_expr: |e: @ast::expr| {
+                    match e.node {
+                        ast::expr_rec(*) =>
+                            cx.sess.span_lint(
+                                structural_records, e.id, it.id,
+                                e.span,
+                                ~"structural records are deprecated"),
+                        _ => ()
+                    }
+                },
+                .. *visit::default_simple_visitor()
+            }));
+        visit::visit_item(it, (), visit);
+    }
 }
 
 fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {

branches/incoming/src/librustc/middle/ty.rs

@@ -233,6 +233,7 @@ struct ctxt_ {
     mut next_id: uint,
     vecs_implicitly_copyable: bool,
     legacy_modes: bool,
+    legacy_records: bool,
     cstore: @mut metadata::cstore::CStore,
     sess: session::Session,
     def_map: resolve::DefMap,
@@ -788,10 +789,16 @@ pub fn mk_ctxt(s: session::Session,
                crate: @ast::crate)
             -> ctxt {
     let mut legacy_modes = false;
+    let mut legacy_records = false;
     for crate.node.attrs.each |attribute| {
         match attribute.node.value.node {
             ast::meta_word(w) if *w == ~"legacy_modes" => {
                 legacy_modes = true;
+                if legacy_records { break; }
+            }
+            ast::meta_word(w) if *w == ~"legacy_records" => {
+                legacy_records = true;
+                if legacy_modes { break; }
             }
             _ => {}
         }
@@ -807,6 +814,7 @@ pub fn mk_ctxt(s: session::Session,
         mut next_id: 0u,
         vecs_implicitly_copyable: vecs_implicitly_copyable,
         legacy_modes: legacy_modes,
+        legacy_records: legacy_records,
         cstore: s.cstore,
         sess: s,
         def_map: dm,

branches/incoming/src/librusti/rusti.rc

@@ -17,6 +17,7 @@
 
 #[crate_type = "lib"];
 
+#[legacy_records];
 #[no_core];
 
 #[allow(vecs_implicitly_copyable,

branches/incoming/src/librusti/wrapper.rs

@@ -16,6 +16,7 @@
 #[allow(non_implicitly_copyable_typarams)];
 #[allow(owned_heap_memory)];
 #[allow(path_statement)];
+#[allow(structural_records)];
 #[allow(unrecognized_lint)];
 #[allow(unused_imports)];
 #[allow(vecs_implicitly_copyable)];

branches/incoming/src/librustpkg/rustpkg.rc

@@ -20,6 +20,8 @@
 #[allow(vecs_implicitly_copyable,
         non_implicitly_copyable_typarams)];
 
+#[legacy_records];
+
 extern mod core(vers = "0.6");
 extern mod std(vers = "0.6");
 extern mod rustc(vers = "0.6");

branches/incoming/src/libsyntax/parse/parser.rs

@@ -1926,7 +1926,7 @@ pub impl Parser {
             fields.push(self.parse_field(token::COLON));
         }
         self.expect(token::RBRACE);
-        self.warn(~"REC");
+        //self.warn(~"REC");
         return expr_rec(fields, base);
     }
 

branches/incoming/src/test/bench/pingpong.rs

@@ -10,6 +10,8 @@
 
 // Compare bounded and unbounded protocol performance.
 
+#[allow(structural_records)]; // Pipes
+// Until a snapshot
 // xfail-pretty
 
 extern mod std;

branches/incoming/src/test/compile-fail/borrowck-assign-comp.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct point {x: int, mut y: int }
+type point = { x: int, y: int };
 
 fn a() {
-    let mut p = point {x: 3, y: 4};
+    let mut p = {x: 3, y: 4};
     let _q = &p; //~ NOTE loan of mutable local variable granted here
 
     // This assignment is illegal because the field x is not
@@ -21,29 +21,29 @@ fn a() {
 }
 
 fn b() {
-    let mut p = point {x: 3, mut y: 4};
-    // This assignment is legal because `y` is inherently mutable (and
-    // hence &_q.y is &mut int).
+    let mut p = {x: 3, mut y: 4};
     let _q = &p;
 
+    // This assignment is legal because `y` is inherently mutable (and
+    // hence &_q.y is &mut int).
     p.y = 5;
 }
 
 fn c() {
     // this is sort of the opposite.  We take a loan to the interior of `p`
     // and then try to overwrite `p` as a whole.
 
-    let mut p = point {x: 3, mut y: 4};
+    let mut p = {x: 3, mut y: 4};
     let _q = &p.y; //~ NOTE loan of mutable local variable granted here
-    p = point {x: 5, mut y: 7};//~ ERROR assigning to mutable local variable prohibited due to outstanding loan
+    p = {x: 5, mut y: 7};//~ ERROR assigning to mutable local variable prohibited due to outstanding loan
     copy p;
 }
 
 fn d() {
     // just for completeness's sake, the easy case, where we take the
     // address of a subcomponent and then modify that subcomponent:
 
-    let mut p = point {x: 3, mut y: 4};
+    let mut p = {x: 3, mut y: 4};
     let _q = &p.y; //~ NOTE loan of mutable field granted here
     p.y = 5; //~ ERROR assigning to mutable field prohibited due to outstanding loan
     copy p;

branches/incoming/src/test/compile-fail/borrowck-assign-to-subfield.rs

@@ -9,23 +9,11 @@
 // except according to those terms.
 
 fn main() {
-    struct A {
-        a: int,
-        w: B,
-        x: @B,
-        y: @const B,
-        z: @mut B
-    }
-    struct B {
-        a: int
-    }
-    let mut p = A {
-        a: 1,
-        w: B {a: 1},
-        x: @B {a: 1},
-        y: @const B {a: 1},
-        z: @mut B {a: 1}
-    };
+    let mut p = {a: 1,
+                 w: {a: 1},
+                 x: @{a: 1},
+                 y: @const {a: 1},
+                 z: @mut{a: 1}};
 
     // even though `x` is not declared as a mutable field,
     // `p` as a whole is mutable, so it can be modified.

branches/incoming/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162-b.rs

@@ -12,12 +12,8 @@ fn each<T>(x: &[T], op: fn(elem: &T) -> bool) {
     uint::range(0, x.len(), |i| op(&x[i]));
 }
 
-struct A {
-    mut a: int
-}
-
 fn main() {
-    let x = [A {mut a: 0}];
+    let x = [{mut a: 0}];
     for each(x) |y| {
         let z = &y.a; //~ ERROR illegal borrow unless pure
         x[0].a = 10; //~ NOTE impure due to assigning to mutable field

branches/incoming/src/test/compile-fail/borrowck-imm-ref-to-mut-rec-field-issue-3162.rs

@@ -13,10 +13,7 @@ fn each<T>(x: &[T], op: fn(elem: &T) -> bool) {
 }
 
 fn main() {
-    struct A {
-        mut a: int
-    }
-    let x = ~[A {mut a: 0}];
+    let x = ~[{mut a: 0}];
     for each(x) |y| {
         let z = &y.a; //~ ERROR illegal borrow unless pure
         x[0].a = 10; //~ NOTE impure due to assigning to mutable field

branches/incoming/src/test/compile-fail/borrowck-loan-rcvr.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct point { x: int, y: int }
+type point = { x: int, y: int };
 
 trait methods {
     fn impurem();
@@ -27,7 +27,7 @@ impl methods for point {
 }
 
 fn a() {
-    let mut p = point {x: 3, y: 4};
+    let mut p = {x: 3, y: 4};
 
     // Here: it's ok to call even though receiver is mutable, because we
     // can loan it out.
@@ -41,7 +41,7 @@ fn a() {
 }
 
 fn b() {
-    let mut p = point {x: 3, y: 4};
+    let mut p = {x: 3, y: 4};
 
     // Here I create an outstanding loan and check that we get conflicts:
 
@@ -56,7 +56,7 @@ fn b() {
 
 fn c() {
     // Loaning @mut as & is considered legal due to dynamic checks:
-    let q = @mut point {x: 3, y: 4};
+    let q = @mut {x: 3, y: 4};
     q.purem();
     q.impurem();
 }

branches/incoming/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs

@@ -8,16 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct node_ {
-    mut a: ~cycle
-}
-
 enum cycle {
-    node(node_),
+    node({mut a: ~cycle}),
     empty
 }
 fn main() {
-    let x = ~node(node_ {mut a: ~empty});
+    let x = ~node({mut a: ~empty});
     // Create a cycle!
     match *x { //~ NOTE loan of immutable local variable granted here
       node(ref y) => {