---

yaml
---
r: 101371
b: refs/heads/master
c: bc8983a
h: refs/heads/master
i:
  101369: 71ebe76
  101367: 0843e89
v: v3

Author: dmanescu

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1d494198bbb9701b6336febcf9d0ceb39e4b7975
+refs/heads/master: bc8983a3fa44f0c35c7fe669913ca7ea82758125
 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/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/front/feature_gate.rs

@@ -48,7 +48,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("log_syntax", Active),
     ("trace_macros", Active),
     ("simd", Active),
-    ("default_type_params", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -235,20 +234,6 @@ impl Visitor<()> for Context {
         }
         visit::walk_expr(self, e, ());
     }
-
-    fn visit_generics(&mut self, generics: &ast::Generics, _: ()) {
-        for type_parameter in generics.ty_params.iter() {
-            match type_parameter.default {
-                Some(ty) => {
-                    self.gate_feature("default_type_params", ty.span,
-                                      "default type parameters are \
-                                       experimental and possibly buggy");
-                }
-                None => {}
-            }
-        }
-        visit::walk_generics(self, generics, ());
-    }
 }
 
 pub fn check_crate(sess: Session, crate: &ast::Crate) {

trunk/src/librustc/metadata/common.rs

@@ -35,6 +35,8 @@ 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,9 +980,26 @@ 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,6 +778,12 @@ 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/metadata/tydecode.rs

@@ -573,12 +573,9 @@ pub fn parse_type_param_def_data(data: &[u8], start: uint,
 }
 
 fn parse_type_param_def(st: &mut PState, conv: conv_did) -> ty::TypeParameterDef {
-    ty::TypeParameterDef {
-        ident: parse_ident(st, ':'),
-        def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
-        bounds: @parse_bounds(st, |x,y| conv(x,y)),
-        default: parse_opt(st, |st| parse_ty(st, |x,y| conv(x,y)))
-    }
+    ty::TypeParameterDef {ident: parse_ident(st, ':'),
+                          def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
+                          bounds: @parse_bounds(st, |x,y| conv(x,y))}
 }
 
 fn parse_bounds(st: &mut PState, conv: conv_did) -> ty::ParamBounds {

trunk/src/librustc/metadata/tyencode.rs

@@ -421,5 +421,4 @@ fn enc_bounds(w: &mut MemWriter, cx: @ctxt, bs: &ty::ParamBounds) {
 pub fn enc_type_param_def(w: &mut MemWriter, cx: @ctxt, v: &ty::TypeParameterDef) {
     mywrite!(w, "{}:{}|", cx.tcx.sess.str_of(v.ident), (cx.ds)(v.def_id));
     enc_bounds(w, cx, v.bounds);
-    enc_opt(w, v.default, |w, t| enc_ty(w, cx, t));
 }