---

yaml
---
r: 68463
b: refs/heads/auto
c: 2bdc88b
h: refs/heads/master
i:
  68461: 7064d0f
  68459: 248743d
  68455: 9ffcdba
  68447: 207805d
v: v3

Author: thestinger

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 5d2e565bb1f4566bdaab053876bacad72c57f582
+refs/heads/auto: 2bdc88b6526f806156a6342ae75a80d99ea6e378
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/Makefile.in

@@ -141,9 +141,6 @@ endif
 CFG_GIT_DIR := $(CFG_SRC_DIR).git
 CFG_RELEASE = 0.7-pre
 CFG_VERSION = $(CFG_RELEASE)
-# windows exe's need numeric versions - don't use anything but
-# numbers and dots here
-CFG_VERSION_WIN = 0.7
 
 ifneq ($(wildcard $(CFG_GIT)),)
 ifneq ($(wildcard $(CFG_GIT_DIR)),)
@@ -314,7 +311,6 @@ $(foreach host,$(CFG_HOST_TRIPLES), \
 export CFG_SRC_DIR
 export CFG_BUILD_DIR
 export CFG_VERSION
-export CFG_VERSION_WIN
 export CFG_BUILD_TRIPLE
 export CFG_LLVM_ROOT
 export CFG_ENABLE_MINGW_CROSS

branches/auto/doc/rust.md

@@ -2862,13 +2862,13 @@ call to the method `make_string`.
 Types in Rust are categorized into kinds, based on various properties of the components of the type.
 The kinds are:
 
-`Freeze`
+`Const`
   : Types of this kind are deeply immutable;
     they contain no mutable memory locations directly or indirectly via pointers.
-`Send`
+`Owned`
   : Types of this kind can be safely sent between tasks.
     This kind includes scalars, owning pointers, owned closures, and
-    structural types containing only other owned types. All `Send` types are `Static`.
+    structural types containing only other owned types. All `Owned` types are `Static`.
 `Static`
   : Types of this kind do not contain any borrowed pointers;
     this can be a useful guarantee for code that breaks borrowing assumptions using [`unsafe` operations](#unsafe-functions).
@@ -2882,7 +2882,7 @@ The kinds are:
     trait provides a single method `finalize` that takes no parameters, and is run
     when values of the type are dropped. Such a method is called a "destructor",
     and are always executed in "top-down" order: a value is completely destroyed
-    before any of the values it owns run their destructors. Only `Send` types
+    before any of the values it owns run their destructors. Only `Owned` types
     that do not implement `Copy` can implement `Drop`.
 
 > **Note:** The `finalize` method may be renamed in future versions of Rust.
@@ -2968,10 +2968,10 @@ frame they are allocated within.
 A task owns all memory it can *safely* reach through local variables,
 as well as managed, owning and borrowed pointers.
 
-When a task sends a value that has the `Send` trait to another task,
+When a task sends a value that has the `Owned` trait to another task,
 it loses ownership of the value sent and can no longer refer to it.
 This is statically guaranteed by the combined use of "move semantics",
-and the compiler-checked _meaning_ of the `Send` trait:
+and the compiler-checked _meaning_ of the `Owned` trait:
 it is only instantiated for (transitively) sendable kinds of data constructor and pointers,
 never including managed or borrowed pointers.
 
@@ -3116,7 +3116,7 @@ These include:
   - read-only and read-write shared variables with various safe mutual exclusion patterns
   - simple locks and semaphores
 
-When such facilities carry values, the values are restricted to the [`Send` type-kind](#type-kinds).
+When such facilities carry values, the values are restricted to the [`Owned` type-kind](#type-kinds).
 Restricting communication interfaces to this kind ensures that no borrowed or managed pointers move between tasks.
 Thus access to an entire data structure can be mediated through its owning "root" value;
 no further locking or copying is required to avoid data races within the substructure of such a value.

branches/auto/doc/tutorial-ffi.md

@@ -159,7 +159,7 @@ pub struct Unique<T> {
     priv ptr: *mut T
 }
 
-impl<T: Send> Unique<T> {
+impl<T: Owned> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         unsafe {
             let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
@@ -182,7 +182,7 @@ impl<T: Send> Unique<T> {
 }
 
 #[unsafe_destructor]
-impl<T: Send> Drop for Unique<T> {
+impl<T: Owned> Drop for Unique<T> {
     fn drop(&self) {
         unsafe {
             let x = intrinsics::init(); // dummy value to swap in

branches/auto/doc/tutorial.md

@@ -1281,9 +1281,9 @@ let your_crayons = ~[BananaMania, Beaver, Bittersweet];
 // Add two vectors to create a new one
 let our_crayons = my_crayons + your_crayons;
 
-// .push_all() will append to a vector, provided it lives in a mutable slot
+// += will append to a vector, provided it lives in a mutable slot
 let mut my_crayons = my_crayons;
-my_crayons.push_all(your_crayons);
+my_crayons += your_crayons;
 ~~~~
 
 > ***Note:*** The above examples of vector addition use owned

branches/auto/mk/dist.mk

@@ -57,7 +57,7 @@ LICENSE.txt: $(S)COPYRIGHT $(S)LICENSE-APACHE $(S)LICENSE-MIT
 	cp $< $@
 
 $(PKG_EXE): rust.iss modpath.iss LICENSE.txt rust-logo.ico \
-            $(PKG_FILES) $(CSREQ3_T_$(CFG_BUILD_TRIPLE)_H_$(CFG_BUILD_TRIPLE))
+            $(PKG_FILES) all rustc-stage3
 	@$(call E, ISCC: $@)
 	$(Q)"$(CFG_ISCC)" $<
 endif

branches/auto/mk/tools.mk

@@ -191,8 +191,7 @@ $(foreach host,$(CFG_HOST_TRIPLES),				\
 $(foreach target,$(CFG_TARGET_TRIPLES),				\
  $(eval $(call TOOLS_STAGE_N_TARGET,0,1,$(host),$(target)))	\
  $(eval $(call TOOLS_STAGE_N_TARGET,1,2,$(host),$(target)))	\
- $(eval $(call TOOLS_STAGE_N_TARGET,2,3,$(host),$(target)))	\
- $(eval $(call TOOLS_STAGE_N_TARGET,3,bogus,$(host),$(target)))))
+ $(eval $(call TOOLS_STAGE_N_TARGET,2,3,$(host),$(target)))))
 
 $(foreach host,$(CFG_HOST_TRIPLES),				\
  $(eval $(call TOOLS_STAGE_N_HOST,0,1,$(host),$(host)))	\

branches/auto/src/compiletest/errors.rs

@@ -21,7 +21,7 @@ pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
     let mut line_num = 1u;
     while !rdr.eof() {
         let ln = rdr.read_line();
-        error_patterns.push_all_move(parse_expected(line_num, ln));
+        error_patterns += parse_expected(line_num, ln);
         line_num += 1u;
     }
     return error_patterns;

branches/auto/src/compiletest/runtest.rs

@@ -226,8 +226,8 @@ actual:\n\
                          ~"-L", config.build_base.to_str(),
                          ~"-L",
                          aux_output_dir_name(config, testfile).to_str()];
-        args.push_all_move(split_maybe_args(&config.rustcflags));
-        args.push_all_move(split_maybe_args(&props.compile_flags));
+        args += split_maybe_args(&config.rustcflags);
+        args += split_maybe_args(&props.compile_flags);
         return ProcArgs {prog: config.rustc_path.to_str(), args: args};
     }
 }
@@ -581,8 +581,8 @@ fn make_compile_args(config: &config, props: &TestProps, extras: ~[~str],
                      ~"-o", xform(config, testfile).to_str(),
                      ~"-L", config.build_base.to_str()]
         + extras;
-    args.push_all_move(split_maybe_args(&config.rustcflags));
-    args.push_all_move(split_maybe_args(&props.compile_flags));
+    args += split_maybe_args(&config.rustcflags);
+    args += split_maybe_args(&props.compile_flags);
     return ProcArgs {prog: config.rustc_path.to_str(), args: args};
 }
 

branches/auto/src/etc/pkg/rust.iss

@@ -1,5 +1,4 @@
 #define CFG_VERSION GetEnv("CFG_VERSION")
-#define CFG_VERSION_WIN GetEnv("CFG_VERSION_WIN")
 
 [Setup]
 
@@ -9,7 +8,7 @@ AppVersion={#CFG_VERSION}
 AppCopyright=Copyright (C) 2006-2013 Mozilla Foundation, MIT license
 AppPublisher=Mozilla Foundation
 AppPublisherURL=http://www.rust-lang.org
-VersionInfoVersion={#CFG_VERSION_WIN}
+VersionInfoVersion={#CFG_VERSION}
 LicenseFile=LICENSE.txt
 
 DisableWelcomePage=true

branches/auto/src/libextra/arc.rs

@@ -112,15 +112,15 @@ impl<'self> Condvar<'self> {
 pub struct ARC<T> { x: UnsafeAtomicRcBox<T> }
 
 /// Create an atomically reference counted wrapper.
-pub fn ARC<T:Freeze + Send>(data: T) -> ARC<T> {
+pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
     ARC { x: UnsafeAtomicRcBox::new(data) }
 }
 
 /**
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-impl<T:Freeze+Send> ARC<T> {
+impl<T:Const+Owned> ARC<T> {
     pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
@@ -133,7 +133,7 @@ impl<T:Freeze+Send> ARC<T> {
  * object. However, one of the `arc` objects can be sent to another task,
  * allowing them to share the underlying data.
  */
-impl<T:Freeze + Send> Clone for ARC<T> {
+impl<T:Const + Owned> Clone for ARC<T> {
     fn clone(&self) -> ARC<T> {
         ARC { x: self.x.clone() }
     }
@@ -149,22 +149,22 @@ struct MutexARCInner<T> { lock: Mutex, failed: bool, data: T }
 struct MutexARC<T> { x: UnsafeAtomicRcBox<MutexARCInner<T>> }
 
 /// Create a mutex-protected ARC with the supplied data.
-pub fn MutexARC<T:Send>(user_data: T) -> MutexARC<T> {
+pub fn MutexARC<T:Owned>(user_data: T) -> MutexARC<T> {
     mutex_arc_with_condvars(user_data, 1)
 }
 /**
  * Create a mutex-protected ARC with the supplied data and a specified number
  * of condvars (as sync::mutex_with_condvars).
  */
-pub fn mutex_arc_with_condvars<T:Send>(user_data: T,
+pub fn mutex_arc_with_condvars<T:Owned>(user_data: T,
                                     num_condvars: uint) -> MutexARC<T> {
     let data =
         MutexARCInner { lock: mutex_with_condvars(num_condvars),
                           failed: false, data: user_data };
     MutexARC { x: UnsafeAtomicRcBox::new(data) }
 }
 
-impl<T:Send> Clone for MutexARC<T> {
+impl<T:Owned> Clone for MutexARC<T> {
     /// Duplicate a mutex-protected ARC, as arc::clone.
     fn clone(&self) -> MutexARC<T> {
         // NB: Cloning the underlying mutex is not necessary. Its reference
@@ -173,7 +173,7 @@ impl<T:Send> Clone for MutexARC<T> {
     }
 }
 
-impl<T:Send> MutexARC<T> {
+impl<T:Owned> MutexARC<T> {
 
     /**
      * Access the underlying mutable data with mutual exclusion from other
@@ -282,14 +282,14 @@ struct RWARC<T> {
 }
 
 /// Create a reader/writer ARC with the supplied data.
-pub fn RWARC<T:Freeze + Send>(user_data: T) -> RWARC<T> {
+pub fn RWARC<T:Const + Owned>(user_data: T) -> RWARC<T> {
     rw_arc_with_condvars(user_data, 1)
 }
 /**
  * Create a reader/writer ARC with the supplied data and a specified number
  * of condvars (as sync::rwlock_with_condvars).
  */
-pub fn rw_arc_with_condvars<T:Freeze + Send>(
+pub fn rw_arc_with_condvars<T:Const + Owned>(
     user_data: T,
     num_condvars: uint) -> RWARC<T>
 {
@@ -299,7 +299,7 @@ pub fn rw_arc_with_condvars<T:Freeze + Send>(
     RWARC { x: UnsafeAtomicRcBox::new(data), }
 }
 
-impl<T:Freeze + Send> RWARC<T> {
+impl<T:Const + Owned> RWARC<T> {
     /// Duplicate a rwlock-protected ARC, as arc::clone.
     pub fn clone(&self) -> RWARC<T> {
         RWARC {
@@ -309,7 +309,7 @@ impl<T:Freeze + Send> RWARC<T> {
 
 }
 
-impl<T:Freeze + Send> RWARC<T> {
+impl<T:Const + Owned> RWARC<T> {
     /**
      * Access the underlying data mutably. Locks the rwlock in write mode;
      * other readers and writers will block.
@@ -435,7 +435,7 @@ impl<T:Freeze + Send> RWARC<T> {
 // lock it. This wraps the unsafety, with the justification that the 'lock'
 // field is never overwritten; only 'failed' and 'data'.
 #[doc(hidden)]
-fn borrow_rwlock<T:Freeze + Send>(state: *const RWARCInner<T>) -> *RWlock {
+fn borrow_rwlock<T:Const + Owned>(state: *const RWARCInner<T>) -> *RWlock {
     unsafe { cast::transmute(&const (*state).lock) }
 }
 
@@ -452,7 +452,7 @@ pub struct RWReadMode<'self, T> {
     token: sync::RWlockReadMode<'self>,
 }
 
-impl<'self, T:Freeze + Send> RWWriteMode<'self, T> {
+impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
     /// Access the pre-downgrade RWARC in write mode.
     pub fn write<U>(&mut self, blk: &fn(x: &mut T) -> U) -> U {
         match *self {
@@ -493,7 +493,7 @@ impl<'self, T:Freeze + Send> RWWriteMode<'self, T> {
     }
 }
 
-impl<'self, T:Freeze + Send> RWReadMode<'self, T> {
+impl<'self, T:Const + Owned> RWReadMode<'self, T> {
     /// Access the post-downgrade rwlock in read mode.
     pub fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
         match *self {

branches/auto/src/libextra/arena.rs

@@ -186,18 +186,20 @@ impl Arena {
     #[inline]
     fn alloc_pod_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
         unsafe {
-            let this = transmute_mut_region(self);
-            let start = round_up_to(this.pod_head.fill, align);
+            // XXX: Borrow check
+            let head = transmute_mut_region(&mut self.pod_head);
+
+            let start = round_up_to(head.fill, align);
             let end = start + n_bytes;
-            if end > at_vec::capacity(this.pod_head.data) {
-                return this.alloc_pod_grow(n_bytes, align);
+            if end > at_vec::capacity(head.data) {
+                return self.alloc_pod_grow(n_bytes, align);
             }
-            this.pod_head.fill = end;
+            head.fill = end;
 
             //debug!("idx = %u, size = %u, align = %u, fill = %u",
             //       start, n_bytes, align, head.fill);
 
-            ptr::offset(vec::raw::to_ptr(this.pod_head.data), start)
+            ptr::offset(vec::raw::to_ptr(head.data), start)
         }
     }
 
@@ -229,31 +231,21 @@ impl Arena {
     fn alloc_nonpod_inner(&mut self, n_bytes: uint, align: uint)
                           -> (*u8, *u8) {
         unsafe {
-            let start;
-            let end;
-            let tydesc_start;
-            let after_tydesc;
-
-            {
-                let head = transmute_mut_region(&mut self.head);
-
-                tydesc_start = head.fill;
-                after_tydesc = head.fill + sys::size_of::<*TyDesc>();
-                start = round_up_to(after_tydesc, align);
-                end = start + n_bytes;
-            }
+            let head = transmute_mut_region(&mut self.head);
 
-            if end > at_vec::capacity(self.head.data) {
+            let tydesc_start = head.fill;
+            let after_tydesc = head.fill + sys::size_of::<*TyDesc>();
+            let start = round_up_to(after_tydesc, align);
+            let end = start + n_bytes;
+            if end > at_vec::capacity(head.data) {
                 return self.alloc_nonpod_grow(n_bytes, align);
             }
-
-            let head = transmute_mut_region(&mut self.head);
             head.fill = round_up_to(end, sys::pref_align_of::<*TyDesc>());
 
             //debug!("idx = %u, size = %u, align = %u, fill = %u",
             //       start, n_bytes, align, head.fill);
 
-            let buf = vec::raw::to_ptr(self.head.data);
+            let buf = vec::raw::to_ptr(head.data);
             return (ptr::offset(buf, tydesc_start), ptr::offset(buf, start));
         }
     }

branches/auto/src/libextra/bitv.rs

@@ -476,15 +476,9 @@ impl Bitv {
      * character is either '0' or '1'.
      */
      pub fn to_str(&self) -> ~str {
-        let mut rs = ~"";
-        for self.each() |i| {
-            if i {
-                rs.push_char('1');
-            } else {
-                rs.push_char('0');
-            }
-        };
-        rs
+       let mut rs = ~"";
+       for self.each() |i| { if i { rs += "1"; } else { rs += "0"; } };
+       rs
      }