Refactor compilation to make it easier to use for tools

src/librustc/session/config.rs

@@ -33,10 +33,11 @@
 use syntax::parse;
 use syntax::parse::token::InternedString;
 
+use getopts;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
-use getopts;
 use std::fmt;
+use std::os;
 
 use llvm;
 
@@ -821,7 +822,6 @@ pub fn parse_cfgspecs(cfgspecs: Vec<String> ) -> ast::CrateConfig {
 }
 
 pub fn build_session_options(matches: &getopts::Matches) -> Options {
-
     let unparsed_crate_types = matches.opt_strs("crate-type");
     let crate_types = parse_crate_types_from_list(unparsed_crate_types)
         .unwrap_or_else(|e| early_error(&e[]));
@@ -1041,7 +1041,22 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         crate_name: crate_name,
         alt_std_name: None,
         libs: libs,
-        unstable_features: UnstableFeatures::Disallow
+        unstable_features: get_unstable_features_setting(),
+    }
+}
+
+pub fn get_unstable_features_setting() -> UnstableFeatures {
+    // Whether this is a feature-staged build, i.e. on the beta or stable channel
+    let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
+    // The secret key needed to get through the rustc build itself by
+    // subverting the unstable features lints
+    let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY");
+    // The matching key to the above, only known by the build system
+    let bootstrap_provided_key = env::var_string("RUSTC_BOOTSTRAP_KEY").ok();
+    match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) {
+        (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat,
+        (true, _, _) => UnstableFeatures::Disallow,
+        (false, _, _) => UnstableFeatures::Default
     }
 }
 

src/librustdoc/test.rs

@@ -21,8 +21,8 @@
 use std::collections::{HashSet, HashMap};
 use testing;
 use rustc::session::{self, config};
+use rustc::session::config::get_unstable_features_setting;
 use rustc::session::search_paths::{SearchPaths, PathKind};
-use rustc_driver::get_unstable_features_setting;
 use rustc_driver::driver;
 use syntax::ast;
 use syntax::codemap::{CodeMap, dummy_spanned};

src/libsyntax/diagnostics/registry.rs

@@ -10,6 +10,7 @@
 
 use std::collections::HashMap;
 
+#[derive(Clone)]
 pub struct Registry {
     descriptions: HashMap<&'static str, &'static str>
 }

src/test/run-pass-fulldeps/compiler-calls.rs

+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that the CompilerCalls interface to the compiler works.
+
+#![feature(rustc_private)]
+#![feature(core)]
+
+extern crate getopts;
+extern crate rustc;
+extern crate rustc_driver;
+extern crate syntax;
+
+use rustc::session::Session;
+use rustc::session::config::{self, Input};
+use rustc_driver::{driver, CompilerCalls};
+use syntax::diagnostics;
+
+
+struct TestCalls {
+    count: u32
+}
+
+impl<'a> CompilerCalls<'a> for TestCalls {
+    fn early_callback(&mut self,
+                      _: &getopts::Matches,
+                      _: &diagnostics::registry::Registry)
+                      -> bool {
+        self.count *= 2;
+        false
+    }
+
+    fn late_callback(&mut self,
+                     _: &getopts::Matches,
+                     _: &Session,
+                     _: &Input,
+                     _: &Option<Path>,
+                     _: &Option<Path>)
+                     -> bool {
+        self.count *= 3;
+        true
+    }
+
+    fn some_input(&mut self, input: Input, input_path: Option<Path>) -> (Input, Option<Path>) {
+        self.count *= 5;
+        (input, input_path)
+    }
+
+    fn no_input(&mut self,
+                _: &getopts::Matches,
+                _: &config::Options,
+                _: &Option<Path>,
+                _: &Option<Path>,
+                _: &diagnostics::registry::Registry)
+                -> Option<(Input, Option<Path>)> {
+        panic!("This shouldn't happen");
+    }
+
+    fn build_controller(&mut self, _: &Session) -> driver::CompileController<'a> {
+        panic!("This shouldn't be called");
+    }
+}
+
+
+fn main() {
+    let mut tc = TestCalls { count: 1 };
+    // we should never get use this filename, but lets make sure they are valid args.
+    let args = vec!["compiler-calls".to_string(), "foo.rs".to_string()];
+    rustc_driver::run_compiler(args.as_slice(), &mut tc);
+    assert!(tc.count == 30);
+}
+