---

yaml
---
r: 152216
b: refs/heads/try2
c: 60e0f6f
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 837013717abaa0bb0e1a63f9fb2847c1f3d64479
+refs/heads/try2: 60e0f6fbb06d8a1c848cd8793edafa42ba4e1940
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -904,7 +904,7 @@ An example of re-exporting:
 ~~~~
 # fn main() { }
 mod quux {
-    pub use quux::foo::{bar, baz};
+    pub use quux::foo::*;
 
     pub mod foo {
         pub fn bar() { }
@@ -913,10 +913,10 @@ mod quux {
 }
 ~~~~
 
-In this example, the module `quux` re-exports two public names defined in `foo`.
+In this example, the module `quux` re-exports all of the public names defined in `foo`.
 
 Also note that the paths contained in `use` items are relative to the crate root.
-So, in the previous example, the `use` refers to `quux::foo::{bar, baz}`, and not simply to `foo::{bar, baz}`.
+So, in the previous example, the `use` refers to `quux::foo::*`, and not simply to `foo::*`.
 This also means that top-level module declarations should be at the crate root if direct usage
 of the declared modules within `use` items is desired.  It is also possible to use `self` and `super`
 at the beginning of a `use` item to refer to the current and direct parent modules respectively.

branches/try2/src/libregex_macros/lib.rs

@@ -20,7 +20,6 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![feature(macro_registrar, managed_boxes, quote)]
-#![allow(unused_imports)] // `quote_expr!` adds some `use` globs which may be unused
 
 extern crate regex;
 extern crate syntax;

branches/try2/src/librustdoc/html/markdown.rs

@@ -287,7 +287,10 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
                 slice::raw::buf_as_slice((*lang).data,
                                        (*lang).size as uint, |lang| {
                     let s = str::from_utf8(lang).unwrap();
-                    parse_lang_string(s)
+                    (s.contains("should_fail"),
+                     s.contains("no_run"),
+                     s.contains("ignore"),
+                     s.contains("notrust"))
                 })
             };
             if notrust { return }
@@ -337,35 +340,6 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
     }
 }
 
-fn parse_lang_string(string: &str) -> (bool,bool,bool,bool) {
-    let mut seen_rust_tags = false;
-    let mut seen_other_tags = false;
-    let mut should_fail = false;
-    let mut no_run = false;
-    let mut ignore = false;
-    let mut notrust = false;
-
-    let mut tokens = string.as_slice().split(|c: char|
-      !(c == '_' || c == '-' || c.is_alphanumeric())
-    );
-
-    for token in tokens {
-        match token {
-            "" => {},
-            "should_fail" => { should_fail = true; seen_rust_tags = true; },
-            "no_run" => { no_run = true; seen_rust_tags = true; },
-            "ignore" => { ignore = true; seen_rust_tags = true; },
-            "notrust" => { notrust = true; seen_rust_tags = true; },
-            "rust" => { notrust = false; seen_rust_tags = true; },
-            _ => { seen_other_tags = true }
-        }
-    }
-
-    let notrust = notrust || (seen_other_tags && !seen_rust_tags);
-
-    (should_fail, no_run, ignore, notrust)
-}
-
 /// By default this markdown renderer generates anchors for each header in the
 /// rendered document. The anchor name is the contents of the header spearated
 /// by hyphens, and a task-local map is used to disambiguate among duplicate
@@ -393,22 +367,3 @@ impl<'a> fmt::Show for MarkdownWithToc<'a> {
         render(fmt, md.as_slice(), true)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::parse_lang_string;
-
-    #[test]
-    fn test_parse_lang_string() {
-        assert_eq!(parse_lang_string(""), (false,false,false,false))
-        assert_eq!(parse_lang_string("rust"), (false,false,false,false))
-        assert_eq!(parse_lang_string("sh"), (false,false,false,true))
-        assert_eq!(parse_lang_string("notrust"), (false,false,false,true))
-        assert_eq!(parse_lang_string("ignore"), (false,false,true,false))
-        assert_eq!(parse_lang_string("should_fail"), (true,false,false,false))
-        assert_eq!(parse_lang_string("no_run"), (false,true,false,false))
-        assert_eq!(parse_lang_string("{.no_run .example}"), (false,true,false,false))
-        assert_eq!(parse_lang_string("{.sh .should_fail}"), (true,false,false,false))
-        assert_eq!(parse_lang_string("{.example .rust}"), (false,false,false,false))
-    }
-}

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

@@ -9,16 +9,16 @@
 // except according to those terms.
 
 use abi;
-use ast::{P, Ident, Generics, NodeId, Expr};
+use ast::{P, Ident};
 use ast;
 use ast_util;
 use attr;
 use codemap::{Span, respan, Spanned, DUMMY_SP};
 use ext::base::ExtCtxt;
+use ext::quote::rt::*;
 use fold::Folder;
 use owned_slice::OwnedSlice;
 use parse::token::special_idents;
