---

yaml
---
r: 85338
b: refs/heads/dist-snap
c: a2ed09a
h: refs/heads/master
v: v3

Author: luqmana

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 0932ab336ffd9c53d3a164e0f94fcab2206c3fee
+refs/heads/dist-snap: a2ed09a006b5ae3cb671feb52e6ee2ea0e4f0a3a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/configure

@@ -371,7 +371,6 @@ opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
-opt optimize-tests 1 "build tests with optimizations"
 opt llvm-assertions 1 "build LLVM with assertions"
 opt debug 0 "build with extra debug fun"
 opt ratchet-bench 0 "ratchet benchmarks"

branches/dist-snap/mk/tests.mk

@@ -552,15 +552,7 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 
 # The tests select when to use debug configuration on their own;
 # remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
-CTEST_RUSTC_FLAGS := $$(subst --cfg debug,,$$(CFG_RUSTC_FLAGS))
-
-# The tests can not be optimized while the rest of the compiler is optimized, so
-# filter out the optimization (if any) from rustc and then figure out if we need
-# to be optimized
-CTEST_RUSTC_FLAGS := $$(subst -O,,$$(CTEST_RUSTC_FLAGS))
-ifndef CFG_DISABLE_OPTIMIZE_TESTS
-CTEST_RUSTC_FLAGS += -O
-endif
+CTEST_RUSTC_FLAGS = $$(subst --cfg debug,,$$(CFG_RUSTC_FLAGS))
 
 CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
 		--compile-lib-path $$(HLIB$(1)_H_$(3))				\

branches/dist-snap/src/libextra/crypto/sha1.rs

