---

yaml
---
r: 148820
b: refs/heads/try2
c: e704561
h: refs/heads/master
v: v3

Author: jfager

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 3e39e3e80dcf726a96ec0fe778f96e2a9dde620b
+refs/heads/try2: e704561003311daa5239e796b31bb4ade0a9eb3d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -3079,7 +3079,7 @@ A value of type `str` is a Unicode string,
 represented as a vector of 8-bit unsigned bytes holding a sequence of UTF-8 codepoints.
 Since `str` is of unknown size, it is not a _first class_ type,
 but can only be instantiated through a pointer type,
-such as `&str` or `~str`.
+such as `&str`, `@str` or `~str`.
 
 ### Tuple types
 
@@ -3115,7 +3115,7 @@ Such a definite-sized vector type is a first-class type, since its size is known
 A vector without such a size is said to be of _indefinite_ size,
 and is therefore not a _first-class_ type.
 An indefinite-size vector can only be instantiated through a pointer type,
-such as `&[T]` or `~[T]`.
+such as `&[T]`, `@[T]` or `~[T]`.
 The kind of a vector type depends on the kind of its element type,
 as with other simple structural types.
 

branches/try2/src/etc/zsh/_rust

@@ -5,110 +5,80 @@ local -a _rustc_opts_switches _rustc_opts_lint _rustc_opts_debug
 typeset -A opt_args
 
 _rustc_opts_switches=(
-    --android-cross-path'[The path to the Android NDK]'
-    --ar'[Program to use for managing archives instead of the default.]'
     --bin'[Compile an executable crate (default)]'
     -c'[Compile and assemble, but do not link]'
     --cfg'[Configure the compilation environment]'
-    --crate-id'[Output the crate id and exit]'
-    --crate-file-name'[Output the file(s) that would be written if compilation continued and exit]'
-    --crate-name'[Output the crate name and exit]'
-    --dep-info'[Output dependency info to <filename> after compiling]'
-    --dylib'[Compile a dynamic library crate]'
     --emit-llvm'[Produce an LLVM bitcode file]'
     {-h,--help}'[Display this message]'
     -L'[Add a directory to the library search path]'
     --lib'[Compile a library crate]'
     --linker'[Program to use for linking instead of the default.]'
     --link-args'[FLAGS is a space-separated list of flags passed to the linker]'
-    --llvm-args'[A list of arguments to pass to llvm, comma separated]'
     --ls'[List the symbols defined by a library crate]'
-    --no-analysis'[Parse and expand the output, but run no analysis or produce output]'
-    --no-rpath'[Disables setting the rpath in libs/exes]'
     --no-trans'[Run all passes except translation; no output]'
     -O'[Equivalent to --opt-level=2]'
     -o'[Write output to <filename>]'
     --opt-level'[Optimize with possible levels 0-3]'
     --out-dir'[Write output to compiler-chosen filename in <dir>]'
     --parse-only'[Parse only; do not compile, assemble, or link]'
-    --passes'[Comma or space separated list of pass names to use]'
     --pretty'[Pretty-print the input instead of compiling]'
-    --rlib'[Compile a rust library crate as an rlib file]'
     -S'[Compile only; do not assemble or link]'
     --save-temps'[Write intermediate files (.bc, .opt.bc, .o) in addition to normal output]'
-    --staticlib'[Compile a static library crate]'
     --sysroot'[Override the system root]'
     --test'[Build a test harness]'
     --target'[Target triple cpu-manufacturer-kernel\[-os\] to compile]'
     --target-cpu'[Select target processor (llc -mcpu=help for details)]'
     --target-feature'[Target specific attributes (llc -mattr=help for details)]'
+    --android-cross-path'[The path to the Android NDK]'
     {-v,--version}'[Print version info and exit]'
 )
 _rustc_opts_lint=(
-    'attribute-usage[detects bad use of attributes]'
+    'path-statement[path statements with no effect]'
+    'missing-trait-doc[detects missing documentation for traits]'
+    'missing-struct-doc[detects missing documentation for structs]'
     'ctypes[proper use of std::libc types in foreign modules]'
-    'dead-assignment[detect assignments that will never be read]'
-    'dead-code[detect piece of code that will never be used]'
-    'default-type-param-usage[prevents explicitly setting a type parameter with a default]'
-    'deprecated[detects use of #\[deprecated\] items]'
-    'experimental[detects use of #\[experimental\] items]'
+    "unused-mut[detect mut variables which don't need to be mutable]"
+    'unused-imports[imports that are never used]'
     'heap-memory[use of any (~ type or @ type) heap memory]'
-    'managed-heap-memory[use of managed (@ type) heap memory]'
-    'missing-doc[detects missing documentation for public members]'
-    'non-camel-case-types[types, variants and traits should have camel case names]'
-    'non-uppercase-pattern-statics[static constants in match patterns should be all caps]'
-    'non-uppercase-statics[static constants should have uppercase identifiers]'
-    'owned-heap-memory[use of owned (~ type) heap memory]'
-    'path-statement[path statements with no effect]'
-    'type-limits[comparisons made useless by limits of the types involved]'
-    'type-overflow[literal out of range for its type]'
-    'unknown-crate-type[unknown crate type found in #\[crate_type\] directive]'
-    'unknown-features[unknown features found in crate-level #\[feature\] directives]'
-    'unnecessary-allocation[detects unnecessary allocations that can be eliminated]'
-    'unnecessary-parens[`if`, `match`, `while` and `return` do not need parentheses]'
-    'unnecessary-qualification[detects unnecessarily qualified names]'
-    'unnecessary-typecast[detects unnecessary type casts, that can be removed]'
-    'unreachable-code[detects unreachable code]'
+    'default-methods[allow default methods]'
+    'unused-variable[detect variables which are not used in any way]'
+    'dead-assignment[detect assignments that will never be read]'
     'unrecognized-lint[unrecognized lint attribute]'
-    'unsafe-block[usage of an `unsafe` block]'
-    'unstable[detects use of #\[unstable\] items (incl. items with no stability attribute)]'
-    'unused-imports[imports that are never used]'
-    'unused-must-use[unused result of an type flagged as #\[must_use\]]'
-    "unused-mut[detect mut variables which don't need to be mutable]"
-    'unused-result[unused result of an expression in a statement]'
+    'type-limits[comparisons made useless by limits of the types involved]'
     'unused-unsafe[unnecessary use of an `unsafe` block]'
-    'unused-variable[detect variables which are not used in any way]'
-    'warnings[mass-change the level for lints which produce warnings]'
-    'while-true[suggest using `loop { }` instead of `while true { }`]'
+    'while-true[suggest using loop { } instead of while(true) { }]'
+    'non-camel-case-types[types, variants and traits should have camel case names]'
+    'managed-heap-memory[use of managed (@ type) heap memory]'
+    'unnecessary-allocation[detects unnecessary allocations that can be eliminated]'
+    'owned-heap-memory[use of owned (~ type) heap memory]'
 )
 
 _rustc_opts_debug=(
-    'asm-comments[generate comments into the assembly (may change behavior)]'
-    'borrowck-stats[gather borrowck statistics]'
-    'count-llvm-insns[count where LLVM instrs originate]'
-    'count-type-sizes[count the sizes of aggregate types]'
-    'debug-info[Produce debug info (experimental)]'
-    'debug-llvm[enable debug output from LLVM]'
-    'extra-debug-info[Extra debugging info (experimental)]'
-    'gc[Garbage collect shared data (experimental)]'
-    'gen-crate-map[Force generation of a toplevel crate map]'
-    'lto[Perform LLVM link-time optimizations]'
-    'meta-stats[gather metadata statistics]'
-    "no-integrated-as[Use external assembler rather than LLVM's integrated one]"
-    'no-landing-pads[omit landing pads for unwinding]'
-    'no-opt[do not optimize, even if -O is passed]'
-    "no-prepopulate-passes[Don't pre-populate the pass managers with a list of passes, only use the passes from --passes]"
-    "no-vectorize-loops[Don't run the loop vectorization optimization passes]"
-    "no-vectorize-slp[Don't run LLVM's SLP vectorization passes]"
-    'no-verify[skip LLVM verification]'
-    'prefer-dynamic[Prefer dynamic linking to static linking]'
-    'print-link-args[Print the arguments passed to the linker]'
-    'print-llvm-passes[Prints the llvm optimization passes being run]'
-    'soft-float[Generate software floating point library calls]'
-    'time-llvm-passes[measure time of each LLVM pass]'
-    'time-passes[measure time of each rustc pass]'
-    'trans-stats[gather trans statistics]'
-    'verbose[in general, enable more debug printouts]'
+    'verbose:in general, enable more debug printouts'
+    'time-passes:measure time of each rustc pass'
+    'count-llvm-insns:count where LLVM instrs originate'
+    'time-llvm-passes:measure time of each LLVM pass'
+    'trans-stats:gather trans statistics'
+    'asm-comments:generate comments into the assembly (may change behavior)'
+    'no-verify:skip LLVM verification'
+    'trace:emit trace logs'
+    'coherence:perform coherence checking'
+    'borrowck-stats:gather borrowck statistics'
+    "borrowck-note-pure:note where purity is req'd"
+    "borrowck-note-loan:note where loans are req'd"
+    'no-landing-pads:omit landing pads for unwinding'
+    'debug-llvm:enable debug output from LLVM'
+    'count-type-sizes:count the sizes of aggregate types'
+    'meta-stats:gather metadata statistics'
+    'no-opt:do not optimize, even if -O is passed'
+    'print-link-args:Print the arguments passed to the linker'
+    'gc:Garbage collect shared data (experimental)'
+    'jit:Execute using JIT (experimental)'
+    'extra-debug-info:Extra debugging info (experimental)'
+    'debug-info:Produce debug info (experimental)'
+    'static:Use or produce static libraries or binaries (experimental)'
+    'no-debug-borrows:do not show where borrow checks fail'
+    'lint-llvm:Run the LLVM lint pass on the pre-optimization IR'
 )
 
 _rustc_opts_fun_lint(){

branches/try2/src/libarena/lib.rs

@@ -27,38 +27,28 @@ extern mod extra;
 use extra::list::{List, Cons, Nil};
 use extra::list;
 
+use std::at_vec;
 use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
 use std::cell::{Cell, RefCell};
 use std::num;
 use std::ptr;
 use std::kinds::marker;
 use std::mem;
-use std::rc::Rc;
 use std::rt::global_heap;
 use std::unstable::intrinsics::{TyDesc, get_tydesc};
 use std::unstable::intrinsics;
 use std::util;
-use std::vec;
 
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
 // will always stay at 0.
 #[deriving(Clone)]
 struct Chunk {
-    data: Rc<RefCell<~[u8]>>,
+    data: RefCell<@[u8]>,
     fill: Cell<uint>,
     is_pod: Cell<bool>,
 }
-impl Chunk {
-    fn capacity(&self) -> uint {
-        self.data.borrow().borrow().get().capacity()
-    }
-
-    unsafe fn as_ptr(&self) -> *u8 {
-        self.data.borrow().borrow().get().as_ptr()
-    }
-}
 
 // Arenas are used to quickly allocate objects that share a
 // lifetime. The arena uses ~[u8] vectors as a backing store to
@@ -107,8 +97,10 @@ impl Arena {
 }
 
 fn chunk(size: uint, is_pod: bool) -> Chunk {
+    let mut v: @[u8] = @[];
+    unsafe { at_vec::raw::reserve(&mut v, size); }
     Chunk {
-        data: Rc::new(RefCell::new(vec::with_capacity(size))),
+        data: RefCell::new(unsafe { cast::transmute(v) }),
         fill: Cell::new(0u),
         is_pod: Cell::new(is_pod),
     }
@@ -139,7 +131,10 @@ fn round_up(base: uint, align: uint) -> uint {
 // in it.
 unsafe fn destroy_chunk(chunk: &Chunk) {
     let mut idx = 0;
-    let buf = chunk.as_ptr();
+    let buf = {
+        let data = chunk.data.borrow();
+        data.get().as_ptr()
+    };
     let fill = chunk.fill.get();
 
     while idx < fill {
@@ -177,13 +172,11 @@ unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
 }
 
 impl Arena {
-    fn chunk_size(&self) -> uint {
-        self.pod_head.capacity()
-    }
     // Functions for the POD part of the arena
     fn alloc_pod_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
-        let new_min_chunk_size = num::max(n_bytes, self.chunk_size());
+        let chunk_size = at_vec::capacity(self.pod_head.data.get());
+        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);
@@ -197,15 +190,15 @@ impl Arena {
             let this = transmute_mut_region(self);
             let start = round_up(this.pod_head.fill.get(), align);
             let end = start + n_bytes;
-            if end > self.chunk_size() {
+            if end > at_vec::capacity(this.pod_head.data.get()) {
                 return this.alloc_pod_grow(n_bytes, align);
             }
             this.pod_head.fill.set(end);
 
             //debug!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill.get());
 
-            this.pod_head.as_ptr().offset(start as int)
+            ptr::offset(this.pod_head.data.get().as_ptr(), start as int)
         }
     }
 
@@ -224,7 +217,8 @@ impl Arena {
     fn alloc_nonpod_grow(&mut self, n_bytes: uint, align: uint)
                          -> (*u8, *u8) {
         // Allocate a new chunk.
-        let new_min_chunk_size = num::max(n_bytes, self.chunk_size());
+        let chunk_size = at_vec::capacity(self.head.data.get());
+        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);
@@ -250,7 +244,7 @@ impl Arena {
                 end = start + n_bytes;
             }
 
-            if end > self.head.capacity() {
+            if end > at_vec::capacity(self.head.data.get()) {
                 return self.alloc_nonpod_grow(n_bytes, align);
             }
 
@@ -260,7 +254,7 @@ impl Arena {
             //debug!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill);
 
-            let buf = self.head.as_ptr();
+            let buf = self.head.data.get().as_ptr();
             return (ptr::offset(buf, tydesc_start as int), ptr::offset(buf, start as int));
         }
     }
@@ -612,3 +606,5 @@ mod test {
         })
     }
 }
+
+

branches/try2/src/libextra/num/bigint.rs

@@ -80,7 +80,7 @@ pub mod BigDigit {
 /**
 A big unsigned integer type.
 
-A `BigUint`-typed value `BigUint { data: ~[a, b, c] }` represents a number
+A `BigUint`-typed value `BigUint { data: @[a, b, c] }` represents a number
 `(a + b * BigDigit::base + c * BigDigit::base^2)`.
 */
 #[deriving(Clone)]

branches/try2/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().unwrap().get_mut_ref())
+        Some(r.mut_shift_ref().get_mut_ref())
     }
 
     #[inline]
@@ -325,7 +325,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> {
             &mut self.remaining1
         };
         self.nelts -= 1;
-        Some(r.mut_pop_ref().unwrap().get_mut_ref())
+        Some(r.mut_pop_ref().get_mut_ref())
     }
 }
 

