---

yaml
---
r: 148445
b: refs/heads/try2
c: bf89b68
h: refs/heads/master
i:
  148443: f71208a
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: 509283d149bb81cad728b2c1b81f7ab8ceb206e1
+refs/heads/try2: bf89b68a3702e10b18e84ef37c3aa19f13418731
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/guide-testing.md

@@ -33,7 +33,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 # Unit testing in Rust
 
 Rust has built in support for simple unit testing. Functions can be
-marked as unit tests using the 'test' attribute.
+marked as unit tests using the `test` attribute.
 
 ~~~
 #[test]
@@ -44,13 +44,13 @@ fn return_none_if_empty() {
 
 A test function's signature must have no arguments and no return
 value. To run the tests in a crate, it must be compiled with the
-'--test' flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
+`--test` flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
 the resulting executable will run all the tests in the crate. A test
 is considered successful if its function returns; if the task running
 the test fails, through a call to `fail!`, a failed `check` or
 `assert`, or some other (`assert_eq`, ...) means, then the test fails.
 
-When compiling a crate with the '--test' flag '--cfg test' is also
+When compiling a crate with the `--test` flag `--cfg test` is also
 implied, so that tests can be conditionally compiled.
 
 ~~~
@@ -64,17 +64,17 @@ mod tests {
 ~~~
 
 Additionally `#[test]` items behave as if they also have the
-`#[cfg(test)]` attribute, and will not be compiled when the --test flag
+`#[cfg(test)]` attribute, and will not be compiled when the `--test` flag
 is not used.
 
-Tests that should not be run can be annotated with the 'ignore'
+Tests that should not be run can be annotated with the `ignore`
 attribute. The existence of these tests will be noted in the test
 runner output, but the test will not be run. Tests can also be ignored
 by configuration so, for example, to ignore a test on windows you can
 write `#[ignore(cfg(target_os = "win32"))]`.
 
 Tests that are intended to fail can be annotated with the
-'should_fail' attribute. The test will be run, and if it causes its
+`should_fail` attribute. The test will be run, and if it causes its
 task to fail then the test will be counted as successful; otherwise it
 will be counted as a failure. For example:
 
@@ -87,11 +87,11 @@ fn test_out_of_bounds_failure() {
 }
 ~~~
 
-A test runner built with the '--test' flag supports a limited set of
+A test runner built with the `--test` flag supports a limited set of
 arguments to control which tests are run: the first free argument
 passed to a test runner specifies a filter used to narrow down the set
-of tests being run; the '--ignored' flag tells the test runner to run
-only tests with the 'ignore' attribute.
+of tests being run; the `--ignored` flag tells the test runner to run
+only tests with the `ignore` attribute.
 
 ## Parallelism
 

branches/try2/src/compiletest/runtest.rs

@@ -237,9 +237,15 @@ actual:\n\
 
     fn make_typecheck_args(config: &config, props: &TestProps, testfile: &Path) -> ProcArgs {
         let aux_dir = aux_output_dir_name(config, testfile);
+        let target = if props.force_host {
+            config.host.as_slice()
+        } else {
+            config.target.as_slice()
+        };
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = ~[~"-",
                          ~"--no-trans", ~"--lib",
+                         ~"--target=" + target,
                          ~"-L", config.build_base.as_str().unwrap().to_owned(),
                          ~"-L",
                          aux_dir.as_str().unwrap().to_owned()];

branches/try2/src/libextra/base64.rs

@@ -237,8 +237,9 @@ impl<'a> FromBase64 for &'a str {
         }
 
         for (idx, byte) in it {
-            if (byte as char) != '=' {
-                return Err(InvalidBase64Character(self.char_at(idx), idx));
+            match byte as char {
+                '='|'\r'|'\n' => continue,
+                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
             }
         }
 
@@ -310,6 +311,8 @@ mod test {
     fn test_from_base64_newlines() {
         assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
                    "foobar".as_bytes().to_owned());
+        assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
+                   "foob".as_bytes().to_owned());
     }
 
     #[test]

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

@@ -33,12 +33,27 @@ use std::hashmap::HashMap;
 use std::iter::Enumerate;
 use std::vec;
 
+
+// Get the last "argument" (has to be done recursively to avoid phoney local ambiguity error)
+macro_rules! last {
+    ( $first:expr, $( $remainder:expr, )+ ) => ( last!( $( $remainder, )+ ) );
+    ( $first:expr, ) => ( $first )
+}
+
 // The actual lang items defined come at the end of this file in one handy table.
 // So you probably just want to nip down to the end.
 macro_rules! lets_do_this {
+    // secondary rule to allow us to use `$num` as both an expression
+    // and a pattern.
+    (
+        $( $num:tt, $variant:ident, $name:expr, $method:ident; )*
+    ) => {
+        lets_do_this!(count = 1 + last!($($num,)*),
+                      $($num, $variant, $name, $method; )*)
+    };
+
     (
-        There are $num_lang_items:expr lang items.
-        $( $num:pat, $variant:ident, $name:expr, $method:ident; )*
+        count = $num_lang_items:expr, $( $num:pat, $variant:ident, $name:expr, $method:ident; )*
     ) => {
 
 pub enum LangItem {
@@ -207,8 +222,6 @@ pub fn collect_language_items(crate: &ast::Crate,
 }
 
 lets_do_this! {
-    There are 40 lang items.
-
 //  ID, Variant name,                    Name,                      Method name;
     0,  FreezeTraitLangItem,             "freeze",                  freeze_trait;
     1,  SendTraitLangItem,               "send",                    send_trait;
@@ -261,4 +274,3 @@ lets_do_this! {
     38, ExchangeHeapLangItem,            "exchange_heap",           exchange_heap;
     39, GcLangItem,                      "gc",                      gc;
 }
-

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

@@ -2287,6 +2287,12 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
                ::util::ppaux::ty_to_str(cx, ty));
 
         let r = match get(ty).sty {
+            // fixed length vectors need special treatment compared to
+            // normal vectors, since they don't necessarily have the
+            // possibilty to have length zero.
+            ty_vec(_, vstore_fixed(0)) => false, // don't need no contents
+            ty_vec(mt, vstore_fixed(_)) => type_requires(cx, seen, r_ty, mt.ty),
+
             ty_nil |
             ty_bot |
             ty_bool |

branches/try2/src/libsyntax/ext/base.rs

@@ -412,6 +412,10 @@ impl<'a> ExtCtxt<'a> {
         self.print_backtrace();
         self.parse_sess.span_diagnostic.span_bug(sp, msg);
     }
+    pub fn span_note(&self, sp: Span, msg: &str) {
+        self.print_backtrace();
+        self.parse_sess.span_diagnostic.span_note(sp, msg);
+    }
     pub fn bug(&self, msg: &str) -> ! {
         self.print_backtrace();
         self.parse_sess.span_diagnostic.handler().bug(msg);

branches/try2/src/libsyntax/ext/quote.rs

@@ -530,7 +530,7 @@ fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> ~[@ast::Stmt] {
     match *tt {
 
         ast::TTTok(sp, ref tok) => {
-            let e_sp = cx.expr_ident(sp, id_ext("sp"));
+            let e_sp = cx.expr_ident(sp, id_ext("_sp"));
             let e_tok = cx.expr_call_ident(sp,
                                            id_ext("TTTok"),
                                            ~[e_sp, mk_token(cx, sp, tok)]);
@@ -628,7 +628,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                                    ~[]);
 
     let stmt_let_sp = cx.stmt_let(sp, false,
-                                  id_ext("sp"),
+                                  id_ext("_sp"),
                                   e_sp);
 
     let stmt_let_tt = cx.stmt_let(sp, true,

branches/try2/src/test/compile-fail/macro-crate-unexported-macro.rs

@@ -10,6 +10,7 @@
 
 // aux-build:macro_crate_test.rs
 // xfail-stage1
+// xfail-android
 
 #[feature(phase)];
 

branches/try2/src/test/compile-fail/phase-syntax-doesnt-resolve.rs

@@ -10,6 +10,7 @@
 
 // aux-build:macro_crate_test.rs
 // xfail-stage1
+// xfail-android
 
 #[feature(phase)];
 

branches/try2/src/test/compile-fail/uninstantiable-fixed-length-vec.rs

@@ -0,0 +1,26 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// issue #11659, the compiler needs to know that a fixed length vector
+// always requires instantiable contents to instantiable itself
+// (unlike a ~[] vector which can have length zero).
+
+// ~ to avoid infinite size.
+struct Uninstantiable { //~ ERROR cannot be instantiated without an instance of itself
+    p: ~[Uninstantiable, .. 1]
+}
+
+struct Instantiable { p: ~[Instantiable, .. 0] }
+
+
+fn main() {
+    let _ = None::<Uninstantiable>;
+    let _ = Instantiable { p: ~([]) };
+}

branches/try2/src/test/run-pass-fulldeps/macro-crate.rs

@@ -11,6 +11,7 @@
 // aux-build:macro_crate_test.rs
 // xfail-stage1
 // xfail-fast
+// xfail-android
 
 #[feature(phase)];
 

branches/try2/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs

@@ -0,0 +1,24 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+
+#[deny(unused_variable)];
+
+extern mod syntax;
+
+use syntax::ext::base::ExtCtxt;
+
+fn test(cx: &mut ExtCtxt) {
+    let foo = 10i;
+    let _e = quote_expr!(cx, $foo);
+}
+
+pub fn main() { }