---

yaml
---
r: 101373
b: refs/heads/master
c: d451c15
h: refs/heads/master
i:
  101371: 3d97ddc
v: v3

Author: nathanielherman

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 362cbbe01c58a8e2b233cdfa9038b6e31ca8d318
+refs/heads/master: d451c150570a7da02314795abd6777c80f361e93
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/README.md

@@ -71,9 +71,9 @@ fetch snapshots, and an OS that can execute the available snapshot binaries.
 
 Snapshot binaries are currently built and tested on several platforms:
 
-* Windows (7, 8, Server 2008 R2), x86 only
-* Linux (2.6.18 or later, various distributions), x86 and x86-64
-* OSX 10.7 (Lion) or greater, x86 and x86-64
+* Windows (7, Server 2008 R2), x86 only
+* Linux (various distributions), x86 and x86-64
+* OSX 10.6 ("Snow Leopard") or greater, x86 and x86-64
 
 You may find that other platforms work, but these are our officially
 supported build environments that are most likely to work.

trunk/doc/rustdoc.md

@@ -139,14 +139,9 @@ that one can still write things like `#[deriving(Eq)]`).
 
 ~~~
 ```rust
-# /!\ The three following lines are comments, which are usually stripped off by
-# the doc-generating tool.  In order to display them anyway in this particular
-# case, the character following the leading '#' is not a usual space like in
-# these first five lines but a non breakable one.
-# 
-# // showing 'fib' in this documentation would just be tedious and detracts from
-# // what's actualy being documented.
-# fn fib(n: int) { n + 2 }
+# // showing 'fib' in this documentation would just be tedious and detracts from
+# // what's actualy being documented.
+# fn fib(n: int) { n + 2 }
 
 do spawn { fib(200); }
 ```

trunk/doc/tutorial.md

@@ -72,9 +72,9 @@ from the Internet on our supported platforms.
 
 Snapshot binaries are currently built and tested on several platforms:
 
-* Windows (7, 8, Server 2008 R2), x86 only
-* Linux (2.6.18 or later, various distributions), x86 and x86-64
-* OSX 10.7 (Lion) or greater, x86 and x86-64
+* Windows (7, Server 2008 R2), x86 only
+* Linux (various distributions), x86 and x86-64
+* OSX 10.6 ("Snow Leopard") or greater, x86 and x86-64
 
 You may find that other platforms work, but these are our "tier 1"
 supported build environments that are most likely to work.
@@ -646,7 +646,7 @@ match mypoint {
 ## Enums
 
 Enums are datatypes that have several alternate representations. For
-example, consider the following type:
+example, consider the type shown earlier:
 
 ~~~~
 # struct Point { x: f64, y: f64 }

trunk/src/libarena/lib.rs

@@ -33,9 +33,9 @@ use std::cast;
 use std::cell::{Cell, RefCell};
 use std::num;
 use std::ptr;
-use std::kinds::marker;
 use std::mem;
 use std::rt::global_heap;
+use std::uint;
 use std::unstable::intrinsics::{TyDesc, get_tydesc};
 use std::unstable::intrinsics;
 use std::util;
@@ -71,14 +71,14 @@ struct Chunk {
 // different chunks than objects without destructors. This reduces
 // overhead when initializing plain-old-data and means we don't need
 // to waste time running the destructors of POD.
+#[no_freeze]
 pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
     // access the head.
     priv head: Chunk,
     priv pod_head: Chunk,
     priv chunks: RefCell<@List<Chunk>>,
-    priv no_freeze: marker::NoFreeze,
 }
 
 impl Arena {
@@ -91,7 +91,6 @@ impl Arena {
             head: chunk(initial_size, false),
             pod_head: chunk(initial_size, true),
             chunks: RefCell::new(@Nil),
-            no_freeze: marker::NoFreeze,
         }
     }
 }
