From 62cf767a4a39b47677d18110359d9e7152dc9d1c Mon Sep 17 00:00:00 2001 From: Tamir Duberstein Date: Tue, 7 Jul 2020 11:12:44 -0400 Subject: [PATCH] Avoid "whitelist" Other terms are more inclusive and precise. --- src/bootstrap/doc.rs | 6 +- src/etc/test-float-parse/runtests.py | 8 +- src/libcore/ffi.rs | 2 +- src/librustc_codegen_llvm/attributes.rs | 8 +- src/librustc_codegen_llvm/back/lto.rs | 57 ++++--- src/librustc_codegen_llvm/llvm_util.rs | 57 ++++--- src/librustc_codegen_ssa/back/linker.rs | 8 +- src/librustc_codegen_ssa/base.rs | 5 +- src/librustc_expand/base.rs | 2 +- src/librustc_feature/builtin_attrs.rs | 144 +++++++++--------- .../persist/dirty_clean.rs | 2 +- src/librustc_interface/util.rs | 4 +- src/librustc_lint/unused.rs | 4 +- src/librustc_metadata/rmeta/decoder.rs | 3 - src/librustc_middle/lint.rs | 5 +- src/librustc_middle/middle/lang_items.rs | 13 +- src/librustc_middle/query/mod.rs | 4 +- src/librustc_mir/const_eval/fn_queries.rs | 2 +- src/librustc_mir/interpret/validity.rs | 2 +- src/librustc_passes/weak_lang_items.rs | 4 +- src/librustc_resolve/late/lifetimes.rs | 2 +- src/librustc_target/spec/tests/tests_impl.rs | 4 +- src/librustc_target/spec/wasm32_base.rs | 16 +- .../traits/error_reporting/suggestions.rs | 2 +- src/librustc_typeck/check/demand.rs | 2 +- src/librustc_typeck/check/expr.rs | 4 +- src/librustc_typeck/collect.rs | 23 +-- src/librustdoc/core.rs | 20 +-- src/librustdoc/html/render.rs | 4 +- src/librustdoc/test.rs | 6 +- src/libstd/time.rs | 2 +- .../hotplug_codegen_backend/the_backend.rs | 2 +- .../sysroot-crates-are-unstable/test.py | 2 +- .../auxiliary/issue-40001-plugin.rs | 20 +-- src/test/ui-fulldeps/issue-40001.rs | 2 +- src/test/ui/asm/type-check-3.rs | 2 +- .../ui/rfc-2126-extern-absolute-paths/meta.rs | 4 +- .../{not-whitelisted.rs => not-allowed.rs} | 0 ...-whitelisted.stderr => not-allowed.stderr} | 2 +- src/test/ui/sse2.rs | 2 +- src/tools/clippy/clippy_lints/src/attrs.rs | 4 +- src/tools/clippy/clippy_lints/src/eq_op.rs | 2 +- .../src/needless_pass_by_value.rs | 4 +- .../clippy_lints/src/non_expressive_names.rs | 18 +-- .../clippy/clippy_lints/src/precedence.rs | 4 +- src/tools/clippy/clippy_lints/src/types.rs | 4 +- .../{whitelist => third-party}/clippy.toml | 0 .../conf_allowlisted.rs} | 0 .../clippy/tests/ui/needless_pass_by_value.rs | 2 +- .../tests/ui/neg_cmp_op_on_partial_ord.rs | 2 +- src/tools/linkchecker/main.rs | 6 +- src/tools/tidy/src/cargo.rs | 4 +- src/tools/tidy/src/deps.rs | 51 ++++--- src/tools/tidy/src/error_codes_check.rs | 4 +- src/tools/tidy/src/extdeps.rs | 8 +- 55 files changed, 296 insertions(+), 278 deletions(-) rename src/test/ui/rfc-2126-extern-absolute-paths/{not-whitelisted.rs => not-allowed.rs} (100%) rename src/test/ui/rfc-2126-extern-absolute-paths/{not-whitelisted.stderr => not-allowed.stderr} (86%) rename src/tools/clippy/tests/ui/crashes/{whitelist => third-party}/clippy.toml (100%) rename src/tools/clippy/tests/ui/crashes/{whitelist/conf_whitelisted.rs => third-party/conf_allowlisted.rs} (100%) diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 4bec6c7791a21..582bc9da0e804 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -439,8 +439,6 @@ impl Step for Std { builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "rustdoc"); compile::std_cargo(builder, target, compiler.stage, &mut cargo); - // Keep a whitelist so we do not build internal stdlib crates, these will be - // build by the rustc step later if enabled. cargo.arg("-p").arg(package); // Create all crate output directories first to make sure rustdoc uses // relative links. @@ -460,6 +458,10 @@ impl Step for Std { builder.run(&mut cargo.into()); }; + // Only build the following crates. While we could just iterate over the + // folder structure, that would also build internal crates that we do + // not want to show in documentation. These crates will later be visited + // by the rustc step, so internal documentation will show them. let krates = ["alloc", "core", "std", "proc_macro", "test"]; for krate in &krates { run_cargo_rustdoc_for(krate); diff --git a/src/etc/test-float-parse/runtests.py b/src/etc/test-float-parse/runtests.py index fe6fd45f9a5f8..7106078f897cf 100644 --- a/src/etc/test-float-parse/runtests.py +++ b/src/etc/test-float-parse/runtests.py @@ -195,9 +195,9 @@ def main(): global MAILBOX tests = [os.path.splitext(f)[0] for f in glob('*.rs') if not f.startswith('_')] - whitelist = sys.argv[1:] - if whitelist: - tests = [test for test in tests if test in whitelist] + listed = sys.argv[1:] + if listed: + tests = [test for test in tests if test in listed] if not tests: print("Error: No tests to run") sys.exit(1) @@ -210,8 +210,6 @@ def main(): mailman.daemon = True mailman.start() for test in tests: - if whitelist and test not in whitelist: - continue run(test) MAILBOX.put(None) mailman.join() diff --git a/src/libcore/ffi.rs b/src/libcore/ffi.rs index ee3192eddbd06..e9689af39d51f 100644 --- a/src/libcore/ffi.rs +++ b/src/libcore/ffi.rs @@ -280,7 +280,7 @@ impl<'a, 'f: 'a> DerefMut for VaList<'a, 'f> { // within a private module. Once RFC 2145 has been implemented look into // improving this. mod sealed_trait { - /// Trait which whitelists the allowed types to be used with [VaList::arg] + /// Trait which permits the allowed types to be used with [VaList::arg]. /// /// [VaList::arg]: ../struct.VaList.html#method.arg #[unstable( diff --git a/src/librustc_codegen_llvm/attributes.rs b/src/librustc_codegen_llvm/attributes.rs index c53a64664a639..89b548a9c5ab2 100644 --- a/src/librustc_codegen_llvm/attributes.rs +++ b/src/librustc_codegen_llvm/attributes.rs @@ -263,7 +263,7 @@ pub fn from_fn_attrs(cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value, instance: ty:: // Windows we end up still needing the `uwtable` attribute even if the `-C // panic=abort` flag is passed. // - // You can also find more info on why Windows is whitelisted here in: + // You can also find more info on why Windows always requires uwtables here: // https://bugzilla.mozilla.org/show_bug.cgi?id=1302078 if cx.sess().must_emit_unwind_tables() { attributes::emit_uwtable(llfn, true); @@ -343,14 +343,14 @@ pub fn from_fn_attrs(cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value, instance: ty:: } pub fn provide(providers: &mut Providers) { - providers.target_features_whitelist = |tcx, cnum| { + providers.supported_target_features = |tcx, cnum| { assert_eq!(cnum, LOCAL_CRATE); if tcx.sess.opts.actually_rustdoc { // rustdoc needs to be able to document functions that use all the features, so - // whitelist them all + // provide them all. llvm_util::all_known_features().map(|(a, b)| (a.to_string(), b)).collect() } else { - llvm_util::target_feature_whitelist(tcx.sess) + llvm_util::supported_target_features(tcx.sess) .iter() .map(|&(a, b)| (a.to_string(), b)) .collect() diff --git a/src/librustc_codegen_llvm/back/lto.rs b/src/librustc_codegen_llvm/back/lto.rs index 9764c9a102e8a..6b02b5e8120db 100644 --- a/src/librustc_codegen_llvm/back/lto.rs +++ b/src/librustc_codegen_llvm/back/lto.rs @@ -62,11 +62,11 @@ fn prepare_lto( } }; let exported_symbols = cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO"); - let mut symbol_white_list = { - let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list"); + let mut symbols_below_threshold = { + let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbols_below_threshold"); exported_symbols[&LOCAL_CRATE].iter().filter_map(symbol_filter).collect::>() }; - info!("{} symbols to preserve in this crate", symbol_white_list.len()); + info!("{} symbols to preserve in this crate", symbols_below_threshold.len()); // If we're performing LTO for the entire crate graph, then for each of our // upstream dependencies, find the corresponding rlib and load the bitcode @@ -102,8 +102,10 @@ fn prepare_lto( let exported_symbols = cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO"); { - let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list"); - symbol_white_list.extend(exported_symbols[&cnum].iter().filter_map(symbol_filter)); + let _timer = + cgcx.prof.generic_activity("LLVM_lto_generate_symbols_below_threshold"); + symbols_below_threshold + .extend(exported_symbols[&cnum].iter().filter_map(symbol_filter)); } let archive = ArchiveRO::open(&path).expect("wanted an rlib"); @@ -124,7 +126,7 @@ fn prepare_lto( } } - Ok((symbol_white_list, upstream_modules)) + Ok((symbols_below_threshold, upstream_modules)) } fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], String> { @@ -155,9 +157,17 @@ pub(crate) fn run_fat( cached_modules: Vec<(SerializedModule, WorkProduct)>, ) -> Result, FatalError> { let diag_handler = cgcx.create_diag_handler(); - let (symbol_white_list, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; - let symbol_white_list = symbol_white_list.iter().map(|c| c.as_ptr()).collect::>(); - fat_lto(cgcx, &diag_handler, modules, cached_modules, upstream_modules, &symbol_white_list) + let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; + let symbols_below_threshold = + symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::>(); + fat_lto( + cgcx, + &diag_handler, + modules, + cached_modules, + upstream_modules, + &symbols_below_threshold, + ) } /// Performs thin LTO by performing necessary global analysis and returning two @@ -169,15 +179,23 @@ pub(crate) fn run_thin( cached_modules: Vec<(SerializedModule, WorkProduct)>, ) -> Result<(Vec>, Vec), FatalError> { let diag_handler = cgcx.create_diag_handler(); - let (symbol_white_list, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; - let symbol_white_list = symbol_white_list.iter().map(|c| c.as_ptr()).collect::>(); + let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; + let symbols_below_threshold = + symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::>(); if cgcx.opts.cg.linker_plugin_lto.enabled() { unreachable!( "We should never reach this case if the LTO step \ is deferred to the linker" ); } - thin_lto(cgcx, &diag_handler, modules, upstream_modules, cached_modules, &symbol_white_list) + thin_lto( + cgcx, + &diag_handler, + modules, + upstream_modules, + cached_modules, + &symbols_below_threshold, + ) } pub(crate) fn prepare_thin(module: ModuleCodegen) -> (String, ThinBuffer) { @@ -192,7 +210,7 @@ fn fat_lto( modules: Vec>, cached_modules: Vec<(SerializedModule, WorkProduct)>, mut serialized_modules: Vec<(SerializedModule, CString)>, - symbol_white_list: &[*const libc::c_char], + symbols_below_threshold: &[*const libc::c_char], ) -> Result, FatalError> { let _timer = cgcx.prof.generic_activity("LLVM_fat_lto_build_monolithic_module"); info!("going for a fat lto"); @@ -306,14 +324,13 @@ fn fat_lto( drop(linker); save_temp_bitcode(&cgcx, &module, "lto.input"); - // Internalize everything that *isn't* in our whitelist to help strip out - // more modules and such + // Internalize everything below threshold to help strip out more modules and such. unsafe { - let ptr = symbol_white_list.as_ptr(); + let ptr = symbols_below_threshold.as_ptr(); llvm::LLVMRustRunRestrictionPass( llmod, ptr as *const *const libc::c_char, - symbol_white_list.len() as libc::size_t, + symbols_below_threshold.len() as libc::size_t, ); save_temp_bitcode(&cgcx, &module, "lto.after-restriction"); } @@ -395,7 +412,7 @@ fn thin_lto( modules: Vec<(String, ThinBuffer)>, serialized_modules: Vec<(SerializedModule, CString)>, cached_modules: Vec<(SerializedModule, WorkProduct)>, - symbol_white_list: &[*const libc::c_char], + symbols_below_threshold: &[*const libc::c_char], ) -> Result<(Vec>, Vec), FatalError> { let _timer = cgcx.prof.generic_activity("LLVM_thin_lto_global_analysis"); unsafe { @@ -463,8 +480,8 @@ fn thin_lto( let data = llvm::LLVMRustCreateThinLTOData( thin_modules.as_ptr(), thin_modules.len() as u32, - symbol_white_list.as_ptr(), - symbol_white_list.len() as u32, + symbols_below_threshold.as_ptr(), + symbols_below_threshold.len() as u32, ) .ok_or_else(|| write::llvm_err(&diag_handler, "failed to prepare thin LTO context"))?; diff --git a/src/librustc_codegen_llvm/llvm_util.rs b/src/librustc_codegen_llvm/llvm_util.rs index 2e2ce1544109a..b631c10334cd1 100644 --- a/src/librustc_codegen_llvm/llvm_util.rs +++ b/src/librustc_codegen_llvm/llvm_util.rs @@ -139,7 +139,7 @@ pub fn time_trace_profiler_finish(file_name: &str) { // to LLVM or the feature detection code will walk past the end of the feature // array, leading to crashes. -const ARM_WHITELIST: &[(&str, Option)] = &[ +const ARM_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("aclass", Some(sym::arm_target_feature)), ("mclass", Some(sym::arm_target_feature)), ("rclass", Some(sym::arm_target_feature)), @@ -162,7 +162,7 @@ const ARM_WHITELIST: &[(&str, Option)] = &[ ("thumb-mode", Some(sym::arm_target_feature)), ]; -const AARCH64_WHITELIST: &[(&str, Option)] = &[ +const AARCH64_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("fp", Some(sym::aarch64_target_feature)), ("neon", Some(sym::aarch64_target_feature)), ("sve", Some(sym::aarch64_target_feature)), @@ -180,7 +180,7 @@ const AARCH64_WHITELIST: &[(&str, Option)] = &[ ("v8.3a", Some(sym::aarch64_target_feature)), ]; -const X86_WHITELIST: &[(&str, Option)] = &[ +const X86_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("adx", Some(sym::adx_target_feature)), ("aes", None), ("avx", None), @@ -224,12 +224,12 @@ const X86_WHITELIST: &[(&str, Option)] = &[ ("xsaves", None), ]; -const HEXAGON_WHITELIST: &[(&str, Option)] = &[ +const HEXAGON_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("hvx", Some(sym::hexagon_target_feature)), ("hvx-length128b", Some(sym::hexagon_target_feature)), ]; -const POWERPC_WHITELIST: &[(&str, Option)] = &[ +const POWERPC_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("altivec", Some(sym::powerpc_target_feature)), ("power8-altivec", Some(sym::powerpc_target_feature)), ("power9-altivec", Some(sym::powerpc_target_feature)), @@ -238,10 +238,10 @@ const POWERPC_WHITELIST: &[(&str, Option)] = &[ ("vsx", Some(sym::powerpc_target_feature)), ]; -const MIPS_WHITELIST: &[(&str, Option)] = +const MIPS_ALLOWED_FEATURES: &[(&str, Option)] = &[("fp64", Some(sym::mips_target_feature)), ("msa", Some(sym::mips_target_feature))]; -const RISCV_WHITELIST: &[(&str, Option)] = &[ +const RISCV_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("m", Some(sym::riscv_target_feature)), ("a", Some(sym::riscv_target_feature)), ("c", Some(sym::riscv_target_feature)), @@ -250,7 +250,7 @@ const RISCV_WHITELIST: &[(&str, Option)] = &[ ("e", Some(sym::riscv_target_feature)), ]; -const WASM_WHITELIST: &[(&str, Option)] = &[ +const WASM_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("simd128", Some(sym::wasm_target_feature)), ("atomics", Some(sym::wasm_target_feature)), ("nontrapping-fptoint", Some(sym::wasm_target_feature)), @@ -259,19 +259,18 @@ const WASM_WHITELIST: &[(&str, Option)] = &[ /// When rustdoc is running, provide a list of all known features so that all their respective /// primitives may be documented. /// -/// IMPORTANT: If you're adding another whitelist to the above lists, make sure to add it to this -/// iterator! +/// IMPORTANT: If you're adding another feature list above, make sure to add it to this iterator! pub fn all_known_features() -> impl Iterator)> { - ARM_WHITELIST - .iter() + std::iter::empty() + .chain(ARM_ALLOWED_FEATURES.iter()) + .chain(AARCH64_ALLOWED_FEATURES.iter()) + .chain(X86_ALLOWED_FEATURES.iter()) + .chain(HEXAGON_ALLOWED_FEATURES.iter()) + .chain(POWERPC_ALLOWED_FEATURES.iter()) + .chain(MIPS_ALLOWED_FEATURES.iter()) + .chain(RISCV_ALLOWED_FEATURES.iter()) + .chain(WASM_ALLOWED_FEATURES.iter()) .cloned() - .chain(AARCH64_WHITELIST.iter().cloned()) - .chain(X86_WHITELIST.iter().cloned()) - .chain(HEXAGON_WHITELIST.iter().cloned()) - .chain(POWERPC_WHITELIST.iter().cloned()) - .chain(MIPS_WHITELIST.iter().cloned()) - .chain(RISCV_WHITELIST.iter().cloned()) - .chain(WASM_WHITELIST.iter().cloned()) } pub fn to_llvm_feature<'a>(sess: &Session, s: &'a str) -> &'a str { @@ -289,7 +288,7 @@ pub fn to_llvm_feature<'a>(sess: &Session, s: &'a str) -> &'a str { pub fn target_features(sess: &Session) -> Vec { let target_machine = create_informational_target_machine(sess); - target_feature_whitelist(sess) + supported_target_features(sess) .iter() .filter_map(|&(feature, gate)| { if UnstableFeatures::from_environment().is_nightly_build() || gate.is_none() { @@ -307,16 +306,16 @@ pub fn target_features(sess: &Session) -> Vec { .collect() } -pub fn target_feature_whitelist(sess: &Session) -> &'static [(&'static str, Option)] { +pub fn supported_target_features(sess: &Session) -> &'static [(&'static str, Option)] { match &*sess.target.target.arch { - "arm" => ARM_WHITELIST, - "aarch64" => AARCH64_WHITELIST, - "x86" | "x86_64" => X86_WHITELIST, - "hexagon" => HEXAGON_WHITELIST, - "mips" | "mips64" => MIPS_WHITELIST, - "powerpc" | "powerpc64" => POWERPC_WHITELIST, - "riscv32" | "riscv64" => RISCV_WHITELIST, - "wasm32" => WASM_WHITELIST, + "arm" => ARM_ALLOWED_FEATURES, + "aarch64" => AARCH64_ALLOWED_FEATURES, + "x86" | "x86_64" => X86_ALLOWED_FEATURES, + "hexagon" => HEXAGON_ALLOWED_FEATURES, + "mips" | "mips64" => MIPS_ALLOWED_FEATURES, + "powerpc" | "powerpc64" => POWERPC_ALLOWED_FEATURES, + "riscv32" | "riscv64" => RISCV_ALLOWED_FEATURES, + "wasm32" => WASM_ALLOWED_FEATURES, _ => &[], } } diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs index 54f55c806d035..43d351342ccad 100644 --- a/src/librustc_codegen_ssa/back/linker.rs +++ b/src/librustc_codegen_ssa/back/linker.rs @@ -1176,10 +1176,10 @@ impl<'a> Linker for WasmLd<'a> { self.cmd.arg("--export").arg(&sym); } - // LLD will hide these otherwise-internal symbols since our `--export` - // list above is a whitelist of what to export. Various bits and pieces - // of tooling use this, so be sure these symbols make their way out of - // the linker as well. + // LLD will hide these otherwise-internal symbols since it only exports + // symbols explicity passed via the `--export` flags above and hides all + // others. Various bits and pieces of tooling use this, so be sure these + // symbols make their way out of the linker as well. self.cmd.arg("--export=__heap_base"); self.cmd.arg("--export=__data_end"); } diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs index 4e257fba44ab6..b28cb071de659 100644 --- a/src/librustc_codegen_ssa/base.rs +++ b/src/librustc_codegen_ssa/base.rs @@ -842,10 +842,9 @@ impl CrateInfo { } } - // No need to look for lang items that are whitelisted and don't - // actually need to exist. + // No need to look for lang items that don't actually need to exist. let missing = - missing.iter().cloned().filter(|&l| !lang_items::whitelisted(tcx, l)).collect(); + missing.iter().cloned().filter(|&l| lang_items::required(tcx, l)).collect(); info.missing_lang_items.insert(cnum, missing); } diff --git a/src/librustc_expand/base.rs b/src/librustc_expand/base.rs index db9293bddeb7d..3e48224ef9f20 100644 --- a/src/librustc_expand/base.rs +++ b/src/librustc_expand/base.rs @@ -735,7 +735,7 @@ pub struct SyntaxExtension { pub kind: SyntaxExtensionKind, /// Span of the macro definition. pub span: Span, - /// Whitelist of unstable features that are treated as stable inside this macro. + /// List of unstable features that are treated as stable inside this macro. pub allow_internal_unstable: Option>, /// Suppresses the `unsafe_code` lint for code produced by this macro. pub allow_internal_unsafe: bool, diff --git a/src/librustc_feature/builtin_attrs.rs b/src/librustc_feature/builtin_attrs.rs index c9a34f033758b..4e2aea34fe7fb 100644 --- a/src/librustc_feature/builtin_attrs.rs +++ b/src/librustc_feature/builtin_attrs.rs @@ -47,7 +47,7 @@ pub enum AttributeType { /// Builtin attribute that may not be consumed by the compiler /// before the unused_attribute check. These attributes /// will be ignored by the unused_attribute lint - Whitelisted, + AssumedUsed, /// Builtin attribute that is only allowed at the crate level CrateLevel, @@ -202,7 +202,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ungated!(allow, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)), ungated!(forbid, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)), ungated!(deny, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)), - ungated!(must_use, Whitelisted, template!(Word, NameValueStr: "reason")), + ungated!(must_use, AssumedUsed, template!(Word, NameValueStr: "reason")), // FIXME(#14407) ungated!( deprecated, Normal, @@ -220,16 +220,16 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ABI, linking, symbols, and FFI ungated!( - link, Whitelisted, + link, AssumedUsed, template!(List: r#"name = "...", /*opt*/ kind = "dylib|static|...", /*opt*/ wasm_import_module = "...""#), ), - ungated!(link_name, Whitelisted, template!(NameValueStr: "name")), + ungated!(link_name, AssumedUsed, template!(NameValueStr: "name")), ungated!(no_link, Normal, template!(Word)), ungated!(repr, Normal, template!(List: "C")), - ungated!(export_name, Whitelisted, template!(NameValueStr: "name")), - ungated!(link_section, Whitelisted, template!(NameValueStr: "name")), - ungated!(no_mangle, Whitelisted, template!(Word)), - ungated!(used, Whitelisted, template!(Word)), + ungated!(export_name, AssumedUsed, template!(NameValueStr: "name")), + ungated!(link_section, AssumedUsed, template!(NameValueStr: "name")), + ungated!(no_mangle, AssumedUsed, template!(Word)), + ungated!(used, AssumedUsed, template!(Word)), // Limits: ungated!(recursion_limit, CrateLevel, template!(NameValueStr: "N")), @@ -249,40 +249,40 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ungated!(path, Normal, template!(NameValueStr: "file")), ungated!(no_std, CrateLevel, template!(Word)), ungated!(no_implicit_prelude, Normal, template!(Word)), - ungated!(non_exhaustive, Whitelisted, template!(Word)), + ungated!(non_exhaustive, AssumedUsed, template!(Word)), // Runtime - ungated!(windows_subsystem, Whitelisted, template!(NameValueStr: "windows|console")), + ungated!(windows_subsystem, AssumedUsed, template!(NameValueStr: "windows|console")), ungated!(panic_handler, Normal, template!(Word)), // RFC 2070 // Code generation: - ungated!(inline, Whitelisted, template!(Word, List: "always|never")), - ungated!(cold, Whitelisted, template!(Word)), - ungated!(no_builtins, Whitelisted, template!(Word)), - ungated!(target_feature, Whitelisted, template!(List: r#"enable = "name""#)), - ungated!(track_caller, Whitelisted, template!(Word)), + ungated!(inline, AssumedUsed, template!(Word, List: "always|never")), + ungated!(cold, AssumedUsed, template!(Word)), + ungated!(no_builtins, AssumedUsed, template!(Word)), + ungated!(target_feature, AssumedUsed, template!(List: r#"enable = "name""#)), + ungated!(track_caller, AssumedUsed, template!(Word)), gated!( - no_sanitize, Whitelisted, + no_sanitize, AssumedUsed, template!(List: "address, memory, thread"), experimental!(no_sanitize) ), - // FIXME: #14408 whitelist docs since rustdoc looks at them - ungated!(doc, Whitelisted, template!(List: "hidden|inline|...", NameValueStr: "string")), + // FIXME: #14408 assume docs are used since rustdoc looks at them. + ungated!(doc, AssumedUsed, template!(List: "hidden|inline|...", NameValueStr: "string")), // ========================================================================== // Unstable attributes: // ========================================================================== // Linking: - gated!(naked, Whitelisted, template!(Word), naked_functions, experimental!(naked)), + gated!(naked, AssumedUsed, template!(Word), naked_functions, experimental!(naked)), gated!( link_args, Normal, template!(NameValueStr: "args"), "the `link_args` attribute is experimental and not portable across platforms, \ it is recommended to use `#[link(name = \"foo\")] instead", ), gated!( - link_ordinal, Whitelisted, template!(List: "ordinal"), raw_dylib, + link_ordinal, AssumedUsed, template!(List: "ordinal"), raw_dylib, experimental!(link_ordinal) ), @@ -321,19 +321,19 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // RFC #1268 gated!(marker, Normal, template!(Word), marker_trait_attr, experimental!(marker)), gated!( - thread_local, Whitelisted, template!(Word), + thread_local, AssumedUsed, template!(Word), "`#[thread_local]` is an experimental feature, and does not currently handle destructors", ), gated!(no_core, CrateLevel, template!(Word), experimental!(no_core)), // RFC 2412 gated!( - optimize, Whitelisted, template!(List: "size|speed"), optimize_attribute, + optimize, AssumedUsed, template!(List: "size|speed"), optimize_attribute, experimental!(optimize), ), - gated!(ffi_returns_twice, Whitelisted, template!(Word), experimental!(ffi_returns_twice)), - gated!(ffi_pure, Whitelisted, template!(Word), experimental!(ffi_pure)), - gated!(ffi_const, Whitelisted, template!(Word), experimental!(ffi_const)), + gated!(ffi_returns_twice, AssumedUsed, template!(Word), experimental!(ffi_returns_twice)), + gated!(ffi_pure, AssumedUsed, template!(Word), experimental!(ffi_pure)), + gated!(ffi_const, AssumedUsed, template!(Word), experimental!(ffi_const)), gated!( register_attr, CrateLevel, template!(List: "attr1, attr2, ..."), experimental!(register_attr), @@ -351,22 +351,22 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // FIXME(#14407) -- only looked at on-demand so we can't // guarantee they'll have already been checked. ungated!( - rustc_deprecated, Whitelisted, + rustc_deprecated, AssumedUsed, template!(List: r#"since = "version", reason = "...""#) ), // FIXME(#14407) - ungated!(stable, Whitelisted, template!(List: r#"feature = "name", since = "version""#)), + ungated!(stable, AssumedUsed, template!(List: r#"feature = "name", since = "version""#)), // FIXME(#14407) ungated!( - unstable, Whitelisted, + unstable, AssumedUsed, template!(List: r#"feature = "name", reason = "...", issue = "N""#), ), // FIXME(#14407) - ungated!(rustc_const_unstable, Whitelisted, template!(List: r#"feature = "name""#)), + ungated!(rustc_const_unstable, AssumedUsed, template!(List: r#"feature = "name""#)), // FIXME(#14407) - ungated!(rustc_const_stable, Whitelisted, template!(List: r#"feature = "name""#)), + ungated!(rustc_const_stable, AssumedUsed, template!(List: r#"feature = "name""#)), gated!( - allow_internal_unstable, Whitelisted, template!(Word, List: "feat1, feat2, ..."), + allow_internal_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."), "allow_internal_unstable side-steps feature gating and stability checks", ), gated!( @@ -378,7 +378,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // Internal attributes: Type system related: // ========================================================================== - gated!(fundamental, Whitelisted, template!(Word), experimental!(fundamental)), + gated!(fundamental, AssumedUsed, template!(Word), experimental!(fundamental)), gated!( may_dangle, Normal, template!(Word), dropck_eyepatch, "`may_dangle` has unstable semantics and may be removed in the future", @@ -388,30 +388,30 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // Internal attributes: Runtime related: // ========================================================================== - rustc_attr!(rustc_allocator, Whitelisted, template!(Word), IMPL_DETAIL), - rustc_attr!(rustc_allocator_nounwind, Whitelisted, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_allocator, AssumedUsed, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_allocator_nounwind, AssumedUsed, template!(Word), IMPL_DETAIL), gated!(alloc_error_handler, Normal, template!(Word), experimental!(alloc_error_handler)), gated!( - default_lib_allocator, Whitelisted, template!(Word), allocator_internals, + default_lib_allocator, AssumedUsed, template!(Word), allocator_internals, experimental!(default_lib_allocator), ), gated!( needs_allocator, Normal, template!(Word), allocator_internals, experimental!(needs_allocator), ), - gated!(panic_runtime, Whitelisted, template!(Word), experimental!(panic_runtime)), - gated!(needs_panic_runtime, Whitelisted, template!(Word), experimental!(needs_panic_runtime)), + gated!(panic_runtime, AssumedUsed, template!(Word), experimental!(panic_runtime)), + gated!(needs_panic_runtime, AssumedUsed, template!(Word), experimental!(needs_panic_runtime)), gated!( - unwind, Whitelisted, template!(List: "allowed|aborts"), unwind_attributes, + unwind, AssumedUsed, template!(List: "allowed|aborts"), unwind_attributes, experimental!(unwind), ), gated!( - compiler_builtins, Whitelisted, template!(Word), + compiler_builtins, AssumedUsed, template!(Word), "the `#[compiler_builtins]` attribute is used to identify the `compiler_builtins` crate \ which contains compiler-rt intrinsics and will never be stable", ), gated!( - profiler_runtime, Whitelisted, template!(Word), + profiler_runtime, AssumedUsed, template!(Word), "the `#[profiler_runtime]` attribute is used to identify the `profiler_builtins` crate \ which contains the profiler runtime and will never be stable", ), @@ -421,19 +421,19 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ========================================================================== gated!( - linkage, Whitelisted, template!(NameValueStr: "external|internal|..."), + linkage, AssumedUsed, template!(NameValueStr: "external|internal|..."), "the `linkage` attribute is experimental and not portable across platforms", ), - rustc_attr!(rustc_std_internal_symbol, Whitelisted, template!(Word), INTERNAL_UNSTABLE), + rustc_attr!(rustc_std_internal_symbol, AssumedUsed, template!(Word), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Macro related: // ========================================================================== - rustc_attr!(rustc_builtin_macro, Whitelisted, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_builtin_macro, AssumedUsed, template!(Word), IMPL_DETAIL), rustc_attr!(rustc_proc_macro_decls, Normal, template!(Word), INTERNAL_UNSTABLE), rustc_attr!( - rustc_macro_transparency, Whitelisted, + rustc_macro_transparency, AssumedUsed, template!(NameValueStr: "transparent|semitransparent|opaque"), "used internally for testing macro hygiene", ), @@ -443,40 +443,40 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ========================================================================== rustc_attr!( - rustc_on_unimplemented, Whitelisted, + rustc_on_unimplemented, AssumedUsed, template!( List: r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#, NameValueStr: "message" ), INTERNAL_UNSTABLE ), - // Whitelists "identity-like" conversion methods to suggest on type mismatch. - rustc_attr!(rustc_conversion_suggestion, Whitelisted, template!(Word), INTERNAL_UNSTABLE), + // Enumerates "identity-like" conversion methods to suggest on type mismatch. + rustc_attr!(rustc_conversion_suggestion, AssumedUsed, template!(Word), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Const related: // ========================================================================== - rustc_attr!(rustc_promotable, Whitelisted, template!(Word), IMPL_DETAIL), - rustc_attr!(rustc_allow_const_fn_ptr, Whitelisted, template!(Word), IMPL_DETAIL), - rustc_attr!(rustc_args_required_const, Whitelisted, template!(List: "N"), INTERNAL_UNSTABLE), + rustc_attr!(rustc_promotable, AssumedUsed, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_allow_const_fn_ptr, AssumedUsed, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_args_required_const, AssumedUsed, template!(List: "N"), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Layout related: // ========================================================================== rustc_attr!( - rustc_layout_scalar_valid_range_start, Whitelisted, template!(List: "value"), + rustc_layout_scalar_valid_range_start, AssumedUsed, template!(List: "value"), "the `#[rustc_layout_scalar_valid_range_start]` attribute is just used to enable \ niche optimizations in libcore and will never be stable", ), rustc_attr!( - rustc_layout_scalar_valid_range_end, Whitelisted, template!(List: "value"), + rustc_layout_scalar_valid_range_end, AssumedUsed, template!(List: "value"), "the `#[rustc_layout_scalar_valid_range_end]` attribute is just used to enable \ niche optimizations in libcore and will never be stable", ), rustc_attr!( - rustc_nonnull_optimization_guaranteed, Whitelisted, template!(Word), + rustc_nonnull_optimization_guaranteed, AssumedUsed, template!(Word), "the `#[rustc_nonnull_optimization_guaranteed]` attribute is just used to enable \ niche optimizations in libcore and will never be stable", ), @@ -501,7 +501,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ), gated!( // Used in resolve: - prelude_import, Whitelisted, template!(Word), + prelude_import, AssumedUsed, template!(Word), "`#[prelude_import]` is for use by rustc only", ), gated!( @@ -509,7 +509,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ "unboxed_closures are still evolving", ), rustc_attr!( - rustc_inherit_overflow_checks, Whitelisted, template!(Word), + rustc_inherit_overflow_checks, AssumedUsed, template!(Word), "the `#[rustc_inherit_overflow_checks]` attribute is just used to control \ overflow checking behavior of several libcore functions that are inlined \ across crates and will never be stable", @@ -540,42 +540,42 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ rustc_attr!(TEST, rustc_layout, Normal, template!(List: "field1, field2, ...")), rustc_attr!(TEST, rustc_regions, Normal, template!(Word)), rustc_attr!( - TEST, rustc_error, Whitelisted, + TEST, rustc_error, AssumedUsed, template!(Word, List: "delay_span_bug_from_inside_query") ), - rustc_attr!(TEST, rustc_dump_user_substs, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_if_this_changed, Whitelisted, template!(Word, List: "DepNode")), - rustc_attr!(TEST, rustc_then_this_would_need, Whitelisted, template!(List: "DepNode")), + rustc_attr!(TEST, rustc_dump_user_substs, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_if_this_changed, AssumedUsed, template!(Word, List: "DepNode")), + rustc_attr!(TEST, rustc_then_this_would_need, AssumedUsed, template!(List: "DepNode")), rustc_attr!( - TEST, rustc_dirty, Whitelisted, + TEST, rustc_dirty, AssumedUsed, template!(List: r#"cfg = "...", /*opt*/ label = "...", /*opt*/ except = "...""#), ), rustc_attr!( - TEST, rustc_clean, Whitelisted, + TEST, rustc_clean, AssumedUsed, template!(List: r#"cfg = "...", /*opt*/ label = "...", /*opt*/ except = "...""#), ), rustc_attr!( - TEST, rustc_partition_reused, Whitelisted, + TEST, rustc_partition_reused, AssumedUsed, template!(List: r#"cfg = "...", module = "...""#), ), rustc_attr!( - TEST, rustc_partition_codegened, Whitelisted, + TEST, rustc_partition_codegened, AssumedUsed, template!(List: r#"cfg = "...", module = "...""#), ), rustc_attr!( - TEST, rustc_expected_cgu_reuse, Whitelisted, + TEST, rustc_expected_cgu_reuse, AssumedUsed, template!(List: r#"cfg = "...", module = "...", kind = "...""#), ), - rustc_attr!(TEST, rustc_synthetic, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_symbol_name, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_def_path, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_mir, Whitelisted, template!(List: "arg1, arg2, ...")), - rustc_attr!(TEST, rustc_dump_program_clauses, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_dump_env_program_clauses, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_object_lifetime_default, Whitelisted, template!(Word)), + rustc_attr!(TEST, rustc_synthetic, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_symbol_name, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_def_path, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_mir, AssumedUsed, template!(List: "arg1, arg2, ...")), + rustc_attr!(TEST, rustc_dump_program_clauses, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_dump_env_program_clauses, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_object_lifetime_default, AssumedUsed, template!(Word)), rustc_attr!(TEST, rustc_dummy, Normal, template!(Word /* doesn't matter*/)), gated!( - omit_gdb_pretty_printer_section, Whitelisted, template!(Word), + omit_gdb_pretty_printer_section, AssumedUsed, template!(Word), "the `#[omit_gdb_pretty_printer_section]` attribute is just used for the Rust test suite", ), ]; diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 2ee95174dffe6..043aff90ce404 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -168,7 +168,7 @@ pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) { // Note that we cannot use the existing "unused attribute"-infrastructure // here, since that is running before codegen. This is also the reason why - // all codegen-specific attributes are `Whitelisted` in rustc_ast::feature_gate. + // all codegen-specific attributes are `AssumedUsed` in rustc_ast::feature_gate. all_attrs.report_unchecked_attrs(&dirty_clean_visitor.checked_attrs); }) } diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index fe091e920627c..5f6f7ce04e950 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -38,8 +38,8 @@ use std::{panic, thread}; /// Adds `target_feature = "..."` cfgs for a variety of platform /// specific features (SSE, NEON etc.). /// -/// This is performed by checking whether a whitelisted set of -/// features is available on the target machine, by querying LLVM. +/// This is performed by checking whether a set of permitted features +/// is available on the target machine, by querying LLVM. pub fn add_configuration( cfg: &mut CrateConfig, sess: &mut Session, diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index c407f608a14c5..2431f7ba54b36 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -287,8 +287,8 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAttributes { let attr_info = attr.ident().and_then(|ident| self.builtin_attributes.get(&ident.name)); if let Some(&&(name, ty, ..)) = attr_info { - if let AttributeType::Whitelisted = ty { - debug!("{:?} is Whitelisted", name); + if let AttributeType::AssumedUsed = ty { + debug!("{:?} is AssumedUsed", name); return; } } diff --git a/src/librustc_metadata/rmeta/decoder.rs b/src/librustc_metadata/rmeta/decoder.rs index 1ac16e0d31193..4746e53ce59a9 100644 --- a/src/librustc_metadata/rmeta/decoder.rs +++ b/src/librustc_metadata/rmeta/decoder.rs @@ -1386,9 +1386,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { let constness = match self.kind(id) { EntryKind::AssocFn(data) => data.decode(self).fn_data.constness, EntryKind::Fn(data) => data.decode(self).constness, - // Some intrinsics can be const fn. While we could recompute this (at least until we - // stop having hardcoded whitelists and move to stability attributes), it seems cleaner - // to treat all const fns equally. EntryKind::ForeignFn(data) => data.decode(self).constness, EntryKind::Variant(..) | EntryKind::Struct(..) => hir::Constness::Const, _ => hir::Constness::NotConst, diff --git a/src/librustc_middle/lint.rs b/src/librustc_middle/lint.rs index bb62c1bb82428..3f0939239e85c 100644 --- a/src/librustc_middle/lint.rs +++ b/src/librustc_middle/lint.rs @@ -230,8 +230,9 @@ pub fn struct_lint_level<'s, 'd>( err.allow_suggestions(false); // If this is a future incompatible lint it'll become a hard error, so - // we have to emit *something*. Also allow lints to whitelist themselves - // on a case-by-case basis for emission in a foreign macro. + // we have to emit *something*. Also, if this lint occurs in the + // expansion of a macro from an external crate, allow individual lints + // to opt-out from being reported. if future_incompatible.is_none() && !lint.report_in_external_macro { err.cancel(); // Don't continue further, since we don't want to have diff --git a/src/librustc_middle/middle/lang_items.rs b/src/librustc_middle/middle/lang_items.rs index 0f98c338c16b1..70c90198276c1 100644 --- a/src/librustc_middle/middle/lang_items.rs +++ b/src/librustc_middle/middle/lang_items.rs @@ -42,19 +42,18 @@ impl<'tcx> TyCtxt<'tcx> { } } -/// Returns `true` if the specified `lang_item` doesn't actually need to be -/// present for this compilation. +/// Returns `true` if the specified `lang_item` must be present for this +/// compilation. /// /// Not all lang items are always required for each compilation, particularly in /// the case of panic=abort. In these situations some lang items are injected by /// crates and don't actually need to be defined in libstd. -pub fn whitelisted(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool { +pub fn required(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool { // If we're not compiling with unwinding, we won't actually need these // symbols. Other panic runtimes ensure that the relevant symbols are // available to link things together, but they're never exercised. - if tcx.sess.panic_strategy() != PanicStrategy::Unwind { - return lang_item == LangItem::EhPersonalityLangItem; + match tcx.sess.panic_strategy() { + PanicStrategy::Abort => lang_item != LangItem::EhPersonalityLangItem, + PanicStrategy::Unwind => true, } - - false } diff --git a/src/librustc_middle/query/mod.rs b/src/librustc_middle/query/mod.rs index 3285be555d30f..0faf389aa385c 100644 --- a/src/librustc_middle/query/mod.rs +++ b/src/librustc_middle/query/mod.rs @@ -1413,10 +1413,10 @@ rustc_queries! { } Other { - query target_features_whitelist(_: CrateNum) -> FxHashMap> { + query supported_target_features(_: CrateNum) -> FxHashMap> { storage(ArenaCacheSelector<'tcx>) eval_always - desc { "looking up the whitelist of target features" } + desc { "looking up supported target features" } } // Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning. diff --git a/src/librustc_mir/const_eval/fn_queries.rs b/src/librustc_mir/const_eval/fn_queries.rs index daa458f70f9a7..70ddd79ee40b0 100644 --- a/src/librustc_mir/const_eval/fn_queries.rs +++ b/src/librustc_mir/const_eval/fn_queries.rs @@ -88,7 +88,7 @@ pub fn is_parent_const_impl_raw(tcx: TyCtxt<'_>, hir_id: hir::HirId) -> bool { } /// Checks whether the function has a `const` modifier or, in case it is an intrinsic, whether -/// said intrinsic is on the whitelist for being const callable. +/// said intrinsic has a `rustc_const_{un,}stable` attribute. fn is_const_fn_raw(tcx: TyCtxt<'_>, def_id: DefId) -> bool { let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs index ab836595a7acc..f95ac309424d0 100644 --- a/src/librustc_mir/interpret/validity.rs +++ b/src/librustc_mir/interpret/validity.rs @@ -45,7 +45,7 @@ macro_rules! throw_validation_failure { /// If $e throws an error matching the pattern, throw a validation failure. /// Other errors are passed back to the caller, unchanged -- and if they reach the root of /// the visitor, we make sure only validation errors and `InvalidProgram` errors are left. -/// This lets you use the patterns as a kind of validation whitelist, asserting which errors +/// This lets you use the patterns as a kind of validation list, asserting which errors /// can possibly happen: /// /// ``` diff --git a/src/librustc_passes/weak_lang_items.rs b/src/librustc_passes/weak_lang_items.rs index f2f07b5d4fb26..12925af8170f0 100644 --- a/src/librustc_passes/weak_lang_items.rs +++ b/src/librustc_passes/weak_lang_items.rs @@ -7,7 +7,7 @@ use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_hir::lang_items; use rustc_hir::lang_items::ITEM_REFS; use rustc_hir::weak_lang_items::WEAK_ITEMS_REFS; -use rustc_middle::middle::lang_items::whitelisted; +use rustc_middle::middle::lang_items::required; use rustc_middle::ty::TyCtxt; use rustc_session::config::CrateType; use rustc_span::symbol::sym; @@ -59,7 +59,7 @@ fn verify<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) { } for (name, &item) in WEAK_ITEMS_REFS.iter() { - if missing.contains(&item) && !whitelisted(tcx, item) && items.require(item).is_err() { + if missing.contains(&item) && required(tcx, item) && items.require(item).is_err() { if item == lang_items::PanicImplLangItem { tcx.sess.err("`#[panic_handler]` function required, but not found"); } else if item == lang_items::OomLangItem { diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs index e9b917168d67b..1467bf537eb49 100644 --- a/src/librustc_resolve/late/lifetimes.rs +++ b/src/librustc_resolve/late/lifetimes.rs @@ -2122,7 +2122,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { self.impl_self { match path.res { - // Whitelist the types that unambiguously always + // Permit the types that unambiguously always // result in the same type constructor being used // (it can't differ between `Self` and `self`). Res::Def(DefKind::Struct | DefKind::Union | DefKind::Enum, _) diff --git a/src/librustc_target/spec/tests/tests_impl.rs b/src/librustc_target/spec/tests/tests_impl.rs index b2ad62e1b260b..b2c2b8254d8f0 100644 --- a/src/librustc_target/spec/tests/tests_impl.rs +++ b/src/librustc_target/spec/tests/tests_impl.rs @@ -16,8 +16,8 @@ pub(super) fn test_target(target: TargetResult) { impl Target { fn check_consistency(&self) { // Check that LLD with the given flavor is treated identically to the linker it emulates. - // If you target really needs to deviate from the rules below, whitelist it - // and document the reasons. + // If your target really needs to deviate from the rules below, except it and document the + // reasons. assert_eq!( self.linker_flavor == LinkerFlavor::Msvc || self.linker_flavor == LinkerFlavor::Lld(LldFlavor::Link), diff --git a/src/librustc_target/spec/wasm32_base.rs b/src/librustc_target/spec/wasm32_base.rs index d4a65aa1a2574..8423573b52d51 100644 --- a/src/librustc_target/spec/wasm32_base.rs +++ b/src/librustc_target/spec/wasm32_base.rs @@ -40,14 +40,14 @@ pub fn options() -> TargetOptions { // corrupting static data. arg("--stack-first"); - // FIXME we probably shouldn't pass this but instead pass an explicit - // whitelist of symbols we'll allow to be undefined. We don't currently have - // a mechanism of knowing, however, which symbols are intended to be - // imported from the environment and which are intended to be imported from - // other objects linked elsewhere. This is a coarse approximation but is - // sure to hide some bugs and frustrate someone at some point, so we should - // ideally work towards a world where we can explicitly list symbols that - // are supposed to be imported and have all other symbols generate errors if + // FIXME we probably shouldn't pass this but instead pass an explicit list + // of symbols we'll allow to be undefined. We don't currently have a + // mechanism of knowing, however, which symbols are intended to be imported + // from the environment and which are intended to be imported from other + // objects linked elsewhere. This is a coarse approximation but is sure to + // hide some bugs and frustrate someone at some point, so we should ideally + // work towards a world where we can explicitly list symbols that are + // supposed to be imported and have all other symbols generate errors if // they remain undefined. arg("--allow-undefined"); diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs index cdfe5f9f92db0..d677d84b2ba13 100644 --- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs +++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs @@ -2139,7 +2139,7 @@ pub trait NextTypeParamName { impl NextTypeParamName for &[hir::GenericParam<'_>] { fn next_type_param_name(&self, name: Option<&str>) -> String { - // This is the whitelist of possible parameter names that we might suggest. + // This is the list of possible parameter names that we might suggest. let name = name.and_then(|n| n.chars().next()).map(|c| c.to_string().to_uppercase()); let name = name.as_deref(); let possible_names = [name.unwrap_or("T"), "T", "U", "V", "X", "Y", "Z", "A", "B", "C"]; diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 85c073ca30034..9a9630f095886 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -236,7 +236,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .tcx .get_attrs(m.def_id) .iter() - // This special internal attribute is used to whitelist + // This special internal attribute is used to permit // "identity-like" conversion methods to be suggested here. // // FIXME (#46459 and #46460): ideally diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index 1eaa5a6c31e20..e6b51f4c2cd2a 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -913,7 +913,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let ty::Adt(..) = rcvr_t.kind { // Try alternative arbitrary self types that could fulfill this call. // FIXME: probe for all types that *could* be arbitrary self-types, not - // just this whitelist. + // just this list. try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::OwnedBoxLangItem)); try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::PinTypeLangItem)); try_alt_rcvr(&mut err, self.tcx.mk_diagnostic_item(rcvr_t, sym::Arc)); @@ -1806,7 +1806,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // If this is an input value, we require its type to be fully resolved // at this point. This allows us to provide helpful coercions which help - // pass the type whitelist in a later pass. + // pass the type candidate list in a later pass. // // We don't require output types to be resolved at this point, which // allows them to be inferred based on how they are used later in the diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 4f88836118d52..15481660a5218 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -2150,7 +2150,7 @@ fn from_target_feature( tcx: TyCtxt<'_>, id: DefId, attr: &ast::Attribute, - whitelist: &FxHashMap>, + supported_target_features: &FxHashMap>, target_features: &mut Vec, ) { let list = match attr.meta_item_list() { @@ -2184,8 +2184,7 @@ fn from_target_feature( // We allow comma separation to enable multiple features. target_features.extend(value.as_str().split(',').filter_map(|feature| { - // Only allow whitelisted features per platform. - let feature_gate = match whitelist.get(feature) { + let feature_gate = match supported_target_features.get(feature) { Some(g) => g, None => { let msg = @@ -2196,7 +2195,7 @@ fn from_target_feature( format!("`{}` is not valid for this target", feature), ); if feature.starts_with('+') { - let valid = whitelist.contains_key(&feature[1..]); + let valid = supported_target_features.contains_key(&feature[1..]); if valid { err.help("consider removing the leading `+` in the feature name"); } @@ -2246,9 +2245,9 @@ fn linkage_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Linkage { // Use the names from src/llvm/docs/LangRef.rst here. Most types are only // applicable to variable declarations and may not really make sense for - // Rust code in the first place but whitelist them anyway and trust that - // the user knows what s/he's doing. Who knows, unanticipated use cases - // may pop up in the future. + // Rust code in the first place but allow them anyway and trust that the + // user knows what s/he's doing. Who knows, unanticipated use cases may pop + // up in the future. // // ghost, dllimport, dllexport and linkonce_odr_autohide are not supported // and don't have to be, LLVM treats them as no-ops. @@ -2283,7 +2282,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs { codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER; } - let whitelist = tcx.target_features_whitelist(LOCAL_CRATE); + let supported_target_features = tcx.supported_target_features(LOCAL_CRATE); let mut inline_span = None; let mut link_ordinal_span = None; @@ -2386,7 +2385,13 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs { check_target_feature_trait_unsafe(tcx, local_id, attr.span); } } - from_target_feature(tcx, id, attr, &whitelist, &mut codegen_fn_attrs.target_features); + from_target_feature( + tcx, + id, + attr, + &supported_target_features, + &mut codegen_fn_attrs.target_features, + ); } else if attr.check_name(sym::linkage) { if let Some(val) = attr.value_str() { codegen_fn_attrs.linkage = Some(linkage_by_name(tcx, id, &val.as_str())); diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index db98ec5d0a72e..6dcb3b00070ca 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -225,7 +225,7 @@ pub fn new_handler( /// * Vector of tuples of lints' name and their associated "max" level /// * HashMap of lint id with their associated "max" level pub fn init_lints( - mut whitelisted_lints: Vec, + mut allowed_lints: Vec, lint_opts: Vec<(String, lint::Level)>, filter_call: F, ) -> (Vec<(String, lint::Level)>, FxHashMap) @@ -234,8 +234,8 @@ where { let warnings_lint_name = lint::builtin::WARNINGS.name; - whitelisted_lints.push(warnings_lint_name.to_owned()); - whitelisted_lints.extend(lint_opts.iter().map(|(lint, _)| lint).cloned()); + allowed_lints.push(warnings_lint_name.to_owned()); + allowed_lints.extend(lint_opts.iter().map(|(lint, _)| lint).cloned()); let lints = || { lint::builtin::HardwiredLints::get_lints() @@ -245,7 +245,7 @@ where let lint_opts = lints() .filter_map(|lint| { - // Whitelist feature-gated lints to avoid feature errors when trying to + // Permit feature-gated lints to avoid feature errors when trying to // allow all lints. if lint.name == warnings_lint_name || lint.feature_gate.is_some() { None @@ -258,9 +258,9 @@ where let lint_caps = lints() .filter_map(|lint| { - // We don't want to whitelist *all* lints so let's - // ignore those ones. - if whitelisted_lints.iter().any(|l| lint.name == l) { + // We don't want to allow *all* lints so let's ignore + // those ones. + if allowed_lints.iter().any(|l| lint.name == l) { None } else { Some((lint::LintId::of(lint), lint::Allow)) @@ -317,9 +317,9 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt let no_crate_level_docs = rustc_lint::builtin::MISSING_CRATE_LEVEL_DOCS.name; let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES.name; - // In addition to those specific lints, we also need to whitelist those given through + // In addition to those specific lints, we also need to allow those given through // command line, otherwise they'll get ignored and we don't want that. - let whitelisted_lints = vec![ + let allowed_lints = vec![ intra_link_resolution_failure_name.to_owned(), missing_docs.to_owned(), missing_doc_example.to_owned(), @@ -328,7 +328,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt invalid_codeblock_attribute_name.to_owned(), ]; - let (lint_opts, lint_caps) = init_lints(whitelisted_lints, lint_opts, |lint| { + let (lint_opts, lint_caps) = init_lints(allowed_lints, lint_opts, |lint| { if lint.name == intra_link_resolution_failure_name || lint.name == invalid_codeblock_attribute_name { diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index f769a0920d16b..8bba21a2e7ace 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -3151,7 +3151,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum) { render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All) } -const ATTRIBUTE_WHITELIST: &[Symbol] = &[ +const ALLOWED_ATTRIBUTES: &[Symbol] = &[ sym::export_name, sym::lang, sym::link_section, @@ -3173,7 +3173,7 @@ fn render_attributes(w: &mut Buffer, it: &clean::Item, top: bool) { let mut attrs = String::new(); for attr in &it.attrs.other_attrs { - if !ATTRIBUTE_WHITELIST.contains(&attr.name_or_empty()) { + if !ALLOWED_ATTRIBUTES.contains(&attr.name_or_empty()) { continue; } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index b40a5ef595009..c2d644bdd05f1 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -47,11 +47,11 @@ pub fn run(options: Options) -> Result<(), String> { let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES.name; - // In addition to those specific lints, we also need to whitelist those given through + // In addition to those specific lints, we also need to allow those given through // command line, otherwise they'll get ignored and we don't want that. - let whitelisted_lints = vec![invalid_codeblock_attribute_name.to_owned()]; + let allowed_lints = vec![invalid_codeblock_attribute_name.to_owned()]; - let (lint_opts, lint_caps) = init_lints(whitelisted_lints, options.lint_opts.clone(), |lint| { + let (lint_opts, lint_caps) = init_lints(allowed_lints, options.lint_opts.clone(), |lint| { if lint.name == invalid_codeblock_attribute_name { None } else { diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 84fa35e01bb09..9f4fa89cd5506 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -241,7 +241,7 @@ impl Instant { // returned instead of what the OS says if the OS goes backwards. // // To hopefully mitigate the impact of this, a few platforms are - // whitelisted as "these at least haven't gone backwards yet". + // excluded as "these at least haven't gone backwards yet". if time::Instant::actually_monotonic() { return Instant(os_now); } 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 efc62361694a5..dd49ca67c6748 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 @@ -52,7 +52,7 @@ impl CodegenBackend for TheBackend { fn provide(&self, providers: &mut Providers) { rustc_symbol_mangling::provide(providers); - providers.target_features_whitelist = |tcx, _cnum| { + providers.supported_target_features = |tcx, _cnum| { Default::default() // Just a dummy }; providers.is_reachable_non_generic = |_tcx, _defid| true; diff --git a/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py b/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py index 927edff4c22a5..f479bdabb9c0c 100644 --- a/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py +++ b/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py @@ -5,7 +5,7 @@ from subprocess import PIPE, Popen -# This is a whitelist of files which are stable crates or simply are not crates, +# This is n list of files which are stable crates or simply are not crates, # we don't check for the instability of these crates as they're all stable! STABLE_CRATES = ['std', 'alloc', 'core', 'proc_macro', 'rsbegin.o', 'rsend.o', 'dllcrt2.o', 'crt2.o', 'clang_rt'] diff --git a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs index 9ba2675477878..4e9d4d342734c 100644 --- a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs +++ b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs @@ -21,19 +21,19 @@ use rustc_span::source_map; #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { - reg.lint_store.register_lints(&[&MISSING_WHITELISTED_ATTR]); - reg.lint_store.register_late_pass(|| box MissingWhitelistedAttrPass); + reg.lint_store.register_lints(&[&MISSING_ALLOWED_ATTR]); + reg.lint_store.register_late_pass(|| box MissingAllowedAttrPass); } declare_lint! { - MISSING_WHITELISTED_ATTR, + MISSING_ALLOWED_ATTR, Deny, - "Checks for missing `whitelisted_attr` attribute" + "Checks for missing `allowed_attr` attribute" } -declare_lint_pass!(MissingWhitelistedAttrPass => [MISSING_WHITELISTED_ATTR]); +declare_lint_pass!(MissingAllowedAttrPass => [MISSING_ALLOWED_ATTR]); -impl<'tcx> LateLintPass<'tcx> for MissingWhitelistedAttrPass { +impl<'tcx> LateLintPass<'tcx> for MissingAllowedAttrPass { fn check_fn( &mut self, cx: &LateContext<'tcx>, @@ -48,10 +48,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingWhitelistedAttrPass { _ => cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(id)), }; - let whitelisted = |attr| pprust::attribute_to_string(attr).contains("whitelisted_attr"); - if !item.attrs.iter().any(whitelisted) { - cx.lint(MISSING_WHITELISTED_ATTR, |lint| { - lint.build("Missing 'whitelisted_attr' attribute").set_span(span).emit() + let allowed = |attr| pprust::attribute_to_string(attr).contains("allowed_attr"); + if !item.attrs.iter().any(allowed) { + cx.lint(MISSING_ALLOWED_ATTR, |lint| { + lint.build("Missing 'allowed_attr' attribute").set_span(span).emit() }); } } diff --git a/src/test/ui-fulldeps/issue-40001.rs b/src/test/ui-fulldeps/issue-40001.rs index c3f98197250d1..e14338fdbbf35 100644 --- a/src/test/ui-fulldeps/issue-40001.rs +++ b/src/test/ui-fulldeps/issue-40001.rs @@ -6,5 +6,5 @@ #![plugin(issue_40001_plugin)] //~ WARNING compiler plugins are deprecated #![register_tool(plugin)] -#[plugin::whitelisted_attr] +#[plugin::allowed_attr] fn main() {} diff --git a/src/test/ui/asm/type-check-3.rs b/src/test/ui/asm/type-check-3.rs index 5de15fe49067a..0f803eff17b8a 100644 --- a/src/test/ui/asm/type-check-3.rs +++ b/src/test/ui/asm/type-check-3.rs @@ -7,7 +7,7 @@ use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps}; fn main() { unsafe { - // Types must be in the whitelist for the register class + // Types must be listed in the register class. asm!("{}", in(reg) 0i128); //~^ ERROR type `i128` cannot be used with this register class diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs b/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs index b3b9aeb8028e1..1fb5878ca2ace 100644 --- a/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs +++ b/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs @@ -1,7 +1,7 @@ // edition:2018 -// Tests that `meta` is whitelisted, even if the crate doesn't exist -// yet (i.e., it causes a different error than `not-whitelisted.rs`). +// Tests that `meta` is allowed, even if the crate doesn't exist +// yet (i.e., it causes a different error than `not-allowed.rs`). use meta; //~ ERROR can't find crate for `meta` fn main() {} diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.rs b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.rs similarity index 100% rename from src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.rs rename to src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.rs diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr similarity index 86% rename from src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr rename to src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr index f324378d4ca68..6d2b4508a0592 100644 --- a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr +++ b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr @@ -1,5 +1,5 @@ error[E0432]: unresolved import `alloc` - --> $DIR/not-whitelisted.rs:5:5 + --> $DIR/not-allowed.rs:5:5 | LL | use alloc; | ^^^^^ no `alloc` external crate diff --git a/src/test/ui/sse2.rs b/src/test/ui/sse2.rs index 74f112464c75d..7726972b95b64 100644 --- a/src/test/ui/sse2.rs +++ b/src/test/ui/sse2.rs @@ -20,7 +20,7 @@ fn main() { assert!(cfg!(target_feature = "sse2"), "SSE2 was not detected as available on an x86 platform"); } - // check a negative case too -- whitelisted on x86, but not enabled by default + // check a negative case too -- allowed on x86, but not enabled by default assert!(cfg!(not(target_feature = "avx2")), "AVX2 shouldn't be detected as available by default on any platform"); } diff --git a/src/tools/clippy/clippy_lints/src/attrs.rs b/src/tools/clippy/clippy_lints/src/attrs.rs index 2505ff32fe523..3f7d6ba646770 100644 --- a/src/tools/clippy/clippy_lints/src/attrs.rs +++ b/src/tools/clippy/clippy_lints/src/attrs.rs @@ -72,7 +72,7 @@ declare_clippy_lint! { /// **What it does:** Checks for `extern crate` and `use` items annotated with /// lint attributes. /// - /// This lint whitelists `#[allow(unused_imports)]`, `#[allow(deprecated)]` and + /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]` and /// `#[allow(unreachable_pub)]` on `use` items and `#[allow(unused_imports)]` on /// `extern crate` items with a `#[macro_use]` attribute. /// @@ -294,7 +294,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes { if let Some(ident) = attr.ident() { match &*ident.as_str() { "allow" | "warn" | "deny" | "forbid" => { - // whitelist `unused_imports`, `deprecated` and `unreachable_pub` for `use` items + // permit `unused_imports`, `deprecated` and `unreachable_pub` for `use` items // and `unused_imports` for `extern crate` items with `macro_use` for lint in lint_list { match item.kind { diff --git a/src/tools/clippy/clippy_lints/src/eq_op.rs b/src/tools/clippy/clippy_lints/src/eq_op.rs index ca921dcfdfe92..cbc93d772dd91 100644 --- a/src/tools/clippy/clippy_lints/src/eq_op.rs +++ b/src/tools/clippy/clippy_lints/src/eq_op.rs @@ -16,7 +16,7 @@ declare_clippy_lint! { /// **Known problems:** False negatives: We had some false positives regarding /// calls (notably [racer](https://github.com/phildawes/racer) had one instance /// of `x.pop() && x.pop()`), so we removed matching any function or method - /// calls. We may introduce a whitelist of known pure functions in the future. + /// calls. We may introduce a list of known pure functions in the future. /// /// **Example:** /// ```rust diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs index 5d47f9425e3ef..29e5d4d166498 100644 --- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs +++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs @@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { // Allow `Borrow` or functions to be taken by value let borrow_trait = need!(get_trait_def_id(cx, &paths::BORROW_TRAIT)); - let whitelisted_traits = [ + let allowed_traits = [ need!(cx.tcx.lang_items().fn_trait()), need!(cx.tcx.lang_items().fn_once_trait()), need!(cx.tcx.lang_items().fn_mut_trait()), @@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { if !is_self(arg); if !ty.is_mutable_ptr(); if !is_copy(cx, ty); - if !whitelisted_traits.iter().any(|&t| implements_trait(cx, ty, t, &[])); + if !allowed_traits.iter().any(|&t| implements_trait(cx, ty, t, &[])); if !implements_borrow_trait; if !all_borrowable_trait; diff --git a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs index 5f14fe97afefa..7128fee9bcf51 100644 --- a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs +++ b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs @@ -78,7 +78,7 @@ struct ExistingName { interned: SymbolStr, span: Span, len: usize, - whitelist: &'static [&'static str], + exemptions: &'static [&'static str], } struct SimilarNamesLocalVisitor<'a, 'tcx> { @@ -117,7 +117,7 @@ impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> { // this list contains lists of names that are allowed to be similar // the assumption is that no name is ever contained in multiple lists. #[rustfmt::skip] -const WHITELIST: &[&[&str]] = &[ +const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[ &["parsed", "parser"], &["lhs", "rhs"], &["tx", "rx"], @@ -156,17 +156,17 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> { } #[must_use] -fn get_whitelist(interned_name: &str) -> Option<&'static [&'static str]> { - for &allow in WHITELIST { - if whitelisted(interned_name, allow) { - return Some(allow); +fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> { + for &list in ALLOWED_TO_BE_SIMILAR { + if allowed_to_be_similar(interned_name, list) { + return Some(list); } } None } #[must_use] -fn whitelisted(interned_name: &str, list: &[&str]) -> bool { +fn allowed_to_be_similar(interned_name: &str, list: &[&str]) -> bool { list.iter() .any(|&name| interned_name.starts_with(name) || interned_name.ends_with(name)) } @@ -212,7 +212,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { return; } for existing_name in &self.0.names { - if whitelisted(&interned_name, existing_name.whitelist) { + if allowed_to_be_similar(&interned_name, existing_name.exemptions) { continue; } let mut split_at = None; @@ -301,7 +301,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { return; } self.0.names.push(ExistingName { - whitelist: get_whitelist(&interned_name).unwrap_or(&[]), + exemptions: get_exemptions(&interned_name).unwrap_or(&[]), interned: interned_name, span: ident.span, len: count, diff --git a/src/tools/clippy/clippy_lints/src/precedence.rs b/src/tools/clippy/clippy_lints/src/precedence.rs index 7dce23dd22306..23793678fa0e2 100644 --- a/src/tools/clippy/clippy_lints/src/precedence.rs +++ b/src/tools/clippy/clippy_lints/src/precedence.rs @@ -5,7 +5,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; -const ODD_FUNCTIONS_WHITELIST: [&str; 14] = [ +const ALLOWED_ODD_FUNCTIONS: [&str; 14] = [ "asin", "asinh", "atan", @@ -109,7 +109,7 @@ impl EarlyLintPass for Precedence { if let ExprKind::Lit(ref lit) = slf.kind { match lit.kind { LitKind::Int(..) | LitKind::Float(..) => { - if ODD_FUNCTIONS_WHITELIST + if ALLOWED_ODD_FUNCTIONS .iter() .any(|odd_function| **odd_function == *path_segment_str) { diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs index b1345f0de5e4b..68f51f0afdccd 100644 --- a/src/tools/clippy/clippy_lints/src/types.rs +++ b/src/tools/clippy/clippy_lints/src/types.rs @@ -1256,7 +1256,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast // don't lint for the result of methods that always return non-negative values if let ExprKind::MethodCall(ref path, _, _, _) = op.kind { let mut method_name = path.ident.name.as_str(); - let whitelisted_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"]; + let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"]; if_chain! { if method_name == "unwrap"; @@ -1267,7 +1267,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast } } - if whitelisted_methods.iter().any(|&name| method_name == name) { + if allowed_methods.iter().any(|&name| method_name == name) { return; } } diff --git a/src/tools/clippy/tests/ui/crashes/whitelist/clippy.toml b/src/tools/clippy/tests/ui/crashes/third-party/clippy.toml similarity index 100% rename from src/tools/clippy/tests/ui/crashes/whitelist/clippy.toml rename to src/tools/clippy/tests/ui/crashes/third-party/clippy.toml diff --git a/src/tools/clippy/tests/ui/crashes/whitelist/conf_whitelisted.rs b/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs similarity index 100% rename from src/tools/clippy/tests/ui/crashes/whitelist/conf_whitelisted.rs rename to src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs diff --git a/src/tools/clippy/tests/ui/needless_pass_by_value.rs b/src/tools/clippy/tests/ui/needless_pass_by_value.rs index e93a7fe2985b3..7a9ba55590dce 100644 --- a/src/tools/clippy/tests/ui/needless_pass_by_value.rs +++ b/src/tools/clippy/tests/ui/needless_pass_by_value.rs @@ -116,7 +116,7 @@ extern "C" fn ext(x: MaybeUninit) -> usize { unsafe { x.assume_init() } } -// whitelist RangeArgument +// exempt RangeArgument fn range>(range: T) { let _ = range.start_bound(); } diff --git a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs index ca70e3b7148ef..0b47119527247 100644 --- a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs +++ b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs @@ -57,6 +57,6 @@ fn main() { // The macro always negates the result of the given comparison in its // internal check which automatically triggered the lint. As it's an // external macro there was no chance to do anything about it which led - // to a whitelisting of all external macros. + // to an exempting of all external macros. assert!(a_value < another_value); } diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs index 9e4e2c433fbed..74601f9e4c679 100644 --- a/src/tools/linkchecker/main.rs +++ b/src/tools/linkchecker/main.rs @@ -11,8 +11,8 @@ //! These values are then translated to file URLs if possible and then the //! destination is asserted to exist. //! -//! A few whitelisted exceptions are allowed as there's known bugs in rustdoc, -//! but this should catch the majority of "broken link" cases. +//! A few exceptions are allowed as there's known bugs in rustdoc, but this +//! should catch the majority of "broken link" cases. use std::collections::hash_map::Entry; use std::collections::{HashMap, HashSet}; @@ -118,7 +118,7 @@ fn check(cache: &mut Cache, root: &Path, file: &Path, errors: &mut bool) -> Opti } // Unfortunately we're not 100% full of valid links today to we need a few - // whitelists to get this past `make check` today. + // exceptions to get this past `make check` today. // FIXME(#32129) if file.ends_with("std/io/struct.IoSlice.html") || file.ends_with("std/string/struct.String.html") diff --git a/src/tools/tidy/src/cargo.rs b/src/tools/tidy/src/cargo.rs index 7c45efba5ea08..7bdd78a91e7de 100644 --- a/src/tools/tidy/src/cargo.rs +++ b/src/tools/tidy/src/cargo.rs @@ -73,8 +73,8 @@ fn verify(tomlfile: &Path, libfile: &Path, bad: &mut bool) { // This is intentional -- this dependency just makes the crate available // for others later on. - let whitelisted = krate.starts_with("panic"); - if toml.contains("name = \"std\"") && whitelisted { + let allowed = krate.starts_with("panic"); + if toml.contains("name = \"std\"") && allowed { continue; } diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs index 4622e15a1cae8..b7d3d428cd283 100644 --- a/src/tools/tidy/src/deps.rs +++ b/src/tools/tidy/src/deps.rs @@ -49,14 +49,14 @@ const EXCEPTIONS: &[(&str, &str)] = &[ /// these and all their dependencies *must not* be in the exception list. const RUNTIME_CRATES: &[&str] = &["std", "core", "alloc", "test", "panic_abort", "panic_unwind"]; -/// Which crates to check against the whitelist? -const WHITELIST_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"]; +/// Crates whose dependencies must be explicitly permitted. +const RESTRICTED_DEPENDENCY_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"]; -/// Whitelist of crates rustc is allowed to depend on. Avoid adding to the list if possible. +/// Crates rustc is allowed to depend on. Avoid adding to the list if possible. /// /// This list is here to provide a speed-bump to adding a new dependency to /// rustc. Please check with the compiler team before adding an entry. -const WHITELIST: &[&str] = &[ +const PERMITTED_DEPENDENCIES: &[&str] = &[ "adler32", "aho-corasick", "annotate-snippets", @@ -190,7 +190,7 @@ pub fn check(path: &Path, cargo: &Path, bad: &mut bool) { .features(cargo_metadata::CargoOpt::AllFeatures); let metadata = t!(cmd.exec()); check_exceptions(&metadata, bad); - check_whitelist(&metadata, bad); + check_dependencies(&metadata, bad); check_crate_duplicate(&metadata, bad); } @@ -272,36 +272,37 @@ fn check_exceptions(metadata: &Metadata, bad: &mut bool) { } } -/// Checks the dependency of `WHITELIST_CRATES` at the given path. Changes `bad` to `true` if a -/// check failed. +/// Checks the dependency of `RESTRICTED_DEPENDENCY_CRATES` at the given path. Changes `bad` to +/// `true` if a check failed. /// -/// Specifically, this checks that the dependencies are on the `WHITELIST`. -fn check_whitelist(metadata: &Metadata, bad: &mut bool) { - // Check that the WHITELIST does not have unused entries. - for name in WHITELIST { +/// Specifically, this checks that the dependencies are on the `PERMITTED_DEPENDENCIES`. +fn check_dependencies(metadata: &Metadata, bad: &mut bool) { + // Check that the PERMITTED_DEPENDENCIES does not have unused entries. + for name in PERMITTED_DEPENDENCIES { if !metadata.packages.iter().any(|p| p.name == *name) { println!( - "could not find whitelisted package `{}`\n\ - Remove from WHITELIST list if it is no longer used.", + "could not find allowed package `{}`\n\ + Remove from PERMITTED_DEPENDENCIES list if it is no longer used.", name ); *bad = true; } } - // Get the whitelist in a convenient form. - let whitelist: HashSet<_> = WHITELIST.iter().cloned().collect(); + // Get the list in a convenient form. + let permitted_dependencies: HashSet<_> = PERMITTED_DEPENDENCIES.iter().cloned().collect(); // Check dependencies. let mut visited = BTreeSet::new(); let mut unapproved = BTreeSet::new(); - for &krate in WHITELIST_CRATES.iter() { + for &krate in RESTRICTED_DEPENDENCY_CRATES.iter() { let pkg = pkg_from_name(metadata, krate); - let mut bad = check_crate_whitelist(&whitelist, metadata, &mut visited, pkg); + let mut bad = + check_crate_dependencies(&permitted_dependencies, metadata, &mut visited, pkg); unapproved.append(&mut bad); } if !unapproved.is_empty() { - println!("Dependencies not on the whitelist:"); + println!("Dependencies not explicitly permitted:"); for dep in unapproved { println!("* {}", dep); } @@ -310,9 +311,9 @@ fn check_whitelist(metadata: &Metadata, bad: &mut bool) { } /// Checks the dependencies of the given crate from the given cargo metadata to see if they are on -/// the whitelist. Returns a list of illegal dependencies. -fn check_crate_whitelist<'a>( - whitelist: &'a HashSet<&'static str>, +/// the list of permitted dependencies. Returns a list of disallowed dependencies. +fn check_crate_dependencies<'a>( + permitted_dependencies: &'a HashSet<&'static str>, metadata: &'a Metadata, visited: &mut BTreeSet<&'a PackageId>, krate: &'a Package, @@ -327,10 +328,10 @@ fn check_crate_whitelist<'a>( visited.insert(&krate.id); - // If this path is in-tree, we don't require it to be on the whitelist. + // If this path is in-tree, we don't require it to be explicitly permitted. if krate.source.is_some() { - // If this dependency is not on `WHITELIST`, add to bad set. - if !whitelist.contains(krate.name.as_str()) { + // If this dependency is not on `PERMITTED_DEPENDENCIES`, add to bad set. + if !permitted_dependencies.contains(krate.name.as_str()) { unapproved.insert(&krate.id); } } @@ -339,7 +340,7 @@ fn check_crate_whitelist<'a>( let to_check = deps_of(metadata, &krate.id); for dep in to_check { - let mut bad = check_crate_whitelist(whitelist, metadata, visited, dep); + let mut bad = check_crate_dependencies(permitted_dependencies, metadata, visited, dep); unapproved.append(&mut bad); } diff --git a/src/tools/tidy/src/error_codes_check.rs b/src/tools/tidy/src/error_codes_check.rs index f7fd0c670d704..3af71f69d2457 100644 --- a/src/tools/tidy/src/error_codes_check.rs +++ b/src/tools/tidy/src/error_codes_check.rs @@ -7,7 +7,7 @@ use std::fs::read_to_string; use std::path::Path; // A few of those error codes can't be tested but all the others can and *should* be tested! -const WHITELIST: &[&str] = &[ +const EXEMPTED_FROM_TEST: &[&str] = &[ "E0183", "E0227", "E0279", "E0280", "E0311", "E0313", "E0314", "E0315", "E0377", "E0456", "E0461", "E0462", "E0464", "E0465", "E0472", "E0473", "E0474", "E0475", "E0476", "E0479", "E0480", "E0481", "E0482", "E0483", "E0484", "E0485", "E0486", "E0487", "E0488", "E0489", @@ -166,7 +166,7 @@ pub fn check(path: &Path, bad: &mut bool) { println!("Found {} error codes", error_codes.len()); for (err_code, nb) in &error_codes { - if !*nb && !WHITELIST.contains(&err_code.as_str()) { + if !*nb && !EXEMPTED_FROM_TEST.contains(&err_code.as_str()) { errors.push(format!("Error code {} needs to have at least one UI test!", err_code)); } } diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs index e3f92d4806152..4d666a502a160 100644 --- a/src/tools/tidy/src/extdeps.rs +++ b/src/tools/tidy/src/extdeps.rs @@ -3,8 +3,8 @@ use std::fs; use std::path::Path; -/// List of whitelisted sources for packages. -const WHITELISTED_SOURCES: &[&str] = &["\"registry+https://github.com/rust-lang/crates.io-index\""]; +/// List of allowed sources for packages. +const ALLOWED_SOURCES: &[&str] = &["\"registry+https://github.com/rust-lang/crates.io-index\""]; /// Checks for external package sources. pub fn check(path: &Path, bad: &mut bool) { @@ -24,8 +24,8 @@ pub fn check(path: &Path, bad: &mut bool) { // Extract source value. let source = line.splitn(2, '=').nth(1).unwrap().trim(); - // Ensure source is whitelisted. - if !WHITELISTED_SOURCES.contains(&&*source) { + // Ensure source is allowed. + if !ALLOWED_SOURCES.contains(&&*source) { println!("invalid source: {}", source); *bad = true; }