From e59e02ef46c360eb6a2e2e30dd7cd10fc71e5e41 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 10:52:38 -0600 Subject: [PATCH 1/9] Privatize some exports from code_stats --- src/librustc/session/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 0ab482c89a125..3b96455424335 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; From 2a9344206be8ecd1cd2106bd93cccf46892fc2e5 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 11:13:11 -0600 Subject: [PATCH 2/9] Normalize variants of CrateType to standard style This is a clippy-breaking change. --- src/librustc/middle/dependency_format.rs | 20 ++++----- src/librustc/middle/entry.rs | 2 +- src/librustc/middle/reachable.rs | 4 +- src/librustc/middle/weak_lang_items.rs | 12 +++--- src/librustc/session/config.rs | 41 +++++++++---------- src/librustc/ty/context.rs | 14 +++---- src/librustc_codegen_llvm/back/link.rs | 40 +++++++++--------- src/librustc_codegen_llvm/back/linker.rs | 4 +- src/librustc_codegen_llvm/back/lto.rs | 12 +++--- .../back/symbol_export.rs | 14 +++---- src/librustc_codegen_llvm/back/write.rs | 6 +-- src/librustc_codegen_llvm/base.rs | 14 +++---- src/librustc_codegen_llvm/context.rs | 2 +- src/librustc_codegen_utils/codegen_backend.rs | 12 +++--- src/librustc_codegen_utils/link.rs | 28 ++++++------- src/librustc_driver/driver.rs | 18 ++++---- src/librustc_metadata/creader.rs | 28 ++++++------- src/librustc_metadata/encoder.rs | 6 +-- src/librustc_save_analysis/lib.rs | 4 +- src/librustdoc/core.rs | 2 +- src/librustdoc/test.rs | 4 +- .../hotplug_codegen_backend/the_backend.rs | 2 +- 22 files changed, 144 insertions(+), 145 deletions(-) diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 4c99b46ddff6e..a9c118d606b2e 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 feeb508d676c9..9c2157aa2b31b 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -59,7 +59,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 diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 19c82d7d27c79..94246db37069a 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 d8570b43fbe27..e8431ce3e109b 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 dda4a2d2418d7..27fc5995d735d 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -12,7 +12,6 @@ //! command line options. pub use self::EntryFnType::*; -pub use self::CrateType::*; pub use self::Passes::*; pub use self::DebugInfoLevel::*; @@ -670,12 +669,12 @@ pub enum EntryFnType { #[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)] @@ -1374,7 +1373,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 +1431,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; @@ -2277,12 +2276,12 @@ pub fn parse_crate_types_from_list(list_list: Vec) -> Result 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 +2359,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), } } } diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 89f3d7c30db92..03a84021a0da6 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -15,7 +15,7 @@ use dep_graph::{DepNode, DepConstructor}; use errors::DiagnosticBuilder; use session::Session; use session::config::{BorrowckMode, OutputFilenames, OptLevel}; -use session::config::CrateType::*; +use session::config::CrateType; use middle; use hir::{TraitCandidate, HirId, ItemLocalId}; use hir::def::{Def, Export}; @@ -1493,12 +1493,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { 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 845a66c6e4436..7cd2deabdeb7c 100644 --- a/src/librustc_codegen_llvm/back/link.rs +++ b/src/librustc_codegen_llvm/back/link.rs @@ -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; } @@ -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)); } @@ -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 7253b5346b9ab..0383539e7c475 100644 --- a/src/librustc_codegen_llvm/back/linker.rs +++ b/src/librustc_codegen_llvm/back/linker.rs @@ -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 } diff --git a/src/librustc_codegen_llvm/back/lto.rs b/src/librustc_codegen_llvm/back/lto.rs index b644422e79532..098676c95a289 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 48de2f3beedfb..5ce0d45a9bc5a 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,7 +235,7 @@ 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)); diff --git a/src/librustc_codegen_llvm/back/write.rs b/src/librustc_codegen_llvm/back/write.rs index 209c3a23c5cc3..484d30ab7a5e4 100644 --- a/src/librustc_codegen_llvm/back/write.rs +++ b/src/librustc_codegen_llvm/back/write.rs @@ -875,7 +875,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 +1341,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 +2346,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` global for every public static `symbol`. diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index 34cd3998f83cc..8fb3670e5ed9b 100644 --- a/src/librustc_codegen_llvm/base.rs +++ b/src/librustc_codegen_llvm/base.rs @@ -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 { diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index 11f8e75831eed..2832c114f5158 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -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 }) } diff --git a/src/librustc_codegen_utils/codegen_backend.rs b/src/librustc_codegen_utils/codegen_backend.rs index 3f230dd5d451b..7e726f00b0bf1 100644 --- a/src/librustc_codegen_utils/codegen_backend.rs +++ b/src/librustc_codegen_utils/codegen_backend.rs @@ -114,8 +114,7 @@ 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( &format!("LLVM unsupported, so output type {} is not supported", cty) @@ -201,13 +200,14 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { let ongoing_codegen = ongoing_codegen.downcast::() .expect("Expected MetadataOnlyCodegenBackend's OngoingCodegen, found Box"); 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 b33482eb868ff..73cffdf7d491d 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_driver/driver.rs b/src/librustc_driver/driver.rs index 2c877e27e2ea7..27b747c633cfe 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, @@ -1501,13 +1501,13 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec 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 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_metadata/creader.rs b/src/librustc_metadata/creader.rs index b5b47fb35dc21..62c06aac1df0e 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 7ed991e0de3a1..4a02a278bc14e 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> { - 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_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 240b33c3c9478..6e49951ff298a 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/librustdoc/core.rs b/src/librustdoc/core.rs index 84741f12ad183..b4b573fcb3d16 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -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 { diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 650a2408aa6ed..401d0d193a161 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(), @@ -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 { 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 a3cd033f86382..87d2026fe2dc8 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::() .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 = From b3267dcb3171f3a6b20eaceea254ab696609b922 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 11:22:14 -0600 Subject: [PATCH 3/9] Normalize variants of Passes to standard style --- src/librustc/session/config.rs | 20 +++++++++----------- src/librustc_codegen_llvm/back/write.rs | 7 +++---- 2 files changed, 12 insertions(+), 15 deletions(-) diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 27fc5995d735d..7d4508e0eea2a 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -12,7 +12,6 @@ //! command line options. pub use self::EntryFnType::*; -pub use self::Passes::*; pub use self::DebugInfoLevel::*; use std::str::FromStr; @@ -679,15 +678,15 @@ pub enum CrateType { #[derive(Clone, Hash)] pub enum Passes { - SomePasses(Vec), - AllPasses, + Some(Vec), + 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, } } } @@ -822,8 +821,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; @@ -934,13 +932,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 @@ -1103,7 +1101,7 @@ options! {CodegenOptions, CodegenSetter, basic_codegen_options, "extra data to put in each output filename"), codegen_units: Option = (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"), @@ -2946,7 +2944,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; diff --git a/src/librustc_codegen_llvm/back/write.rs b/src/librustc_codegen_llvm/back/write.rs index 484d30ab7a5e4..aec43be0795b1 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}; @@ -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 { From 442a4744e38136b79f818833d784145eb952b26a Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 11:29:45 -0600 Subject: [PATCH 4/9] Normalize EntryFnType variants to standard style --- src/librustc/middle/entry.rs | 7 ++++--- src/librustc/session/config.rs | 5 ++--- src/librustc_codegen_llvm/base.rs | 6 +++--- src/librustc_mir/monomorphize/collector.rs | 2 +- src/librustc_typeck/check/mod.rs | 4 ++-- src/librustc_typeck/lib.rs | 4 ++-- 6 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 9c2157aa2b31b..b0acc6f20e691 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; @@ -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/session/config.rs b/src/librustc/session/config.rs index 7d4508e0eea2a..e69e6215ba14b 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -11,7 +11,6 @@ //! Contains infrastructure for configuring the compiler, including parsing //! command line options. -pub use self::EntryFnType::*; pub use self::DebugInfoLevel::*; use std::str::FromStr; @@ -662,8 +661,8 @@ impl Options { // functions #[derive(Copy, Clone, PartialEq)] pub enum EntryFnType { - EntryMain, - EntryStart, + Main, + Start, } #[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug)] diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index 8fb3670e5ed9b..d98a8981da724 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, NoDebugInfo, 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. } diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index 97f1f2a76ca2b..7f5851734fe85 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -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_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 4cde171f1bfd4..8c47df8b04221 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 4f1609455178b..9fd5db16fb108 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), } } } From 2bc71971e5d91834d165b80b16858a49c9e00aba Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 11:41:10 -0600 Subject: [PATCH 5/9] Normalize DebugInfoLevel to standard style --- src/librustc/session/config.rs | 28 ++++++++++------------ src/librustc_codegen_llvm/back/link.rs | 6 ++--- src/librustc_codegen_llvm/back/linker.rs | 10 ++++---- src/librustc_codegen_llvm/back/write.rs | 2 +- src/librustc_codegen_llvm/base.rs | 4 ++-- src/librustc_codegen_llvm/context.rs | 6 ++--- src/librustc_codegen_llvm/debuginfo/gdb.rs | 4 ++-- src/librustc_codegen_llvm/debuginfo/mod.rs | 8 +++---- src/librustc_codegen_llvm/mir/mod.rs | 6 ++--- src/librustc_mir/transform/simplify.rs | 4 ++-- 10 files changed, 38 insertions(+), 40 deletions(-) diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index e69e6215ba14b..2281aca7a624e 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -11,8 +11,6 @@ //! Contains infrastructure for configuring the compiler, including parsing //! command line options. -pub use self::DebugInfoLevel::*; - use std::str::FromStr; use session::{early_error, early_warn, Session}; @@ -110,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)] @@ -378,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 [TRACKED], describe_lints: bool [UNTRACKED], @@ -603,7 +601,7 @@ pub fn basic_options() -> Options { Options { crate_types: Vec::new(), optimize: OptLevel::No, - debuginfo: NoDebugInfo, + debuginfo: DebugInfo::None, lint_opts: Vec::new(), lint_cap: None, describe_lints: false, @@ -2080,12 +2078,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, @@ -2184,7 +2182,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 \ @@ -2391,7 +2389,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}; @@ -2448,7 +2446,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); diff --git a/src/librustc_codegen_llvm/back/link.rs b/src/librustc_codegen_llvm/back/link.rs index 7cd2deabdeb7c..108734b67d3b8 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; @@ -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 } @@ -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() { diff --git a/src/librustc_codegen_llvm/back/linker.rs b/src/librustc_codegen_llvm/back/linker.rs index 0383539e7c475..e0a30ef5dbc9a 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. @@ -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/write.rs b/src/librustc_codegen_llvm/back/write.rs index aec43be0795b1..a5c6a0d5cd690 100644 --- a/src/librustc_codegen_llvm/back/write.rs +++ b/src/librustc_codegen_llvm/back/write.rs @@ -344,7 +344,7 @@ pub struct CodegenContext { pub tm_factory: Arc 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, diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index d98a8981da724..41336165684f6 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, EntryFnType}; +use rustc::session::config::{self, DebugInfo, EntryFnType}; use rustc::session::Session; use rustc_incremental; use allocator; @@ -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/context.rs b/src/librustc_codegen_llvm/context.rs index 2832c114f5158..2f557d0b09998 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}; @@ -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 08128a729b5f0..f6faddb894ffd 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 143b122a5a172..d4fb2549a752c 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/mir/mod.rs b/src/librustc_codegen_llvm/mir/mod.rs index a099cb5c64b21..8fdb67f5930ce 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_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs index 6e8471c672934..164790db4b5ec 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); } From 3cc4450a8a256d703ff64013b64bc1fd45d1f4f2 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 12:22:10 -0600 Subject: [PATCH 6/9] Simplify some handling of target_pointer_width --- src/librustc_codegen_llvm/intrinsic.rs | 27 ++++--------------------- src/librustc_codegen_llvm/mir/rvalue.rs | 14 ++----------- 2 files changed, 6 insertions(+), 35 deletions(-) diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs index 06a5c34a4cae0..0b5a6757333f2 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 { - use rustc::ty::TyFloat; +fn float_type_width<'tcx>(sty: &ty::TypeVariants<'tcx>) -> Option { 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/rvalue.rs b/src/librustc_codegen_llvm/mir/rvalue.rs index 02b5c27840eab..dda33ae3fecdf 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") }; From 5fcef251d3db36c334535d8f5d96b5b44f5eb75e Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 12:36:11 -0600 Subject: [PATCH 7/9] Move basic_options to impl of Default --- src/librustc/session/config.rs | 122 +++++++++--------- src/librustc_driver/test.rs | 2 +- src/librustdoc/core.rs | 6 +- src/librustdoc/test.rs | 4 +- src/test/run-make-fulldeps/issue-19371/foo.rs | 4 +- 5 files changed, 70 insertions(+), 68 deletions(-) diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 2281aca7a624e..f5a2b3730d51c 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -596,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: 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, +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, + } } } @@ -2529,6 +2530,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(); @@ -2613,9 +2615,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")))]); @@ -2635,8 +2637,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"))), @@ -2656,9 +2658,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![ ( @@ -2705,9 +2707,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), @@ -2742,8 +2744,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), @@ -2768,10 +2770,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 @@ -2831,10 +2833,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![ @@ -2881,9 +2883,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![ @@ -2916,8 +2918,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")); @@ -3054,8 +3056,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; @@ -3184,7 +3186,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_driver/test.rs b/src/librustc_driver/test.rs index 5b2092ea9eb11..03651322bc980 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -99,7 +99,7 @@ fn test_env(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/librustdoc/core.rs b/src/librustdoc/core.rs index b4b573fcb3d16..f2327ba3e8834 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, clean::TypeKind)>; @@ -127,7 +127,7 @@ pub fn new_handler(error_format: ErrorOutputType, codemap: Option = match error_format { ErrorOutputType::HumanReadable(color_config) => Box::new( EmitterWriter::stderr( @@ -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 401d0d193a161..d8e382f6998ce 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -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())); @@ -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/issue-19371/foo.rs b/src/test/run-make-fulldeps/issue-19371/foo.rs index 6f5e2affdbd3c..d83b21e64415d 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, Box) { 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") { From a9093a4dd80e617d50b26647ec2adcb727d2dd29 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 13:20:47 -0600 Subject: [PATCH 8/9] Move share_generics getter onto options directly --- src/librustc/session/config.rs | 18 +++++++++++++++ src/librustc/ty/context.rs | 22 ++----------------- .../back/symbol_export.rs | 2 +- src/librustc_codegen_llvm/callee.rs | 2 +- src/librustc_codegen_utils/symbol_names.rs | 2 +- src/librustc_mir/monomorphize/collector.rs | 2 +- src/librustc_mir/monomorphize/partitioning.rs | 2 +- 7 files changed, 25 insertions(+), 25 deletions(-) diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index f5a2b3730d51c..3111777f4ad5a 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -653,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 diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 03a84021a0da6..0cfdea68e881c 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -14,7 +14,7 @@ use dep_graph::DepGraph; use dep_graph::{DepNode, DepConstructor}; use errors::DiagnosticBuilder; use session::Session; -use session::config::{BorrowckMode, OutputFilenames, OptLevel}; +use session::config::{BorrowckMode, OutputFilenames}; use session::config::CrateType; use middle; use hir::{TraitCandidate, HirId, ItemLocalId}; @@ -1469,27 +1469,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.use_mir_borrowck() } - #[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 { diff --git a/src/librustc_codegen_llvm/back/symbol_export.rs b/src/librustc_codegen_llvm/back/symbol_export.rs index 5ce0d45a9bc5a..02434b7be0bda 100644 --- a/src/librustc_codegen_llvm/back/symbol_export.rs +++ b/src/librustc_codegen_llvm/back/symbol_export.rs @@ -242,7 +242,7 @@ fn exported_symbols_provider_local<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, 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/callee.rs b/src/librustc_codegen_llvm/callee.rs index e64dedac55a24..3594351802fe9 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_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs index ac71ecff96457..d834a6502b280 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_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index 7f5851734fe85..230d6f0472edd 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 } diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index bd0b2c6c278b1..8d6d01633a12e 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 { From 0ae2aa232047e16019d1b90726ca2c397371e5aa Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 26 Jul 2018 16:18:06 -0600 Subject: [PATCH 9/9] Use diagnostic API on Session --- src/librustc/session/mod.rs | 2 +- src/librustc_codegen_utils/codegen_backend.rs | 2 +- src/librustc_driver/driver.rs | 2 +- src/librustc_passes/ast_validation.rs | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 3b96455424335..0173c4933f821 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -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_codegen_utils/codegen_backend.rs b/src/librustc_codegen_utils/codegen_backend.rs index 7e726f00b0bf1..ae8f65303a7fe 100644 --- a/src/librustc_codegen_utils/codegen_backend.rs +++ b/src/librustc_codegen_utils/codegen_backend.rs @@ -116,7 +116,7 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { match *cty { 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) ); }, diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 27b747c633cfe..805a5ecd99130 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -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. diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index c6bad9e1980fb..0ea90e7453190 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) {