@@ -179,7 +178,7 @@ impl Arena {
         let new_min_chunk_size = num::max(n_bytes, chunk_size);
         self.chunks.set(@Cons(self.pod_head.clone(), self.chunks.get()));
         self.pod_head =
-            chunk(num::next_power_of_two(new_min_chunk_size + 1u), true);
+            chunk(uint::next_power_of_two(new_min_chunk_size + 1u), true);
 
         return self.alloc_pod_inner(n_bytes, align);
     }
@@ -221,7 +220,7 @@ impl Arena {
         let new_min_chunk_size = num::max(n_bytes, chunk_size);
         self.chunks.set(@Cons(self.head.clone(), self.chunks.get()));
         self.head =
-            chunk(num::next_power_of_two(new_min_chunk_size + 1u), false);
+            chunk(uint::next_power_of_two(new_min_chunk_size + 1u), false);
 
         return self.alloc_nonpod_inner(n_bytes, align);
     }

trunk/src/libextra/arc.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -45,9 +45,9 @@ use sync;
 use sync::{Mutex, RWLock};
 
 use std::cast;
-use std::kinds::marker;
 use std::sync::arc::UnsafeArc;
 use std::task;
+use std::borrow;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
 pub struct Condvar<'a> {
@@ -151,19 +151,17 @@ impl<T:Freeze + Send> Clone for Arc<T> {
 struct MutexArcInner<T> { lock: Mutex, failed: bool, data: T }
 
 /// An Arc with mutable data protected by a blocking mutex.
-pub struct MutexArc<T> {
-    priv x: UnsafeArc<MutexArcInner<T>>,
-    priv marker: marker::NoFreeze,
-}
+#[no_freeze]
+pub struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
+
 
 impl<T:Send> Clone for MutexArc<T> {
     /// Duplicate a mutex-protected Arc. See arc::clone for more details.
     #[inline]
     fn clone(&self) -> MutexArc<T> {
         // NB: Cloning the underlying mutex is not necessary. Its reference
         // count would be exactly the same as the shared state's.
-        MutexArc { x: self.x.clone(),
-                   marker: marker::NoFreeze, }
+        MutexArc { x: self.x.clone() }
     }
 }
 
@@ -182,8 +180,7 @@ impl<T:Send> MutexArc<T> {
             lock: Mutex::new_with_condvars(num_condvars),
             failed: false, data: user_data
         };
-        MutexArc { x: UnsafeArc::new(data),
-                   marker: marker::NoFreeze, }
+        MutexArc { x: UnsafeArc::new(data) }
     }
 
     /**
@@ -322,17 +319,16 @@ struct RWArcInner<T> { lock: RWLock, failed: bool, data: T }
  *
  * Unlike mutex_arcs, rw_arcs are safe, because they cannot be nested.
  */
+#[no_freeze]
 pub struct RWArc<T> {
     priv x: UnsafeArc<RWArcInner<T>>,
-    priv marker: marker::NoFreeze,
 }
 
 impl<T:Freeze + Send> Clone for RWArc<T> {
     /// Duplicate a rwlock-protected Arc. See arc::clone for more details.
     #[inline]
     fn clone(&self) -> RWArc<T> {
-        RWArc { x: self.x.clone(),
-                marker: marker::NoFreeze, }
+        RWArc { x: self.x.clone() }
     }
 
 }
@@ -352,8 +348,7 @@ impl<T:Freeze + Send> RWArc<T> {
             lock: RWLock::new_with_condvars(num_condvars),
             failed: false, data: user_data
         };
