---

yaml
---
r: 151191
b: refs/heads/try2
c: cbf1131
h: refs/heads/master
i:
  151189: b621863
  151187: 43254e8
  151183: 13d5b80
v: v3

Author: bors

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

branches/try2/mk/tests.mk

@@ -349,6 +349,16 @@ TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(SREQ$(1)_T_$(2)_H_$(3)) \
 			    $$(foreach crate,$$(TARGET_CRATES),\
 				$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)) \
 				$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4))
+
+# The regex crate depends on the regex_macros crate during testing, but it
+# notably depend on the *host* regex_macros crate, not the target version.
+# Additionally, this is not a dependency in stage1, only in stage2.
+ifeq ($(4),regex)
+ifneq ($(1),1)
+TESTDEP_$(1)_$(2)_$(3)_$(4) += $$(TLIB$(1)_T_$(3)_H_$(3))/stamp.regex_macros
+endif
+endif
+
 else
 TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4))
 endif

branches/try2/src/doc/complement-lang-faq.md

@@ -22,8 +22,8 @@ Some examples that demonstrate different aspects of the language:
 
 [sprocketnes]: https://github.com/pcwalton/sprocketnes
 [hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash.rs
-[HashMap]: https://github.com/mozilla/rust/blob/master/src/libstd/hashmap.rs
-[json]: https://github.com/mozilla/rust/blob/master/src/libextra/json.rs
+[HashMap]: https://github.com/mozilla/rust/blob/master/src/libcollections/hashmap.rs
+[json]: https://github.com/mozilla/rust/blob/master/src/libserialize/json.rs
 
 You may also be interested in browsing [GitHub's Rust][github-rust] page.
 

branches/try2/src/doc/tutorial.md

@@ -1797,11 +1797,6 @@ spawn(proc() {
 });
 ~~~~
 
-> *Note:* If you want to see the output of `debug!` statements, you will need to turn on
-> `debug!` logging.  To enable `debug!` logging, set the RUST_LOG environment
-> variable to the name of your crate, which, for a file named `foo.rs`, will be
-> `foo` (e.g., with bash, `export RUST_LOG=foo`).
-
 ## Closure compatibility
 
 Rust closures have a convenient subtyping property: you can pass any kind of

branches/try2/src/etc/maketest.py

@@ -12,26 +12,53 @@
 import os
 import sys
 
-# FIXME #12303 these tests are broken on windows
-if os.name == 'nt':
-    print 'ignoring make tests on windows'
-    sys.exit(0)
+# msys1/msys2 automatically converts `/abs/path1:/abs/path2` into
+# `c:\real\abs\path1;c:\real\abs\path2` (semicolons) if shell thinks
+# the value is list of paths.
+# this causes great confusion and error: shell and Makefile doesn't like
+# windows paths so it is really error-prone. revert it for peace.
+def normalize_path(v):
+    # c:\path -> /c/path
+    if ':\\' in v:
+        v = '/' + v.replace(':\\', '/')
+    v = v.replace('\\', '/')
+    return v
+
+
+def putenv(name, value):
+    if os.name == 'nt':
+        value = normalize_path(value)
+    os.putenv(name, value)
+
 
 make = sys.argv[2]
-os.putenv('RUSTC', os.path.abspath(sys.argv[3]))
-os.putenv('TMPDIR', os.path.abspath(sys.argv[4]))
-os.putenv('CC', sys.argv[5])
-os.putenv('RUSTDOC', os.path.abspath(sys.argv[6]))
+putenv('RUSTC', os.path.abspath(sys.argv[3]))
+putenv('TMPDIR', os.path.abspath(sys.argv[4]))
+putenv('CC', sys.argv[5])
+putenv('RUSTDOC', os.path.abspath(sys.argv[6]))
 filt = sys.argv[7]
 ldpath = sys.argv[8]
 if ldpath != '':
-    os.putenv(ldpath.split('=')[0], ldpath.split('=')[1])
+    name = ldpath.split('=')[0]
+    value = ldpath.split('=')[1]
+    if os.name == 'nt' and name != 'PATH':
+        value = ":".join(normalize_path(v) for v in value.split(";"))
+    os.putenv(name, value)
 
 if not filt in sys.argv[1]:
     sys.exit(0)
 print('maketest: ' + os.path.basename(os.path.dirname(sys.argv[1])))
 
-proc = subprocess.Popen([make, '-C', sys.argv[1]],
+path = sys.argv[1]
+if path[-1] == '/':
+    # msys1 has a bug that `make` fails to include `../tools.mk` (parent dir)
+    # if `-C path` option is given and `path` is absolute directory with
+    # trailing slash (`c:/path/to/test/`).
+    # the easist workaround is to remove the slash (`c:/path/to/test`).
+    # msys2 seems to fix this problem.
+    path = path[:-1]
+
+proc = subprocess.Popen([make, '-C', path],
                         stdout = subprocess.PIPE,
                         stderr = subprocess.PIPE)
 out, err = proc.communicate()

branches/try2/src/libnum/bigint.rs

@@ -230,7 +230,8 @@ impl Sub<BigUint, BigUint> for BigUint {
             lo
         }).collect();
 
-        assert_eq!(borrow, 0);     // <=> assert!((self >= other));
+        assert!(borrow == 0,
+                "Cannot subtract other from self because other is larger than self.");
         return BigUint::new(diff);
     }
 }