branches/try2/src/libextra/serialize.rs

@@ -18,6 +18,7 @@ Core encoding and decoding interfaces.
 #[forbid(non_camel_case_types)];
 
 
+use std::at_vec;
 use std::hashmap::{HashMap, HashSet};
 use std::rc::Rc;
 use std::trie::{TrieMap, TrieSet};
@@ -309,6 +310,18 @@ impl<D:Decoder> Decodable<D> for ~str {
     }
 }
 
+impl<S:Encoder> Encodable<S> for @str {
+    fn encode(&self, s: &mut S) {
+        s.emit_str(*self)
+    }
+}
+
+impl<D:Decoder> Decodable<D> for @str {
+    fn decode(d: &mut D) -> @str {
+        d.read_str().to_managed()
+    }
+}
+
 impl<S:Encoder> Encodable<S> for f32 {
     fn encode(&self, s: &mut S) {
         s.emit_f32(*self)
@@ -443,6 +456,26 @@ impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
     }
 }
 
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
+    fn encode(&self, s: &mut S) {
+        s.emit_seq(self.len(), |s| {
+            for (i, e) in self.iter().enumerate() {
+                s.emit_seq_elt(i, |s| e.encode(s))
+            }
+        })
+    }
+}
+
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
+    fn decode(d: &mut D) -> @[T] {
+        d.read_seq(|d, len| {
+            at_vec::from_fn(len, |i| {
+                d.read_seq_elt(i, |d| Decodable::decode(d))
+            })
+        })
+    }
+}
+
 impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
     fn encode(&self, s: &mut S) {
         s.emit_option(|s| {