---

yaml
---
r: 144928
b: refs/heads/try2
c: 959d9d6
h: refs/heads/master
v: v3

Author: pnkfelix

[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: 753d8c226c75b72edd939793223d28f4baf932fd
+refs/heads/try2: 959d9d60e143fb969fa5bc778a2017a9312bd435
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/driver/driver.rs

@@ -190,9 +190,6 @@ pub fn phase_2_configure_and_expand(sess: Session,
     crate = time(time_passes, ~"std injection", ||
                  front::std_inject::maybe_inject_libstd_ref(sess, crate));
 
-    crate = time(time_passes, ~"assigning node ids", ||
-                 front::assign_node_ids::assign_node_ids(sess, crate));
-
     return crate;
 }
 
@@ -210,7 +207,6 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                                    crate: @ast::Crate) -> CrateAnalysis {
 
     let time_passes = sess.time_passes();
-
     let ast_map = time(time_passes, ~"ast indexing", ||
                        syntax::ast_map::map_crate(sess.diagnostic(), crate));
 
@@ -816,7 +812,6 @@ pub fn build_session_(sopts: @session::options,
         building_library: @mut false,
         working_dir: os::getcwd(),
         lints: @mut HashMap::new(),
-        node_id: @mut 1
     }
 }
 

branches/try2/src/librustc/driver/session.rs

@@ -28,7 +28,6 @@ use syntax::abi;
 use syntax::parse::token;
 use syntax;
 
-use std::int;
 use std::hashmap::HashMap;
 
 #[deriving(Eq)]
