---

yaml
---
r: 107707
b: refs/heads/dist-snap
c: 28b987b
h: refs/heads/master
i:
  107705: 4116a96
  107703: f0a5338
v: v3

Author: dmanescu

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: d21b18306cd3679e94c58d9d5c1c4a3d291167fe
+refs/heads/dist-snap: 28b987b99a32dfac004643200a9414ee832afa1c
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/tests.mk

@@ -344,8 +344,7 @@ ifeq ($(NO_REBUILD),)
 STDTESTDEP_$(1)_$(2)_$(3)_$(4) = $$(SREQ$(1)_T_$(2)_H_$(3)) \
                             $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.extra \
                             $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.rustuv \
-                            $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.green \
-                            $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.native
+                            $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.green
 else
 STDTESTDEP_$(1)_$(2)_$(3)_$(4) =
 endif

branches/dist-snap/src/etc/generate-deriving-span-tests.py

@@ -118,7 +118,7 @@ def write_file(name, string):
 for (trait, supers, errs) in [('Rand', [], 1),
                               ('Clone', [], 1), ('DeepClone', ['Clone'], 1),
                               ('Eq', [], 2), ('Ord', [], 8),
-                              ('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1)]:
+                              ('TotalEq', [], 2), ('TotalOrd', ['TotalEq'], 2)]:
     traits[trait] = (ALL, supers, errs)
 
 for (trait, (types, super_traits, error_count)) in traits.items():

branches/dist-snap/src/libextra/dlist.rs

@@ -47,17 +47,13 @@ struct Node<T> {
 }
 
 /// Double-ended DList iterator
+#[deriving(Clone)]
 pub struct Items<'a, T> {
     priv head: &'a Link<T>,
     priv tail: Rawlink<Node<T>>,
     priv nelem: uint,
 }
 
-// FIXME #11820: the &'a Option<> of the Link stops clone working.
-impl<'a, T> Clone for Items<'a, T> {
-    fn clone(&self) -> Items<'a, T> { *self }
-}
-
 /// Double-ended mutable DList iterator
 pub struct MutItems<'a, T> {
     priv list: &'a mut DList<T>,

branches/dist-snap/src/librustc/front/feature_gate.rs

@@ -47,6 +47,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("macro_registrar", Active),
     ("log_syntax", Active),
     ("trace_macros", Active),
+    ("simd", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -171,6 +172,13 @@ impl Visitor<()> for Context {
                 }
             }
 
+            ast::ItemStruct(..) => {
+                if attr::contains_name(i.attrs, "simd") {
+                    self.gate_feature("simd", i.span,
+                                      "SIMD types are experimental and possibly buggy");
+                }
+            }
+
             _ => {}
         }
 

branches/dist-snap/src/librustc/middle/kind.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 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.
 //
@@ -184,6 +184,9 @@ fn with_appropriate_checker(cx: &Context,
         let id = ast_util::def_id_of_def(fv.def).node;
         let var_t = ty::node_id_to_type(cx.tcx, id);
 
+        // check that only immutable variables are implicitly copied in
+        check_imm_free_var(cx, fv.def, fv.span);
+
         check_freevar_bounds(cx, fv.span, var_t, bounds, None);
     }
 
@@ -444,6 +447,23 @@ pub fn check_trait_cast_bounds(cx: &Context, sp: Span, ty: ty::t,
     });
 }
 
