De-@ codemap and diagnostic.

Author: eddyb

src/librustc/back/link.rs

@@ -1352,9 +1352,8 @@ fn add_upstream_rust_crates(args: &mut Vec<~str>, sess: &Session,
     }
 
     // Converts a library file-stem into a cc -l argument
-    fn unlib(config: @session::Config, stem: &str) -> ~str {
-        if stem.starts_with("lib") &&
-            config.os != abi::OsWin32 {
+    fn unlib(config: &session::Config, stem: &str) -> ~str {
+        if stem.starts_with("lib") && config.os != abi::OsWin32 {
             stem.slice(3, stem.len()).to_owned()
         } else {
             stem.to_owned()
@@ -1434,7 +1433,7 @@ fn add_upstream_rust_crates(args: &mut Vec<~str>, sess: &Session,
             // what its name is
             let dir = cratepath.dirname_str().unwrap();
             if !dir.is_empty() { args.push("-L" + dir); }
-            let libarg = unlib(sess.targ_cfg, cratepath.filestem_str().unwrap());
+            let libarg = unlib(&sess.targ_cfg, cratepath.filestem_str().unwrap());
             args.push("-l" + libarg);
         }
     }

src/librustc/driver/driver.rs

@@ -27,7 +27,7 @@ use middle::{trans, freevars, kind, ty, typeck, lint, astencode, reachable};
 use middle;
 use util::common::time;
 use util::ppaux;
-use util::nodemap::NodeSet;
+use util::nodemap::{NodeMap, NodeSet};
 
 use serialize::{json, Encodable};
 
@@ -39,7 +39,6 @@ use std::mem::drop;
 use std::os;
 use std::vec_ng::Vec;
 use std::vec_ng;
-use collections::HashMap;
 use getopts::{optopt, optmulti, optflag, optflagopt};
 use getopts;
 use syntax::ast;
@@ -75,9 +74,9 @@ pub fn anon_src() -> ~str {
 
 pub fn source_name(input: &Input) -> ~str {
     match *input {
-      // FIXME (#9639): This needs to handle non-utf8 paths
-      FileInput(ref ifile) => ifile.as_str().unwrap().to_str(),
-      StrInput(_) => anon_src()
+        // FIXME (#9639): This needs to handle non-utf8 paths
+        FileInput(ref ifile) => ifile.as_str().unwrap().to_str(),
+        StrInput(_) => anon_src()
     }
 }
 
@@ -213,7 +212,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
                                     -> (ast::Crate, syntax::ast_map::Map) {
     let time_passes = sess.time_passes();
 
-    sess.building_library.set(session::building_library(sess.opts, &krate));
+    sess.building_library.set(session::building_library(&sess.opts, &krate));
     sess.crate_types.set(session::collect_crate_types(sess,
                                                       krate.attrs
                                                            .as_slice()));
@@ -315,7 +314,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
     sess.macro_registrar_fn.with_mut(|r| *r =
         time(time_passes, "looking for macro registrar", (), |_|
             syntax::ext::registrar::find_macro_registrar(
-                sess.span_diagnostic, krate)));
+                sess.diagnostic(), krate)));
 
     let freevars = time(time_passes, "freevar finding", (), |_|
                         freevars::annotate_freevars(def_map, krate));
@@ -541,19 +540,14 @@ fn write_out_deps(sess: &Session,
 
     // Build a list of files used to compile the output and
     // write Makefile-compatible dependency rules
-    let files: Vec<~str> = {
-        let files = sess.codemap.files.borrow();
-        files.get()
-             .iter()
-             .filter_map(|fmap| {
-                 if fmap.is_real_file() {
-                     Some(fmap.name.clone())
-                 } else {
-                     None
-                 }
-             })
-             .collect()
-    };
+    let files: Vec<~str> = sess.codemap().files.borrow().get()
+                               .iter().filter_map(|fmap| {
+                                    if fmap.deref().is_real_file() {
+                                        Some(fmap.deref().name.clone())
+                                    } else {
+                                        None
+                                    }
+                                }).collect();
     let mut file = try!(io::File::create(&deps_filename));
     for path in out_filenames.iter() {
         try!(write!(&mut file as &mut Writer,
@@ -741,8 +735,7 @@ static architecture_abis : &'static [(&'static str, abi::Architecture)] = &'stat
 
     ("mips",   abi::Mips)];
 
-pub fn build_target_config(sopts: @session::Options)
-                           -> @session::Config {
+pub fn build_target_config(sopts: &session::Options) -> session::Config {
     let os = match get_os(sopts.target_triple) {
       Some(os) => os,
       None => early_error("unknown operating system")
@@ -764,14 +757,13 @@ pub fn build_target_config(sopts: @session::Options)
       abi::Arm => arm::get_target_strs(target_triple, os),
       abi::Mips => mips::get_target_strs(target_triple, os)
     };
-    let target_cfg = @session::Config {
+    session::Config {
         os: os,
         arch: arch,
         target_strs: target_strs,
         int_type: int_type,
         uint_type: uint_type,
-    };
-    return target_cfg;
+    }
 }
 
 pub fn host_triple() -> ~str {
@@ -938,7 +930,7 @@ pub fn build_session_options(matches: &getopts::Matches)
                        matches.opt_present("crate-file-name"));
     let cg = build_codegen_options(matches);
 
-    @session::Options {
+    session::Options {
         crate_types: crate_types,
         gc: gc,
         optimize: opt_level,
@@ -991,25 +983,24 @@ pub fn build_codegen_options(matches: &getopts::Matches)
     return cg;
 }
 
-pub fn build_session(sopts: @session::Options,
+pub fn build_session(sopts: session::Options,
                      local_crate_source_file: Option<Path>)
                      -> Session {
-    let codemap = @codemap::CodeMap::new();
+    let codemap = codemap::CodeMap::new();
     let diagnostic_handler =
         diagnostic::default_handler();
     let span_diagnostic_handler =
         diagnostic::mk_span_handler(diagnostic_handler, codemap);
 
-    build_session_(sopts, local_crate_source_file, codemap, span_diagnostic_handler)
+    build_session_(sopts, local_crate_source_file, span_diagnostic_handler)
 }
 
-pub fn build_session_(sopts: @session::Options,
+pub fn build_session_(sopts: session::Options,
                       local_crate_source_file: Option<Path>,
-                      codemap: @codemap::CodeMap,
-                      span_diagnostic_handler: @diagnostic::SpanHandler)
+                      span_diagnostic: diagnostic::SpanHandler)
                       -> Session {
-    let target_cfg = build_target_config(sopts);
-    let p_s = parse::new_parse_sess_special_handler(span_diagnostic_handler, codemap);
+    let target_cfg = build_target_config(&sopts);
+    let p_s = parse::new_parse_sess_special_handler(span_diagnostic);
     let default_sysroot = match sopts.maybe_sysroot {
         Some(_) => None,
         None => Some(filesearch::get_or_default_sysroot())
@@ -1029,19 +1020,17 @@ pub fn build_session_(sopts: @session::Options,
         opts: sopts,
         cstore: CStore::new(token::get_ident_interner()),
         parse_sess: p_s,
-        codemap: codemap,
         // For a library crate, this is always none
         entry_fn: RefCell::new(None),
         entry_type: Cell::new(None),
         macro_registrar_fn: RefCell::new(None),
-        span_diagnostic: span_diagnostic_handler,
         default_sysroot: default_sysroot,
         building_library: Cell::new(false),
         local_crate_source_file: local_crate_source_file,
         working_dir: os::getcwd(),
-        lints: RefCell::new(HashMap::new()),
+        lints: RefCell::new(NodeMap::new()),
         node_id: Cell::new(1),
-        crate_types: @RefCell::new(Vec::new()),
+        crate_types: RefCell::new(Vec::new()),
         features: front::feature_gate::Features::new(),
         recursion_limit: Cell::new(64),
     }

src/librustc/driver/session.rs

@@ -16,6 +16,7 @@ use front;
 use metadata::filesearch;
 use metadata;
 use middle::lint;
+use util::nodemap::NodeMap;
 
 use syntax::attr::AttrMetaMethods;
 use syntax::ast::NodeId;
@@ -28,7 +29,7 @@ use syntax;
 
 use std::cell::{Cell, RefCell};
 use std::vec_ng::Vec;
-use collections::{HashMap,HashSet};
+use collections::HashSet;
 
 pub struct Config {
     os: abi::Os,
@@ -174,26 +175,23 @@ pub enum CrateType {
 }
 
 pub struct Session {
-    targ_cfg: @Config,
-    opts: @Options,
+    targ_cfg: Config,
+    opts: Options,
     cstore: metadata::cstore::CStore,
     parse_sess: ParseSess,
-    codemap: @codemap::CodeMap,
     // For a library crate, this is always none
     entry_fn: RefCell<Option<(NodeId, codemap::Span)>>,
     entry_type: Cell<Option<EntryFnType>>,
-    span_diagnostic: @diagnostic::SpanHandler,
     macro_registrar_fn: RefCell<Option<ast::DefId>>,
     default_sysroot: Option<Path>,
     building_library: Cell<bool>,
     // The name of the root source file of the crate, in the local file system. The path is always
     // expected to be absolute. `None` means that there is no source file.
     local_crate_source_file: Option<Path>,
     working_dir: Path,
-    lints: RefCell<HashMap<ast::NodeId,
-                           Vec<(lint::Lint, codemap::Span, ~str)> >>,
+    lints: RefCell<NodeMap<Vec<(lint::Lint, codemap::Span, ~str)>>>,
     node_id: Cell<ast::NodeId>,
-    crate_types: @RefCell<Vec<CrateType> >,
+    crate_types: RefCell<Vec<CrateType>>,
     features: front::feature_gate::Features,
 
     /// The maximum recursion limit for potentially infinitely recursive
@@ -203,52 +201,52 @@ pub struct Session {
 
 impl Session {
     pub fn span_fatal(&self, sp: Span, msg: &str) -> ! {
-        self.span_diagnostic.span_fatal(sp, msg)
+        self.diagnostic().span_fatal(sp, msg)
     }
     pub fn fatal(&self, msg: &str) -> ! {
-        self.span_diagnostic.handler().fatal(msg)
+        self.diagnostic().handler().fatal(msg)
     }
     pub fn span_err(&self, sp: Span, msg: &str) {
-        self.span_diagnostic.span_err(sp, msg)
+        self.diagnostic().span_err(sp, msg)
     }
     pub fn err(&self, msg: &str) {
-        self.span_diagnostic.handler().err(msg)
+        self.diagnostic().handler().err(msg)
     }
     pub fn err_count(&self) -> uint {
-        self.span_diagnostic.handler().err_count()
+        self.diagnostic().handler().err_count()
     }
     pub fn has_errors(&self) -> bool {
-        self.span_diagnostic.handler().has_errors()
+        self.diagnostic().handler().has_errors()
     }
     pub fn abort_if_errors(&self) {
-        self.span_diagnostic.handler().abort_if_errors()
+        self.diagnostic().handler().abort_if_errors()
     }
     pub fn span_warn(&self, sp: Span, msg: &str) {
-        self.span_diagnostic.span_warn(sp, msg)
+        self.diagnostic().span_warn(sp, msg)
     }
     pub fn warn(&self, msg: &str) {
-        self.span_diagnostic.handler().warn(msg)
+        self.diagnostic().handler().warn(msg)
     }
     pub fn span_note(&self, sp: Span, msg: &str) {
-        self.span_diagnostic.span_note(sp, msg)
+        self.diagnostic().span_note(sp, msg)
     }
     pub fn span_end_note(&self, sp: Span, msg: &str) {
-        self.span_diagnostic.span_end_note(sp, msg)
+        self.diagnostic().span_end_note(sp, msg)
     }
     pub fn note(&self, msg: &str) {
-        self.span_diagnostic.handler().note(msg)
+        self.diagnostic().handler().note(msg)
     }
     pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
-        self.span_diagnostic.span_bug(sp, msg)
+        self.diagnostic().span_bug(sp, msg)
     }
     pub fn bug(&self, msg: &str) -> ! {
-        self.span_diagnostic.handler().bug(msg)
+        self.diagnostic().handler().bug(msg)
     }
     pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
-        self.span_diagnostic.span_unimpl(sp, msg)
+        self.diagnostic().span_unimpl(sp, msg)
     }
     pub fn unimpl(&self, msg: &str) -> ! {
-        self.span_diagnostic.handler().unimpl(msg)
+        self.diagnostic().handler().unimpl(msg)
     }
     pub fn add_lint(&self,
                     lint: lint::Lint,
@@ -275,12 +273,15 @@ impl Session {
 
         v
     }
-    pub fn diagnostic(&self) -> @diagnostic::SpanHandler {
-        self.span_diagnostic
+    pub fn diagnostic<'a>(&'a self) -> &'a diagnostic::SpanHandler {
+        &self.parse_sess.span_diagnostic
     }
     pub fn debugging_opt(&self, opt: u64) -> bool {
         (self.opts.debugging_opts & opt) != 0
     }
+    pub fn codemap<'a>(&'a self) -> &'a codemap::CodeMap {
+        &self.parse_sess.span_diagnostic.cm
+    }
     // This exists to help with refactoring to eliminate impossible
     // cases later on
     pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
@@ -328,8 +329,8 @@ impl Session {
 }
 
 /// Some reasonable defaults
-pub fn basic_options() -> @Options {
-    @Options {
+pub fn basic_options() -> Options {
+    Options {
         crate_types: Vec::new(),
         gc: false,
         optimize: No,

src/librustc/lib.rs

@@ -295,26 +295,26 @@ pub fn run_compiler(args: &[~str]) {
         d::parse_pretty(&sess, a)
     });
     match pretty {
-      Some::<d::PpMode>(ppm) => {
-        d::pretty_print_input(sess, cfg, &input, ppm);
-        return;
-      }
-      None::<d::PpMode> => {/* continue */ }
+        Some::<d::PpMode>(ppm) => {
+            d::pretty_print_input(sess, cfg, &input, ppm);
+            return;
+        }
+        None::<d::PpMode> => {/* continue */ }
     }
     let ls = matches.opt_present("ls");
     if ls {
         match input {
-          d::FileInput(ref ifile) => {
-            let mut stdout = io::stdout();
-            d::list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
-          }
-          d::StrInput(_) => {
-            d::early_error("can not list metadata for stdin");
-          }
+            d::FileInput(ref ifile) => {
+                let mut stdout = io::stdout();
+                d::list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
+            }
+            d::StrInput(_) => {
+                d::early_error("can not list metadata for stdin");
+            }
         }
         return;
     }
-    let (crate_id, crate_name, crate_file_name) = sopts.print_metas;
+    let (crate_id, crate_name, crate_file_name) = sess.opts.print_metas;
     // these nasty nested conditions are to avoid doing extra work
     if crate_id || crate_name || crate_file_name {
         let attrs = parse_crate_attrs(&sess, &input);

src/librustc/metadata/creader.rs

@@ -88,7 +88,7 @@ fn dump_crates(crate_cache: &[cache_entry]) {
 }
 
 fn warn_if_multiple_versions(e: &mut Env,
-                             diag: @SpanHandler,
+                             diag: &SpanHandler,
                              crate_cache: &[cache_entry]) {
     if crate_cache.len() != 0u {
         let name = crate_cache[crate_cache.len() - 1].crate_id.name.clone();

src/librustc/metadata/csearch.rs

@@ -214,11 +214,11 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(class_id.krate);
     let all_items = reader::get_doc(reader::Doc(cdata.data()), tag_items);
-    let class_doc = expect(tcx.diag,
+    let class_doc = expect(tcx.sess.diagnostic(),
                            decoder::maybe_find_item(class_id.node, all_items),
                            || format!("get_field_type: class ID {:?} not found",
                                    class_id) );
-    let the_field = expect(tcx.diag,
+    let the_field = expect(tcx.sess.diagnostic(),
         decoder::maybe_find_item(def.node, class_doc),
         || format!("get_field_type: in class {:?}, field ID {:?} not found",
                  class_id, def) );