@@ -217,58 +216,57 @@ pub struct Session_ {
     building_library: @mut bool,
     working_dir: Path,
     lints: @mut HashMap<ast::NodeId, ~[(lint::lint, codemap::Span, ~str)]>,
-    node_id: @mut uint,
 }
 
 pub type Session = @Session_;
 
 impl Session_ {
-    pub fn span_fatal(&self, sp: Span, msg: &str) -> ! {
+    pub fn span_fatal(@self, sp: Span, msg: &str) -> ! {
         self.span_diagnostic.span_fatal(sp, msg)
     }
-    pub fn fatal(&self, msg: &str) -> ! {
+    pub fn fatal(@self, msg: &str) -> ! {
         self.span_diagnostic.handler().fatal(msg)
     }
-    pub fn span_err(&self, sp: Span, msg: &str) {
+    pub fn span_err(@self, sp: Span, msg: &str) {
         self.span_diagnostic.span_err(sp, msg)
     }
-    pub fn err(&self, msg: &str) {
+    pub fn err(@self, msg: &str) {
         self.span_diagnostic.handler().err(msg)
     }
-    pub fn err_count(&self) -> uint {
+    pub fn err_count(@self) -> uint {
         self.span_diagnostic.handler().err_count()
     }
-    pub fn has_errors(&self) -> bool {
+    pub fn has_errors(@self) -> bool {
         self.span_diagnostic.handler().has_errors()
     }
-    pub fn abort_if_errors(&self) {
+    pub fn abort_if_errors(@self) {
         self.span_diagnostic.handler().abort_if_errors()
     }
-    pub fn span_warn(&self, sp: Span, msg: &str) {
+    pub fn span_warn(@self, sp: Span, msg: &str) {
         self.span_diagnostic.span_warn(sp, msg)
     }
-    pub fn warn(&self, msg: &str) {
+    pub fn warn(@self, msg: &str) {
         self.span_diagnostic.handler().warn(msg)
     }
-    pub fn span_note(&self, sp: Span, msg: &str) {
+    pub fn span_note(@self, sp: Span, msg: &str) {
         self.span_diagnostic.span_note(sp, msg)
     }
-    pub fn note(&self, msg: &str) {
+    pub fn note(@self, msg: &str) {
         self.span_diagnostic.handler().note(msg)
     }
-    pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
+    pub fn span_bug(@self, sp: Span, msg: &str) -> ! {
         self.span_diagnostic.span_bug(sp, msg)
     }
-    pub fn bug(&self, msg: &str) -> ! {
+    pub fn bug(@self, msg: &str) -> ! {
         self.span_diagnostic.handler().bug(msg)
     }
-    pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
+    pub fn span_unimpl(@self, sp: Span, msg: &str) -> ! {
         self.span_diagnostic.span_unimpl(sp, msg)
     }
-    pub fn unimpl(&self, msg: &str) -> ! {
+    pub fn unimpl(@self, msg: &str) -> ! {
         self.span_diagnostic.handler().unimpl(msg)
     }
-    pub fn add_lint(&self,
+    pub fn add_lint(@self,
                     lint: lint::lint,
                     id: ast::NodeId,
                     sp: Span,
@@ -279,85 +277,77 @@ impl Session_ {
         }
         self.lints.insert(id, ~[(lint, sp, msg)]);
     }
-    pub fn next_node_id(&self) -> ast::NodeId {
-        self.reserve_node_ids(1)
+    pub fn next_node_id(@self) -> ast::NodeId {
+        return syntax::parse::next_node_id(self.parse_sess);
     }
-    pub fn reserve_node_ids(&self, count: uint) -> ast::NodeId {
-        let v = *self.node_id;
-        *self.node_id += count;
-        if v > (int::max_value as uint) {
-            self.bug("Input too large, ran out of node ids!");
-        }
-        v as int
-    }
-    pub fn diagnostic(&self) -> @mut diagnostic::span_handler {
+    pub fn diagnostic(@self) -> @mut diagnostic::span_handler {
         self.span_diagnostic
     }
-    pub fn debugging_opt(&self, opt: uint) -> bool {
+    pub fn debugging_opt(@self, opt: uint) -> bool {
         (self.opts.debugging_opts & opt) != 0u
     }
     // This exists to help with refactoring to eliminate impossible
     // cases later on
-    pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
+    pub fn impossible_case(@self, sp: Span, msg: &str) -> ! {
         self.span_bug(sp, fmt!("Impossible case reached: %s", msg));
     }
-    pub fn verbose(&self) -> bool { self.debugging_opt(verbose) }
-    pub fn time_passes(&self) -> bool { self.debugging_opt(time_passes) }
-    pub fn count_llvm_insns(&self) -> bool {
+    pub fn verbose(@self) -> bool { self.debugging_opt(verbose) }
+    pub fn time_passes(@self) -> bool { self.debugging_opt(time_passes) }
+    pub fn count_llvm_insns(@self) -> bool {
         self.debugging_opt(count_llvm_insns)
     }
-    pub fn count_type_sizes(&self) -> bool {
+    pub fn count_type_sizes(@self) -> bool {
         self.debugging_opt(count_type_sizes)
     }
-    pub fn time_llvm_passes(&self) -> bool {
+    pub fn time_llvm_passes(@self) -> bool {
         self.debugging_opt(time_llvm_passes)
     }
-    pub fn trans_stats(&self) -> bool { self.debugging_opt(trans_stats) }
-    pub fn meta_stats(&self) -> bool { self.debugging_opt(meta_stats) }
-    pub fn asm_comments(&self) -> bool { self.debugging_opt(asm_comments) }
-    pub fn no_verify(&self) -> bool { self.debugging_opt(no_verify) }
-    pub fn lint_llvm(&self) -> bool { self.debugging_opt(lint_llvm) }
-    pub fn trace(&self) -> bool { self.debugging_opt(trace) }
-    pub fn coherence(&self) -> bool { self.debugging_opt(coherence) }
-    pub fn borrowck_stats(&self) -> bool { self.debugging_opt(borrowck_stats) }
-    pub fn borrowck_note_pure(&self) -> bool {
+    pub fn trans_stats(@self) -> bool { self.debugging_opt(trans_stats) }
+    pub fn meta_stats(@self) -> bool { self.debugging_opt(meta_stats) }
+    pub fn asm_comments(@self) -> bool { self.debugging_opt(asm_comments) }
+    pub fn no_verify(@self) -> bool { self.debugging_opt(no_verify) }
+    pub fn lint_llvm(@self) -> bool { self.debugging_opt(lint_llvm) }
+    pub fn trace(@self) -> bool { self.debugging_opt(trace) }
+    pub fn coherence(@self) -> bool { self.debugging_opt(coherence) }
+    pub fn borrowck_stats(@self) -> bool { self.debugging_opt(borrowck_stats) }
+    pub fn borrowck_note_pure(@self) -> bool {
         self.debugging_opt(borrowck_note_pure)
     }
-    pub fn borrowck_note_loan(&self) -> bool {
+    pub fn borrowck_note_loan(@self) -> bool {
         self.debugging_opt(borrowck_note_loan)
     }
-    pub fn no_monomorphic_collapse(&self) -> bool {
+    pub fn no_monomorphic_collapse(@self) -> bool {
         self.debugging_opt(no_monomorphic_collapse)
     }
-    pub fn debug_borrows(&self) -> bool {
+    pub fn debug_borrows(@self) -> bool {
         self.opts.optimize == No && !self.debugging_opt(no_debug_borrows)
     }
-    pub fn once_fns(&self) -> bool { self.debugging_opt(once_fns) }
-    pub fn print_llvm_passes(&self) -> bool {
+    pub fn once_fns(@self) -> bool { self.debugging_opt(once_fns) }
+    pub fn print_llvm_passes(@self) -> bool {
         self.debugging_opt(print_llvm_passes)
     }
-    pub fn no_prepopulate_passes(&self) -> bool {
+    pub fn no_prepopulate_passes(@self) -> bool {
         self.debugging_opt(no_prepopulate_passes)
     }
-    pub fn no_vectorize_loops(&self) -> bool {
+    pub fn no_vectorize_loops(@self) -> bool {
         self.debugging_opt(no_vectorize_loops)
     }
-    pub fn no_vectorize_slp(&self) -> bool {
+    pub fn no_vectorize_slp(@self) -> bool {
         self.debugging_opt(no_vectorize_slp)
     }
 
     // pointless function, now...
-    pub fn str_of(&self, id: ast::Ident) -> @str {
+    pub fn str_of(@self, id: ast::Ident) -> @str {
         token::ident_to_str(&id)
     }
 
     // pointless function, now...
-    pub fn ident_of(&self, st: &str) -> ast::Ident {
+    pub fn ident_of(@self, st: &str) -> ast::Ident {
         token::str_to_ident(st)
     }
 
     // pointless function, now...
-    pub fn intr(&self) -> @syntax::parse::token::ident_interner {
+    pub fn intr(@self) -> @syntax::parse::token::ident_interner {
         token::get_ident_interner()
     }
 }

branches/try2/src/librustc/front/assign_node_ids.rs

@@ -45,7 +45,7 @@ fn inject_libstd_ref(sess: Session, crate: &ast::Crate) -> @ast::Crate {
 
     let precursor = @fold::AstFoldFns {
         fold_crate: |crate, fld| {
-            let n1 = ast::DUMMY_NODE_ID;
+            let n1 = sess.next_node_id();
             let vi1 = ast::view_item {
                 node: ast::view_item_extern_mod(
                         sess.ident_of("std"), None, ~[], n1),
@@ -86,7 +86,7 @@ fn inject_libstd_ref(sess: Session, crate: &ast::Crate) -> @ast::Crate {
             }
         },
         fold_mod: |module, fld| {
-            let n2 = ast::DUMMY_NODE_ID;
+            let n2 = sess.next_node_id();
 
             let prelude_path = ast::Path {
                 span: dummy_sp(),

branches/try2/src/librustc/front/std_inject.rs

@@ -280,10 +280,10 @@ fn mk_std(cx: &TestCtxt) -> ast::view_item {
         ast::view_item_use(
             ~[@nospan(ast::view_path_simple(id_extra,
                                             path_node(~[id_extra]),
-                                            ast::DUMMY_NODE_ID))])
+                                            cx.sess.next_node_id()))])
     } else {
         let mi = attr::mk_name_value_item_str(@"vers", @"0.8-pre");
-        ast::view_item_extern_mod(id_extra, None, ~[mi], ast::DUMMY_NODE_ID)
+        ast::view_item_extern_mod(id_extra, None, ~[mi], cx.sess.next_node_id())
     };
     ast::view_item {
         node: vi,
@@ -325,7 +325,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
     let item = ast::item {
         ident: cx.sess.ident_of("__test"),
         attrs: ~[resolve_unexported_attr],
-        id: ast::DUMMY_NODE_ID,
+        id: cx.sess.next_node_id(),
         node: item_,
         vis: ast::public,
         span: dummy_sp(),
@@ -367,7 +367,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
     let item = ast::item {
         ident: cx.sess.ident_of("__test"),
         attrs: ~[resolve_unexported_attr],
-        id: ast::DUMMY_NODE_ID,
+        id: cx.sess.next_node_id(),
         node: item_,
         vis: ast::public,
         span: dummy_sp(),
@@ -448,14 +448,15 @@ fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
         descs.push(mk_test_desc_and_fn_rec(cx, test));
     }
 
+    let sess = cx.sess;
     let inner_expr = @ast::Expr {
-        id: ast::DUMMY_NODE_ID,
+        id: sess.next_node_id(),
         node: ast::ExprVec(descs, ast::MutImmutable),
         span: dummy_sp(),
     };
 
     @ast::Expr {
-        id: ast::DUMMY_NODE_ID,
+        id: sess.next_node_id(),
         node: ast::ExprVstore(inner_expr, ast::ExprVstoreSlice),
         span: dummy_sp(),
     }
@@ -474,15 +475,15 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
         nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));
 
     let name_expr = @ast::Expr {
-          id: ast::DUMMY_NODE_ID,
+          id: cx.sess.next_node_id(),
           node: ast::ExprLit(@name_lit),
           span: span
     };
 
     let fn_path = path_node_global(path);
 
     let fn_expr = @ast::Expr {
-        id: ast::DUMMY_NODE_ID,
+        id: cx.sess.next_node_id(),
         node: ast::ExprPath(fn_path),
         span: span,
     };
@@ -528,15 +529,15 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
         nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));
 
     let name_expr = @ast::Expr {
-          id: ast::DUMMY_NODE_ID,
+          id: cx.sess.next_node_id(),
           node: ast::ExprLit(@name_lit),
           span: span
     };
 
     let fn_path = path_node_global(path);
 
     let fn_expr = @ast::Expr {
-        id: ast::DUMMY_NODE_ID,
+        id: cx.sess.next_node_id(),
         node: ast::ExprPath(fn_path),
         span: span,
     };

branches/try2/src/librustc/front/test.rs

@@ -157,10 +157,10 @@ fn reserve_id_range(sess: Session,
     // Handle the case of an empty range:
     if from_id_range.empty() { return from_id_range; }
     let cnt = from_id_range.max - from_id_range.min;
-    assert!(cnt >= 0);
-    let to_id_min = sess.reserve_node_ids(cnt as uint);
-    let to_id_max = to_id_min + cnt;
-    ast_util::id_range { min: to_id_min, max: to_id_max }
+    let to_id_min = sess.parse_sess.next_id;
+    let to_id_max = sess.parse_sess.next_id + cnt;
+    sess.parse_sess.next_id = to_id_max;
+    ast_util::id_range { min: to_id_min, max: to_id_min }
 }
 
 impl ExtendedDecodeContext {