-use parse::token::InternedString;
 use parse::token;
 
 pub struct Field {

branches/try2/src/libsyntax/ext/deriving/bounds.rs

@@ -12,7 +12,6 @@ use ast::{MetaItem, MetaWord, Item};
 use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 
 pub fn expand_deriving_bound(cx: &mut ExtCtxt,
                              span: Span,

branches/try2/src/libsyntax/ext/deriving/clone.rs

@@ -13,7 +13,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_clone(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/cmp/eq.rs

@@ -13,7 +13,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_eq(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/cmp/ord.rs

@@ -14,7 +14,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_ord(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/cmp/totaleq.rs

@@ -13,7 +13,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_totaleq(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/cmp/totalord.rs

@@ -14,7 +14,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 use std::cmp::{Ordering, Equal, Less, Greater};

branches/try2/src/libsyntax/ext/deriving/decodable.rs

@@ -19,7 +19,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 use parse::token;
 

branches/try2/src/libsyntax/ext/deriving/default.rs

@@ -13,7 +13,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_default(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/encodable.rs

@@ -88,7 +88,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token;
 
 pub fn expand_deriving_encodable(cx: &mut ExtCtxt,
@@ -176,14 +175,6 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                 stmts.push(cx.stmt_expr(call));
             }
 
-            // unit structs have no fields and need to return Ok()
-            if stmts.is_empty() {
-                let ret_ok = cx.expr(trait_span,
-                                     ExprRet(Some(cx.expr_ok(trait_span,
-                                                             cx.expr_lit(trait_span, LitNil)))));
-                stmts.push(cx.stmt_expr(ret_ok));
-            }
-
             let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg);
             cx.expr_method_call(trait_span,
                                 encoder,

branches/try2/src/libsyntax/ext/deriving/generic/mod.rs

@@ -191,9 +191,8 @@ use codemap::Span;
 use owned_slice::OwnedSlice;
 use parse::token::InternedString;
 
-use self::ty::*;
-
-pub mod ty;
+pub use self::ty::*;
+mod ty;
 
 pub struct TraitDef<'a> {
     /// The span for the current #[deriving(Foo)] header.

branches/try2/src/libsyntax/ext/deriving/hash.rs

@@ -14,7 +14,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_hash(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/primitive.rs

@@ -14,7 +14,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,

branches/try2/src/libsyntax/ext/deriving/rand.rs

@@ -14,7 +14,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::{AstBuilder};
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 
 pub fn expand_deriving_rand(cx: &mut ExtCtxt,
                             span: Span,

branches/try2/src/libsyntax/ext/deriving/show.rs

@@ -15,7 +15,6 @@ use ext::format;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token;
 
 use collections::HashMap;

branches/try2/src/libsyntax/ext/deriving/zero.rs

@@ -13,7 +13,6 @@ use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
-use ext::deriving::generic::ty::*;
 use parse::token::InternedString;
 
 pub fn expand_deriving_zero(cx: &mut ExtCtxt,

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

@@ -36,17 +36,8 @@ pub mod rt {
     use parse;
     use print::pprust;
 
-    #[cfg(not(stage0))]
-    use ast::{TokenTree, Generics, Expr};
-
-    // NOTE remove this after snapshot
-    // (stage0 quasiquoter needs this)
-    #[cfg(stage0)]
-    pub use ast::{Generics, TokenTree, TTTok};
-    #[cfg(stage0)]
-    pub use parse::token::{IDENT, SEMI, LBRACE, RBRACE, LIFETIME, COLON, AND, BINOP, EQ,
-                           LBRACKET, RBRACKET, LPAREN, RPAREN, POUND, NOT, MOD_SEP, DOT, COMMA};
-
+    pub use ast::*;
+    pub use parse::token::*;
     pub use parse::new_parser_from_tts;
     pub use codemap::{BytePos, Span, dummy_spanned};
 
@@ -81,7 +72,7 @@ pub mod rt {
 
     impl ToSource for ast::Ident {
         fn to_source(&self) -> String {
-            token::get_ident(*self).get().to_string()
+            get_ident(*self).get().to_string()
         }
     }
 
@@ -694,14 +685,11 @@ fn expand_wrapper(cx: &ExtCtxt,
                   sp: Span,
                   cx_expr: @ast::Expr,
                   expr: @ast::Expr) -> @ast::Expr {
-    let uses = [
-        &["syntax", "ast"],
-        &["syntax", "parse", "token"],
-        &["syntax", "ext", "quote", "rt"],
-    ].iter().map(|path| {
-        let path = path.iter().map(|s| s.to_string()).collect();
-        cx.view_use_glob(sp, ast::Inherited, ids_ext(path))
-    }).collect();
+    let uses = vec![ cx.view_use_glob(sp, ast::Inherited,
+                                   ids_ext(vec!["syntax".to_string(),
+                                                "ext".to_string(),
+                                                "quote".to_string(),
+                                                "rt".to_string()])) ];
 
     let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr);
 

branches/try2/src/libsyntax/lib.rs

@@ -48,7 +48,6 @@ pub mod util {
 pub mod syntax {
     pub use ext;
     pub use parse;
-    pub use ast;
 }
 
 pub mod owned_slice;

branches/try2/src/test/compile-fail/issue-10764.rs

@@ -0,0 +1,15 @@
+// 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.
+
+fn f(_: extern "Rust" fn()) {}
+extern fn bar() {}
+
+fn main() { f(bar) }
+//~^ ERROR: expected `fn()` but found `extern "C" fn()`

branches/try2/src/test/run-pass/extern-pass-TwoU64s.rs

@@ -11,6 +11,8 @@
 // Test a foreign function that accepts and returns a struct
 // by value.
 
+// ignore-win32 #9205
+
 #[deriving(PartialEq, Show)]
 struct TwoU64s {
     one: u64, two: u64

branches/try2/src/test/run-pass/extern-return-TwoU64s.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-win32 #9205
+
 struct TwoU64s {
     one: u64, two: u64
 }

branches/try2/src/test/run-pass/issue-10764.rs

@@ -0,0 +1,11 @@
+// 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.
+
+extern "Rust" fn main() {}