---

yaml
---
r: 144359
b: refs/heads/try2
c: 4c75d36
h: refs/heads/master
i:
  144357: b79fee9
  144355: a43a1d5
  144351: 3cf2b3b
v: v3

Author: brson

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

branches/try2/.gitattributes

@@ -8,6 +8,3 @@ src/rt/msvc/* -whitespace
 src/rt/vg/* -whitespace
 src/rt/linenoise/* -whitespace
 src/rt/jemalloc/**/* -whitespace
-src/rt/jemalloc/include/jemalloc/jemalloc.h.in text eol=lf
-src/rt/jemalloc/include/jemalloc/jemalloc_defs.h.in text eol=lf
-src/rt/jemalloc/include/jemalloc/internal/jemalloc_internal.h.in text eol=lf

branches/try2/doc/tutorial.md

@@ -1864,7 +1864,7 @@ so you could not apply `head` to a type
 that does not implement `Clone`.
 
 While most traits can be defined and implemented by user code,
-three traits are automatically derived and implemented
+two traits are automatically derived and implemented
 for all applicable types by the compiler,
 and may not be overridden:
 
@@ -1877,12 +1877,6 @@ These are types that do not contain anything intrinsically mutable.
 Intrinsically mutable values include `@mut`
 and `Cell` in the standard library.
 
-* `'static` - Non-borrowed types.
-These are types that do not contain any data whose lifetime is bound to
-a particular stack frame. These are types that do not contain any
-borrowed pointers, or types where the only contained borrowed pointers
-have the `'static` lifetime.
-
 > ***Note:*** These two traits were referred to as 'kinds' in earlier
 > iterations of the language, and often still are.
 
@@ -2141,30 +2135,6 @@ select the method to call at runtime.
 
 This usage of traits is similar to Java interfaces.
 
-By default, each of the three storage classes for traits enforce a
-particular set of built-in kinds that their contents must fulfill in
-order to be packaged up in a trait object of that storage class.
-
-* The contents of owned traits (`~Trait`) must fulfill the `Send` bound.
-* The contents of managed traits (`@Trait`) must fulfill the `'static` bound.
-* The contents of borrowed traits (`&Trait`) are not constrained by any bound.
-
-Consequently, the trait objects themselves automatically fulfill their
-respective kind bounds. However, this default behavior can be overridden by
-specifying a list of bounds on the trait type, for example, by writing `~Trait:`
-(which indicates that the contents of the owned trait need not fulfill any
-bounds), or by writing `~Trait:Send+Freeze`, which indicates that in addition
-to fulfilling `Send`, contents must also fulfill `Freeze`, and as a consequence,
-the trait itself fulfills `Freeze`.
-
-* `~Trait:Send` is equivalent to `~Trait`.
-* `@Trait:'static` is equivalent to `@Trait`.
-* `&Trait:` is equivalent to `&Trait`.
-
-Builtin kind bounds can also be specified on closure types in the same way (for
-example, by writing `fn:Freeze()`), and the default behaviours are the same as
-for traits of the same storage class.
-
 ## Trait inheritance
 
 We can write a trait declaration that _inherits_ from other traits, called _supertraits_.

branches/try2/mk/tests.mk

@@ -73,24 +73,16 @@ TEST_RATCHET_NOISE_PERCENT=10.0
 
 # Whether to ratchet or merely save benchmarks
 ifdef CFG_RATCHET_BENCH
-CRATE_TEST_EXTRA_ARGS=\
+CRATE_TEST_BENCH_ARGS=\
   --test $(TEST_BENCH) \
   --ratchet-metrics $(call TEST_RATCHET_FILE,$(1),$(2),$(3),$(4)) \
   --ratchet-noise-percent $(TEST_RATCHET_NOISE_PERCENT)
 else
-CRATE_TEST_EXTRA_ARGS=\
+CRATE_TEST_BENCH_ARGS=\
   --test $(TEST_BENCH) \
   --save-metrics $(call TEST_RATCHET_FILE,$(1),$(2),$(3),$(4))
 endif
 
