diff options
| author | bors <bors@rust-lang.org> | 2018-08-04 18:22:39 +0000 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2018-08-04 18:22:39 +0000 |
| commit | 94c3c340cce53396d23a20b236fa94f1d34b6df7 (patch) | |
| tree | 5e4fd9877c9ae60131d28c97f15eac835b2030d8 | |
| parent | 215bf3abd9c0eb1fd0c6cae7c92a842732dc033d (diff) | |
| parent | 0ae2aa232047e16019d1b90726ca2c397371e5aa (diff) | |
| download | rust-94c3c340cce53396d23a20b236fa94f1d34b6df7.tar.gz rust-94c3c340cce53396d23a20b236fa94f1d34b6df7.zip | |
Auto merge of #52758 - Mark-Simulacrum:session-cleanup, r=pnkfelix
Cleanup for librustc::session Some rather straightforward cleanup. Each commit mostly stands alone.
38 files changed, 313 insertions, 346 deletions
diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 4c99b46ddff..a9c118d606b 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -115,30 +115,30 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let preferred_linkage = match ty { // cdylibs must have all static dependencies. - config::CrateTypeCdylib => Linkage::Static, + config::CrateType::Cdylib => Linkage::Static, // Generating a dylib without `-C prefer-dynamic` means that we're going // to try to eagerly statically link all dependencies. This is normally // done for end-product dylibs, not intermediate products. - config::CrateTypeDylib if !sess.opts.cg.prefer_dynamic => Linkage::Static, - config::CrateTypeDylib => Linkage::Dynamic, + config::CrateType::Dylib if !sess.opts.cg.prefer_dynamic => Linkage::Static, + config::CrateType::Dylib => Linkage::Dynamic, // If the global prefer_dynamic switch is turned off, or the final // executable will be statically linked, prefer static crate linkage. - config::CrateTypeExecutable if !sess.opts.cg.prefer_dynamic || + config::CrateType::Executable if !sess.opts.cg.prefer_dynamic || sess.crt_static() => Linkage::Static, - config::CrateTypeExecutable => Linkage::Dynamic, + config::CrateType::Executable => Linkage::Dynamic, // proc-macro crates are required to be dylibs, and they're currently // required to link to libsyntax as well. - config::CrateTypeProcMacro => Linkage::Dynamic, + config::CrateType::ProcMacro => Linkage::Dynamic, // No linkage happens with rlibs, we just needed the metadata (which we // got long ago), so don't bother with anything. - config::CrateTypeRlib => Linkage::NotLinked, + config::CrateType::Rlib => Linkage::NotLinked, // staticlibs must have all static dependencies. - config::CrateTypeStaticlib => Linkage::Static, + config::CrateType::Staticlib => Linkage::Static, }; if preferred_linkage == Linkage::NotLinked { @@ -155,8 +155,8 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // Staticlibs, cdylibs, and static executables must have all static // dependencies. If any are not found, generate some nice pretty errors. - if ty == config::CrateTypeCdylib || ty == config::CrateTypeStaticlib || - (ty == config::CrateTypeExecutable && sess.crt_static() && + if ty == config::CrateType::Cdylib || ty == config::CrateType::Staticlib || + (ty == config::CrateType::Executable && sess.crt_static() && !sess.target.target.options.crt_static_allows_dylibs) { for &cnum in tcx.crates().iter() { if tcx.dep_kind(cnum).macros_only() { continue } diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index feeb508d676..b0acc6f20e6 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -12,6 +12,7 @@ use hir::map as hir_map; use hir::def_id::{CRATE_DEF_INDEX}; use session::{config, Session}; +use session::config::EntryFnType; use syntax::ast::NodeId; use syntax::attr; use syntax::entry::EntryPointType; @@ -59,7 +60,7 @@ pub fn find_entry_point(session: &Session, hir_map: &hir_map::Map, crate_name: &str) { let any_exe = session.crate_types.borrow().iter().any(|ty| { - *ty == config::CrateTypeExecutable + *ty == config::CrateType::Executable }); if !any_exe { // No need to find a main function @@ -155,11 +156,11 @@ fn find_item(item: &Item, ctxt: &mut EntryContext, at_root: bool) { fn configure_main(this: &mut EntryContext, crate_name: &str) { if let Some((node_id, span)) = this.start_fn { - this.session.entry_fn.set(Some((node_id, span, config::EntryStart))); + this.session.entry_fn.set(Some((node_id, span, EntryFnType::Start))); } else if let Some((node_id, span)) = this.attr_main_fn { - this.session.entry_fn.set(Some((node_id, span, config::EntryMain))); + this.session.entry_fn.set(Some((node_id, span, EntryFnType::Main))); } else if let Some((node_id, span)) = this.main_fn { - this.session.entry_fn.set(Some((node_id, span, config::EntryMain))); + this.session.entry_fn.set(Some((node_id, span, EntryFnType::Main))); } else { // No main function this.session.entry_fn.set(None); diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 19c82d7d27c..94246db3706 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -408,8 +408,8 @@ fn reachable_set<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) -> let access_levels = &tcx.privacy_access_levels(LOCAL_CRATE); let any_library = tcx.sess.crate_types.borrow().iter().any(|ty| { - *ty == config::CrateTypeRlib || *ty == config::CrateTypeDylib || - *ty == config::CrateTypeProcMacro + *ty == config::CrateType::Rlib || *ty == config::CrateType::Dylib || + *ty == config::CrateType::ProcMacro }); let mut reachable_context = ReachableContext { tcx, diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index d8570b43fbe..e8431ce3e10 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -89,12 +89,12 @@ fn verify<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // emitting something that's not an rlib. let needs_check = tcx.sess.crate_types.borrow().iter().any(|kind| { match *kind { - config::CrateTypeDylib | - config::CrateTypeProcMacro | - config::CrateTypeCdylib | - config::CrateTypeExecutable | - config::CrateTypeStaticlib => true, - config::CrateTypeRlib => false, + config::CrateType::Dylib | + config::CrateType::ProcMacro | + config::CrateType::Cdylib | + config::CrateType::Executable | + config::CrateType::Staticlib => true, + config::CrateType::Rlib => false, } }); if !needs_check { diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index dda4a2d2418..3111777f4ad 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -11,11 +11,6 @@ //! Contains infrastructure for configuring the compiler, including parsing //! command line options. -pub use self::EntryFnType::*; -pub use self::CrateType::*; -pub use self::Passes::*; -pub use self::DebugInfoLevel::*; - use std::str::FromStr; use session::{early_error, early_warn, Session}; @@ -113,10 +108,10 @@ impl CrossLangLto { } #[derive(Clone, Copy, PartialEq, Hash)] -pub enum DebugInfoLevel { - NoDebugInfo, - LimitedDebugInfo, - FullDebugInfo, +pub enum DebugInfo { + None, + Limited, + Full, } #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, RustcEncodable, RustcDecodable)] @@ -381,7 +376,7 @@ top_level_options!( // Include the debug_assertions flag into dependency tracking, since it // can influence whether overflow checks are done or not. debug_assertions: bool [TRACKED], - debuginfo: DebugInfoLevel [TRACKED], + debuginfo: DebugInfo [TRACKED], lint_opts: Vec<(String, lint::Level)> [TRACKED], lint_cap: Option<lint::Level> [TRACKED], describe_lints: bool [UNTRACKED], @@ -601,37 +596,38 @@ pub fn host_triple() -> &'static str { (option_env!("CFG_COMPILER_HOST_TRIPLE")).expect("CFG_COMPILER_HOST_TRIPLE") } -/// Some reasonable defaults -pub fn basic_options() -> Options { - Options { - crate_types: Vec::new(), - optimize: OptLevel::No, - debuginfo: NoDebugInfo, - lint_opts: Vec::new(), - lint_cap: None, - describe_lints: false, - output_types: OutputTypes(BTreeMap::new()), - search_paths: SearchPaths::new(), - maybe_sysroot: None, - target_triple: TargetTriple::from_triple(host_triple()), - test: false, - incremental: None, - debugging_opts: basic_debugging_options(), - prints: Vec::new(), - borrowck_mode: BorrowckMode::Ast, - cg: basic_codegen_options(), - error_format: ErrorOutputType::default(), - externs: Externs(BTreeMap::new()), - crate_name: None, - alt_std_name: None, - libs: Vec::new(), - unstable_features: UnstableFeatures::Disallow, - debug_assertions: true, - actually_rustdoc: false, - cli_forced_codegen_units: None, - cli_forced_thinlto_off: false, - remap_path_prefix: Vec::new(), - edition: DEFAULT_EDITION, +impl Default for Options { + fn default() -> Options { + Options { + crate_types: Vec::new(), + optimize: OptLevel::No, + debuginfo: DebugInfo::None, + lint_opts: Vec::new(), + lint_cap: None, + describe_lints: false, + output_types: OutputTypes(BTreeMap::new()), + search_paths: SearchPaths::new(), + maybe_sysroot: None, + target_triple: TargetTriple::from_triple(host_triple()), + test: false, + incremental: None, + debugging_opts: basic_debugging_options(), + prints: Vec::new(), + borrowck_mode: BorrowckMode::Ast, + cg: basic_codegen_options(), + error_format: ErrorOutputType::default(), + externs: Externs(BTreeMap::new()), + crate_name: None, + alt_std_name: None, + libs: Vec::new(), + unstable_features: UnstableFeatures::Disallow, + debug_assertions: true, + actually_rustdoc: false, + cli_forced_codegen_units: None, + cli_forced_thinlto_off: false, + remap_path_prefix: Vec::new(), + edition: DEFAULT_EDITION, + } } } @@ -657,6 +653,24 @@ impl Options { !self.debugging_opts.parse_only && // The file is just being parsed !self.debugging_opts.ls // The file is just being queried } + + #[inline] + pub fn share_generics(&self) -> bool { + match self.debugging_opts.share_generics { + Some(setting) => setting, + None => { + self.incremental.is_some() || + match self.optimize { + OptLevel::No | + OptLevel::Less | + OptLevel::Size | + OptLevel::SizeMin => true, + OptLevel::Default | + OptLevel::Aggressive => false, + } + } + } + } } // The type of entry function, so @@ -664,31 +678,31 @@ impl Options { // functions #[derive(Copy, Clone, PartialEq)] pub enum EntryFnType { - EntryMain, - EntryStart, + Main, + Start, } #[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug)] pub enum CrateType { - CrateTypeExecutable, - CrateTypeDylib, - CrateTypeRlib, - CrateTypeStaticlib, - CrateTypeCdylib, - CrateTypeProcMacro, + Executable, + Dylib, + Rlib, + Staticlib, + Cdylib, + ProcMacro, } #[derive(Clone, Hash)] pub enum Passes { - SomePasses(Vec<String>), - AllPasses, + Some(Vec<String>), + All, } impl Passes { pub fn is_empty(&self) -> bool { match *self { - SomePasses(ref v) => v.is_empty(), - AllPasses => false, + Passes::Some(ref v) => v.is_empty(), + Passes::All => false, } } } @@ -823,8 +837,7 @@ macro_rules! options { #[allow(dead_code)] mod $mod_set { - use super::{$struct_name, Passes, SomePasses, AllPasses, Sanitizer, Lto, - CrossLangLto}; + use super::{$struct_name, Passes, Sanitizer, Lto, CrossLangLto}; use rustc_target::spec::{LinkerFlavor, PanicStrategy, RelroLevel}; use std::path::PathBuf; @@ -935,13 +948,13 @@ macro_rules! options { fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool { match v { Some("all") => { - *slot = AllPasses; + *slot = Passes::All; true } v => { let mut passes = vec![]; if parse_list(&mut passes, v) { - *slot = SomePasses(passes); + *slot = Passes::Some(passes); true } else { false @@ -1104,7 +1117,7 @@ options! {CodegenOptions, CodegenSetter, basic_codegen_options, "extra data to put in each output filename"), codegen_units: Option<usize> = (None, parse_opt_uint, [UNTRACKED], "divide crate into N units to optimize in parallel"), - remark: Passes = (SomePasses(Vec::new()), parse_passes, [UNTRACKED], + remark: Passes = (Passes::Some(Vec::new()), parse_passes, [UNTRACKED], "print remarks for these optimization passes (space separated, or \"all\")"), no_stack_check: bool = (false, parse_bool, [UNTRACKED], "the --no-stack-check flag is deprecated and does nothing"), @@ -1374,7 +1387,7 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, } pub fn default_lib_output() -> CrateType { - CrateTypeRlib + CrateType::Rlib } pub fn default_configuration(sess: &Session) -> ast::CrateConfig { @@ -1432,7 +1445,7 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig { if sess.opts.debug_assertions { ret.insert((Symbol::intern("debug_assertions"), None)); } - if sess.opts.crate_types.contains(&CrateTypeProcMacro) { + if sess.opts.crate_types.contains(&CrateType::ProcMacro) { ret.insert((Symbol::intern("proc_macro"), None)); } return ret; @@ -2084,12 +2097,12 @@ pub fn build_session_options_and_crate_config( if cg.debuginfo.is_some() { early_error(error_format, "-g and -C debuginfo both provided"); } - FullDebugInfo + DebugInfo::Full } else { match cg.debuginfo { - None | Some(0) => NoDebugInfo, - Some(1) => LimitedDebugInfo, - Some(2) => FullDebugInfo, + None | Some(0) => DebugInfo::None, + Some(1) => DebugInfo::Limited, + Some(2) => DebugInfo::Full, Some(arg) => { early_error( error_format, @@ -2188,7 +2201,7 @@ pub fn build_session_options_and_crate_config( Some(m) => early_error(error_format, &format!("unknown borrowck mode `{}`", m)), }; - if !cg.remark.is_empty() && debuginfo == NoDebugInfo { + if !cg.remark.is_empty() && debuginfo == DebugInfo::None { early_warn( error_format, "-C remark will not show source locations without \ @@ -2277,12 +2290,12 @@ pub fn parse_crate_types_from_list(list_list: Vec<String>) -> Result<Vec<CrateTy for part in unparsed_crate_type.split(',') { let new_part = match part { "lib" => default_lib_output(), - "rlib" => CrateTypeRlib, - "staticlib" => CrateTypeStaticlib, - "dylib" => CrateTypeDylib, - "cdylib" => CrateTypeCdylib, - "bin" => CrateTypeExecutable, - "proc-macro" => CrateTypeProcMacro, + "rlib" => CrateType::Rlib, + "staticlib" => CrateType::Staticlib, + "dylib" => CrateType::Dylib, + "cdylib" => CrateType::Cdylib, + "bin" => CrateType::Executable, + "proc-macro" => CrateType::ProcMacro, _ => { return Err(format!("unknown crate type: `{}`", part)); } @@ -2360,12 +2373,12 @@ pub mod nightly_options { impl fmt::Display for CrateType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - CrateTypeExecutable => "bin".fmt(f), - CrateTypeDylib => "dylib".fmt(f), - CrateTypeRlib => "rlib".fmt(f), - CrateTypeStaticlib => "staticlib".fmt(f), - CrateTypeCdylib => "cdylib".fmt(f), - CrateTypeProcMacro => "proc-macro".fmt(f), + CrateType::Executable => "bin".fmt(f), + CrateType::Dylib => "dylib".fmt(f), + CrateType::Rlib => "rlib".fmt(f), + CrateType::Staticlib => "staticlib".fmt(f), + CrateType::Cdylib => "cdylib".fmt(f), + CrateType::ProcMacro => "proc-macro".fmt(f), } } } @@ -2395,7 +2408,7 @@ mod dep_tracking { use std::hash::Hash; use std::path::PathBuf; use std::collections::hash_map::DefaultHasher; - use super::{CrateType, DebugInfoLevel, ErrorOutputType, Lto, OptLevel, OutputTypes, + use super::{CrateType, DebugInfo, ErrorOutputType, Lto, OptLevel, OutputTypes, Passes, Sanitizer, CrossLangLto}; use syntax::feature_gate::UnstableFeatures; use rustc_target::spec::{PanicStrategy, RelroLevel, TargetTriple}; @@ -2452,7 +2465,7 @@ mod dep_tracking { impl_dep_tracking_hash_via_hash!(Passes); impl_dep_tracking_hash_via_hash!(OptLevel); impl_dep_tracking_hash_via_hash!(Lto); - impl_dep_tracking_hash_via_hash!(DebugInfoLevel); + impl_dep_tracking_hash_via_hash!(DebugInfo); impl_dep_tracking_hash_via_hash!(UnstableFeatures); impl_dep_tracking_hash_via_hash!(OutputTypes); impl_dep_tracking_hash_via_hash!(cstore::NativeLibraryKind); @@ -2535,6 +2548,7 @@ mod tests { use syntax::symbol::Symbol; use syntax::edition::{Edition, DEFAULT_EDITION}; use syntax; + use super::Options; fn optgroups() -> getopts::Options { let mut opts = getopts::Options::new(); @@ -2619,9 +2633,9 @@ mod tests { #[test] fn test_output_types_tracking_hash_different_paths() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); - let mut v3 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); + let mut v3 = Options::default(); v1.output_types = OutputTypes::new(&[(OutputType::Exe, Some(PathBuf::from("./some/thing")))]); @@ -2641,8 +2655,8 @@ mod tests { #[test] fn test_output_types_tracking_hash_different_construction_order() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); v1.output_types = OutputTypes::new(&[ (OutputType::Exe, Some(PathBuf::from("./some/thing"))), @@ -2662,9 +2676,9 @@ mod tests { #[test] fn test_externs_tracking_hash_different_construction_order() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); - let mut v3 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); + let mut v3 = Options::default(); v1.externs = Externs::new(mk_map(vec![ ( @@ -2711,9 +2725,9 @@ mod tests { #[test] fn test_lints_tracking_hash_different_values() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); - let mut v3 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); + let mut v3 = Options::default(); v1.lint_opts = vec![ (String::from("a"), lint::Allow), @@ -2748,8 +2762,8 @@ mod tests { #[test] fn test_lints_tracking_hash_different_construction_order() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); v1.lint_opts = vec![ (String::from("a"), lint::Allow), @@ -2774,10 +2788,10 @@ mod tests { #[test] fn test_search_paths_tracking_hash_different_order() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); - let mut v3 = super::basic_options(); - let mut v4 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); + let mut v3 = Options::default(); + let mut v4 = Options::default(); // Reference v1.search_paths @@ -2837,10 +2851,10 @@ mod tests { #[test] fn test_native_libs_tracking_hash_different_values() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); - let mut v3 = super::basic_options(); - let mut v4 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); + let mut v3 = Options::default(); + let mut v4 = Options::default(); // Reference v1.libs = vec![ @@ -2887,9 +2901,9 @@ mod tests { #[test] fn test_native_libs_tracking_hash_different_order() { - let mut v1 = super::basic_options(); - let mut v2 = super::basic_options(); - let mut v3 = super::basic_options(); + let mut v1 = Options::default(); + let mut v2 = Options::default(); + let mut v3 = Options::default(); // Reference v1.libs = vec![ @@ -2922,8 +2936,8 @@ mod tests { #[test] fn test_codegen_options_tracking_hash() { - let reference = super::basic_options(); - let mut opts = super::basic_options(); + let reference = Options::default(); + let mut opts = Options::default(); // Make sure the changing an [UNTRACKED] option leaves the hash unchanged opts.cg.ar = Some(String::from("abc")); @@ -2947,7 +2961,7 @@ mod tests { opts.cg.codegen_units = Some(42); assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash()); - opts.cg.remark = super::SomePasses(vec![String::from("pass1"), String::from("pass2")]); + opts.cg.remark = super::Passes::Some(vec![String::from("pass1"), String::from("pass2")]); assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash()); opts.cg.save_temps = true; @@ -3060,8 +3074,8 @@ mod tests { #[test] fn test_debugging_options_tracking_hash() { - let reference = super::basic_options(); - let mut opts = super::basic_options(); + let reference = Options::default(); + let mut opts = Options::default(); // Make sure the changing an [UNTRACKED] option leaves the hash unchanged opts.debugging_opts.verbose = true; @@ -3190,7 +3204,7 @@ mod tests { #[test] fn test_edition_parsing() { // test default edition - let options = super::basic_options(); + let options = Options::default(); assert!(options.edition == DEFAULT_EDITION); let matches = optgroups() diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 0ab482c89a1..0173c4933f8 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub use self::code_stats::{CodeStats, DataTypeKind, FieldInfo}; -pub use self::code_stats::{SizeKind, TypeSizeInfo, VariantInfo}; +pub use self::code_stats::{DataTypeKind, SizeKind, FieldInfo, VariantInfo}; +use self::code_stats::CodeStats; use hir::def_id::CrateNum; use ich::Fingerprint; @@ -965,7 +965,7 @@ impl Session { } pub fn teach(&self, code: &DiagnosticId) -> bool { - self.opts.debugging_opts.teach && self.parse_sess.span_diagnostic.must_teach(code) + self.opts.debugging_opts.teach && self.diagnostic().must_teach(code) } /// Are we allowed to use features from the Rust 2018 edition? diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 89f3d7c30db..0cfdea68e88 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -14,8 +14,8 @@ use dep_graph::DepGraph; use dep_graph::{DepNode, DepConstructor}; use errors::DiagnosticBuilder; use session::Session; -use session::config::{BorrowckMode, OutputFilenames, OptLevel}; -use session::config::CrateType::*; +use session::config::{BorrowckMode, OutputFilenames}; +use session::config::CrateType; use middle; use hir::{TraitCandidate, HirId, ItemLocalId}; use hir::def::{Def, Export}; @@ -1470,35 +1470,17 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } #[inline] - pub fn share_generics(self) -> bool { - match self.sess.opts.debugging_opts.share_generics { - Some(setting) => setting, - None => { - self.sess.opts.incremental.is_some() || - match self.sess.opts.optimize { - OptLevel::No | - OptLevel::Less | - OptLevel::Size | - OptLevel::SizeMin => true, - OptLevel::Default | - OptLevel::Aggressive => false, - } - } - } - } - - #[inline] pub fn local_crate_exports_generics(self) -> bool { - debug_assert!(self.share_generics()); + debug_assert!(self.sess.opts.share_generics()); self.sess.crate_types.borrow().iter().any(|crate_type| { match crate_type { - CrateTypeExecutable | - CrateTypeStaticlib | - CrateTypeProcMacro | - CrateTypeCdylib => false, - CrateTypeRlib | - CrateTypeDylib => true, + CrateType::Executable | + CrateType::Staticlib | + CrateType::ProcMacro | + CrateType::Cdylib => false, + CrateType::Rlib | + CrateType::Dylib => true, } }) } diff --git a/src/librustc_codegen_llvm/back/link.rs b/src/librustc_codegen_llvm/back/link.rs index 845a66c6e44..108734b67d3 100644 --- a/src/librustc_codegen_llvm/back/link.rs +++ b/src/librustc_codegen_llvm/back/link.rs @@ -17,7 +17,7 @@ use super::command::Command; use super::rpath::RPathConfig; use super::rpath; use metadata::METADATA_FILENAME; -use rustc::session::config::{self, NoDebugInfo, OutputFilenames, OutputType, PrintRequest}; +use rustc::session::config::{self, DebugInfo, OutputFilenames, OutputType, PrintRequest}; use rustc::session::config::{RUST_CGU_EXT, Lto}; use rustc::session::filesearch; use rustc::session::search_paths::PathKind; @@ -151,7 +151,7 @@ pub(crate) fn link_binary(sess: &Session, let output_metadata = sess.opts.output_types.contains_key(&OutputType::Metadata); if (sess.opts.debugging_opts.no_codegen || !sess.opts.output_types.should_codegen()) && !output_metadata && - crate_type == config::CrateTypeExecutable { + crate_type == config::CrateType::Executable { continue; } @@ -200,7 +200,7 @@ pub(crate) fn link_binary(sess: &Session, /// split-dwarf like schemes. fn preserve_objects_for_their_debuginfo(sess: &Session) -> bool { // If the objects don't have debuginfo there's nothing to preserve. - if sess.opts.debuginfo == NoDebugInfo { + if sess.opts.debuginfo == DebugInfo::None { return false } @@ -208,7 +208,7 @@ fn preserve_objects_for_their_debuginfo(sess: &Session) -> bool { // the objects as they're losslessly contained inside the archives. let output_linked = sess.crate_types.borrow() .iter() - .any(|x| *x != config::CrateTypeRlib && *x != config::CrateTypeStaticlib); + .any(|x| *x != config::CrateType::Rlib && *x != config::CrateType::Staticlib); if !output_linked { return false } @@ -255,10 +255,10 @@ pub(crate) fn each_linked_rlib(sess: &Session, f: &mut dyn FnMut(CrateNum, &Path)) -> Result<(), String> { let crates = info.used_crates_static.iter(); let fmts = sess.dependency_formats.borrow(); - let fmts = fmts.get(&config::CrateTypeExecutable) - .or_else(|| fmts.get(&config::CrateTypeStaticlib)) - .or_else(|| fmts.get(&config::CrateTypeCdylib)) - .or_else(|| fmts.get(&config::CrateTypeProcMacro)); + let fmts = fmts.get(&config::CrateType::Executable) + .or_else(|| fmts.get(&config::CrateType::Staticlib)) + .or_else(|| fmts.get(&config::CrateType::Cdylib)) + .or_else(|| fmts.get(&config::CrateType::ProcMacro)); let fmts = match fmts { Some(f) => f, None => return Err("could not find formats for rlibs".to_string()) @@ -344,14 +344,14 @@ fn link_binary_output(sess: &Session, if outputs.outputs.should_codegen() { let out_filename = out_filename(sess, crate_type, outputs, crate_name); match crate_type { - config::CrateTypeRlib => { + config::CrateType::Rlib => { link_rlib(sess, codegen_results, RlibFlavor::Normal, &out_filename, &tmpdir).build(); } - config::CrateTypeStaticlib => { + config::CrateType::Staticlib => { link_staticlib(sess, codegen_results, &out_filename, &tmpdir); } _ => { @@ -644,7 +644,7 @@ fn link_natively(sess: &Session, } cmd.args(&sess.opts.debugging_opts.pre_link_arg); - let pre_link_objects = if crate_type == config::CrateTypeExecutable { + let pre_link_objects = if crate_type == config::CrateType::Executable { &sess.target.target.options.pre_link_objects_exe } else { &sess.target.target.options.pre_link_objects_dll @@ -653,7 +653,7 @@ fn link_natively(sess: &Session, cmd.arg(root.join(obj)); } - if crate_type == config::CrateTypeExecutable && sess.crt_static() { + if crate_type == config::CrateType::Executable && sess.crt_static() { for obj in &sess.target.target.options.pre_link_objects_exe_crt { cmd.arg(root.join(obj)); } @@ -834,7 +834,7 @@ fn link_natively(sess: &Session, // the symbols. Note, though, that if the object files are being preserved // for their debug information there's no need for us to run dsymutil. if sess.target.target.options.is_like_osx && - sess.opts.debuginfo != NoDebugInfo && + sess.opts.debuginfo != DebugInfo::None && !preserve_objects_for_their_debuginfo(sess) { match Command::new("dsymutil").arg(out_filename).output() { @@ -1013,7 +1013,7 @@ fn link_args(cmd: &mut dyn Linker, } cmd.output_filename(out_filename); - if crate_type == config::CrateTypeExecutable && + if crate_type == config::CrateType::Executable && sess.target.target.options.is_like_windows { if let Some(ref s) = codegen_results.windows_subsystem { cmd.subsystem(s); @@ -1022,7 +1022,7 @@ fn link_args(cmd: &mut dyn Linker, // If we're building a dynamic library then some platforms need to make sure // that all symbols are exported correctly from the dynamic library. - if crate_type != config::CrateTypeExecutable || + if crate_type != config::CrateType::Executable || sess.target.target.options.is_like_emscripten { cmd.export_symbols(tmpdir, crate_type); } @@ -1030,8 +1030,8 @@ fn link_args(cmd: &mut dyn Linker, // When linking a dynamic library, we put the metadata into a section of the // executable. This metadata is in a separate object file from the main // object file, so we link that in here. - if crate_type == config::CrateTypeDylib || - crate_type == config::CrateTypeProcMacro { + if crate_type == config::CrateType::Dylib || + crate_type == config::CrateType::ProcMacro { if let Some(obj) = codegen_results.metadata_module.object.as_ref() { cmd.add_object(obj); } @@ -1047,13 +1047,13 @@ fn link_args(cmd: &mut dyn Linker, // Try to strip as much out of the generated object by removing unused // sections if possible. See more comments in linker.rs if !sess.opts.cg.link_dead_code { - let keep_metadata = crate_type == config::CrateTypeDylib; + let keep_metadata = crate_type == config::CrateType::Dylib; cmd.gc_sections(keep_metadata); } let used_link_args = &codegen_results.crate_info.link_args; - if crate_type == config::CrateTypeExecutable { + if crate_type == config::CrateType::Executable { let mut position_independent_executable = false; if t.options.position_independent_executables { @@ -1145,10 +1145,10 @@ fn link_args(cmd: &mut dyn Linker, add_upstream_native_libraries(cmd, sess, codegen_results, crate_type); // Tell the linker what we're doing. - if crate_type != config::CrateTypeExecutable { + if crate_type != config::CrateType::Executable { cmd.build_dylib(out_filename); } - if crate_type == config::CrateTypeExecutable && sess.crt_static() { + if crate_type == config::CrateType::Executable && sess.crt_static() { cmd.build_static_executable(); } @@ -1448,7 +1448,7 @@ fn add_upstream_rust_crates(cmd: &mut dyn Linker, if (!is_full_lto_enabled(sess) || ignored_for_lto(sess, &codegen_results.crate_info, cnum)) && - crate_type != config::CrateTypeDylib && + crate_type != config::CrateType::Dylib && !skip_native { cmd.link_rlib(&fix_windows_verbatim_for_gcc(cratepath)); return @@ -1524,7 +1524,7 @@ fn add_upstream_rust_crates(cmd: &mut dyn Linker, // Note, though, that we don't want to include the whole of a // compiler-builtins crate (e.g. compiler-rt) because it'll get // repeatedly linked anyway. - if crate_type == config::CrateTypeDylib && + if crate_type == config::CrateType::Dylib && codegen_results.crate_info.compiler_builtins != Some(cnum) { cmd.link_whole_rlib(&fix_windows_verbatim_for_gcc(&dst)); } else { diff --git a/src/librustc_codegen_llvm/back/linker.rs b/src/librustc_codegen_llvm/back/linker.rs index 7253b5346b9..e0a30ef5dbc 100644 --- a/src/librustc_codegen_llvm/back/linker.rs +++ b/src/librustc_codegen_llvm/back/linker.rs @@ -21,7 +21,7 @@ use back::symbol_export; use rustc::hir::def_id::{LOCAL_CRATE, CrateNum}; use rustc::middle::dependency_format::Linkage; use rustc::session::Session; -use rustc::session::config::{self, CrateType, OptLevel, DebugInfoLevel, +use rustc::session::config::{self, CrateType, OptLevel, DebugInfo, CrossLangLto}; use rustc::ty::TyCtxt; use rustc_target::spec::{LinkerFlavor, LldFlavor}; @@ -338,7 +338,7 @@ impl<'a> Linker for GccLinker<'a> { fn debuginfo(&mut self) { match self.sess.opts.debuginfo { - DebugInfoLevel::NoDebugInfo => { + DebugInfo::None => { // If we are building without debuginfo enabled and we were called with // `-Zstrip-debuginfo-if-disabled=yes`, tell the linker to strip any debuginfo // found when linking to get rid of symbols from libstd. @@ -387,8 +387,8 @@ impl<'a> Linker for GccLinker<'a> { // exported symbols to ensure we don't expose any more. The object files // have far more public symbols than we actually want to export, so we // hide them all here. - if crate_type == CrateType::CrateTypeDylib || - crate_type == CrateType::CrateTypeProcMacro { + if crate_type == CrateType::Dylib || + crate_type == CrateType::ProcMacro { return } @@ -826,9 +826,9 @@ impl<'a> Linker for EmLinker<'a> { fn debuginfo(&mut self) { // Preserve names or generate source maps depending on debug info self.cmd.arg(match self.sess.opts.debuginfo { - DebugInfoLevel::NoDebugInfo => "-g0", - DebugInfoLevel::LimitedDebugInfo => "-g3", - DebugInfoLevel::FullDebugInfo => "-g4" + DebugInfo::None => "-g0", + DebugInfo::Limited => "-g3", + DebugInfo::Full => "-g4" }); } diff --git a/src/librustc_codegen_llvm/back/lto.rs b/src/librustc_codegen_llvm/back/lto.rs index b644422e795..098676c95a2 100644 --- a/src/librustc_codegen_llvm/back/lto.rs +++ b/src/librustc_codegen_llvm/back/lto.rs @@ -32,13 +32,13 @@ use std::sync::Arc; pub fn crate_type_allows_lto(crate_type: config::CrateType) -> bool { match crate_type { - config::CrateTypeExecutable | - config::CrateTypeStaticlib | - config::CrateTypeCdylib => true, + config::CrateType::Executable | + config::CrateType::Staticlib | + config::CrateType::Cdylib => true, - config::CrateTypeDylib | - config::CrateTypeRlib | - config::CrateTypeProcMacro => false, + config::CrateType::Dylib | + config::CrateType::Rlib | + config::CrateType::ProcMacro => false, } } diff --git a/src/librustc_codegen_llvm/back/symbol_export.rs b/src/librustc_codegen_llvm/back/symbol_export.rs index 48de2f3beed..02434b7be0b 100644 --- a/src/librustc_codegen_llvm/back/symbol_export.rs +++ b/src/librustc_codegen_llvm/back/symbol_export.rs @@ -37,12 +37,12 @@ pub fn threshold(tcx: TyCtxt) -> SymbolExportLevel { fn crate_export_threshold(crate_type: config::CrateType) -> SymbolExportLevel { match crate_type { - config::CrateTypeExecutable | - config::CrateTypeStaticlib | - config::CrateTypeProcMacro | - config::CrateTypeCdylib => SymbolExportLevel::C, - config::CrateTypeRlib | - config::CrateTypeDylib => SymbolExportLevel::Rust, + config::CrateType::Executable | + config::CrateType::Staticlib | + config::CrateType::ProcMacro | + config::CrateType::Cdylib => SymbolExportLevel::C, + config::CrateType::Rlib | + config::CrateType::Dylib => SymbolExportLevel::Rust, } } @@ -235,14 +235,14 @@ fn exported_symbols_provider_local<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } } - if tcx.sess.crate_types.borrow().contains(&config::CrateTypeDylib) { + if tcx.sess.crate_types.borrow().contains(&config::CrateType::Dylib) { let symbol_name = metadata_symbol_name(tcx); let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(&symbol_name)); symbols.push((exported_symbol, SymbolExportLevel::Rust)); } - if tcx.share_generics() && tcx.local_crate_exports_generics() { + if tcx.sess.opts.share_generics() && tcx.local_crate_exports_generics() { use rustc::mir::mono::{Linkage, Visibility, MonoItem}; use rustc::ty::InstanceDef; diff --git a/src/librustc_codegen_llvm/back/write.rs b/src/librustc_codegen_llvm/back/write.rs index 209c3a23c5c..a5c6a0d5cd6 100644 --- a/src/librustc_codegen_llvm/back/write.rs +++ b/src/librustc_codegen_llvm/back/write.rs @@ -20,8 +20,7 @@ use consts; use rustc_incremental::{copy_cgu_workproducts_to_incr_comp_cache_dir, in_incr_comp_dir}; use rustc::dep_graph::{WorkProduct, WorkProductId, WorkProductFileKind}; use rustc::middle::cstore::{LinkMeta, EncodedMetadata}; -use rustc::session::config::{self, OutputFilenames, OutputType, Passes, SomePasses, - AllPasses, Sanitizer, Lto}; +use rustc::session::config::{self, OutputFilenames, OutputType, Passes, Sanitizer, Lto}; use rustc::session::Session; use rustc::util::nodemap::FxHashMap; use time_graph::{self, TimeGraph, Timeline}; @@ -345,7 +344,7 @@ pub struct CodegenContext { pub tm_factory: Arc<dyn Fn() -> Result<&'static mut llvm::TargetMachine, String> + Send + Sync>, pub msvc_imps_needed: bool, pub target_pointer_width: String, - debuginfo: config::DebugInfoLevel, + debuginfo: config::DebugInfo, // Number of cgus excluding the allocator/metadata modules pub total_cgus: usize, @@ -461,8 +460,8 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void llvm::diagnostic::Optimization(opt) => { let enabled = match cgcx.remark { - AllPasses => true, - SomePasses(ref v) => v.iter().any(|s| *s == opt.pass_name), + Passes::All => true, + Passes::Some(ref v) => v.iter().any(|s| *s == opt.pass_name), }; if enabled { @@ -875,7 +874,7 @@ pub(crate) struct CompiledModules { } fn need_crate_bitcode_for_rlib(sess: &Session) -> bool { - sess.crate_types.borrow().contains(&config::CrateTypeRlib) && + sess.crate_types.borrow().contains(&config::CrateType::Rlib) && sess.opts.output_types.contains_key(&OutputType::Exe) } @@ -1341,7 +1340,7 @@ fn execute_work_item(cgcx: &CodegenContext, // anything about it yet until we've got a final product. Lto::Yes | Lto::Fat | Lto::Thin => { cgcx.crate_types.len() != 1 || - cgcx.crate_types[0] != config::CrateTypeRlib + cgcx.crate_types[0] != config::CrateType::Rlib } // When we're automatically doing ThinLTO for multi-codegen-unit @@ -2346,7 +2345,7 @@ pub(crate) fn submit_codegened_module_to_llvm(tcx: TyCtxt, fn msvc_imps_needed(tcx: TyCtxt) -> bool { tcx.sess.target.target.options.is_like_msvc && - tcx.sess.crate_types.borrow().iter().any(|ct| *ct == config::CrateTypeRlib) + tcx.sess.crate_types.borrow().iter().any(|ct| *ct == config::CrateType::Rlib) } // Create a `__imp_<symbol> = &symbol` global for every public static `symbol`. diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index 34cd3998f83..41336165684 100644 --- a/src/librustc_codegen_llvm/base.rs +++ b/src/librustc_codegen_llvm/base.rs @@ -46,7 +46,7 @@ use rustc::middle::cstore::{self, LinkMeta, LinkagePreference}; use rustc::middle::exported_symbols; use rustc::util::common::{time, print_time_passes_entry}; use rustc::util::profiling::ProfileCategory; -use rustc::session::config::{self, NoDebugInfo}; +use rustc::session::config::{self, DebugInfo, EntryFnType}; use rustc::session::Session; use rustc_incremental; use allocator; @@ -560,8 +560,8 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx) { let et = cx.sess().entry_fn.get().map(|e| e.2); match et { - Some(config::EntryMain) => create_entry_fn(cx, span, main_llfn, main_def_id, true), - Some(config::EntryStart) => create_entry_fn(cx, span, main_llfn, main_def_id, false), + Some(EntryFnType::Main) => create_entry_fn(cx, span, main_llfn, main_def_id, true), + Some(EntryFnType::Start) => create_entry_fn(cx, span, main_llfn, main_def_id, false), None => {} // Do nothing. } @@ -645,14 +645,14 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, let kind = tcx.sess.crate_types.borrow().iter().map(|ty| { match *ty { - config::CrateTypeExecutable | - config::CrateTypeStaticlib | - config::CrateTypeCdylib => MetadataKind::None, + config::CrateType::Executable | + config::CrateType::Staticlib | + config::CrateType::Cdylib => MetadataKind::None, - config::CrateTypeRlib => MetadataKind::Uncompressed, + config::CrateType::Rlib => MetadataKind::Uncompressed, - config::CrateTypeDylib | - config::CrateTypeProcMacro => MetadataKind::Compressed, + config::CrateType::Dylib | + config::CrateType::ProcMacro => MetadataKind::Compressed, } }).max().unwrap_or(MetadataKind::None); @@ -1102,7 +1102,7 @@ impl CrateInfo { let load_wasm_items = tcx.sess.crate_types.borrow() .iter() - .any(|c| *c != config::CrateTypeRlib) && + .any(|c| *c != config::CrateType::Rlib) && tcx.sess.opts.target_triple.triple() == "wasm32-unknown-unknown"; if load_wasm_items { @@ -1249,7 +1249,7 @@ fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } // Finalize debuginfo - if cx.sess().opts.debuginfo != NoDebugInfo { + if cx.sess().opts.debuginfo != DebugInfo::None { debuginfo::finalize(&cx); } diff --git a/src/librustc_codegen_llvm/callee.rs b/src/librustc_codegen_llvm/callee.rs index e64dedac55a..3594351802f 100644 --- a/src/librustc_codegen_llvm/callee.rs +++ b/src/librustc_codegen_llvm/callee.rs @@ -133,7 +133,7 @@ pub fn get_fn( // This is a monomorphization. Its expected visibility depends // on whether we are in share-generics mode. - if cx.tcx.share_generics() { + if cx.tcx.sess.opts.share_generics() { // We are in share_generics mode. if instance_def_id.is_local() { diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index 11f8e75831e..2f557d0b099 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -26,7 +26,7 @@ use type_of::PointeeInfo; use rustc_data_structures::base_n; use rustc::mir::mono::Stats; -use rustc::session::config::{self, NoDebugInfo}; +use rustc::session::config::{self, DebugInfo}; use rustc::session::Session; use rustc::ty::layout::{LayoutError, LayoutOf, Size, TyLayout}; use rustc::ty::{self, Ty, TyCtxt}; @@ -147,7 +147,7 @@ fn get_tls_model(sess: &Session) -> llvm::ThreadLocalMode { fn is_any_library(sess: &Session) -> bool { sess.crate_types.borrow().iter().any(|ty| { - *ty != config::CrateTypeExecutable + *ty != config::CrateType::Executable }) } @@ -270,7 +270,7 @@ impl<'a, 'tcx> CodegenCx<'a, 'tcx> { let (llcx, llmod) = (&*llvm_module.llcx, llvm_module.llmod()); - let dbg_cx = if tcx.sess.opts.debuginfo != NoDebugInfo { + let dbg_cx = if tcx.sess.opts.debuginfo != DebugInfo::None { let dctx = debuginfo::CrateDebugContext::new(llmod); debuginfo::metadata::compile_unit_metadata(tcx, &codegen_unit.name().as_str(), @@ -770,7 +770,7 @@ fn declare_intrinsic(cx: &CodegenCx<'ll, '_>, key: &str) -> Option<&'ll Value> { ifn!("llvm.assume", fn(i1) -> void); ifn!("llvm.prefetch", fn(i8p, t_i32, t_i32, t_i32) -> void); - if cx.sess().opts.debuginfo != NoDebugInfo { + if cx.sess().opts.debuginfo != DebugInfo::None { ifn!("llvm.dbg.declare", fn(Type::metadata(cx), Type::metadata(cx)) -> void); ifn!("llvm.dbg.value", fn(Type::metadata(cx), t_i64, Type::metadata(cx)) -> void); } diff --git a/src/librustc_codegen_llvm/debuginfo/gdb.rs b/src/librustc_codegen_llvm/debuginfo/gdb.rs index 08128a729b5..f6faddb894f 100644 --- a/src/librustc_codegen_llvm/debuginfo/gdb.rs +++ b/src/librustc_codegen_llvm/debuginfo/gdb.rs @@ -15,7 +15,7 @@ use llvm; use common::{C_bytes, CodegenCx, C_i32}; use builder::Builder; use declare; -use rustc::session::config::NoDebugInfo; +use rustc::session::config::DebugInfo; use type_::Type; use value::Value; @@ -81,6 +81,6 @@ pub fn needs_gdb_debug_scripts_section(cx: &CodegenCx) -> bool { "omit_gdb_pretty_printer_section"); !omit_gdb_pretty_printer_section && - cx.sess().opts.debuginfo != NoDebugInfo && + cx.sess().opts.debuginfo != DebugInfo::None && cx.sess().target.target.options.emit_debug_gdb_scripts } diff --git a/src/librustc_codegen_llvm/debuginfo/mod.rs b/src/librustc_codegen_llvm/debuginfo/mod.rs index 143b122a5a1..d4fb2549a75 100644 --- a/src/librustc_codegen_llvm/debuginfo/mod.rs +++ b/src/librustc_codegen_llvm/debuginfo/mod.rs @@ -32,7 +32,7 @@ use builder::Builder; use monomorphize::Instance; use rustc::ty::{self, ParamEnv, Ty, InstanceDef}; use rustc::mir; -use rustc::session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo}; +use rustc::session::config::{self, DebugInfo}; use rustc::util::nodemap::{DefIdMap, FxHashMap, FxHashSet}; use value::Value; @@ -214,7 +214,7 @@ pub fn create_function_debug_context( llfn: &'ll Value, mir: &mir::Mir, ) -> FunctionDebugContext<'ll> { - if cx.sess().opts.debuginfo == NoDebugInfo { + if cx.sess().opts.debuginfo == DebugInfo::None { return FunctionDebugContext::DebugInfoDisabled; } @@ -314,7 +314,7 @@ pub fn create_function_debug_context( cx: &CodegenCx<'ll, 'tcx>, sig: ty::FnSig<'tcx>, ) -> &'ll DIArray { - if cx.sess().opts.debuginfo == LimitedDebugInfo { + if cx.sess().opts.debuginfo == DebugInfo::Limited { return create_DIArray(DIB(cx), &[]); } @@ -400,7 +400,7 @@ pub fn create_function_debug_context( name_to_append_suffix_to.push('>'); // Again, only create type information if full debuginfo is enabled - let template_params: Vec<_> = if cx.sess().opts.debuginfo == FullDebugInfo { + let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full { let names = get_parameter_names(cx, generics); substs.iter().zip(names).filter_map(|(kind, name)| { if let UnpackedKind::Type(ty) = kind.unpack() { diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs index 06a5c34a4ca..0b5a6757333 100644 --- a/src/librustc_codegen_llvm/intrinsic.rs +++ b/src/librustc_codegen_llvm/intrinsic.rs @@ -1778,14 +1778,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#, fn int_type_width_signed(ty: Ty, cx: &CodegenCx) -> Option<(u64, bool)> { match ty.sty { ty::TyInt(t) => Some((match t { - ast::IntTy::Isize => { - match &cx.tcx.sess.target.target.target_pointer_width[..] { - "16" => 16, - "32" => 32, - "64" => 64, - tws => bug!("Unsupported target word size for isize: {}", tws), - } - }, + ast::IntTy::Isize => cx.tcx.sess.target.isize_ty.bit_width().unwrap() as u64, ast::IntTy::I8 => 8, ast::IntTy::I16 => 16, ast::IntTy::I32 => 32, @@ -1793,14 +1786,7 @@ fn int_type_width_signed(ty: Ty, cx: &CodegenCx) -> Option<(u64, bool)> { ast::IntTy::I128 => 128, }, true)), ty::TyUint(t) => Some((match t { - ast::UintTy::Usize => { - match &cx.tcx.sess.target.target.target_pointer_width[..] { - "16" => 16, - "32" => 32, - "64" => 64, - tws => bug!("Unsupported target word size for usize: {}", tws), - } - }, + ast::UintTy::Usize => cx.tcx.sess.target.usize_ty.bit_width().unwrap() as u64, ast::UintTy::U8 => 8, ast::UintTy::U16 => 16, ast::UintTy::U32 => 32, @@ -1813,14 +1799,9 @@ fn int_type_width_signed(ty: Ty, cx: &CodegenCx) -> Option<(u64, bool)> { // Returns the width of a float TypeVariant // Returns None if the type is not a float -fn float_type_width<'tcx>(sty: &ty::TypeVariants<'tcx>) - -> Option<u64> { - use rustc::ty::TyFloat; +fn float_type_width<'tcx>(sty: &ty::TypeVariants<'tcx>) -> Option<u64> { match *sty { - TyFloat(t) => Some(match t { - ast::FloatTy::F32 => 32, - ast::FloatTy::F64 => 64, - }), + ty::TyFloat(t) => Some(t.bit_width() as u64), _ => None, } } diff --git a/src/librustc_codegen_llvm/mir/mod.rs b/src/librustc_codegen_llvm/mir/mod.rs index a099cb5c64b..8fdb67f5930 100644 --- a/src/librustc_codegen_llvm/mir/mod.rs +++ b/src/librustc_codegen_llvm/mir/mod.rs @@ -16,7 +16,7 @@ use rustc::ty::{self, Ty, TypeFoldable, UpvarSubsts}; use rustc::ty::layout::{LayoutOf, TyLayout}; use rustc::mir::{self, Mir}; use rustc::ty::subst::Substs; -use rustc::session::config::FullDebugInfo; +use rustc::session::config::DebugInfo; use base; use builder::Builder; use common::{CodegenCx, Funclet}; @@ -267,7 +267,7 @@ pub fn codegen_mir( if let Some(name) = decl.name { // User variable let debug_scope = fx.scopes[decl.visibility_scope]; - let dbg = debug_scope.is_valid() && bx.sess().opts.debuginfo == FullDebugInfo; + let dbg = debug_scope.is_valid() && bx.sess().opts.debuginfo == DebugInfo::Full; if !memory_locals.contains(local) && !dbg { debug!("alloc: {:?} ({}) -> operand", local, name); @@ -426,7 +426,7 @@ fn arg_local_refs( // Get the argument scope, if it exists and if we need it. let arg_scope = scopes[mir::OUTERMOST_SOURCE_SCOPE]; - let arg_scope = if bx.sess().opts.debuginfo == FullDebugInfo { + let arg_scope = if bx.sess().opts.debuginfo == DebugInfo::Full { arg_scope.scope_metadata } else { None diff --git a/src/librustc_codegen_llvm/mir/rvalue.rs b/src/librustc_codegen_llvm/mir/rvalue.rs index 02b5c27840e..dda33ae3fec 100644 --- a/src/librustc_codegen_llvm/mir/rvalue.rs +++ b/src/librustc_codegen_llvm/mir/rvalue.rs @@ -733,18 +733,8 @@ fn get_overflow_intrinsic(oop: OverflowOp, bx: &Builder<'_, 'll, '_>, ty: Ty) -> let tcx = bx.tcx(); let new_sty = match ty.sty { - TyInt(Isize) => match &tcx.sess.target.target.target_pointer_width[..] { - "16" => TyInt(I16), - "32" => TyInt(I32), - "64" => TyInt(I64), - _ => panic!("unsupported target word size") - }, - TyUint(Usize) => match &tcx.sess.target.target.target_pointer_width[..] { - "16" => TyUint(U16), - "32" => TyUint(U32), - "64" => TyUint(U64), - _ => panic!("unsupported target word size") - }, + TyInt(Isize) => TyInt(tcx.sess.target.isize_ty), + TyUint(Usize) => TyUint(tcx.sess.target.usize_ty), ref t @ TyUint(_) | ref t @ TyInt(_) => t.clone(), _ => panic!("tried to get overflow intrinsic for op applied to non-int type") }; diff --git a/src/librustc_codegen_utils/codegen_backend.rs b/src/librustc_codegen_utils/codegen_backend.rs index 3f230dd5d45..ae8f65303a7 100644 --- a/src/librustc_codegen_utils/codegen_backend.rs +++ b/src/librustc_codegen_utils/codegen_backend.rs @@ -114,10 +114,9 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { fn init(&self, sess: &Session) { for cty in sess.opts.crate_types.iter() { match *cty { - CrateType::CrateTypeRlib | CrateType::CrateTypeDylib | - CrateType::CrateTypeExecutable => {}, + CrateType::Rlib | CrateType::Dylib | CrateType::Executable => {}, _ => { - sess.parse_sess.span_diagnostic.warn( + sess.diagnostic().warn( &format!("LLVM unsupported, so output type {} is not supported", cty) ); }, @@ -201,13 +200,14 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { let ongoing_codegen = ongoing_codegen.downcast::<OngoingCodegen>() .expect("Expected MetadataOnlyCodegenBackend's OngoingCodegen, found Box<dyn Any>"); for &crate_type in sess.opts.crate_types.iter() { - if crate_type != CrateType::CrateTypeRlib && crate_type != CrateType::CrateTypeDylib { + if crate_type != CrateType::Rlib && + crate_type != CrateType::Dylib { continue; } let output_name = out_filename(sess, crate_type, &outputs, &ongoing_codegen.crate_name.as_str()); let mut compressed = ongoing_codegen.metadata_version.clone(); - let metadata = if crate_type == CrateType::CrateTypeDylib { + let metadata = if crate_type == CrateType::Dylib { DeflateEncoder::new(&mut compressed, Compression::fast()) .write_all(&ongoing_codegen.metadata.raw_data) .unwrap(); @@ -220,8 +220,8 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { } sess.abort_if_errors(); - if !sess.opts.crate_types.contains(&CrateType::CrateTypeRlib) - && !sess.opts.crate_types.contains(&CrateType::CrateTypeDylib) + if !sess.opts.crate_types.contains(&CrateType::Rlib) + && !sess.opts.crate_types.contains(&CrateType::Dylib) { sess.fatal("Executables are not supported by the metadata-only backend."); } diff --git a/src/librustc_codegen_utils/link.rs b/src/librustc_codegen_utils/link.rs index b33482eb868..73cffdf7d49 100644 --- a/src/librustc_codegen_utils/link.rs +++ b/src/librustc_codegen_utils/link.rs @@ -114,24 +114,24 @@ pub fn filename_for_input(sess: &Session, let libname = format!("{}{}", crate_name, sess.opts.cg.extra_filename); match crate_type { - config::CrateTypeRlib => { + config::CrateType::Rlib => { outputs.out_directory.join(&format!("lib{}.rlib", libname)) } - config::CrateTypeCdylib | - config::CrateTypeProcMacro | - config::CrateTypeDylib => { + config::CrateType::Cdylib | + config::CrateType::ProcMacro | + config::CrateType::Dylib => { let (prefix, suffix) = (&sess.target.target.options.dll_prefix, &sess.target.target.options.dll_suffix); outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix)) } - config::CrateTypeStaticlib => { + config::CrateType::Staticlib => { let (prefix, suffix) = (&sess.target.target.options.staticlib_prefix, &sess.target.target.options.staticlib_suffix); outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix)) } - config::CrateTypeExecutable => { + config::CrateType::Executable => { let suffix = &sess.target.target.options.exe_suffix; let out_filename = outputs.path(OutputType::Exe); if suffix.is_empty() { @@ -148,15 +148,15 @@ pub fn filename_for_input(sess: &Session, /// Default crate type is used when crate type isn't provided neither /// through cmd line arguments nor through crate attributes /// -/// It is CrateTypeExecutable for all platforms but iOS as there is no +/// It is CrateType::Executable for all platforms but iOS as there is no /// way to run iOS binaries anyway without jailbreaking and /// interaction with Rust code through static library is the only /// option for now pub fn default_output_for_target(sess: &Session) -> config::CrateType { if !sess.target.target.options.executables { - config::CrateTypeStaticlib + config::CrateType::Staticlib } else { - config::CrateTypeExecutable + config::CrateType::Executable } } @@ -164,9 +164,9 @@ pub fn default_output_for_target(sess: &Session) -> config::CrateType { pub fn invalid_output_for_target(sess: &Session, crate_type: config::CrateType) -> bool { match crate_type { - config::CrateTypeCdylib | - config::CrateTypeDylib | - config::CrateTypeProcMacro => { + config::CrateType::Cdylib | + config::CrateType::Dylib | + config::CrateType::ProcMacro => { if !sess.target.target.options.dynamic_linking { return true } @@ -178,12 +178,12 @@ pub fn invalid_output_for_target(sess: &Session, } if sess.target.target.options.only_cdylib { match crate_type { - config::CrateTypeProcMacro | config::CrateTypeDylib => return true, + config::CrateType::ProcMacro | config::CrateType::Dylib => return true, _ => {} } } if !sess.target.target.options.executables { - if crate_type == config::CrateTypeExecutable { + if crate_type == config::CrateType::Executable { return true } } diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs index ac71ecff964..d834a6502b2 100644 --- a/src/librustc_codegen_utils/symbol_names.rs +++ b/src/librustc_codegen_utils/symbol_names.rs @@ -201,7 +201,7 @@ fn get_symbol_hash<'a, 'tcx>( if avoid_cross_crate_conflicts { let instantiating_crate = if is_generic { - if !def_id.is_local() && tcx.share_generics() { + if !def_id.is_local() && tcx.sess.opts.share_generics() { // If we are re-using a monomorphization from another crate, // we have to compute the symbol hash accordingly. let upstream_monomorphizations = tcx.upstream_monomorphizations_for(def_id); diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 2c877e27e2e..805a5ecd991 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -1058,7 +1058,7 @@ where krate = time(sess, "maybe creating a macro crate", || { let crate_types = sess.crate_types.borrow(); let num_crate_types = crate_types.len(); - let is_proc_macro_crate = crate_types.contains(&config::CrateTypeProcMacro); + let is_proc_macro_crate = crate_types.contains(&config::CrateType::ProcMacro); let is_test_crate = sess.opts.test; syntax_ext::proc_macro_registrar::modify( &sess.parse_sess, @@ -1133,7 +1133,7 @@ where // Unresolved macros might be due to mistyped `#[macro_use]`, // so abort after checking for unknown attributes. (#49074) if resolver.found_unresolved_macro { - sess.parse_sess.span_diagnostic.abort_if_errors(); + sess.diagnostic().abort_if_errors(); } // Lower ast -> hir. @@ -1501,13 +1501,13 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<c .filter_map(|a| { if a.check_name("crate_type") { match a.value_str() { - Some(ref n) if *n == "rlib" => Some(config::CrateTypeRlib), - Some(ref n) if *n == "dylib" => Some(config::CrateTypeDylib), - Some(ref n) if *n == "cdylib" => Some(config::CrateTypeCdylib), + Some(ref n) if *n == "rlib" => Some(config::CrateType::Rlib), + Some(ref n) if *n == "dylib" => Some(config::CrateType::Dylib), + Some(ref n) if *n == "cdylib" => Some(config::CrateType::Cdylib), Some(ref n) if *n == "lib" => Some(config::default_lib_output()), - Some(ref n) if *n == "staticlib" => Some(config::CrateTypeStaticlib), - Some(ref n) if *n == "proc-macro" => Some(config::CrateTypeProcMacro), - Some(ref n) if *n == "bin" => Some(config::CrateTypeExecutable), + Some(ref n) if *n == "staticlib" => Some(config::CrateType::Staticlib), + Some(ref n) if *n == "proc-macro" => Some(config::CrateType::ProcMacro), + Some(ref n) if *n == "bin" => Some(config::CrateType::Executable), Some(_) => { session.buffer_lint( lint::builtin::UNKNOWN_CRATE_TYPES, @@ -1534,7 +1534,7 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<c // If we're generating a test executable, then ignore all other output // styles at all other locations if session.opts.test { - return vec![config::CrateTypeExecutable]; + return vec![config::CrateType::Executable]; } // Only check command line flags if present. If no types are specified by @@ -1598,7 +1598,7 @@ pub fn compute_crate_disambiguator(session: &Session) -> CrateDisambiguator { let is_exe = session .crate_types .borrow() - .contains(&config::CrateTypeExecutable); + .contains(&config::CrateType::Executable); hasher.write(if is_exe { b"exe" } else { b"lib" }); CrateDisambiguator::from(hasher.finish()) diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 5b2092ea9eb..03651322bc9 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -99,7 +99,7 @@ fn test_env<F>(source_string: &str, where F: FnOnce(Env) { syntax::with_globals(|| { - let mut options = config::basic_options(); + let mut options = config::Options::default(); options.debugging_opts.verbose = true; options.unstable_features = UnstableFeatures::Allow; diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index b5b47fb35dc..62c06aac1df 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -627,7 +627,7 @@ impl<'a> CrateLoader<'a> { // If we're only compiling an rlib, then there's no need to select a // panic runtime, so we just skip this section entirely. let any_non_rlib = self.sess.crate_types.borrow().iter().any(|ct| { - *ct != config::CrateTypeRlib + *ct != config::CrateType::Rlib }); if !any_non_rlib { info!("panic runtime injection skipped, only generating rlib"); @@ -738,13 +738,13 @@ impl<'a> CrateLoader<'a> { if !self.sess.crate_types.borrow().iter().all(|ct| { match *ct { // Link the runtime - config::CrateTypeStaticlib | - config::CrateTypeExecutable => true, + config::CrateType::Staticlib | + config::CrateType::Executable => true, // This crate will be compiled with the required // instrumentation pass - config::CrateTypeRlib | - config::CrateTypeDylib | - config::CrateTypeCdylib => + config::CrateType::Rlib | + config::CrateType::Dylib | + config::CrateType::Cdylib => false, _ => { self.sess.err(&format!("Only executables, staticlibs, \ @@ -760,10 +760,10 @@ impl<'a> CrateLoader<'a> { if !self.sess.crate_types.borrow().iter().all(|ct| { match *ct { // Link the runtime - config::CrateTypeExecutable => true, + config::CrateType::Executable => true, // This crate will be compiled with the required // instrumentation pass - config::CrateTypeRlib => false, + config::CrateType::Rlib => false, _ => { self.sess.err(&format!("Only executables and rlibs can be \ compiled with `-Z sanitizer`")); @@ -853,12 +853,12 @@ impl<'a> CrateLoader<'a> { let mut need_exe_alloc = false; for ct in self.sess.crate_types.borrow().iter() { match *ct { - config::CrateTypeExecutable => need_exe_alloc = true, - config::CrateTypeDylib | - config::CrateTypeProcMacro | - config::CrateTypeCdylib | - config::CrateTypeStaticlib => need_lib_alloc = true, - config::CrateTypeRlib => {} + config::CrateType::Executable => need_exe_alloc = true, + config::CrateType::Dylib | + config::CrateType::ProcMacro | + config::CrateType::Cdylib | + config::CrateType::Staticlib => need_lib_alloc = true, + config::CrateType::Rlib => {} } } if !need_lib_alloc && !need_exe_alloc { diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 7ed991e0de3..4a02a278bc1 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -28,7 +28,7 @@ use rustc::traits::specialization_graph; use rustc::ty::{self, Ty, TyCtxt, ReprOptions, SymbolName}; use rustc::ty::codec::{self as ty_codec, TyEncoder}; -use rustc::session::config::{self, CrateTypeProcMacro}; +use rustc::session::config::{self, CrateType}; use rustc::util::nodemap::FxHashMap; use rustc_data_structures::stable_hasher::StableHasher; @@ -478,7 +478,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { let attrs = tcx.hir.krate_attrs(); let link_meta = self.link_meta; - let is_proc_macro = tcx.sess.crate_types.borrow().contains(&CrateTypeProcMacro); + let is_proc_macro = tcx.sess.crate_types.borrow().contains(&CrateType::ProcMacro); let has_default_lib_allocator = attr::contains_name(&attrs, "default_lib_allocator"); let has_global_allocator = *tcx.sess.has_global_allocator.get(); @@ -1542,7 +1542,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { } fn encode_dylib_dependency_formats(&mut self, _: ()) -> LazySeq<Option<LinkagePreference>> { - match self.tcx.sess.dependency_formats.borrow().get(&config::CrateTypeDylib) { + match self.tcx.sess.dependency_formats.borrow().get(&config::CrateType::Dylib) { Some(arr) => { self.lazy_seq(arr.iter().map(|slot| { match *slot { diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index 97f1f2a76ca..230d6f0472e 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -770,7 +770,7 @@ fn should_monomorphize_locally<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: // If we are not in share generics mode, we don't link to upstream // monomorphizations but always instantiate our own internal versions // instead. - if !tcx.share_generics() { + if !tcx.sess.opts.share_generics() { return false } @@ -1047,7 +1047,7 @@ impl<'b, 'a, 'v> RootCollector<'b, 'a, 'v> { /// the return type of `main`. This is not needed when /// the user writes their own `start` manually. fn push_extra_entry_roots(&mut self) { - if self.tcx.sess.entry_fn.get().map(|e| e.2) != Some(config::EntryMain) { + if self.tcx.sess.entry_fn.get().map(|e| e.2) != Some(config::EntryFnType::Main) { return } diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index bd0b2c6c278..8d6d01633a1 100644 --- a/src/librustc_mir/monomorphize/partitioning.rs +++ b/src/librustc_mir/monomorphize/partitioning.rs @@ -304,7 +304,7 @@ fn place_root_mono_items<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // available to downstream crates. This depends on whether we are in // share-generics mode and whether the current crate can even have // downstream crates. - let export_generics = tcx.share_generics() && + let export_generics = tcx.sess.opts.share_generics() && tcx.local_crate_exports_generics(); for mono_item in mono_items { diff --git a/src/librustc_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs index 6e8471c6729..164790db4b5 100644 --- a/src/librustc_mir/transform/simplify.rs +++ b/src/librustc_mir/transform/simplify.rs @@ -42,7 +42,7 @@ use rustc_data_structures::indexed_vec::{Idx, IndexVec}; use rustc::ty::TyCtxt; use rustc::mir::*; use rustc::mir::visit::{MutVisitor, Visitor, PlaceContext}; -use rustc::session::config::FullDebugInfo; +use rustc::session::config::DebugInfo; use std::borrow::Cow; use transform::{MirPass, MirSource}; @@ -294,7 +294,7 @@ impl MirPass for SimplifyLocals { } // We may need to keep dead user variables live for debuginfo. - if tcx.sess.opts.debuginfo == FullDebugInfo { + if tcx.sess.opts.debuginfo == DebugInfo::Full { for local in mir.vars_iter() { marker.locals.insert(local); } diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index c6bad9e1980..0ea90e74531 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -32,7 +32,7 @@ struct AstValidator<'a> { impl<'a> AstValidator<'a> { fn err_handler(&self) -> &errors::Handler { - &self.session.parse_sess.span_diagnostic + &self.session.diagnostic() } fn check_lifetime(&self, ident: Ident) { diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 240b33c3c94..6e49951ff29 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -44,7 +44,7 @@ use rustc::hir::def::Def as HirDef; use rustc::hir::map::{Node, NodeTraitItem, NodeImplItem}; use rustc::hir::def_id::{DefId, LOCAL_CRATE}; use rustc::middle::cstore::ExternCrate; -use rustc::session::config::CrateType::CrateTypeExecutable; +use rustc::session::config::CrateType; use rustc::ty::{self, TyCtxt}; use rustc_typeck::hir_ty_to_ty; @@ -1048,7 +1048,7 @@ impl<'a> DumpHandler<'a> { let executable = sess.crate_types .borrow() .iter() - .any(|ct| *ct == CrateTypeExecutable); + .any(|ct| *ct == CrateType::Executable); let mut out_name = if executable { "".to_owned() } else { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 4cde171f1bf..8c47df8b042 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1111,7 +1111,7 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>, if let Some((id, _, entry_type)) = *fcx.tcx.sess.entry_fn.borrow() { if id == fn_id { match entry_type { - config::EntryMain => { + config::EntryFnType::Main => { let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]); let trait_ref = ty::TraitRef::new(term_id, substs); let return_ty_span = decl.output.span(); @@ -1122,7 +1122,7 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>, traits::Obligation::new( cause, param_env, trait_ref.to_predicate())); }, - config::EntryStart => {}, + config::EntryFnType::Start => {}, } } } diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 4f160945517..9fd5db16fb1 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -318,8 +318,8 @@ fn check_start_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, fn check_for_entry_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { if let Some((id, sp, entry_type)) = *tcx.sess.entry_fn.borrow() { match entry_type { - config::EntryMain => check_main_fn_ty(tcx, id, sp), - config::EntryStart => check_start_fn_ty(tcx, id, sp), + config::EntryFnType::Main => check_main_fn_ty(tcx, id, sp), + config::EntryFnType::Start => check_start_fn_ty(tcx, id, sp), } } } diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 84741f12ad1..f2327ba3e88 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -43,7 +43,7 @@ use clean; use clean::Clean; use html::render::RenderInfo; -pub use rustc::session::config::{Input, CodegenOptions}; +pub use rustc::session::config::{Input, Options, CodegenOptions}; pub use rustc::session::search_paths::SearchPaths; pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>; @@ -127,7 +127,7 @@ pub fn new_handler(error_format: ErrorOutputType, codemap: Option<Lrc<codemap::C { // rustdoc doesn't override (or allow to override) anything from this that is relevant here, so // stick to the defaults - let sessopts = config::basic_options(); + let sessopts = Options::default(); let emitter: Box<dyn Emitter + sync::Send> = match error_format { ErrorOutputType::HumanReadable(color_config) => Box::new( EmitterWriter::stderr( @@ -223,7 +223,7 @@ pub fn run_core(search_paths: SearchPaths, let sessopts = config::Options { maybe_sysroot, search_paths, - crate_types: vec![config::CrateTypeRlib], + crate_types: vec![config::CrateType::Rlib], lint_opts: if !allow_warnings { lints } else { @@ -243,7 +243,7 @@ pub fn run_core(search_paths: SearchPaths, error_format, edition, describe_lints, - ..config::basic_options() + ..Options::default() }; driver::spawn_thread_pool(sessopts, move |sessopts| { let codemap = Lrc::new(codemap::CodeMap::new(sessopts.file_path_mapping())); diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 650a2408aa6..d8e382f6998 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -73,7 +73,7 @@ pub fn run(input_path: &Path, maybe_sysroot: maybe_sysroot.clone().or_else( || Some(env::current_exe().unwrap().parent().unwrap().parent().unwrap().to_path_buf())), search_paths: libs.clone(), - crate_types: vec![config::CrateTypeDylib], + crate_types: vec![config::CrateType::Dylib], cg: cg.clone(), externs: externs.clone(), unstable_features: UnstableFeatures::from_environment(), @@ -83,7 +83,7 @@ pub fn run(input_path: &Path, ..config::basic_debugging_options() }, edition, - ..config::basic_options().clone() + ..config::Options::default() }; driver::spawn_thread_pool(sessopts, |sessopts| { let codemap = Lrc::new(CodeMap::new(sessopts.file_path_mapping())); @@ -216,7 +216,7 @@ fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize, maybe_sysroot: maybe_sysroot.or_else( || Some(env::current_exe().unwrap().parent().unwrap().parent().unwrap().to_path_buf())), search_paths: libs, - crate_types: vec![config::CrateTypeExecutable], + crate_types: vec![config::CrateType::Executable], output_types: outputs, externs, cg: config::CodegenOptions { @@ -230,7 +230,7 @@ fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize, ..config::basic_debugging_options() }, edition, - ..config::basic_options().clone() + ..config::Options::default() }; // Shuffle around a few input and output handles here. We're going to pass diff --git a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs index a3cd033f863..87d2026fe2d 100644 --- a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs +++ b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs @@ -63,7 +63,7 @@ impl CodegenBackend for TheBackend { let crate_name = ongoing_codegen.downcast::<Symbol>() .expect("in join_codegen_and_link: ongoing_codegen is not a Symbol"); for &crate_type in sess.opts.crate_types.iter() { - if crate_type != CrateType::CrateTypeRlib { + if crate_type != CrateType::Rlib { sess.fatal(&format!("Crate type is {:?}", crate_type)); } let output_name = diff --git a/src/test/run-make-fulldeps/issue-19371/foo.rs b/src/test/run-make-fulldeps/issue-19371/foo.rs index 6f5e2affdbd..d83b21e6441 100644 --- a/src/test/run-make-fulldeps/issue-19371/foo.rs +++ b/src/test/run-make-fulldeps/issue-19371/foo.rs @@ -19,7 +19,7 @@ extern crate rustc_codegen_utils; extern crate syntax; use rustc::session::{build_session, Session}; -use rustc::session::config::{basic_options, Input, Options, +use rustc::session::config::{Input, Options, OutputType, OutputTypes}; use rustc_driver::driver::{self, compile_input, CompileController}; use rustc_metadata::cstore::CStore; @@ -63,7 +63,7 @@ fn basic_sess(opts: Options) -> (Session, Rc<CStore>, Box<CodegenBackend>) { fn compile(code: String, output: PathBuf, sysroot: PathBuf) { syntax::with_globals(|| { - let mut opts = basic_options(); + let mut opts = Options::default(); opts.output_types = OutputTypes::new(&[(OutputType::Exe, None)]); opts.maybe_sysroot = Some(sysroot); if let Ok(linker) = std::env::var("RUSTC_LINKER") { |