@@ -1755,6 +1756,13 @@ mod biguint_tests {
         }
     }
 
+    #[test]
+    #[should_fail]
+    fn test_sub_fail_on_underflow() {
+        let (a, b) : (BigUint, BigUint) = (Zero::zero(), One::one());
+        a - b;
+    }
+
     static mul_triples: &'static [(&'static [BigDigit],
                                    &'static [BigDigit],
                                    &'static [BigDigit])] = &[

branches/try2/src/librustc/back/link.rs

@@ -152,6 +152,12 @@ pub mod write {
                              (sess.targ_cfg.os == abi::OsMacos &&
                               sess.targ_cfg.arch == abi::X86_64);
 
+            // OSX has -dead_strip, which doesn't rely on ffunction_sections
+            // FIXME(#13846) this should be enabled for windows
+            let ffunction_sections = sess.targ_cfg.os != abi::OsMacos &&
+                                     sess.targ_cfg.os != abi::OsWin32;
+            let fdata_sections = ffunction_sections;
+
             let reloc_model = match sess.opts.cg.relocation_model.as_slice() {
                 "pic" => lib::llvm::RelocPIC,
                 "static" => lib::llvm::RelocStatic,
@@ -173,9 +179,11 @@ pub mod write {
                             lib::llvm::CodeModelDefault,
                             reloc_model,
                             opt_level,
-                            true,
+                            true /* EnableSegstk */,
                             use_softfp,
-                            no_fp_elim
+                            no_fp_elim,
+                            ffunction_sections,
+                            fdata_sections,
                         )
                     })
                 })
@@ -1136,20 +1144,38 @@ fn link_args(sess: &Session,
         args.push("-nodefaultlibs".to_owned());
     }
 
+    // If we're building a dylib, we don't use --gc-sections because LLVM has
+    // already done the best it can do, and we also don't want to eliminate the
+    // metadata. If we're building an executable, however, --gc-sections drops
+    // the size of hello world from 1.8MB to 597K, a 67% reduction.
+    if !dylib && sess.targ_cfg.os != abi::OsMacos {
+        args.push("-Wl,--gc-sections".to_owned());
+    }
+
     if sess.targ_cfg.os == abi::OsLinux {
         // GNU-style linkers will use this to omit linking to libraries which
         // don't actually fulfill any relocations, but only for libraries which
         // follow this flag. Thus, use it before specifying libraries to link to.
         args.push("-Wl,--as-needed".to_owned());
 
-        // GNU-style linkers support optimization with -O. --gc-sections
-        // removes metadata and potentially other useful things, so don't
-        // include it. GNU ld doesn't need a numeric argument, but other linkers
-        // do.
+        // GNU-style linkers support optimization with -O. GNU ld doesn't need a
+        // numeric argument, but other linkers do.
         if sess.opts.optimize == session::Default ||
            sess.opts.optimize == session::Aggressive {
             args.push("-Wl,-O1".to_owned());
         }
+    } else if sess.targ_cfg.os == abi::OsMacos {
+        // The dead_strip option to the linker specifies that functions and data
+        // unreachable by the entry point will be removed. This is quite useful
+        // with Rust's compilation model of compiling libraries at a time into
+        // one object file. For example, this brings hello world from 1.7MB to
+        // 458K.
+        //
+        // Note that this is done for both executables and dynamic libraries. We
+        // won't get much benefit from dylibs because LLVM will have already
+        // stripped away as much as it could. This has not been seen to impact
+        // link times negatively.
+        args.push("-Wl,-dead_strip".to_owned());
     }
 
     if sess.targ_cfg.os == abi::OsWin32 {

branches/try2/src/librustc/front/config.rs

@@ -70,6 +70,7 @@ fn fold_mod(cx: &mut Context, m: &ast::Mod) -> ast::Mod {
         filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
     }).collect();
     ast::Mod {
+        inner: m.inner,
         view_items: filtered_view_items,
         items: flattened_items
     }

