---

yaml
---
r: 152235
b: refs/heads/try2
c: 559ff5e
h: refs/heads/master
i:
  152233: 17bbcd5
  152231: 99a7ecf
v: v3

Author: luqmana

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

branches/try2/src/libregex_macros/lib.rs

@@ -20,6 +20,7 @@
        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/librustc/middle/typeck/check/mod.rs

@@ -168,15 +168,6 @@ pub struct Inherited<'a> {
     upvar_borrow_map: RefCell<ty::UpvarBorrowMap>,
 }
 
-#[deriving(Clone)]
-pub enum FnKind {
-    // A do-closure.
-    DoBlock,
-
-    // A normal closure or fn item.
-    Vanilla
-}
-
 #[deriving(Clone)]
 pub struct FnStyleState {
     pub def: ast::NodeId,
@@ -249,11 +240,6 @@ pub struct FnCtxt<'a> {
     // can actually be made to live as long as it needs to live.
     region_lb: Cell<ast::NodeId>,
 
-    // Says whether we're inside a for loop, in a do block
-    // or neither. Helps with error messages involving the
-    // function return type.
-    fn_kind: FnKind,
-
     inh: &'a Inherited<'a>,
 
     ccx: &'a CrateCtxt<'a>,
@@ -289,7 +275,6 @@ fn blank_fn_ctxt<'a>(ccx: &'a CrateCtxt<'a>,
         ret_ty: rty,
         ps: RefCell::new(FnStyleState::function(ast::NormalFn, 0)),
         region_lb: Cell::new(region_bnd),
-        fn_kind: Vanilla,
         inh: inh,
         ccx: ccx
     }