-        RWArc { x: UnsafeArc::new(data),
-                marker: marker::NoFreeze, }
+        RWArc { x: UnsafeArc::new(data), }
     }
 
     /**
@@ -470,7 +465,7 @@ impl<T:Freeze + Send> RWArc<T> {
             // of this cast is removing the mutability.)
             let new_data = data;
             // Downgrade ensured the token belonged to us. Just a sanity check.
-            assert!((&(*state).data as *T as uint) == (new_data as *mut T as uint));
+            assert!(borrow::ref_eq(&(*state).data, new_data));
             // Produce new token
             RWReadMode {
                 data: new_data,

trunk/src/libextra/hex.rs

@@ -1,4 +1,4 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -60,7 +60,7 @@ pub trait FromHex {
 pub enum FromHexError {
     /// The input contained a character not part of the hex format
     InvalidHexCharacter(char, uint),
-    /// The input had an invalid length
+    /// The input had a invalid length
     InvalidHexLength,
 }
 

trunk/src/libextra/num/bigint.rs

@@ -1292,7 +1292,7 @@ impl ToStrRadix for BigInt {
 }
 
 impl FromStrRadix for BigInt {
-    /// Creates and initializes a BigInt.
+    /// Creates and initializes an BigInt.
     #[inline]
     fn from_str_radix(s: &str, radix: uint) -> Option<BigInt> {
         BigInt::parse_bytes(s.as_bytes(), radix)
@@ -1385,7 +1385,7 @@ impl<R: Rng> RandBigInt for R {
 }
 
 impl BigInt {
-    /// Creates and initializes a BigInt.
+    /// Creates and initializes an BigInt.
     #[inline]
     pub fn new(sign: Sign, v: ~[BigDigit]) -> BigInt {
         BigInt::from_biguint(sign, BigUint::new(v))

trunk/src/libextra/ringbuf.rs

@@ -303,7 +303,7 @@ impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
             &mut self.remaining2
         };
         self.nelts -= 1;
-        Some(r.mut_shift_ref().get_mut_ref())
+        Some(r.mut_shift_ref().unwrap().get_mut_ref())
     }
 
     #[inline]

trunk/src/libextra/sync.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -18,6 +18,7 @@
  */
 
 
+use std::borrow;
 use std::comm;
 use std::unstable::sync::Exclusive;
 use std::sync::arc::UnsafeArc;
@@ -633,7 +634,7 @@ impl RWLock {
     /// To be called inside of the write_downgrade block.
     pub fn downgrade<'a>(&self, token: RWLockWriteMode<'a>)
                          -> RWLockReadMode<'a> {
