---

yaml
---
r: 103613
b: refs/heads/try
c: 2e24adf
h: refs/heads/master
i:
  103611: 0bb438d
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: e90a8c4a35bffe6f0b9b46185147f907b79191ca
+refs/heads/try: 2e24adf52182b6162e42fed5ec004e73bbefa213
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/.gitignore

@@ -75,12 +75,10 @@ src/.DS_Store
 /doc/latex
 /doc/std
 /doc/extra
-/doc/flate
 /doc/green
 /doc/native
 /doc/rustc
 /doc/syntax
-/doc/rustdoc
 /doc/rustuv
 /doc/rustpkg
 /nd/

branches/try/doc/guide-runtime.md

@@ -176,7 +176,7 @@ implemented in user-space.
 The primary concern of an M:N runtime is that a Rust task cannot block itself in
 a syscall. If this happens, then the entire OS thread is frozen and unavailable
 for running more Rust tasks, making this a (M-1):N runtime (and you can see how
-this can reach 0/deadlock). By using asynchronous I/O under the hood (all I/O
+this can reach 0/deadlock. By using asynchronous I/O under the hood (all I/O
 still looks synchronous in terms of code), OS threads are never blocked until
 the appropriate time comes.
 

branches/try/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/try/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/try/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/try/src/librustc/front/feature_gate.rs

@@ -47,7 +47,6 @@ 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
@@ -172,13 +171,6 @@ 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/try/src/librustc/metadata/encoder.rs

@@ -766,8 +766,6 @@ fn encode_info_for_struct_ctor(ecx: &EncodeContext,
     ebml_w.start_tag(tag_items_data_item);
     encode_def_id(ebml_w, local_def(ctor_id));
     encode_family(ebml_w, 'f');
-    encode_bounds_and_type(ebml_w, ecx,
-                           &lookup_item_type(ecx.tcx, local_def(ctor_id)));
     encode_name(ecx, ebml_w, name);
     encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, ctor_id));
     encode_path(ecx, ebml_w, path, ast_map::PathName(name));

branches/try/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/try/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/try/src/libstd/lib.rs

@@ -52,14 +52,13 @@
       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, simd)];
+#[feature(macro_rules, globs, asm, managed_boxes, thread_local, link_args)];
 
 // 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/try/src/libstd/rt/unwind.rs

@@ -391,6 +391,10 @@ pub fn begin_unwind_raw(msg: *u8, file: *u8, line: uint) -> ! {
 /// the actual formatting into this shared place.
 #[inline(never)] #[cold]
 pub fn begin_unwind_fmt(msg: &fmt::Arguments, file: &'static str, line: uint) -> ! {
+    // We do two allocations here, unfortunately. But (a) they're
+    // required with the current scheme, and (b) we don't handle
+    // failure + OOM properly anyway (see comment in begin_unwind
+    // below).
     begin_unwind_inner(~fmt::format(msg), file, line)
 }
 

branches/try/src/libstd/unstable/simd.rs

@@ -12,42 +12,32 @@
 
 #[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/try/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/try/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/try/src/test/auxiliary/issue_10031_aux.rs

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

branches/try/src/test/compile-fail/deriving-no-inner-impl-error-message.rs

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

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

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

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

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

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

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

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

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

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

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

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

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