---

yaml
---
r: 231687
b: refs/heads/auto
c: 7c8c72d
h: refs/heads/master
i:
  231685: 4491f91
  231683: 70487af
  231679: 12dac55
v: v3

Author: steveklabnik

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: cd138dc4475fa90b007969d0a4e00f230be777cf
+refs/heads/auto: 7c8c72d3b0d12b6d595c7316c3e68a205acdeaf8
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/mk/crates.mk

@@ -56,7 +56,7 @@ TARGET_CRATES := libc std flate arena term \
 		 alloc_system
 RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
-                rustc_data_structures rustc_front rustc_platform_intrinsics
+                rustc_data_structures rustc_platform_intrinsics
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
 TOOLS := compiletest rustdoc rustc rustbook error-index-generator
 
@@ -71,24 +71,23 @@ DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc rustc_bitflags
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
                      rustc_typeck rustc_resolve log syntax serialize rustc_llvm \
-		             rustc_trans rustc_privacy rustc_lint rustc_front
+		     rustc_trans rustc_privacy rustc_lint
 
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
-	                log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics
-DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics
-DEPS_rustc_borrowck := rustc rustc_front log graphviz syntax
-DEPS_rustc_resolve := rustc rustc_front log syntax
-DEPS_rustc_privacy := rustc rustc_front log syntax
+	                log syntax serialize rustc_llvm rustc_platform_intrinsics
+DEPS_rustc_typeck := rustc syntax rustc_platform_intrinsics
+DEPS_rustc_borrowck := rustc log graphviz syntax
+DEPS_rustc_resolve := rustc log syntax
+DEPS_rustc_privacy := rustc log syntax
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               log graphviz rustc_llvm rustc_back rustc_data_structures
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
 DEPS_rustc_platform_intrinsics := rustc rustc_llvm
-DEPS_rustc_back := std syntax rustc_llvm rustc_front flate log libc
-DEPS_rustc_front := std syntax log serialize
+DEPS_rustc_back := std syntax rustc_llvm flate log libc
 DEPS_rustc_data_structures := std log serialize
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
-                test rustc_lint rustc_front
+                test rustc_lint
 DEPS_rustc_bitflags := core
 DEPS_flate := std native:miniz
 DEPS_arena := std

branches/auto/mk/docs.mk

@@ -191,6 +191,7 @@ ifdef CFG_DISABLE_DOCS
 endif
 
 docs: $(DOC_TARGETS)
+doc: docs
 compiler-docs: $(COMPILER_DOC_TARGETS)
 
 trpl: doc/book/index.html

branches/auto/src/compiletest/runtest.rs

@@ -268,7 +268,7 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = vec!("-".to_owned(),
                             "-Zunstable-options".to_owned(),
-                            "--unpretty".to_owned(),
+                            "--pretty".to_owned(),
                             pretty_type,
                             format!("--target={}", config.target),
                             "-L".to_owned(),

branches/auto/src/doc/trpl/lifetimes.md

@@ -108,7 +108,7 @@ If we wanted an `&mut` reference, we’d do this:
 
 If you compare `&mut i32` to `&'a mut i32`, they’re the same, it’s just that
 the lifetime `'a` has snuck in between the `&` and the `mut i32`. We read `&mut
-i32` as ‘a mutable reference to an `i32`’ and `&'a mut i32` as ‘a mutable
+i32` as ‘a mutable reference to an i32’ and `&'a mut i32` as ‘a mutable
 reference to an `i32` with the lifetime `'a`’.
 
 # In `struct`s

branches/auto/src/librustc/front/map/blocks.rs renamed to branches/auto/src/librustc/ast_map/blocks.rs

@@ -23,13 +23,12 @@
 
 pub use self::Code::*;
 
-use front::map::{self, Node};
+use ast_map::{self, Node};
 use syntax::abi;
-use rustc_front::hir::{Block, FnDecl};
-use syntax::ast::{NodeId, Ident};
-use rustc_front::hir as ast;
+use syntax::ast::{Block, FnDecl, NodeId};
+use syntax::ast;
 use syntax::codemap::Span;
-use rustc_front::visit::FnKind;
+use syntax::visit::FnKind;
 
 /// An FnLikeNode is a Node that is like a fn, in that it has a decl
 /// and a body (as well as a NodeId, a span, etc).
@@ -41,7 +40,7 @@ use rustc_front::visit::FnKind;
 ///
 /// To construct one, use the `Code::from_node` function.
 #[derive(Copy, Clone)]
-pub struct FnLikeNode<'a> { node: map::Node<'a> }
+pub struct FnLikeNode<'a> { node: ast_map::Node<'a> }
 
 /// MaybeFnLike wraps a method that indicates if an object
 /// corresponds to some FnLikeNode.