-        if !((self as *RWLock) == (token.lock as *RWLock)) {
+        if !borrow::ref_eq(self, token.lock) {
             fail!("Can't downgrade() with a different rwlock's write_mode!");
         }
         unsafe {

trunk/src/librustc/back/link.rs

@@ -96,7 +96,6 @@ pub mod write {
     use lib::llvm::llvm;
     use lib::llvm::{ModuleRef, TargetMachineRef, PassManagerRef};
     use lib;
-    use syntax::abi;
     use util::common::time;
 
     use std::c_str::ToCStr;
@@ -130,10 +129,7 @@ pub mod write {
             let use_softfp = sess.opts.debugging_opts & session::USE_SOFTFP != 0;
 
             // FIXME: #11906: Omitting frame pointers breaks retrieving the value of a parameter.
-            // FIXME: #11954: mac64 unwinding may not work with fp elim
-            let no_fp_elim = sess.opts.debuginfo ||
-                             (sess.targ_cfg.os == abi::OsMacos &&
-                              sess.targ_cfg.arch == abi::X86_64);
+            let no_fp_elim = sess.opts.debuginfo;
 
             let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|T| {
                 sess.opts.target_cpu.with_c_str(|CPU| {

trunk/src/librustc/metadata/common.rs

@@ -35,8 +35,6 @@ pub static tag_items_data_item_variant: uint = 0x0eu;
 
 pub static tag_items_data_parent_item: uint = 0x0fu;
 
-pub static tag_items_data_item_is_tuple_struct_ctor: uint = 0x10u;
-
 pub static tag_index: uint = 0x11u;
 
 pub static tag_index_buckets: uint = 0x12u;

trunk/src/librustc/metadata/decoder.rs

@@ -980,26 +980,9 @@ pub fn get_static_methods_if_impl(intr: @IdentInterner,
     return Some(static_impl_methods);
 }
 
-/// If node_id is the constructor of a tuple struct, retrieve the NodeId of
-/// the actual type definition, otherwise, return None
-pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd,
-                                           node_id: ast::NodeId) -> Option<ast::NodeId> {
-    let item = lookup_item(node_id, cdata.data());
-    let mut ret = None;
-    reader::tagged_docs(item, tag_items_data_item_is_tuple_struct_ctor, |_| {
-        ret = Some(item_reqd_and_translated_parent_item(cdata.cnum, item));
-        false
-    });
-    ret.map(|x| x.node)
-}
-
 pub fn get_item_attrs(cdata: Cmd,
                       node_id: ast::NodeId,
                       f: |~[@ast::MetaItem]|) {
-    // The attributes for a tuple struct are attached to the definition, not the ctor;
-    // we assume that someone passing in a tuple struct ctor is actually wanting to
-    // look at the definition
-    let node_id = get_tuple_struct_definition_if_ctor(cdata, node_id).unwrap_or(node_id);
     let item = lookup_item(node_id, cdata.data());
     reader::tagged_docs(item, tag_attributes, |attributes| {
         reader::tagged_docs(attributes, tag_attribute, |attribute| {

trunk/src/librustc/metadata/encoder.rs

@@ -778,12 +778,6 @@ fn encode_info_for_struct_ctor(ecx: &EncodeContext,
         encode_symbol(ecx, ebml_w, ctor_id);
     }
 
-    // indicate that this is a tuple struct ctor, because downstream users will normally want
-    // the tuple struct definition, but without this there is no way for them to tell that
-    // they actually have a ctor rather than a normal function
-    ebml_w.start_tag(tag_items_data_item_is_tuple_struct_ctor);
-    ebml_w.end_tag();
-
     ebml_w.end_tag();
 }
 

trunk/src/librustc/middle/const_eval.rs

@@ -11,9 +11,7 @@
 
 use metadata::csearch;
 use middle::astencode;
-
 use middle::ty;
-use middle::typeck::astconv;
 use middle;
 
 use syntax::{ast, ast_map, ast_util};
@@ -447,17 +445,8 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
           _ => Err(~"Bad operands for binary")
         }
       }
-      ExprCast(base, target_ty) => {
-        // This tends to get called w/o the type actually having been
-        // populated in the ctxt, which was causing things to blow up
-        // (#5900). Fall back to doing a limited lookup to get past it.
-        let ety = ty::expr_ty_opt(tcx.ty_ctxt(), e)
-                .or_else(|| astconv::ast_ty_to_prim_ty(tcx.ty_ctxt(), target_ty))
-                .unwrap_or_else(|| tcx.ty_ctxt().sess.span_fatal(
-                    target_ty.span,
-                    format!("Target type not found for const cast")
-                ));
-
+      ExprCast(base, _) => {
+        let ety = tcx.expr_ty(e);
         let base = eval_const_expr_partial(tcx, base);
         match base {
             Err(_) => base,

trunk/src/librustc/middle/kind.rs

@@ -485,7 +485,7 @@ pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: Span) -> bool {
     }
 }
 
-/// This is rather subtle.  When we are casting a value to an instantiated
+/// This is rather subtle.  When we are casting a value to a instantiated
 /// trait like `a as trait<'r>`, regionck already ensures that any references
 /// that appear in the type of `a` are bounded by `'r` (ed.: rem
 /// FIXME(#5723)).  However, it is possible that there are *type parameters*
@@ -516,7 +516,7 @@ pub fn check_cast_for_escaping_regions(
     target_ty: ty::t,
     source_span: Span)
 {
-    // Determine what type we are casting to; if it is not a trait, then no
+    // Determine what type we are casting to; if it is not an trait, then no
     // worries.
     match ty::get(target_ty).sty {
         ty::ty_trait(..) => {}