+fn check_imm_free_var(cx: &Context, def: Def, sp: Span) {
+    match def {
+        DefLocal(_, BindByValue(MutMutable)) => {
+            cx.tcx.sess.span_err(
+                sp,
+                "mutable variables cannot be implicitly captured");
+        }
+        DefLocal(..) | DefArg(..) | DefBinding(..) => { /* ok */ }
+        DefUpvar(_, def1, _, _) => { check_imm_free_var(cx, *def1, sp); }
+        _ => {
+            cx.tcx.sess.span_bug(
+                sp,
+                format!("unknown def for free variable: {:?}", def));
+        }
+    }
+}
+
 fn check_copy(cx: &Context, ty: ty::t, sp: Span, reason: &str) {
     debug!("type_contents({})={}",
            ty_to_str(cx.tcx, ty),

branches/dist-snap/src/librustc/middle/trans/_match.rs

@@ -399,17 +399,13 @@ struct BindingInfo {
 
 type BindingsMap = HashMap<Ident, BindingInfo>;
 
+#[deriving(Clone)]
 struct ArmData<'a,'b> {
     bodycx: &'b Block<'b>,
     arm: &'a ast::Arm,
     bindings_map: @BindingsMap
 }
 
-// FIXME #11820: method resolution is unreliable with &
-impl<'a,'b> Clone for ArmData<'a, 'b> {
-    fn clone(&self) -> ArmData<'a, 'b> { *self }
-}
-
 /**
  * Info about Match.
  * If all `pats` are matched then arm `data` will be executed.
@@ -2231,3 +2227,5 @@ fn bind_irrefutable_pat<'a>(
     }
     return bcx;
 }
+
+

branches/dist-snap/src/libstd/lib.rs

@@ -52,13 +52,14 @@
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
-#[feature(macro_rules, globs, asm, managed_boxes, thread_local, link_args)];
+#[feature(macro_rules, globs, asm, managed_boxes, thread_local, link_args, simd)];
 
 // Don't link to std. We are std.
 #[no_std];
 
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
+#[allow(unknown_features)];
 
 // When testing libstd, bring in libuv as the I/O backend so tests can print
 // things and all of the std::io tests have an I/O interface to run on top

branches/dist-snap/src/libstd/unstable/simd.rs

@@ -12,32 +12,42 @@
 
 #[allow(non_camel_case_types)];
 
+#[experimental]
 #[simd]
 pub struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8);
 
+#[experimental]
 #[simd]
 pub struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
 
+#[experimental]
 #[simd]
 pub struct i32x4(i32, i32, i32, i32);
 
+#[experimental]
 #[simd]
 pub struct i64x2(i64, i64);
 
+#[experimental]
 #[simd]
 pub struct u8x16(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8);
 
+#[experimental]
 #[simd]
 pub struct u16x8(u16, u16, u16, u16, u16, u16, u16, u16);
 
+#[experimental]
 #[simd]
 pub struct u32x4(u32, u32, u32, u32);
 
+#[experimental]
 #[simd]
 pub struct u64x2(u64, u64);
 
+#[experimental]
 #[simd]
 pub struct f32x4(f32, f32, f32, f32);
 
+#[experimental]
 #[simd]
 pub struct f64x2(f64, f64);

branches/dist-snap/src/libsyntax/ext/deriving/cmp/ord.rs

@@ -78,10 +78,14 @@ fn cs_op(less: bool, equal: bool, cx: &ExtCtxt, span: Span, substr: &Substructur
                 _ => cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`")
             };
 
-            let cmp = cx.expr_binary(span, op, self_f, other_f);
+            let cmp = cx.expr_binary(span, op,
+                                     cx.expr_deref(span, self_f),
+                                     cx.expr_deref(span, other_f));
 
             let not_cmp = cx.expr_unary(span, ast::UnNot,
-                                        cx.expr_binary(span, op, other_f, self_f));
+                                        cx.expr_binary(span, op,
+                                                       cx.expr_deref(span, other_f),
+                                                       cx.expr_deref(span, self_f)));
 
             let and = cx.expr_binary(span, ast::BiAnd, not_cmp, subexpr);
             cx.expr_binary(span, ast::BiOr, cmp, and)

branches/dist-snap/src/libsyntax/ext/deriving/generic.rs

@@ -1013,8 +1013,7 @@ impl<'a> TraitDef<'a> {
             };
             let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i)));
             paths.push(path.clone());
-            let val = cx.expr(sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(path))));
-            ident_expr.push((sp, opt_id, val));
+            ident_expr.push((sp, opt_id, cx.expr_path(path)));
         }
 
         let subpats = self.create_subpatterns(paths, mutbl);
@@ -1058,8 +1057,7 @@ impl<'a> TraitDef<'a> {
                     let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i)));
 
                     paths.push(path.clone());
-                    let val = cx.expr(sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(path))));
-                    ident_expr.push((sp, None, val));
+                    ident_expr.push((sp, None, cx.expr_path(path)));
                 }
 
                 let subpats = self.create_subpatterns(paths, mutbl);
@@ -1134,7 +1132,7 @@ pub fn cs_same_method(f: |&ExtCtxt, Span, ~[@Expr]| -> @Expr,
                 cx.expr_method_call(field.span,
                                     field.self_,
                                     substructure.method_ident,
-                                    field.other.map(|e| cx.expr_addr_of(field.span, *e)))
+                                    field.other.clone())
             });
 
             f(cx, trait_span, called)

branches/dist-snap/src/test/compile-fail/deriving-span-TotalEq-enum-struct-variant.rs

@@ -20,6 +20,7 @@ struct Error;
 enum Enum {
    A {
      x: Error //~ ERROR
+//~^ ERROR
    }
 }
 

branches/dist-snap/src/test/compile-fail/deriving-span-TotalEq-enum.rs

@@ -20,6 +20,7 @@ struct Error;
 enum Enum {
    A(
      Error //~ ERROR
+//~^ ERROR
      )
 }
 

branches/dist-snap/src/test/compile-fail/deriving-span-TotalEq-struct.rs

@@ -19,6 +19,7 @@ struct Error;
 #[deriving(TotalEq)]
 struct Struct {
     x: Error //~ ERROR
+//~^ ERROR
 }
 
 fn main() {}

branches/dist-snap/src/test/compile-fail/deriving-span-TotalEq-tuple-struct.rs

@@ -19,6 +19,7 @@ struct Error;
 #[deriving(TotalEq)]
 struct Struct(
     Error //~ ERROR
+//~^ ERROR
 );
 
 fn main() {}

branches/dist-snap/src/test/compile-fail/deriving-span-TotalOrd-enum-struct-variant.rs

@@ -20,6 +20,7 @@ struct Error;
 enum Enum {
    A {
      x: Error //~ ERROR
+//~^ ERROR
    }
 }
 

branches/dist-snap/src/test/compile-fail/deriving-span-TotalOrd-enum.rs

@@ -20,6 +20,7 @@ struct Error;
 enum Enum {
    A(
      Error //~ ERROR
+//~^ ERROR
      )
 }
 

branches/dist-snap/src/test/compile-fail/deriving-span-TotalOrd-struct.rs

@@ -19,6 +19,7 @@ struct Error;
 #[deriving(TotalOrd,TotalEq)]
 struct Struct {
     x: Error //~ ERROR
+//~^ ERROR
 }
 
 fn main() {}

branches/dist-snap/src/test/compile-fail/deriving-span-TotalOrd-tuple-struct.rs

@@ -19,6 +19,7 @@ struct Error;
 #[deriving(TotalOrd,TotalEq)]
 struct Struct(
     Error //~ ERROR
+//~^ ERROR
 );
 
 fn main() {}

branches/dist-snap/src/test/compile-fail/gated-simd.rs

@@ -0,0 +1,14 @@
+// Copyright 2014 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.
+
+#[simd]
+pub struct i64x2(i64, i64); //~ ERROR: SIMD types are experimental
+
+fn main() {}

branches/dist-snap/src/test/run-pass/kindck-implicit-close-over-mut-var.rs renamed to branches/dist-snap/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 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.
 //
@@ -13,41 +13,38 @@ use std::task;
 fn user(_i: int) {}
 
 fn foo() {
-    // Here, i is *copied* into the proc (heap closure).
-    // Requires allocation.  The proc's copy is not mutable.
+    // Here, i is *moved* into the closure: Not actually OK
     let mut i = 0;
     do task::spawn {
-        user(i);
-        println!("spawned {}", i)
+        user(i); //~ ERROR mutable variables cannot be implicitly captured
     }
-    i += 1;
-    println!("original {}", i)
 }
 
 fn bar() {
-    // Here, the original i has not been moved, only copied, so is still
-    // mutable outside of the proc.
+    // Here, i would be implicitly *copied* but it
+    // is mutable: bad
     let mut i = 0;
     while i < 10 {
         do task::spawn {
-            user(i);
+            user(i); //~ ERROR mutable variables cannot be implicitly captured
         }
         i += 1;
     }
 }
 
 fn car() {
-    // Here, i must be shadowed in the proc to be mutable.
+    // Here, i is mutable, but *explicitly* shadowed copied:
     let mut i = 0;
     while i < 10 {
-        do task::spawn {
-            let mut i = i;
-            i += 1;
-            user(i);
+        {
+            let i = i;
+            do task::spawn {
+                user(i);
+            }
         }
         i += 1;
     }
 }
 
-pub fn main() {}
-
+fn main() {
+}