Remove dependencies on driver from trans et al. by moving various

structs out from driver and into other places.

Author: nikomatsakis

src/librustc/middle/ty.rs

@@ -92,6 +92,17 @@ pub const INITIAL_DISCRIMINANT_VALUE: Disr = 0;
 
 // Data types
 
+/// The complete set of all analyses described in this module. This is
+/// produced by the driver and fed to trans and later passes.
+pub struct CrateAnalysis<'tcx> {
+    pub exp_map2: middle::resolve::ExportMap2,
+    pub exported_items: middle::privacy::ExportedItems,
+    pub public_items: middle::privacy::PublicItems,
+    pub ty_cx: ty::ctxt<'tcx>,
+    pub reachable: NodeSet,
+    pub name: String,
+}
+
 #[deriving(PartialEq, Eq, Hash)]
 pub struct field<'tcx> {
     pub name: ast::Name,

src/librustc/session/config.rs

@@ -114,6 +114,59 @@ pub struct Options {
     pub alt_std_name: Option<String>
 }
 
+pub enum Input {
+    /// Load source from file
+    File(Path),
+    /// The string is the source
+    Str(String)
+}
+
+impl Input {
+    pub fn filestem(&self) -> String {
+        match *self {
+            Input::File(ref ifile) => ifile.filestem_str().unwrap().to_string(),
+            Input::Str(_) => "rust_out".to_string(),
+        }
+    }
+}
+
+#[deriving(Clone)]
+pub struct OutputFilenames {
+    pub out_directory: Path,
+    pub out_filestem: String,
+    pub single_output_file: Option<Path>,
+    pub extra: String,
+}
+
+impl OutputFilenames {
+    pub fn path(&self, flavor: OutputType) -> Path {
+        match self.single_output_file {
+            Some(ref path) => return path.clone(),
+            None => {}
+        }
+        self.temp_path(flavor)
+    }
+
+    pub fn temp_path(&self, flavor: OutputType) -> Path {
+        let base = self.out_directory.join(self.filestem());
+        match flavor {
+            OutputTypeBitcode => base.with_extension("bc"),
+            OutputTypeAssembly => base.with_extension("s"),
+            OutputTypeLlvmAssembly => base.with_extension("ll"),
+            OutputTypeObject => base.with_extension("o"),
+            OutputTypeExe => base,
+        }
+    }
+
+    pub fn with_extension(&self, extension: &str) -> Path {
+        self.out_directory.join(self.filestem()).with_extension(extension)
+    }
+
+    pub fn filestem(&self) -> String {
+        format!("{}{}", self.out_filestem, self.extra)
+    }
+}
+
 pub fn host_triple() -> &'static str {
     // Get the host triple out of the build environment. This ensures that our
     // idea of the host triple is the same as for the set of libraries we've

src/librustc_trans/back/link.rs

@@ -13,15 +13,13 @@ use super::archive;
 use super::rpath;
 use super::rpath::RPathConfig;
 use super::svh::Svh;
-use driver::driver::{CrateTranslation, OutputFilenames, Input, FileInput};
 use session::config;
 use session::config::NoDebugInfo;
-use session::config::{OutputTypeBitcode, OutputTypeExe, OutputTypeObject};
+use session::config::{OutputFilenames, Input, OutputTypeBitcode, OutputTypeExe, OutputTypeObject};
 use session::Session;
 use metadata::common::LinkMeta;
 use metadata::{encoder, cstore, filesearch, csearch, creader};
-use trans::context::CrateContext;
-use trans::common::gensym_name;
+use trans::{CrateContext, CrateTranslation, gensym_name};
 use middle::ty::{mod, Ty};
 use util::common::time;
 use util::ppaux;