@@ -159,7 +159,7 @@ impl Sha1 {
 }
 
 impl Digest for Sha1 {
-    fn reset(&mut self) {
+    pub fn reset(&mut self) {
         self.length_bits = 0;
         self.h[0] = 0x67452301u32;
         self.h[1] = 0xEFCDAB89u32;
@@ -169,9 +169,9 @@ impl Digest for Sha1 {
         self.buffer.reset();
         self.computed = false;
     }
-    fn input(&mut self, msg: &[u8]) { add_input(self, msg); }
-    fn result(&mut self, out: &mut [u8]) { return mk_result(self, out); }
-    fn output_bits(&self) -> uint { 160 }
+    pub fn input(&mut self, msg: &[u8]) { add_input(self, msg); }
+    pub fn result(&mut self, out: &mut [u8]) { return mk_result(self, out); }
+    pub fn output_bits(&self) -> uint { 160 }
 }
 
 #[cfg(test)]

branches/dist-snap/src/libextra/enum_set.rs

@@ -21,9 +21,9 @@ pub struct EnumSet<E> {
 /// An iterface for casting C-like enum to uint and back.
 pub trait CLike {
     /// Converts C-like enum to uint.
-    fn to_uint(&self) -> uint;
+    pub fn to_uint(&self) -> uint;
     /// Converts uint to C-like enum.
-    fn from_uint(uint) -> Self;
+    pub fn from_uint(uint) -> Self;
 }
 
 fn bit<E:CLike>(e: E) -> uint {
@@ -142,11 +142,11 @@ mod test {
     }
 
     impl CLike for Foo {
-        fn to_uint(&self) -> uint {
+        pub fn to_uint(&self) -> uint {
             *self as uint
         }
 
-        fn from_uint(v: uint) -> Foo {
+        pub fn from_uint(v: uint) -> Foo {
             unsafe { cast::transmute(v) }
         }
     }

branches/dist-snap/src/libextra/num/bigint.rs

@@ -537,7 +537,7 @@ impl ToStrRadix for BigUint {
 impl FromStrRadix for BigUint {
     /// Creates and initializes an BigUint.
 
-    fn from_str_radix(s: &str, radix: uint)
+    pub fn from_str_radix(s: &str, radix: uint)
         -> Option<BigUint> {
         BigUint::parse_bytes(s.as_bytes(), radix)
     }

branches/dist-snap/src/libextra/terminfo/parm.rs

@@ -475,6 +475,103 @@ impl FormatOp {
     }
 }
 
+#[cfg(stage0)]
+fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
+    let mut s = match val {
+        Number(d) => {
+            match op {
+                FormatString => {
+                    return Err(~"non-number on stack with %s")
+                }
+                _ => {
+                    let radix = match op {
+                        FormatDigit => 10,
+                        FormatOctal => 8,
+                        FormatHex|FormatHEX => 16,
+                        FormatString => util::unreachable()
+                    };
+                    let mut s = ~[];
+                    match op {
+                        FormatDigit => {
+                            let sign = if flags.sign { SignAll } else { SignNeg };
+                            do int_to_str_bytes_common(d, radix, sign) |c| {
+                                s.push(c);
+                            }
+                        }
+                        _ => {
+                            do int_to_str_bytes_common(d as uint, radix, SignNone) |c| {
+                                s.push(c);
+                            }
+                        }
+                    };
+                    if flags.precision > s.len() {
+                        let mut s_ = vec::with_capacity(flags.precision);
+                        let n = flags.precision - s.len();
+                        s_.grow(n, &('0' as u8));
+                        s_.push_all_move(s);
+                        s = s_;
+                    }
+                    assert!(!s.is_empty(), "string conversion produced empty result");
+                    match op {
+                        FormatDigit => {
+                            if flags.space && !(s[0] == '-' as u8 || s[0] == '+' as u8) {
+                                s.unshift(' ' as u8);
+                            }
+                        }
+                        FormatOctal => {
+                            if flags.alternate && s[0] != '0' as u8 {
+                                s.unshift('0' as u8);
+                            }
+                        }
+                        FormatHex => {
+                            if flags.alternate {
+                                let s_ = util::replace(&mut s, ~['0' as u8, 'x' as u8]);
+                                s.push_all_move(s_);
+                            }
+                        }
+                        FormatHEX => {
+                            s = s.into_ascii().to_upper().into_bytes();
+                            if flags.alternate {
+                                let s_ = util::replace(&mut s, ~['0' as u8, 'X' as u8]);
+                                s.push_all_move(s_);
+                            }
+                        }
+                        FormatString => util::unreachable()
+                    }
+                    s
+                }
+            }
+        }
+        String(s) => {
+            match op {
+                FormatString => {
+                    let mut s = s.as_bytes().to_owned();
+                    if flags.precision > 0 && flags.precision < s.len() {
+                        s.truncate(flags.precision);
+                    }
+                    s
+                }
+                _ => {
+                    return Err(fmt!("non-string on stack with %%%c", op.to_char()))
+                }
+            }
+        }
+    };
+    if flags.width > s.len() {
+        let n = flags.width - s.len();
+        if flags.left {
+            s.grow(n, &(' ' as u8));
+        } else {
+            let mut s_ = vec::with_capacity(flags.width);
+            s_.grow(n, &(' ' as u8));
+            s_.push_all_move(s);
+            s = s_;
+        }
+    }
+    Ok(s)
+}
+
+#[cfg(not(stage0))]
 fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
     let mut s = match val {
         Number(d) => {

branches/dist-snap/src/libextra/test.rs

@@ -104,7 +104,7 @@ pub struct Metric {
 pub struct MetricMap(TreeMap<~str,Metric>);
 
 impl Clone for MetricMap {
-    fn clone(&self) -> MetricMap {
+    pub fn clone(&self) -> MetricMap {
         MetricMap((**self).clone())
     }
 }

branches/dist-snap/src/libextra/treemap.rs

@@ -853,7 +853,7 @@ impl<K: TotalOrd, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for TreeMap<K, V
 }
 
 impl<T: TotalOrd, Iter: Iterator<T>> FromIterator<T, Iter> for TreeSet<T> {
-    fn from_iterator(iter: &mut Iter) -> TreeSet<T> {
+    pub fn from_iterator(iter: &mut Iter) -> TreeSet<T> {
         let mut set = TreeSet::new();
         set.extend(iter);
         set

branches/dist-snap/src/libextra/url.rs

@@ -701,7 +701,7 @@ pub fn to_str(url: &Url) -> ~str {
 }
 
 impl ToStr for Url {
-    fn to_str(&self) -> ~str {
+    pub fn to_str(&self) -> ~str {
         to_str(self)
     }
 }

branches/dist-snap/src/librustc/back/rpath.rs

@@ -130,6 +130,19 @@ pub fn get_absolute_rpath(lib: &Path) -> Path {
     os::make_absolute(lib).dir_path()
 }
 
+#[cfg(stage0)]
+pub fn get_install_prefix_rpath(target_triple: &str) -> Path {
+    let install_prefix = env!("CFG_PREFIX");
+
+    if install_prefix == "" {
+        fail!("rustc compiled without CFG_PREFIX environment variable");
+    }
+
+    let tlib = filesearch::relative_target_lib_path(target_triple);
+    os::make_absolute(&Path(install_prefix).push_rel(&tlib))
+}
+
+#[cfg(not(stage0))]
 pub fn get_install_prefix_rpath(target_triple: &str) -> Path {
     let install_prefix = env!("CFG_PREFIX");
 

branches/dist-snap/src/librustc/driver/driver.rs

@@ -65,14 +65,14 @@ pub fn source_name(input: &input) -> @str {
     }
 }
 
-pub fn default_configuration(sess: Session) ->
+pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::CrateConfig {
-    let tos = match sess.targ_cfg.os {
-        session::os_win32 =>   @"win32",
-        session::os_macos =>   @"macos",
-        session::os_linux =>   @"linux",
-        session::os_android => @"android",
-        session::os_freebsd => @"freebsd"
+    let (libc, tos) = match sess.targ_cfg.os {
+        session::os_win32 =>   (@"msvcrt.dll", @"win32"),
+        session::os_macos =>   (@"libc.dylib", @"macos"),
+        session::os_linux =>   (@"libc.so.6",  @"linux"),
+        session::os_android => (@"libc.so",    @"android"),
+        session::os_freebsd => (@"libc.so.7",  @"freebsd")
     };
 
     // ARM is bi-endian, however using NDK seems to default
@@ -92,7 +92,10 @@ pub fn default_configuration(sess: Session) ->
          mk(@"target_arch", arch),
          mk(@"target_endian", end),
          mk(@"target_word_size", wordsz),
-    ];
+         mk(@"target_libc", libc),
+         // Build bindings.
+         mk(@"build_compiler", argv0),
+         mk(@"build_input", source_name(input))];
 }
 
 pub fn append_configuration(cfg: &mut ast::CrateConfig, name: @str) {
@@ -101,11 +104,11 @@ pub fn append_configuration(cfg: &mut ast::CrateConfig, name: @str) {
     }
 }
 
-pub fn build_configuration(sess: Session) ->
+pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::CrateConfig {
     // Combine the configuration requested by the session (command line) with
     // some default and generated configuration items
-    let default_cfg = default_configuration(sess);
+    let default_cfg = default_configuration(sess, argv0, input);
     let mut user_cfg = sess.opts.cfg.clone();
     // If the user wants a test runner, then add the test cfg
     if sess.opts.test { append_configuration(&mut user_cfg, @"test") }
@@ -575,6 +578,25 @@ pub fn build_target_config(sopts: @session::options,
     return target_cfg;
 }
 
+#[cfg(stage0)]
+pub fn host_triple() -> ~str {
+    // Get the host triple out of the build environment. This ensures that our
+    // idea of the host triple is the same as for the set of libraries we've
+    // actually built.  We can't just take LLVM's host triple because they
+    // normalize all ix86 architectures to i386.
+    //
+    // Instead of grabbing the host triple (for the current host), we grab (at
+    // compile time) the target triple that this rustc is built with and
+    // calling that (at runtime) the host triple.
+    let ht = env!("CFG_COMPILER_TRIPLE");
+    return if ht != "" {
+            ht.to_owned()
+        } else {
+            fail!("rustc built without CFG_COMPILER_TRIPLE")
+        };
+}
+
+#[cfg(not(stage0))]
 pub fn host_triple() -> ~str {
     // Get the host triple out of the build environment. This ensures that our
     // idea of the host triple is the same as for the set of libraries we've
@@ -977,7 +999,7 @@ pub fn list_metadata(sess: Session, path: &Path, out: @io::Writer) {
 mod test {
 
     use driver::driver::{build_configuration, build_session};
-    use driver::driver::{build_session_options, optgroups};
+    use driver::driver::{build_session_options, optgroups, str_input};
 
     use extra::getopts::groups::getopts;
     use extra::getopts;
@@ -995,7 +1017,7 @@ mod test {
         let sessopts = build_session_options(
             @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
-        let cfg = build_configuration(sess);
+        let cfg = build_configuration(sess, @"whatever", &str_input(@""));
         assert!((attr::contains_name(cfg, "test")));
     }
 
@@ -1013,7 +1035,7 @@ mod test {
         let sessopts = build_session_options(
             @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
-        let cfg = build_configuration(sess);
+        let cfg = build_configuration(sess, @"whatever", &str_input(@""));
         let mut test_items = cfg.iter().filter(|m| "test" == m.name());
         assert!(test_items.next().is_some());
         assert!(test_items.next().is_none());

branches/dist-snap/src/librustc/metadata/filesearch.rs

@@ -200,6 +200,16 @@ fn push_if_exists(vec: &mut ~[Path], p: &Path) {
 
 // The name of the directory rustc expects libraries to be located.
 // On Unix should be "lib", on windows "bin"
+#[cfg(stage0)]
+pub fn libdir() -> ~str {
+   let libdir = env!("CFG_LIBDIR");
+   if libdir.is_empty() {
+      fail!("rustc compiled without CFG_LIBDIR environment variable");
+   }
+   libdir.to_owned()
+}
+
+#[cfg(not(stage0))]
 pub fn libdir() -> ~str {
     (env!("CFG_LIBDIR")).to_owned()
 }

branches/dist-snap/src/librustc/middle/check_const.rs

@@ -160,6 +160,7 @@ pub fn check_expr(sess: Session,
           expr_field(*) |
           expr_index(*) |
           expr_tup(*) |
+          expr_repeat(*) |
           expr_struct(*) => { }
           expr_addr_of(*) => {
                 sess.span_err(

branches/dist-snap/src/librustc/middle/const_eval.rs

@@ -153,6 +153,8 @@ pub fn classify(e: &expr,
                 lookup_constness(tcx, e)
               }
 
+              ast::expr_repeat(*) => general_const,
+
               _ => non_const
             };
         tcx.ccache.insert(did, cn);