---

yaml
---
r: 151187
b: refs/heads/try2
c: 5371146
h: refs/heads/master
i:
  151185: 3c88628
  151183: 13d5b80
v: v3

Author: adrientetar

[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: 33259d979742e643a5dda4889d17d59c6fcf63e4
+refs/heads/try2: 53711461070ec8ad0d71c4bcdb35de3120e07ec5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/tests.mk

@@ -349,16 +349,6 @@ 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/libcollections/hashmap.rs
-[json]: https://github.com/mozilla/rust/blob/master/src/libserialize/json.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
 
 You may also be interested in browsing [GitHub's Rust][github-rust] page.
 

branches/try2/src/doc/tutorial.md

@@ -1793,6 +1793,11 @@ 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,53 +12,26 @@
 import os
 import sys
 
-# 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)
-
+# FIXME #12303 these tests are broken on windows
+if os.name == 'nt':
+    print 'ignoring make tests on windows'
+    sys.exit(0)
 
 make = sys.argv[2]
-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]))
+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]))
 filt = sys.argv[7]
 ldpath = sys.argv[8]
 if ldpath != '':
-    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)
+    os.putenv(ldpath.split('=')[0], ldpath.split('=')[1])
 
 if not filt in sys.argv[1]:
     sys.exit(0)
 print('maketest: ' + os.path.basename(os.path.dirname(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],
+proc = subprocess.Popen([make, '-C', sys.argv[1]],
                         stdout = subprocess.PIPE,
                         stderr = subprocess.PIPE)
 out, err = proc.communicate()

branches/try2/src/libnum/bigint.rs

@@ -230,8 +230,7 @@ impl Sub<BigUint, BigUint> for BigUint {
             lo
         }).collect();
 
-        assert!(borrow == 0,
-                "Cannot subtract other from self because other is larger than self.");
+        assert_eq!(borrow, 0);     // <=> assert!((self >= other));
         return BigUint::new(diff);
     }
 }
@@ -1756,13 +1755,6 @@ 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,12 +152,6 @@ 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,
@@ -179,11 +173,9 @@ pub mod write {
                             lib::llvm::CodeModelDefault,
                             reloc_model,
                             opt_level,
-                            true /* EnableSegstk */,
+                            true,
                             use_softfp,
-                            no_fp_elim,
-                            ffunction_sections,
-                            fdata_sections,
+                            no_fp_elim
                         )
                     })
                 })
@@ -1144,38 +1136,20 @@ 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. GNU ld doesn't need a
-        // numeric argument, but other linkers do.
+        // 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.
         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,7 +70,6 @@ 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,14 +130,16 @@ impl<'a> Visitor<()> for Context<'a> {
 
     fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
         match i.node {
-            ast::ViewItemUse(ref path) => {
-                match path.node {
-                    ast::ViewPathGlob(..) => {
-                        self.gate_feature("globs", path.span,
-                                          "glob import statements are \
-                                           experimental and possibly buggy");
+            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::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(vp),
+            node: ast::ViewItemUse(vec!(vp)),
             attrs: Vec::new(),
             vis: ast::Inherited,
             span: DUMMY_SP,

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

@@ -143,7 +143,6 @@ 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(),
         };
@@ -300,9 +299,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(
-            @nospan(ast::ViewPathSimple(id_test,
-                                        path_node(vec!(id_test)),
-                                        ast::DUMMY_NODE_ID))),
+            vec!(@nospan(ast::ViewPathSimple(id_test,
+                                             path_node(vec!(id_test)),
+                                             ast::DUMMY_NODE_ID)))),
          ast::Public)
     } else {
         (ast::ViewItemExternCrate(id_test,
@@ -336,7 +335,6 @@ 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,9 +1748,7 @@ pub mod llvm {
                                            Level: CodeGenOptLevel,
                                            EnableSegstk: bool,
                                            UseSoftFP: bool,
-                                           NoFramePointerElim: bool,
-                                           FunctionSections: bool,
-                                           DataSections: bool) -> TargetMachineRef;
+                                           NoFramePointerElim: bool) -> TargetMachineRef;
         pub fn LLVMRustDisposeTargetMachine(T: TargetMachineRef);
         pub fn LLVMRustAddAnalysisPasses(T: TargetMachineRef,
                                          PM: PassManagerRef,

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

@@ -138,6 +138,23 @@ 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), '/');
 
@@ -344,7 +361,8 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         return ty::mk_vec(st.tcx, mt, sz);
       }
       'v' => {
-        return ty::mk_str(st.tcx);
+        let v = parse_vstore(st, |x,y| conv(x,y));
+        return ty::mk_str(st.tcx, v);
       }
       'T' => {
         assert_eq!(next(st), '[');

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

@@ -177,6 +177,21 @@ 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);
@@ -260,8 +275,9 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
                 None => mywrite!(w, "|"),
             }
         }
-        ty::ty_str => {
+        ty::ty_str(v) => {
             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,7 +405,6 @@ 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,14 +68,7 @@ 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_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 => {
+            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_uniq(_) | ty::ty_str(ty::VstoreUniq) |
                 ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
                 ty::ty_closure(~ty::ClosureTy { store: ty::UniqTraitStore, .. }) => {
                     n_uniq += 1;