@@ -156,7 +154,7 @@ pub fn find_crate_name(sess: Option<&Session>,
     if let Some((attr, s)) = attr_crate_name {
         return validate(s.get().to_string(), Some(attr.span));
     }
-    if let FileInput(ref path) = *input {
+    if let Input::File(ref path) = *input {
         if let Some(s) = path.filestem_str() {
             return validate(s.to_string(), None);
         }

src/librustc_trans/back/write.rs

@@ -10,13 +10,13 @@
 
 use back::lto;
 use back::link::{get_cc_prog, remove};
-use driver::driver::{CrateTranslation, ModuleTranslation, OutputFilenames};
-use session::config::{NoDebugInfo, Passes, SomePasses, AllPasses};
+use session::config::{OutputFilenames, NoDebugInfo, Passes, SomePasses, AllPasses};
 use session::Session;
 use session::config;
 use llvm;
 use llvm::{ModuleRef, TargetMachineRef, PassManagerRef, DiagnosticInfoRef, ContextRef};
 use llvm::SMDiagnosticRef;
+use trans::{CrateTranslation, ModuleTranslation};
 use util::common::time;
 use syntax::codemap;
 use syntax::diagnostic;

src/librustc_trans/driver/driver.rs

@@ -8,15 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub use self::Input::*;
-
 use back::link;
 use back::write;
 use session::Session;
-use session::config;
+use session::config::{mod, Input, OutputFilenames};
 use lint;
-use llvm::{ContextRef, ModuleRef};
-use metadata::common::LinkMeta;
 use metadata::creader;
 use middle::{stability, ty, reachable};
 use middle::dependency_format;
@@ -28,7 +24,6 @@ use rustc::typeck;
 use trans;
 
 use util::common::time;
-use util::nodemap::{NodeSet};
 
 use serialize::{json, Encodable};
 
@@ -114,36 +109,19 @@ pub fn anon_src() -> String {
 pub fn source_name(input: &Input) -> String {
     match *input {
         // FIXME (#9639): This needs to handle non-utf8 paths
-        FileInput(ref ifile) => ifile.as_str().unwrap().to_string(),
-        StrInput(_) => anon_src()
-    }
-}
-
-pub enum Input {
-    /// Load source from file
-    FileInput(Path),
-    /// The string is the source
-    StrInput(String)
-}
-
-impl Input {
-    fn filestem(&self) -> String {
-        match *self {
-            FileInput(ref ifile) => ifile.filestem_str().unwrap().to_string(),
-            StrInput(_) => "rust_out".to_string(),
-        }
+        Input::File(ref ifile) => ifile.as_str().unwrap().to_string(),
+        Input::Str(_) => anon_src()
     }
 }
 
-
 pub fn phase_1_parse_input(sess: &Session, cfg: ast::CrateConfig, input: &Input)
     -> ast::Crate {
     let krate = time(sess.time_passes(), "parsing", (), |_| {
         match *input {
-            FileInput(ref file) => {
+            Input::File(ref file) => {
                 parse::parse_crate_from_file(&(*file), cfg.clone(), &sess.parse_sess)
             }
-            StrInput(ref src) => {
+            Input::Str(ref src) => {
                 parse::parse_crate_from_source_str(anon_src().to_string(),
                                                    src.to_string(),
                                                    cfg.clone(),
@@ -343,23 +321,13 @@ pub fn assign_node_ids_and_map<'ast>(sess: &Session,
     map
 }
 
-pub struct CrateAnalysis<'tcx> {
-    pub exp_map2: middle::resolve::ExportMap2,
-    pub exported_items: middle::privacy::ExportedItems,
-    pub public_items: middle::privacy::PublicItems,
-    pub ty_cx: ty::ctxt<'tcx>,
-    pub reachable: NodeSet,
-    pub name: String,
-}
-
-
 /// Run the resolution, typechecking, region checking and other
 /// miscellaneous analysis passes on the crate. Return various
 /// structures carrying the results of the analysis.
 pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
                                          ast_map: ast_map::Map<'tcx>,
                                          type_arena: &'tcx TypedArena<ty::TyS<'tcx>>,
-                                         name: String) -> CrateAnalysis<'tcx> {
+                                         name: String) -> ty::CrateAnalysis<'tcx> {
     let time_passes = sess.time_passes();
     let krate = ast_map.krate();
 
@@ -474,7 +442,7 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
     time(time_passes, "lint checking", (), |_|
          lint::check_crate(&ty_cx, &exported_items));
 
-    CrateAnalysis {
+    ty::CrateAnalysis {
         exp_map2: exp_map2,
         ty_cx: ty_cx,
         exported_items: exported_items,
@@ -486,7 +454,7 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
 
 pub fn phase_save_analysis(sess: &Session,
                            krate: &ast::Crate,
-                           analysis: &CrateAnalysis,
+                           analysis: &ty::CrateAnalysis,
                            odir: &Option<Path>) {
     if (sess.opts.debugging_opts & config::SAVE_ANALYSIS) == 0 {
         return;
@@ -495,39 +463,24 @@ pub fn phase_save_analysis(sess: &Session,
          save::process_crate(sess, krate, analysis, odir));
 }
 
-pub struct ModuleTranslation {
-    pub llcx: ContextRef,
-    pub llmod: ModuleRef,
-}
-
-pub struct CrateTranslation {
-    pub modules: Vec<ModuleTranslation>,
-    pub metadata_module: ModuleTranslation,
-    pub link: LinkMeta,
-    pub metadata: Vec<u8>,
-    pub reachable: Vec<String>,
-    pub crate_formats: dependency_format::Dependencies,
-    pub no_builtins: bool,
-}
-
 /// Run the translation phase to LLVM, after which the AST and analysis can
 /// be discarded.
-pub fn phase_4_translate_to_llvm<'tcx>(analysis: CrateAnalysis<'tcx>)
-                                       -> (ty::ctxt<'tcx>, CrateTranslation) {
+pub fn phase_4_translate_to_llvm<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
+                                       -> (ty::ctxt<'tcx>, trans::CrateTranslation) {
     let time_passes = analysis.ty_cx.sess.time_passes();
 
     time(time_passes, "resolving dependency formats", (), |_|
          dependency_format::calculate(&analysis.ty_cx));
 
     // Option dance to work around the lack of stack once closures.
     time(time_passes, "translation", analysis, |analysis|
-         trans::base::trans_crate(analysis))
+         trans::trans_crate(analysis))
 }
 
 /// Run LLVM itself, producing a bitcode file, assembly file or object file
 /// as a side effect.
 pub fn phase_5_run_llvm_passes(sess: &Session,
-                               trans: &CrateTranslation,
+                               trans: &trans::CrateTranslation,
                                outputs: &OutputFilenames) {
     if sess.opts.cg.no_integrated_as {
         let output_type = config::OutputTypeAssembly;
@@ -555,7 +508,7 @@ pub fn phase_5_run_llvm_passes(sess: &Session,
 /// Run the linker on any artifacts that resulted from the LLVM run.
 /// This should produce either a finished executable or library.
 pub fn phase_6_link_output(sess: &Session,
-                           trans: &CrateTranslation,
+                           trans: &trans::CrateTranslation,
                            outputs: &OutputFilenames) {
     let old_path = os::getenv("PATH").unwrap_or_else(||String::new());
     let mut new_path = sess.host_filesearch().get_tools_search_paths();
@@ -640,8 +593,8 @@ fn write_out_deps(sess: &Session,
         // Use default filename: crate source filename with extension replaced
         // by ".d"
         (true, None) => match *input {
-            FileInput(..) => outputs.with_extension("d"),
-            StrInput(..) => {
+            Input::File(..) => outputs.with_extension("d"),
+            Input::Str(..) => {
                 sess.warn("can not write --dep-info without a filename \
                            when compiling stdin.");
                 return
@@ -752,43 +705,6 @@ pub fn collect_crate_metadata(session: &Session,
     session.opts.cg.metadata.clone()
 }
 
-#[deriving(Clone)]
-pub struct OutputFilenames {
-    pub out_directory: Path,
-    pub out_filestem: String,
-    pub single_output_file: Option<Path>,
-    extra: String,
-}
-
-impl OutputFilenames {
-    pub fn path(&self, flavor: config::OutputType) -> Path {
-        match self.single_output_file {
-            Some(ref path) => return path.clone(),
-            None => {}
-        }
-        self.temp_path(flavor)
-    }
-
-    pub fn temp_path(&self, flavor: config::OutputType) -> Path {
-        let base = self.out_directory.join(self.filestem());
-        match flavor {
-            config::OutputTypeBitcode => base.with_extension("bc"),
-            config::OutputTypeAssembly => base.with_extension("s"),
-            config::OutputTypeLlvmAssembly => base.with_extension("ll"),
-            config::OutputTypeObject => base.with_extension("o"),
-            config::OutputTypeExe => base,
-        }
-    }
-
-    pub fn with_extension(&self, extension: &str) -> Path {
-        self.out_directory.join(self.filestem()).with_extension(extension)
-    }
-
-    fn filestem(&self) -> String {
-        format!("{}{}", self.out_filestem, self.extra)
-    }
-}
-
 pub fn build_output_filenames(input: &Input,
                               odir: &Option<Path>,
                               ofile: &Option<Path>,

src/librustc_trans/driver/mod.rs

@@ -11,8 +11,8 @@
 pub use syntax::diagnostic;
 
 use back::link;
-use driver::driver::{Input, FileInput, StrInput};
 use session::{config, Session, build_session};
+use session::config::Input;
 use lint::Lint;
 use lint;
 use metadata;
@@ -89,9 +89,9 @@ fn run_compiler(args: &[String]) {
             if ifile == "-" {
                 let contents = io::stdin().read_to_end().unwrap();
                 let src = String::from_utf8(contents).unwrap();
-                (StrInput(src), None)
+                (Input::Str(src), None)
             } else {
-                (FileInput(Path::new(ifile)), Some(Path::new(ifile)))
+                (Input::File(Path::new(ifile)), Some(Path::new(ifile)))
             }
         }
         _ => early_error("multiple input filenames provided")
@@ -116,11 +116,11 @@ fn run_compiler(args: &[String]) {
     let r = matches.opt_strs("Z");
     if r.contains(&("ls".to_string())) {
         match input {
-            FileInput(ref ifile) => {
+            Input::File(ref ifile) => {
                 let mut stdout = io::stdout();
                 list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
             }
-            StrInput(_) => {
+            Input::Str(_) => {
                 early_error("can not list metadata for stdin");
             }
         }
@@ -411,12 +411,12 @@ fn print_crate_info(sess: &Session,
 fn parse_crate_attrs(sess: &Session, input: &Input) ->
                      Vec<ast::Attribute> {
     let result = match *input {
-        FileInput(ref ifile) => {
+        Input::File(ref ifile) => {
             parse::parse_crate_attrs_from_file(ifile,
                                                Vec::new(),
                                                &sess.parse_sess)
         }
-        StrInput(ref src) => {
+        Input::Str(ref src) => {
             parse::parse_crate_attrs_from_source_str(
                 driver::anon_src().to_string(),
                 src.to_string(),