@@ -356,7 +341,7 @@ fn check_bare_fn(ccx: &CrateCtxt,
         ty::ty_bare_fn(ref fn_ty) => {
             let inh = Inherited::new(ccx.tcx, param_env);
             let fcx = check_fn(ccx, fn_ty.fn_style, &fn_ty.sig,
-                               decl, id, body, Vanilla, &inh);
+                               decl, id, body, &inh);
 
             vtable::resolve_in_block(&fcx, body);
             regionck::regionck_fn(&fcx, body);
@@ -440,7 +425,6 @@ fn check_fn<'a>(ccx: &'a CrateCtxt<'a>,
                 decl: &ast::FnDecl,
                 id: ast::NodeId,
                 body: &ast::Block,
-                fn_kind: FnKind,
                 inherited: &'a Inherited<'a>) -> FnCtxt<'a>
 {
     /*!
@@ -479,7 +463,6 @@ fn check_fn<'a>(ccx: &'a CrateCtxt<'a>,
         ret_ty: ret_ty,
         ps: RefCell::new(FnStyleState::function(fn_style, id)),
         region_lb: Cell::new(body.id),
-        fn_kind: fn_kind,
         inh: inherited,
         ccx: ccx
     };
@@ -2295,7 +2278,6 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                      store: ty::TraitStore,
                      decl: &ast::FnDecl,
                      body: ast::P<ast::Block>,
-                     fn_kind: FnKind,
                      expected: Option<ty::t>) {
         let tcx = fcx.ccx.tcx;
 
@@ -2373,7 +2355,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
         };
 
         check_fn(fcx.ccx, inherited_style, &fty_sig,
-                 decl, id, body, fn_kind, fcx.inh);
+                 decl, id, body, fcx.inh);
     }
 
 
@@ -3044,7 +3026,6 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                       ty::RegionTraitStore(region, ast::MutMutable),
                       decl,
                       body,
-                      Vanilla,
                       expected);
       }
       ast::ExprProc(decl, body) => {
@@ -3053,7 +3034,6 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                       ty::UniqTraitStore,
                       decl,
                       body,
-                      Vanilla,
                       expected);
       }
       ast::ExprBlock(b) => {

branches/try2/src/libsyntax/crateid.rs

@@ -1,4 +1,4 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -13,7 +13,7 @@ use std::fmt;
 /// CrateIds identify crates and include the crate name and optionally a path
 /// and version. In the full form, they look like relative URLs. Example:
 /// `github.com/mozilla/rust#std:1.0` would be a package ID with a path of
-/// `github.com/mozilla/rust` and a crate name of `std` with a version of
+/// `gitub.com/mozilla/rust` and a crate name of `std` with a version of
 /// `1.0`. If no crate name is given after the hash, the name is inferred to
 /// be the last component of the path. If no version is given, it is inferred
 /// to be `0.0`.

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

@@ -401,16 +401,6 @@ fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::Expr {
                         vec!(e_str))
 }
 
-fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) -> @ast::Expr {
-    let idents = vec!(id_ext("syntax"), id_ext("ast"), id_ext(name));
-    cx.expr_path(cx.path_global(sp, idents))
-}
-
-fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> @ast::Expr {
-    let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
-    cx.expr_path(cx.path_global(sp, idents))
-}
-
 fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> @ast::Expr {
     let name = match bop {
         PLUS => "PLUS",
@@ -424,96 +414,116 @@ fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> @ast::Expr {
         SHL => "SHL",
         SHR => "SHR"
     };
-    mk_token_path(cx, sp, name)
+    cx.expr_ident(sp, id_ext(name))
 }
 
 fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
 
     match *tok {
         BINOP(binop) => {
-            return cx.expr_call(sp, mk_token_path(cx, sp, "BINOP"), vec!(mk_binop(cx, sp, binop)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("BINOP"),
+                                      vec!(mk_binop(cx, sp, binop)));
         }
         BINOPEQ(binop) => {
-            return cx.expr_call(sp, mk_token_path(cx, sp, "BINOPEQ"),
-                                vec!(mk_binop(cx, sp, binop)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("BINOPEQ"),
+                                      vec!(mk_binop(cx, sp, binop)));
         }
 
         LIT_CHAR(i) => {
             let e_char = cx.expr_lit(sp, ast::LitChar(i));
 
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_CHAR"), vec!(e_char));
+            return cx.expr_call_ident(sp, id_ext("LIT_CHAR"), vec!(e_char));
         }
 
         LIT_INT(i, ity) => {
             let s_ity = match ity {
-                ast::TyI => "TyI",
-                ast::TyI8 => "TyI8",
-                ast::TyI16 => "TyI16",
-                ast::TyI32 => "TyI32",
-                ast::TyI64 => "TyI64"
+                ast::TyI => "TyI".to_string(),
+                ast::TyI8 => "TyI8".to_string(),
+                ast::TyI16 => "TyI16".to_string(),
+                ast::TyI32 => "TyI32".to_string(),
+                ast::TyI64 => "TyI64".to_string()
             };
-            let e_ity = mk_ast_path(cx, sp, s_ity);
+            let e_ity = cx.expr_ident(sp, id_ext(s_ity.as_slice()));
+
             let e_i64 = cx.expr_lit(sp, ast::LitInt(i, ast::TyI64));
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_INT"), vec!(e_i64, e_ity));
+
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIT_INT"),
+                                      vec!(e_i64, e_ity));
         }
 
         LIT_UINT(u, uty) => {
             let s_uty = match uty {
-                ast::TyU => "TyU",
-                ast::TyU8 => "TyU8",
-                ast::TyU16 => "TyU16",
-                ast::TyU32 => "TyU32",
-                ast::TyU64 => "TyU64"
+                ast::TyU => "TyU".to_string(),
+                ast::TyU8 => "TyU8".to_string(),
+                ast::TyU16 => "TyU16".to_string(),
+                ast::TyU32 => "TyU32".to_string(),
+                ast::TyU64 => "TyU64".to_string()
             };
-            let e_uty = mk_ast_path(cx, sp, s_uty);
+            let e_uty = cx.expr_ident(sp, id_ext(s_uty.as_slice()));
+
             let e_u64 = cx.expr_lit(sp, ast::LitUint(u, ast::TyU64));
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_UINT"), vec!(e_u64, e_uty));
+
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIT_UINT"),
+                                      vec!(e_u64, e_uty));
         }
 
         LIT_INT_UNSUFFIXED(i) => {
             let e_i64 = cx.expr_lit(sp, ast::LitInt(i, ast::TyI64));
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_INT_UNSUFFIXED"), vec!(e_i64));
+
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIT_INT_UNSUFFIXED"),
+                                      vec!(e_i64));
         }
 
         LIT_FLOAT(fident, fty) => {
             let s_fty = match fty {
-                ast::TyF32 => "TyF32",
-                ast::TyF64 => "TyF64",
-                ast::TyF128 => "TyF128"
+                ast::TyF32 => "TyF32".to_string(),
+                ast::TyF64 => "TyF64".to_string(),
+                ast::TyF128 => "TyF128".to_string()
             };
-            let e_fty = mk_ast_path(cx, sp, s_fty);
+            let e_fty = cx.expr_ident(sp, id_ext(s_fty.as_slice()));
+
             let e_fident = mk_ident(cx, sp, fident);
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_FLOAT"), vec!(e_fident, e_fty));
+
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIT_FLOAT"),
+                                      vec!(e_fident, e_fty));
         }
 
         LIT_STR(ident) => {
-            return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "LIT_STR"),
-                                vec!(mk_ident(cx, sp, ident)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIT_STR"),
+                                      vec!(mk_ident(cx, sp, ident)));
         }
 
         LIT_STR_RAW(ident, n) => {
-            return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "LIT_STR_RAW"),
-                                vec!(mk_ident(cx, sp, ident), cx.expr_uint(sp, n)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIT_STR_RAW"),
+                                      vec!(mk_ident(cx, sp, ident),
+                                        cx.expr_uint(sp, n)));
         }
 
         IDENT(ident, b) => {
-            return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "IDENT"),
-                                vec!(mk_ident(cx, sp, ident), cx.expr_bool(sp, b)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("IDENT"),
+                                      vec!(mk_ident(cx, sp, ident),
+                                        cx.expr_bool(sp, b)));
         }
 
         LIFETIME(ident) => {
-            return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "LIFETIME"),
-                                vec!(mk_ident(cx, sp, ident)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("LIFETIME"),
+                                      vec!(mk_ident(cx, sp, ident)));
         }
 
         DOC_COMMENT(ident) => {
-            return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "DOC_COMMENT"),
-                                vec!(mk_ident(cx, sp, ident)));
+            return cx.expr_call_ident(sp,
+                                      id_ext("DOC_COMMENT"),
+                                      vec!(mk_ident(cx, sp, ident)));
         }
 
         INTERPOLATED(_) => fail!("quote! with interpolated token"),
@@ -555,16 +565,19 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
         EOF => "EOF",
         _ => fail!()
     };
-    mk_token_path(cx, sp, name)
+    cx.expr_ident(sp, id_ext(name))
 }
 
+
 fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> Vec<@ast::Stmt> {
+
     match *tt {
+
         ast::TTTok(sp, ref tok) => {
             let e_sp = cx.expr_ident(sp, id_ext("_sp"));
-            let e_tok = cx.expr_call(sp,
-                                     mk_ast_path(cx, sp, "TTTok"),
-                                     vec!(e_sp, mk_token(cx, sp, tok)));
+            let e_tok = cx.expr_call_ident(sp,
+                                           id_ext("TTTok"),
+                                           vec!(e_sp, mk_token(cx, sp, tok)));
             let e_push =
                 cx.expr_method_call(sp,
                                     cx.expr_ident(sp, id_ext("tt")),
@@ -682,6 +695,8 @@ fn expand_wrapper(cx: &ExtCtxt,
                   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();