-# If we're sharding the testsuite between parallel testers,
-# pass this argument along to the compiletest and crate test
-# invocations.
-ifdef TEST_SHARD
-  CTEST_TESTARGS += --test-shard=$(TEST_SHARD)
-  CRATE_TEST_EXTRA_ARGS += --test-shard=$(TEST_SHARD)
-endif
-
 define DEF_TARGET_COMMANDS
 
 ifdef CFG_UNIXY_$(1)
@@ -409,7 +401,7 @@ $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 	@$$(call E, run: $$<)
 	$$(Q)$$(call CFG_RUN_TEST_$(2),$$<,$(2),$(3)) $$(TESTARGS)	\
 	--logfile $$(call TEST_LOG_FILE,$(1),$(2),$(3),$(4)) \
-	$$(call CRATE_TEST_EXTRA_ARGS,$(1),$(2),$(3),$(4)) \
+	$$(call CRATE_TEST_BENCH_ARGS,$(1),$(2),$(3),$(4)) \
 	&& touch $$@
 endef
 
@@ -423,7 +415,7 @@ $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 	@$(CFG_ADB) shell '(cd $(CFG_ADB_TEST_DIR); LD_LIBRARY_PATH=. \
 		./$$(notdir $$<) \
 		--logfile $(CFG_ADB_TEST_DIR)/check-stage$(1)-T-$(2)-H-$(3)-$(4).log \
-		$$(call CRATE_TEST_EXTRA_ARGS,$(1),$(2),$(3),$(4)))' \
+		$$(call CRATE_TEST_BENCH_ARGS,$(1),$(2),$(3),$(4)))' \
 		> tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp
 	@cat tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp
 	@touch tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).log

branches/try2/src/compiletest/common.rs

@@ -68,11 +68,6 @@ pub struct config {
     // Percent change in metrics to consider noise
     ratchet_noise_percent: Option<f64>,
 
-    // "Shard" of the testsuite to run: this has the form of
-    // two numbers (a,b), and causes only those tests with
-    // positional order equal to a mod b to run.
-    test_shard: Option<(uint,uint)>,
-
     // A command line to prefix program execution with,
     // for running under valgrind
     runtool: Option<~str>,

branches/try2/src/compiletest/compiletest.rs

@@ -75,7 +75,6 @@ pub fn parse_config(args: ~[~str]) -> config {
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
-          optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", "A.B"),
           optflag("h", "help", "show this message"),
          ];
 
@@ -149,7 +148,6 @@ pub fn parse_config(args: ~[~str]) -> config {
                     ~"") { true }
                 else { false }
             } else { false },
-        test_shard: test::opt_shard(getopts::opt_maybe_str(matches, "test-shard")),
         verbose: getopts::opt_present(matches, "verbose")
     }
 }
@@ -174,10 +172,6 @@ pub fn log_config(config: &config) {
     logv(c, fmt!("adb_path: %s", config.adb_path));
     logv(c, fmt!("adb_test_dir: %s", config.adb_test_dir));
     logv(c, fmt!("adb_device_status: %b", config.adb_device_status));
-    match config.test_shard {
-        None => logv(c, ~"test_shard: (all)"),
-        Some((a,b)) => logv(c, fmt!("test_shard: %u.%u", a, b))
-    }
     logv(c, fmt!("verbose: %b", config.verbose));
     logv(c, fmt!("\n"));
 }
@@ -240,7 +234,6 @@ pub fn test_opts(config: &config) -> test::TestOpts {
         ratchet_metrics: config.ratchet_metrics.clone(),
         ratchet_noise_percent: config.ratchet_noise_percent.clone(),
         save_metrics: config.save_metrics.clone(),
-        test_shard: config.test_shard.clone()
     }
 }
 

branches/try2/src/libextra/json.rs

@@ -459,24 +459,26 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
     }
 }
 