branches/try2/src/librustc/front/feature_gate.rs

@@ -130,16 +130,14 @@ impl<'a> Visitor<()> for Context<'a> {
 
     fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
         match i.node {
-            ast::ViewItemUse(ref paths) => {
-                for path in paths.iter() {
-                    match path.node {
-                        ast::ViewPathGlob(..) => {
-                            self.gate_feature("globs", path.span,
-                                              "glob import statements are \
-                                               experimental and possibly buggy");
-                        }
-                        _ => {}
+            ast::ViewItemUse(ref path) => {
+                match path.node {
+                    ast::ViewPathGlob(..) => {
+                        self.gate_feature("globs", path.span,
+                                          "glob import statements are \
+                                           experimental and possibly buggy");
                     }
+                    _ => {}
                 }
             }
             ast::ViewItemExternCrate(..) => {

branches/try2/src/librustc/front/std_inject.rs

@@ -166,7 +166,7 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
 
         let vp = @codemap::dummy_spanned(ast::ViewPathGlob(prelude_path, ast::DUMMY_NODE_ID));
         let vi2 = ast::ViewItem {
-            node: ast::ViewItemUse(vec!(vp)),
+            node: ast::ViewItemUse(vp),
             attrs: Vec::new(),
             vis: ast::Inherited,
             span: DUMMY_SP,

branches/try2/src/librustc/front/test.rs

@@ -143,6 +143,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
         }
 
         let mod_nomain = ast::Mod {
+            inner: m.inner,
             view_items: m.view_items.clone(),
             items: m.items.iter().map(|i| nomain(&self.cx, *i)).collect(),
         };
@@ -299,9 +300,9 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
     let id_test = token::str_to_ident("test");
     let (vi, vis) = if cx.is_test_crate {
         (ast::ViewItemUse(
-            vec!(@nospan(ast::ViewPathSimple(id_test,
-                                             path_node(vec!(id_test)),
-                                             ast::DUMMY_NODE_ID)))),
+            @nospan(ast::ViewPathSimple(id_test,
+                                        path_node(vec!(id_test)),
+                                        ast::DUMMY_NODE_ID))),
          ast::Public)
     } else {
         (ast::ViewItemExternCrate(id_test,
@@ -335,6 +336,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
     )).unwrap();
 
     let testmod = ast::Mod {
+        inner: DUMMY_SP,
         view_items: view_items,
         items: vec!(mainfn, tests),
     };

branches/try2/src/librustc/lib/llvm.rs

@@ -1748,7 +1748,9 @@ pub mod llvm {
                                            Level: CodeGenOptLevel,
                                            EnableSegstk: bool,
                                            UseSoftFP: bool,
-                                           NoFramePointerElim: bool) -> TargetMachineRef;
+                                           NoFramePointerElim: bool,
+                                           FunctionSections: bool,
+                                           DataSections: bool) -> TargetMachineRef;
         pub fn LLVMRustDisposeTargetMachine(T: TargetMachineRef);
         pub fn LLVMRustAddAnalysisPasses(T: TargetMachineRef,
                                          PM: PassManagerRef,

branches/try2/src/librustc/metadata/tydecode.rs

@@ -138,23 +138,6 @@ pub fn parse_substs_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx:
     parse_substs(&mut st, conv)
 }
 
-fn parse_vstore(st: &mut PState, conv: conv_did) -> ty::Vstore {
-    assert_eq!(next(st), '/');
-
-    let c = peek(st);
-    if '0' <= c && c <= '9' {
-        let n = parse_uint(st);
-        assert_eq!(next(st), '|');
-        return ty::VstoreFixed(n);
-    }
-
-    match next(st) {
-        '~' => ty::VstoreUniq,
-        '&' => ty::VstoreSlice(parse_region(st, conv)),
-        c => st.tcx.sess.bug(format!("parse_vstore(): bad input '{}'", c))
-    }
-}
-
 fn parse_size(st: &mut PState) -> Option<uint> {
     assert_eq!(next(st), '/');
 
@@ -361,8 +344,7 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         return ty::mk_vec(st.tcx, mt, sz);
       }
       'v' => {
-        let v = parse_vstore(st, |x,y| conv(x,y));
-        return ty::mk_str(st.tcx, v);
+        return ty::mk_str(st.tcx);
       }
       'T' => {
         assert_eq!(next(st), '[');

branches/try2/src/librustc/metadata/tyencode.rs

@@ -177,21 +177,6 @@ fn enc_bound_region(w: &mut MemWriter, cx: &ctxt, br: ty::BoundRegion) {
     }
 }
 
-pub fn enc_vstore(w: &mut MemWriter, cx: &ctxt,
-                  v: ty::Vstore,
-                  enc_mut: |&mut MemWriter|) {
-    mywrite!(w, "/");
-    match v {
-        ty::VstoreFixed(u) => mywrite!(w, "{}|", u),
-        ty::VstoreUniq => mywrite!(w, "~"),
-        ty::VstoreSlice(r) => {
-            mywrite!(w, "&");
-            enc_region(w, cx, r);
-            enc_mut(w);
-        }
-    }
-}
-
 pub fn enc_trait_ref(w: &mut MemWriter, cx: &ctxt, s: &ty::TraitRef) {
     mywrite!(w, "{}|", (cx.ds)(s.def_id));
     enc_substs(w, cx, &s.substs);
@@ -275,9 +260,8 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
                 None => mywrite!(w, "|"),
             }
         }
-        ty::ty_str(v) => {
+        ty::ty_str => {
             mywrite!(w, "v");
-            enc_vstore(w, cx, v, |_| {});
         }
         ty::ty_closure(ref f) => {
             mywrite!(w, "f");

branches/try2/src/librustc/middle/check_match.rs

@@ -405,6 +405,7 @@ fn missing_ctor(cx: &MatchCheckCtxt,
       ty::ty_struct(..) => check_matrix_for_wild(cx, m),
       ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty: ty, ..}) => match ty::get(ty).sty {
           ty::ty_vec(_, None) => ctor_for_slice(m),
+          ty::ty_str => Some(single),
           _ => check_matrix_for_wild(cx, m),
       },
       ty::ty_enum(eid, _) => {

branches/try2/src/librustc/middle/effect.rs

@@ -68,7 +68,14 @@ impl<'a> EffectCheckVisitor<'a> {
         debug!("effect: checking index with base type {}",
                 ppaux::ty_to_str(self.tcx, base_type));
         match ty::get(base_type).sty {
-            ty::ty_str(..) => {
+            ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
+                ty::ty_str => {
+                    self.tcx.sess.span_err(e.span,
+                        "modification of string types is not allowed");
+                }
+                _ => {}
+            },
+            ty::ty_str => {
                 self.tcx.sess.span_err(e.span,
                     "modification of string types is not allowed");
             }

branches/try2/src/librustc/middle/lint.rs

@@ -911,7 +911,7 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) {
                 ty::ty_box(_) => {
                     n_box += 1;
                 }
-                ty::ty_uniq(_) | ty::ty_str(ty::VstoreUniq) |
+                ty::ty_uniq(_) |
                 ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
                 ty::ty_closure(~ty::ClosureTy { store: ty::UniqTraitStore, .. }) => {
                     n_uniq += 1;