---

yaml
---
r: 143222
b: refs/heads/try2
c: 5991c60
h: refs/heads/master
v: v3

Author: blake2-ppc

[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: 4a726f0573dcfcd01ae9b37266014df0e26f2e22
+refs/heads/try2: 5991c607501595b32998a3367171ca42f5d8ef0b
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial-container.md

@@ -192,15 +192,15 @@ let mut it = xs.iter().zip(ys.iter());
 
 // print out the pairs of elements up to (&3, &"baz")
 for it.advance |(x, y)| {
-    printfln!("%d %s", *x, *y);
+    println(fmt!("%d %s", *x, *y));
 
     if *x == 3 {
         break;
     }
 }
 
 // yield and print the last pair from the iterator
-printfln!("last: %?", it.next());
+println(fmt!("last: %?", it.next()));
 
 // the iterator is now fully consumed
 assert!(it.next().is_none());
@@ -294,59 +294,15 @@ another `DoubleEndedIterator` with `next` and `next_back` exchanged.
 ~~~
 let xs = [1, 2, 3, 4, 5, 6];
 let mut it = xs.iter();
-printfln!("%?", it.next()); // prints `Some(&1)`
-printfln!("%?", it.next()); // prints `Some(&2)`
-printfln!("%?", it.next_back()); // prints `Some(&6)`
+println(fmt!("%?", it.next())); // prints `Some(&1)`
+println(fmt!("%?", it.next())); // prints `Some(&2)`
+println(fmt!("%?", it.next_back())); // prints `Some(&6)`
 
 // prints `5`, `4` and `3`
 for it.invert().advance |&x| {
-    printfln!("%?", x)
+    println(fmt!("%?", x))
 }
 ~~~
 
 The `rev_iter` and `mut_rev_iter` methods on vectors just return an inverted
 version of the standard immutable and mutable vector iterators.
-
-The `chain_`, `transform`, `filter`, `filter_map` and `peek` adaptors are
-`DoubleEndedIterator` implementations if the underlying iterators are.
-
-~~~
-let xs = [1, 2, 3, 4];
-let ys = [5, 6, 7, 8];
-let mut it = xs.iter().chain_(ys.iter()).transform(|&x| x * 2);
-
-printfln!("%?", it.next()); // prints `Some(2)`
-
-// prints `16`, `14`, `12`, `10`, `8`, `6`, `4`
-for it.invert().advance |x| {
-    printfln!("%?", x);
-}
-~~~
-
-## Random-access iterators
-
-The `RandomAccessIterator` trait represents an iterator offering random access
-to the whole range. The `indexable` method retrieves the number of elements
-accessible with the `idx` method.
-
-The `chain_` adaptor is an implementation of `RandomAccessIterator` if the
-underlying iterators are.
-
-~~~
-let xs = [1, 2, 3, 4, 5];
-let ys = ~[7, 9, 11];
-let mut it = xs.iter().chain_(ys.iter());
-printfln!("%?", it.idx(0)); // prints `Some(&1)`
-printfln!("%?", it.idx(5)); // prints `Some(&7)`
-printfln!("%?", it.idx(7)); // prints `Some(&11)`
-printfln!("%?", it.idx(8)); // prints `None`
-
-// yield two elements from the beginning, and one from the end
-it.next();
-it.next();
-it.next_back();
-
-printfln!("%?", it.idx(0)); // prints `Some(&3)`
-printfln!("%?", it.idx(4)); // prints `Some(&9)`
-printfln!("%?", it.idx(6)); // prints `None`
-~~~

branches/try2/doc/tutorial.md

@@ -499,8 +499,8 @@ types.
 > items.
 
 ~~~~
-use std::float;
-use std::num::atan;
+# use std::float;
+# use std::num::atan;
 fn angle(vector: (float, float)) -> float {
     let pi = float::consts::pi;
     match vector {
@@ -555,7 +555,7 @@ while cake_amount > 0 {
 `loop` denotes an infinite loop, and is the preferred way of writing `while true`:
 
 ~~~~
-use std::int;
+# use std::int;
 let mut x = 5;
 loop {
     x += x - 3;
@@ -701,7 +701,7 @@ get at their contents. All variant constructors can be used as
 patterns, as in this definition of `area`:
 
 ~~~~
-use std::float;
+# use std::float;
 # struct Point {x: float, y: float}
 # enum Shape { Circle(Point, float), Rectangle(Point, Point) }
 fn area(sh: Shape) -> float {
@@ -733,7 +733,7 @@ fn point_from_direction(dir: Direction) -> Point {
 Enum variants may also be structs. For example:
 
 ~~~~
-use std::float;
+# use std::float;
 # struct Point { x: float, y: float }
 # fn square(x: float) -> float { x * x }
 enum Shape {
@@ -1599,8 +1599,7 @@ lists back to back. Since that is so unsightly, empty argument lists
 may be omitted from `do` expressions.
 
 ~~~~
-use std::task::spawn;
-
+# use std::task::spawn;
 do spawn {
    debug!("Kablam!");
 }
@@ -1729,7 +1728,7 @@ impl Circle {
 To call such a method, just prefix it with the type name and a double colon:
 
 ~~~~
-use std::float::consts::pi;
+# use std::float::consts::pi;
 struct Circle { radius: float }
 impl Circle {
     fn new(area: float) -> Circle { Circle { radius: (area / pi).sqrt() } }
@@ -1775,7 +1774,7 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-use std::hashmap::HashMap;
+# use std::hashmap::HashMap;
 type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
@@ -2001,7 +2000,7 @@ name and a double colon.  The compiler uses type inference to decide which
 implementation to use.
 
 ~~~~
-use std::float::consts::pi;
+# use std::float::consts::pi;
 trait Shape { fn new(area: float) -> Self; }
 struct Circle { radius: float }
 struct Square { length: float }
@@ -2157,7 +2156,7 @@ trait Circle : Shape { fn radius(&self) -> float; }
 Now, we can implement `Circle` on a type only if we also implement `Shape`.
 
 ~~~~
-use std::float::consts::pi;
+# use std::float::consts::pi;
 # trait Shape { fn area(&self) -> float; }
 # trait Circle : Shape { fn radius(&self) -> float; }
 # struct Point { x: float, y: float }
@@ -2192,7 +2191,7 @@ fn radius_times_area<T: Circle>(c: T) -> float {
 Likewise, supertrait methods may also be called on trait objects.
 
 ~~~ {.xfail-test}
-use std::float::consts::pi;
+# use std::float::consts::pi;
 # trait Shape { fn area(&self) -> float; }
 # trait Circle : Shape { fn radius(&self) -> float; }
 # struct Point { x: float, y: float }

branches/try2/mk/snap.mk

@@ -12,8 +12,13 @@ define DEF_SNAP_FOR_STAGE_H
 # $(1) stage
 # $(2) triple
 
+ifdef CFG_INSTALL_SNAP
+snap-stage$(1)-H-$(2): $$(HSREQ$(1)_H_$(2))
+	$(CFG_PYTHON) $(S)src/etc/make-snapshot.py stage$(1) $(2) install
+else
 snap-stage$(1)-H-$(2): $$(HSREQ$(1)_H_$(2))
 	$(CFG_PYTHON) $(S)src/etc/make-snapshot.py stage$(1) $(2)
+endif
 
 endef
 

branches/try2/mk/target.mk

@@ -17,7 +17,8 @@ export CFG_COMPILER_TRIPLE
 # code, make sure that these common warnings are denied by default. These can
 # be overridden during development temporarily. For stage0, we allow all these
 # to suppress warnings which may be bugs in stage0 (should be fixed in stage1+)
-WFLAGS_ST0 = -A warnings
+# NOTE: add "-A warnings" after snapshot to WFLAGS_ST0
+WFLAGS_ST0 = -A unrecognized-lint
 WFLAGS_ST1 = -D warnings
 WFLAGS_ST2 = -D warnings
 

branches/try2/src/compiletest/compiletest.rs

@@ -242,13 +242,13 @@ pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
     let mut tests = ~[];
     let dirs = os::list_dir_path(&config.src_base);
     for dirs.iter().advance |file| {
-        let file = file.clone();
+        let file = (*file).clone();
         debug!("inspecting file %s", file.to_str());
-        if is_test(config, &file) {
-            let t = do make_test(config, &file) {
+        if is_test(config, file) {
+            let t = do make_test(config, file) {
                 match config.mode {
-                    mode_codegen => make_metrics_test_closure(config, &file),
-                    _ => make_test_closure(config, &file)
+                    mode_codegen => make_metrics_test_closure(config, file),
+                    _ => make_test_closure(config, file)
                 }
             };
             tests.push(t)

branches/try2/src/compiletest/runtest.rs

@@ -292,7 +292,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             }
         }
         if i != num_check_lines {
-            fatal_ProcRes(fmt!("line not found in debugger output: %s",
+            fatal_ProcRes(fmt!("line not found in debugger output: %s"
                                check_lines[i]), &ProcRes);
         }
     }

branches/try2/src/etc/emacs/README.md

@@ -98,8 +98,3 @@ marking, press x, and ELPA will install the packages for you (under
 ~/.emacs.d/elpa/).
 
 * or using <kbd>M-x package-install rust-mode
-
-### Known bugs
-
-* Combining `global-whitespace-mode` and `rust-mode` is generally glitchy.
-  See [Issue #3994](https://github.com/mozilla/rust/issues/3994).

branches/try2/src/etc/extract-tests.py

@@ -60,6 +60,9 @@
             if not re.search(r"\bextern mod extra\b", block):
                 block = "extern mod extra;\n" + block
             block = """#[ forbid(ctypes) ];
+#[ forbid(deprecated_pattern) ];
+#[ forbid(implicit_copies) ];
+#[ forbid(non_implicitly_copyable_typarams) ];
 #[ forbid(path_statement) ];
 #[ forbid(type_limits) ];
 #[ forbid(unrecognized_lint) ];

branches/try2/src/etc/make-snapshot.py

@@ -3,4 +3,7 @@
 
 import snapshot, sys
 
-print(snapshot.make_snapshot(sys.argv[1], sys.argv[2]))
+if len(sys.argv) == 3:
+    print(snapshot.make_snapshot(sys.argv[1], sys.argv[2], ""))
+else:
+    print(snapshot.make_snapshot(sys.argv[1], sys.argv[2], sys.argv[3]))

branches/try2/src/etc/snapshot.py

@@ -156,7 +156,7 @@ def hash_file(x):
     return scrub(h.hexdigest())
 
 
-def make_snapshot(stage, triple):
+def make_snapshot(stage, triple, flag):
     kernel = get_kernel(triple)
     platform = get_platform(triple)
     rev = local_rev_short_sha()
@@ -190,4 +190,33 @@ def in_tar_name(fn):
 
     shutil.move(file0, file1)
 
+    if flag == "install":
+      # FIXME (#2664): this is an ugly quick hack; pls make it better
+      path  = file1
+      comps = path.split("-")
+      parts = { 'year': comps[2], \
+                'month': comps[3], \
+                'date': comps[4], \
+                'check': comps[5], \
+                'plat': comps[6], \
+                'arch': comps[7], \
+                'sha': comps[8].split(".")[0] }
+
+      shutil.move(path, "dl/" + path)
+      shutil.move('src/snapshots.txt', 'src/snapshots-old.txt')
+
+      newf = open('src/snapshots.txt', 'w')
+      newf.write("T %(year)s-%(month)s-%(date)s %(check)s\n" % parts)
+      newf.write("  %(plat)s-%(arch)s %(sha)s\n\n" % parts)
+
+      oldf = open('src/snapshots-old.txt', 'r')
+      for line in oldf:
+        newf.write(line)
+      oldf.close()
+
+      newf.close()
+
+      os.remove('src/snapshots-old.txt')
+
+
     return file1

branches/try2/src/etc/tidy.py

@@ -49,9 +49,9 @@ def do_license_check(name, contents):
                     report_err("FIXME without issue number")
             if line.find("TODO") != -1:
                 report_err("TODO is deprecated; use FIXME")
-            match = re.match(r'^.*//\s*(NOTE.*)$', line)
-            if match:
-                report_warn(match.group(1))
+            idx = line.find("// NOTE")
+            if idx != -1:
+                report_warn("NOTE" + line[idx + len("// NOTE"):])
         if (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):
             report_err("tab character")

branches/try2/src/etc/zsh/_rust

@@ -33,9 +33,12 @@ _rustc_opts_switches=(
 )
 _rustc_opts_lint=(
     'path-statement[path statements with no effect]'
+    'deprecated-pattern[warn about deprecated uses of pattern bindings]'
+    'non-implicitly-copyable-typarams[passing non implicitly copyable types as copy type params]'
     'missing-trait-doc[detects missing documentation for traits]'
     'missing-struct-doc[detects missing documentation for structs]'
     'ctypes[proper use of core::libc types in foreign modules]'
+    'implicit-copies[implicit copies of non implicitly copyable data]'
     "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]'

branches/try2/src/libextra/arc.rs

@@ -305,6 +305,7 @@ struct RWARCInner<T> { priv lock: RWlock, priv failed: bool, priv data: T }
  *
  * Unlike mutex_arcs, rw_arcs are safe, because they cannot be nested.
  */
+#[mutable] // XXX remove after snap
 #[no_freeze]
 struct RWARC<T> {
     priv x: UnsafeAtomicRcBox<RWARCInner<T>>,

branches/try2/src/libextra/arena.rs

@@ -46,7 +46,15 @@ use std::sys;
 use std::uint;
 use std::vec;
 use std::unstable::intrinsics;
-use std::unstable::intrinsics::{TyDesc, get_tydesc};
+use std::unstable::intrinsics::{TyDesc};
+
+#[cfg(not(stage0))]
+use std::unstable::intrinsics::{get_tydesc};
+
+#[cfg(stage0)]
+unsafe fn get_tydesc<T>() -> *TyDesc {
+    intrinsics::get_tydesc::<T>() as *TyDesc
+}
 
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
@@ -57,6 +65,7 @@ struct Chunk {
     is_pod: bool,
 }
 
+#[mutable] // XXX remove after snap
 #[no_freeze]
 pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
@@ -108,6 +117,19 @@ fn round_up_to(base: uint, align: uint) -> uint {
     (base + (align - 1)) & !(align - 1)
 }
 
+#[inline]
+#[cfg(not(stage0))]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    // This function should be inlined when stage0 is gone
+    ((*tydesc).drop_glue)(data);
+}
+
+#[inline]
+#[cfg(stage0)]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    ((*tydesc).drop_glue)(0 as **TyDesc, data);
+}
+
 // Walk down a chunk, running the destructors for any objects stored
 // in it.
 unsafe fn destroy_chunk(chunk: &Chunk) {
@@ -127,7 +149,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         //debug!("freeing object: idx = %u, size = %u, align = %u, done = %b",
         //       start, size, align, is_done);
         if is_done {
-            ((*tydesc).drop_glue)(ptr::offset(buf, start) as *i8);
+            call_drop_glue(tydesc, ptr::offset(buf, start) as *i8);
         }
 
         // Find where the next tydesc lives