-impl Json{
-    /// Encodes a json value into a io::writer.  Uses a single line.
-    pub fn to_writer(&self, wr: @io::Writer) {
-        let mut encoder = Encoder(wr);
-        self.encode(&mut encoder)
-    }
+/// Encodes a json value into a io::writer
+pub fn to_writer(wr: @io::Writer, json: &Json) {
+    let mut encoder = Encoder(wr);
+    json.encode(&mut encoder)
+}
 
-    /// Encodes a json value into a io::writer.
-    /// Pretty-prints in a more readable format.
-    pub fn to_pretty_writer(&self, wr: @io::Writer) {
-        let mut encoder = PrettyEncoder(wr);
-        self.encode(&mut encoder)
-    }
+/// Encodes a json value into a string
+pub fn to_str(json: &Json) -> ~str {
+    io::with_str_writer(|wr| to_writer(wr, json))
+}
 
-    /// Encodes a json value into a string
-    pub fn to_pretty_str(&self) -> ~str {
-        io::with_str_writer(|wr| self.to_pretty_writer(wr))
-    }
+/// Encodes a json value into a io::writer
+pub fn to_pretty_writer(wr: @io::Writer, json: &Json) {
+    let mut encoder = PrettyEncoder(wr);
+    json.encode(&mut encoder)
+}
+
+/// Encodes a json value into a string
+pub fn to_pretty_str(json: &Json) -> ~str {
+    io::with_str_writer(|wr| to_pretty_writer(wr, json))
 }
 
 pub struct Parser<T> {
@@ -1305,10 +1307,7 @@ impl<A:ToJson> ToJson for Option<A> {
 }
 
 impl to_str::ToStr for Json {
-    /// Encodes a json value into a string
-    fn to_str(&self) -> ~str {
-      io::with_str_writer(|wr| self.to_writer(wr))
-    }
+    fn to_str(&self) -> ~str { to_str(self) }
 }
 
 impl to_str::ToStr for Error {
@@ -1359,67 +1358,69 @@ mod tests {
 
     #[test]
     fn test_write_null() {
-        assert_eq!(Null.to_str(), ~"null");
-        assert_eq!(Null.to_pretty_str(), ~"null");
+        assert_eq!(to_str(&Null), ~"null");
+        assert_eq!(to_pretty_str(&Null), ~"null");
     }
 
 
     #[test]
     fn test_write_number() {
-        assert_eq!(Number(3f).to_str(), ~"3");
-        assert_eq!(Number(3f).to_pretty_str(), ~"3");
+        assert_eq!(to_str(&Number(3f)), ~"3");
+        assert_eq!(to_pretty_str(&Number(3f)), ~"3");
 
-        assert_eq!(Number(3.1f).to_str(), ~"3.1");
-        assert_eq!(Number(3.1f).to_pretty_str(), ~"3.1");
+        assert_eq!(to_str(&Number(3.1f)), ~"3.1");
+        assert_eq!(to_pretty_str(&Number(3.1f)), ~"3.1");
 
-        assert_eq!(Number(-1.5f).to_str(), ~"-1.5");
-        assert_eq!(Number(-1.5f).to_pretty_str(), ~"-1.5");
+        assert_eq!(to_str(&Number(-1.5f)), ~"-1.5");
+        assert_eq!(to_pretty_str(&Number(-1.5f)), ~"-1.5");
 
-        assert_eq!(Number(0.5f).to_str(), ~"0.5");
-        assert_eq!(Number(0.5f).to_pretty_str(), ~"0.5");
+        assert_eq!(to_str(&Number(0.5f)), ~"0.5");
+        assert_eq!(to_pretty_str(&Number(0.5f)), ~"0.5");
     }
 
     #[test]
     fn test_write_str() {
-        assert_eq!(String(~"").to_str(), ~"\"\"");
-        assert_eq!(String(~"").to_pretty_str(), ~"\"\"");
+        assert_eq!(to_str(&String(~"")), ~"\"\"");
+        assert_eq!(to_pretty_str(&String(~"")), ~"\"\"");
 
-        assert_eq!(String(~"foo").to_str(), ~"\"foo\"");
-        assert_eq!(String(~"foo").to_pretty_str(), ~"\"foo\"");
+        assert_eq!(to_str(&String(~"foo")), ~"\"foo\"");
+        assert_eq!(to_pretty_str(&String(~"foo")), ~"\"foo\"");
     }
 
     #[test]
     fn test_write_bool() {
-        assert_eq!(Boolean(true).to_str(), ~"true");
-        assert_eq!(Boolean(true).to_pretty_str(), ~"true");
+        assert_eq!(to_str(&Boolean(true)), ~"true");
+        assert_eq!(to_pretty_str(&Boolean(true)), ~"true");
 
-        assert_eq!(Boolean(false).to_str(), ~"false");
-        assert_eq!(Boolean(false).to_pretty_str(), ~"false");
+        assert_eq!(to_str(&Boolean(false)), ~"false");
+        assert_eq!(to_pretty_str(&Boolean(false)), ~"false");
     }
 
     #[test]
     fn test_write_list() {
-        assert_eq!(List(~[]).to_str(), ~"[]");
-        assert_eq!(List(~[]).to_pretty_str(), ~"[]");
+        assert_eq!(to_str(&List(~[])), ~"[]");
+        assert_eq!(to_pretty_str(&List(~[])), ~"[]");
 
-        assert_eq!(List(~[Boolean(true)]).to_str(), ~"[true]");
+        assert_eq!(to_str(&List(~[Boolean(true)])), ~"[true]");
         assert_eq!(
-            List(~[Boolean(true)]).to_pretty_str(),
+            to_pretty_str(&List(~[Boolean(true)])),
             ~"\
             [\n  \
                 true\n\
             ]"
         );
 
-        let longTestList = List(~[
+        assert_eq!(to_str(&List(~[
             Boolean(false),
             Null,
-            List(~[String(~"foo\nbar"), Number(3.5f)])]);
-
-        assert_eq!(longTestList.to_str(),
-            ~"[false,null,[\"foo\\nbar\",3.5]]");
+            List(~[String(~"foo\nbar"), Number(3.5f)])
+        ])), ~"[false,null,[\"foo\\nbar\",3.5]]");
         assert_eq!(
-            longTestList.to_pretty_str(),
+            to_pretty_str(&List(~[
+                Boolean(false),
+                Null,
+                List(~[String(~"foo\nbar"), Number(3.5f)])
+            ])),
             ~"\
             [\n  \
                 false,\n  \
@@ -1434,30 +1435,28 @@ mod tests {
 
     #[test]
     fn test_write_object() {
-        assert_eq!(mk_object([]).to_str(), ~"{}");
-        assert_eq!(mk_object([]).to_pretty_str(), ~"{}");
+        assert_eq!(to_str(&mk_object([])), ~"{}");
+        assert_eq!(to_pretty_str(&mk_object([])), ~"{}");
 
         assert_eq!(
-            mk_object([(~"a", Boolean(true))]).to_str(),
+            to_str(&mk_object([(~"a", Boolean(true))])),
             ~"{\"a\":true}"
         );
         assert_eq!(
-            mk_object([(~"a", Boolean(true))]).to_pretty_str(),
+            to_pretty_str(&mk_object([(~"a", Boolean(true))])),
             ~"\
             {\n  \
                 \"a\": true\n\
             }"
         );
 
-        let complexObj = mk_object([
+        assert_eq!(
+            to_str(&mk_object([
                 (~"b", List(~[
                     mk_object([(~"c", String(~"\x0c\r"))]),
                     mk_object([(~"d", String(~""))])
                 ]))
-            ]);
-
-        assert_eq!(
-            complexObj.to_str(),
+            ])),
             ~"{\
                 \"b\":[\
                     {\"c\":\"\\f\\r\"},\
@@ -1466,7 +1465,12 @@ mod tests {
             }"
         );
         assert_eq!(
-            complexObj.to_pretty_str(),
+            to_pretty_str(&mk_object([
+                (~"b", List(~[
+                    mk_object([(~"c", String(~"\x0c\r"))]),
+                    mk_object([(~"d", String(~""))])
+                ]))
+            ])),
             ~"\
             {\n  \
                 \"b\": [\n    \
@@ -1490,8 +1494,8 @@ mod tests {
 
         // We can't compare the strings directly because the object fields be
         // printed in a different order.
-        assert_eq!(a.clone(), from_str(a.to_str()).unwrap());
-        assert_eq!(a.clone(), from_str(a.to_pretty_str()).unwrap());
+        assert_eq!(a.clone(), from_str(to_str(&a)).unwrap());
+        assert_eq!(a.clone(), from_str(to_pretty_str(&a)).unwrap());
     }
 
     #[test]