@@ -87,7 +86,7 @@ pub enum Code<'a> {
 }
 
 impl<'a> Code<'a> {
-    pub fn id(&self) -> NodeId {
+    pub fn id(&self) -> ast::NodeId {
         match *self {
             FnLikeCode(node) => node.id(),
             BlockCode(block) => block.id,
@@ -96,7 +95,7 @@ impl<'a> Code<'a> {
 
     /// Attempts to construct a Code from presumed FnLike or Block node input.
     pub fn from_node(node: Node) -> Option<Code> {
-        if let map::NodeBlock(block) = node {
+        if let ast_map::NodeBlock(block) = node {
             Some(BlockCode(block))
         } else {
             FnLikeNode::from_node(node).map(|fn_like| FnLikeCode(fn_like))
@@ -107,15 +106,15 @@ impl<'a> Code<'a> {
 /// These are all the components one can extract from a fn item for
 /// use when implementing FnLikeNode operations.
 struct ItemFnParts<'a> {
-    ident:    Ident,
+    ident:    ast::Ident,
     decl:     &'a ast::FnDecl,
     unsafety: ast::Unsafety,
     constness: ast::Constness,
     abi:      abi::Abi,
     vis:      ast::Visibility,
     generics: &'a ast::Generics,
     body:     &'a Block,
-    id:       NodeId,
+    id:       ast::NodeId,
     span:     Span
 }
 
@@ -138,10 +137,10 @@ impl<'a> FnLikeNode<'a> {
     /// Attempts to construct a FnLikeNode from presumed FnLike node input.
     pub fn from_node(node: Node) -> Option<FnLikeNode> {
         let fn_like = match node {
-            map::NodeItem(item) => item.is_fn_like(),
-            map::NodeTraitItem(tm) => tm.is_fn_like(),
-            map::NodeImplItem(_) => true,
-            map::NodeExpr(e) => e.is_fn_like(),
+            ast_map::NodeItem(item) => item.is_fn_like(),
+            ast_map::NodeTraitItem(tm) => tm.is_fn_like(),
+            ast_map::NodeImplItem(_) => true,
+            ast_map::NodeExpr(e) => e.is_fn_like(),
             _ => false
         };
         if fn_like {
@@ -203,7 +202,7 @@ impl<'a> FnLikeNode<'a> {
     fn handle<A, I, M, C>(self, item_fn: I, method: M, closure: C) -> A where
         I: FnOnce(ItemFnParts<'a>) -> A,
         M: FnOnce(NodeId,
-                  Ident,
+                  ast::Ident,
                   &'a ast::MethodSig,
                   Option<ast::Visibility>,
                   &'a ast::Block,
@@ -212,7 +211,7 @@ impl<'a> FnLikeNode<'a> {
         C: FnOnce(ClosureParts<'a>) -> A,
     {
         match self.node {
-            map::NodeItem(i) => match i.node {
+            ast_map::NodeItem(i) => match i.node {
                 ast::ItemFn(ref decl, unsafety, constness, abi, ref generics, ref block) =>
                     item_fn(ItemFnParts {
                         id: i.id,
@@ -228,13 +227,13 @@ impl<'a> FnLikeNode<'a> {
                     }),
                 _ => panic!("item FnLikeNode that is not fn-like"),
             },
-            map::NodeTraitItem(ti) => match ti.node {
+            ast_map::NodeTraitItem(ti) => match ti.node {
                 ast::MethodTraitItem(ref sig, Some(ref body)) => {
                     method(ti.id, ti.ident, sig, None, body, ti.span)
                 }
                 _ => panic!("trait method FnLikeNode that is not fn-like"),
             },
-            map::NodeImplItem(ii) => {
+            ast_map::NodeImplItem(ii) => {
                 match ii.node {
                     ast::MethodImplItem(ref sig, ref body) => {
                         method(ii.id, ii.ident, sig, Some(ii.vis), body, ii.span)
@@ -244,7 +243,7 @@ impl<'a> FnLikeNode<'a> {
                     }
                 }
             }
-            map::NodeExpr(e) => match e.node {
+            ast_map::NodeExpr(e) => match e.node {
                 ast::ExprClosure(_, ref decl, ref block) =>
                     closure(ClosureParts::new(&**decl, &**block, e.id, e.span)),
                 _ => panic!("expr FnLikeNode that is not fn-like"),

branches/auto/src/librustc/front/map/mod.rs renamed to branches/auto/src/librustc/ast_map/mod.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -15,17 +15,14 @@ use self::MapEntry::*;
 use metadata::inline::InlinedItem;
 use metadata::inline::InlinedItem as II;
 use middle::def_id::DefId;
-
 use syntax::abi;
-use syntax::ast::{Name, NodeId, Ident, CRATE_NODE_ID, DUMMY_NODE_ID};
-use syntax::codemap::{Span, Spanned};
+use syntax::ast::*;
+use syntax::ast_util;
+use syntax::codemap::{DUMMY_SP, Span, Spanned};
+use syntax::fold::Folder;
 use syntax::parse::token;
-
-use rustc_front::hir::*;
-use rustc_front::fold::Folder;
-use rustc_front::visit::{self, Visitor};
-use rustc_front::util;
-use rustc_front::print::pprust;
+use syntax::print::pprust;
+use syntax::visit::{self, Visitor};
 
 use arena::TypedArena;
 use std::cell::RefCell;
@@ -162,7 +159,7 @@ impl<'ast> Clone for MapEntry<'ast> {
 }
 
 #[derive(Debug)]
-pub struct InlinedParent {
+struct InlinedParent {
     path: Vec<PathElem>,
     ii: InlinedItem
 }
@@ -230,7 +227,7 @@ impl<'ast> MapEntry<'ast> {
 
 /// Stores a crate and any number of inlined items from other crates.
 pub struct Forest {
-    pub krate: Crate,
+    krate: Crate,
     inlined_items: TypedArena<InlinedParent>
 }
 
@@ -249,10 +246,9 @@ impl Forest {
 
 /// Represents a mapping from Node IDs to AST elements and their parent
 /// Node IDs
-#[derive(Clone)]
 pub struct Map<'ast> {
     /// The backing storage for all the AST nodes.
-    pub forest: &'ast Forest,
+    forest: &'ast Forest,
 
     /// NodeIds are sequential integers from 0, so we can be
     /// super-compact by storing them in a vector. Not everything with
@@ -874,7 +870,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
     }
 
     fn visit_stmt(&mut self, stmt: &'ast Stmt) {
-        let id = util::stmt_id(stmt);
+        let id = ast_util::stmt_id(stmt);
         self.insert(id, NodeStmt(stmt));
         let parent_node = self.parent_node;
         self.parent_node = id;
@@ -921,7 +917,20 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
     }
 }
 
-pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> {
+pub fn map_crate<'ast, F: FoldOps>(forest: &'ast mut Forest, fold_ops: F) -> Map<'ast> {
+    // Replace the crate with an empty one to take it out.
+    let krate = mem::replace(&mut forest.krate, Crate {
+        module: Mod {
+            inner: DUMMY_SP,
+            items: vec![],
+        },
+        attrs: vec![],
+        config: vec![],
+        exported_macros: vec![],
+        span: DUMMY_SP
+    });
+    forest.krate = IdAndSpanUpdater { fold_ops: fold_ops }.fold_crate(krate);
+
     let mut collector = NodeCollector {
         map: vec![],
         parent_node: CRATE_NODE_ID,
@@ -965,11 +974,11 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
         II::Item(i) => II::Item(fld.fold_item(i).expect_one("expected one item")),
         II::TraitItem(d, ti) => {
             II::TraitItem(fld.fold_ops.new_def_id(d),
-                        fld.fold_trait_item(ti).expect_one("expected one trait item"))
+                          fld.fold_trait_item(ti).expect_one("expected one trait item"))
         }
         II::ImplItem(d, ii) => {
             II::ImplItem(fld.fold_ops.new_def_id(d),
-                       fld.fold_impl_item(ii).expect_one("expected one impl item"))
+                         fld.fold_impl_item(ii).expect_one("expected one impl item"))
         }
         II::Foreign(i) => II::Foreign(fld.fold_foreign_item(i))
     };
@@ -1055,6 +1064,7 @@ fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String {
                 ItemTrait(..) => "trait",
                 ItemImpl(..) => "impl",
                 ItemDefaultImpl(..) => "default impl",
+                ItemMac(..) => "macro"
             };
             format!("{} {}{}", item_str, path_str, id_str)
         }
@@ -1081,6 +1091,10 @@ fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String {
                             map.path_to_string(id),
                             id_str)
                 }
+                MacImplItem(ref mac) => {
+                    format!("method macro {}{}",
+                            pprust::mac_to_string(mac), id_str)
+                }
             }
         }
         Some(NodeTraitItem(ti)) => {

branches/auto/src/librustc/lib.rs

@@ -73,7 +73,6 @@ extern crate graphviz;
 extern crate libc;
 extern crate rustc_llvm;
 extern crate rustc_back;
-extern crate rustc_front;
 extern crate rustc_data_structures;
 extern crate serialize;
 extern crate rbml;
@@ -102,9 +101,7 @@ pub mod back {
     pub use rustc_back::svh;
 }
 
-pub mod front {
-    pub mod map;
-}
+pub mod ast_map;
 
 pub mod middle {
     pub mod astconv_util;