From 579592514120d90bbe650cdff0b64fb7cb1d0311 Mon Sep 17 00:00:00 2001 From: Lukasz Anforowicz Date: Tue, 28 Nov 2023 17:40:05 +0000 Subject: [PATCH 01/13] Add unstable `-Zdefault-hidden-visibility` cmdline flag for `rustc`. The new flag has been described in the Major Change Proposal at https://github.com/rust-lang/compiler-team/issues/656 --- compiler/rustc_codegen_gcc/src/allocator.rs | 2 +- compiler/rustc_codegen_llvm/src/allocator.rs | 6 ++-- compiler/rustc_codegen_llvm/src/declare.rs | 4 +-- compiler/rustc_interface/src/tests.rs | 1 + .../rustc_monomorphize/src/partitioning.rs | 2 +- compiler/rustc_session/src/options.rs | 2 ++ compiler/rustc_session/src/session.rs | 8 +++++ compiler/rustc_target/src/spec/mod.rs | 6 +++- .../default-hidden-visibility.md | 12 ++++++++ tests/codegen/default-hidden-visibility.rs | 29 +++++++++++++++++++ 10 files changed, 64 insertions(+), 8 deletions(-) create mode 100644 src/doc/unstable-book/src/compiler-flags/default-hidden-visibility.md create mode 100644 tests/codegen/default-hidden-visibility.rs diff --git a/compiler/rustc_codegen_gcc/src/allocator.rs b/compiler/rustc_codegen_gcc/src/allocator.rs index c8c098e2973f0..7c7044830f3d4 100644 --- a/compiler/rustc_codegen_gcc/src/allocator.rs +++ b/compiler/rustc_codegen_gcc/src/allocator.rs @@ -90,7 +90,7 @@ fn create_wrapper_function( .collect(); let func = context.new_function(None, FunctionType::Exported, output.unwrap_or(void), &args, from_name, false); - if tcx.sess.target.options.default_hidden_visibility { + if tcx.sess.default_hidden_visibility() { #[cfg(feature="master")] func.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden)); } diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs index 798014d668e22..7acd18d69edda 100644 --- a/compiler/rustc_codegen_llvm/src/allocator.rs +++ b/compiler/rustc_codegen_llvm/src/allocator.rs @@ -76,7 +76,7 @@ pub(crate) unsafe fn codegen( // __rust_alloc_error_handler_should_panic let name = OomStrategy::SYMBOL; let ll_g = llvm::LLVMRustGetOrInsertGlobal(llmod, name.as_ptr().cast(), name.len(), i8); - if tcx.sess.target.default_hidden_visibility { + if tcx.sess.default_hidden_visibility() { llvm::LLVMRustSetVisibility(ll_g, llvm::Visibility::Hidden); } let val = tcx.sess.opts.unstable_opts.oom.should_panic(); @@ -85,7 +85,7 @@ pub(crate) unsafe fn codegen( let name = NO_ALLOC_SHIM_IS_UNSTABLE; let ll_g = llvm::LLVMRustGetOrInsertGlobal(llmod, name.as_ptr().cast(), name.len(), i8); - if tcx.sess.target.default_hidden_visibility { + if tcx.sess.default_hidden_visibility() { llvm::LLVMRustSetVisibility(ll_g, llvm::Visibility::Hidden); } let llval = llvm::LLVMConstInt(i8, 0, False); @@ -130,7 +130,7 @@ fn create_wrapper_function( None }; - if tcx.sess.target.default_hidden_visibility { + if tcx.sess.default_hidden_visibility() { llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden); } if tcx.sess.must_emit_unwind_tables() { diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs index 164b12cf8d411..78c0725a63784 100644 --- a/compiler/rustc_codegen_llvm/src/declare.rs +++ b/compiler/rustc_codegen_llvm/src/declare.rs @@ -84,7 +84,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { fn_type: &'ll Type, ) -> &'ll Value { // Declare C ABI functions with the visibility used by C by default. - let visibility = if self.tcx.sess.target.default_hidden_visibility { + let visibility = if self.tcx.sess.default_hidden_visibility() { llvm::Visibility::Hidden } else { llvm::Visibility::Default @@ -107,7 +107,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { unnamed: llvm::UnnamedAddr, fn_type: &'ll Type, ) -> &'ll Value { - let visibility = if self.tcx.sess.target.default_hidden_visibility { + let visibility = if self.tcx.sess.default_hidden_visibility() { llvm::Visibility::Hidden } else { llvm::Visibility::Default diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs index ce58b2ab06170..25fa2b375473e 100644 --- a/compiler/rustc_interface/src/tests.rs +++ b/compiler/rustc_interface/src/tests.rs @@ -748,6 +748,7 @@ fn test_unstable_options_tracking_hash() { tracked!(cross_crate_inline_threshold, InliningThreshold::Always); tracked!(debug_info_for_profiling, true); tracked!(debug_macros, true); + tracked!(default_hidden_visibility, Some(true)); tracked!(dep_info_omit_d_target, true); tracked!(dual_proc_macros, true); tracked!(dwarf_version, Some(5)); diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs index c2b307910e42b..e06935d4e4762 100644 --- a/compiler/rustc_monomorphize/src/partitioning.rs +++ b/compiler/rustc_monomorphize/src/partitioning.rs @@ -883,7 +883,7 @@ fn mono_item_visibility<'tcx>( } fn default_visibility(tcx: TyCtxt<'_>, id: DefId, is_generic: bool) -> Visibility { - if !tcx.sess.target.default_hidden_visibility { + if !tcx.sess.default_hidden_visibility() { return Visibility::Default; } diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 7a6108bfbe24c..8efd380c1643f 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -1548,6 +1548,8 @@ options! { "compress debug info sections (none, zlib, zstd, default: none)"), deduplicate_diagnostics: bool = (true, parse_bool, [UNTRACKED], "deduplicate identical diagnostics (default: yes)"), + default_hidden_visibility: Option = (None, parse_opt_bool, [TRACKED], + "overrides the `default_hidden_visibility` setting of the target"), dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED], "in dep-info output, omit targets for tracking dependencies of the dep-info files \ themselves (default: no)"), diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index 24c7459392abe..69b861ea38068 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -961,6 +961,14 @@ impl Session { termize::dimensions().map_or(default_column_width, |(w, _)| w) } } + + /// Whether the default visibility of symbols should be "hidden" rather than "default". + pub fn default_hidden_visibility(&self) -> bool { + self.opts + .unstable_opts + .default_hidden_visibility + .unwrap_or(self.target.options.default_hidden_visibility) + } } // JUSTIFICATION: defn of the suggested wrapper fns diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 63002aa4aa404..7b967450715d8 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -2089,7 +2089,11 @@ pub struct TargetOptions { pub no_builtins: bool, /// The default visibility for symbols in this target should be "hidden" - /// rather than "default" + /// rather than "default". + /// + /// This value typically shouldn't be accessed directly, but through + /// the `rustc_session::Session::default_hidden_visibility` method, which + /// allows `rustc` users to override this setting using cmdline flags. pub default_hidden_visibility: bool, /// Whether a .debug_gdb_scripts section will be added to the output object file diff --git a/src/doc/unstable-book/src/compiler-flags/default-hidden-visibility.md b/src/doc/unstable-book/src/compiler-flags/default-hidden-visibility.md new file mode 100644 index 0000000000000..579add4a9d985 --- /dev/null +++ b/src/doc/unstable-book/src/compiler-flags/default-hidden-visibility.md @@ -0,0 +1,12 @@ +# `default-hidden-visibility` + +The tracking issue for this feature is: https://github.com/rust-lang/compiler-team/issues/656 + +------------------------ + +This flag can be used to override the target's +[`default_hidden_visibility`](https://doc.rust-lang.org/beta/nightly-rustc/rustc_target/spec/struct.TargetOptions.html#structfield.default_hidden_visibility) +setting. +Using `-Zdefault_hidden_visibility=yes` is roughly equivalent to Clang's +[`-fvisibility=hidden`](https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-fvisibility) +cmdline flag. diff --git a/tests/codegen/default-hidden-visibility.rs b/tests/codegen/default-hidden-visibility.rs new file mode 100644 index 0000000000000..1d5a8eb1efcf2 --- /dev/null +++ b/tests/codegen/default-hidden-visibility.rs @@ -0,0 +1,29 @@ +// Verifies that `Session::default_hidden_visibility` is affected when using the related cmdline +// flag. This is a regression test for https://github.com/rust-lang/compiler-team/issues/656. See +// also https://github.com/rust-lang/rust/issues/73295 and +// https://github.com/rust-lang/rust/issues/37530. +// +// revisions:NONE YES NO +//[YES] compile-flags: -Zdefault-hidden-visibility=yes +//[NO] compile-flags: -Zdefault-hidden-visibility=no +// +// `compiler/rustc_target/src/spec/base/wasm.rs` has a different default value of +// `default_hidden_visibility` - it wouldn't match the test expectations below. +// [NONE] ignore-wasm32 + +// The test scenario is specifically about visibility of symbols exported out of dynamically linked +// libraries. +#![crate_type = "dylib"] + +// The test scenario needs to use a Rust-public, but non-explicitly-exported symbol +// (e.g. the test doesn't use `#[no_mangle]`, because currently it implies that +// the symbol should be exported; we don't want that - we want to test the *default* +// export setting instead). +// . +// We want to verify that the cmdline flag affects the visibility of this symbol: +// +// NONE: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = constant +// YES: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = hidden constant +// NO: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = constant +#[used] +pub static exported_symbol: [u8; 6] = *b"foobar"; From eb8478a5a21a1d298e111dd70d78c32ba5920dd4 Mon Sep 17 00:00:00 2001 From: Lukasz Anforowicz Date: Fri, 8 Dec 2023 19:39:53 +0000 Subject: [PATCH 02/13] Skipping the new `default-hidden-visibility.rs` test for WASM targets. The test expectations don't apply to WASM, where the target spec has a different default value of `default_hidden_visibility`. See the test comments for more details. --- tests/codegen/default-hidden-visibility.rs | 23 ++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/tests/codegen/default-hidden-visibility.rs b/tests/codegen/default-hidden-visibility.rs index 1d5a8eb1efcf2..a2c8b69344310 100644 --- a/tests/codegen/default-hidden-visibility.rs +++ b/tests/codegen/default-hidden-visibility.rs @@ -2,14 +2,21 @@ // flag. This is a regression test for https://github.com/rust-lang/compiler-team/issues/656. See // also https://github.com/rust-lang/rust/issues/73295 and // https://github.com/rust-lang/rust/issues/37530. + +// We test 3 combinations of command-line flags: +// * No extra command-line flag: DEFAULT +// * Overriding to "yes": YES +// * Overriding to "no": NO // -// revisions:NONE YES NO -//[YES] compile-flags: -Zdefault-hidden-visibility=yes -//[NO] compile-flags: -Zdefault-hidden-visibility=no -// +// revisions:DEFAULT YES NO +// [YES] compile-flags: -Zdefault-hidden-visibility=yes +// [NO] compile-flags: -Zdefault-hidden-visibility=no + // `compiler/rustc_target/src/spec/base/wasm.rs` has a different default value of // `default_hidden_visibility` - it wouldn't match the test expectations below. -// [NONE] ignore-wasm32 +// And therefore we skip this test on WASM: +// +// ignore-wasm32 // The test scenario is specifically about visibility of symbols exported out of dynamically linked // libraries. @@ -22,8 +29,8 @@ // . // We want to verify that the cmdline flag affects the visibility of this symbol: // -// NONE: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = constant -// YES: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = hidden constant -// NO: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = constant +// DEFAULT: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = constant +// YES: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = hidden constant +// NO: @{{.*}}default_hidden_visibility{{.*}}exported_symbol{{.*}} = constant #[used] pub static exported_symbol: [u8; 6] = *b"foobar"; From f635cd2e826c60e793c4dfe1da4628be219e90a4 Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Wed, 6 Dec 2023 02:42:59 +0000 Subject: [PATCH 03/13] Restore `const PartialEq` --- library/core/src/cmp.rs | 12 ++++++ .../call-generic-in-impl.rs | 2 +- .../call-generic-in-impl.stderr | 8 ---- .../call-generic-method-chain.rs | 4 +- .../call-generic-method-chain.stderr | 14 ------ .../call-generic-method-dup-bound.rs | 4 +- .../call-generic-method-dup-bound.stderr | 14 ------ .../call-generic-method-fail.rs | 5 +-- .../call-generic-method-fail.stderr | 12 ++++++ .../call-generic-method-pass.rs | 4 +- .../call-generic-method-pass.stderr | 8 ---- .../const-impl-trait.rs | 1 + .../const-impl-trait.stderr | 43 +++++-------------- .../const_derives/derive-const-use.rs | 4 +- .../const_derives/derive-const-use.stderr | 14 ++---- .../const_derives/derive-const-with-params.rs | 4 +- .../derive-const-with-params.stderr | 10 ----- 17 files changed, 52 insertions(+), 111 deletions(-) delete mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr delete mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.stderr delete mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.stderr create mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.stderr delete mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr delete mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs index fadf2fcc9fce6..85246f4f3dc4d 100644 --- a/library/core/src/cmp.rs +++ b/library/core/src/cmp.rs @@ -224,6 +224,7 @@ use self::Ordering::*; append_const_msg )] #[rustc_diagnostic_item = "PartialEq"] +#[cfg_attr(not(bootstrap), const_trait)] pub trait PartialEq { /// This method tests for `self` and `other` values to be equal, and is used /// by `==`. @@ -1414,12 +1415,23 @@ mod impls { macro_rules! partial_eq_impl { ($($t:ty)*) => ($( #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(bootstrap)] impl PartialEq for $t { #[inline] fn eq(&self, other: &$t) -> bool { (*self) == (*other) } #[inline] fn ne(&self, other: &$t) -> bool { (*self) != (*other) } } + + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_cmp", issue = "92391")] + #[cfg(not(bootstrap))] + impl const PartialEq for $t { + #[inline] + fn eq(&self, other: &$t) -> bool { (*self) == (*other) } + #[inline] + fn ne(&self, other: &$t) -> bool { (*self) != (*other) } + } )*) } diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.rs index 5120e6bfb4117..50c46579086c6 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.rs @@ -1,4 +1,4 @@ -// known-bug: #110395 +// check-pass #![feature(const_trait_impl)] #[const_trait] diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr deleted file mode 100644 index 4007fd455f88c..0000000000000 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/call-generic-in-impl.rs:9:16 - | -LL | impl const MyPartialEq for T { - | ^^^^^^^^^ - -error: aborting due to 1 previous error - diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.rs index 3febb328a83ca..0df370bff8dac 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.rs @@ -1,8 +1,8 @@ //! Basic test for calling methods on generic type parameters in `const fn`. -// known-bug: #110395 +// check-pass -#![feature(const_trait_impl)] +#![feature(const_trait_impl, effects)] struct S; diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.stderr deleted file mode 100644 index 37faa3f6bce23..0000000000000 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-chain.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/call-generic-method-chain.rs:18:32 - | -LL | const fn equals_self(t: &T) -> bool { - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/call-generic-method-chain.rs:22:40 - | -LL | const fn equals_self_wrapper(t: &T) -> bool { - | ^^^^^^^^^ - -error: aborting due to 2 previous errors - diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.rs index e618160d3b6f0..b0d5d06851526 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.rs @@ -1,6 +1,6 @@ -// known-bug: #110395 +// check-pass -#![feature(const_trait_impl)] +#![feature(const_trait_impl, effects)] struct S; diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.stderr deleted file mode 100644 index 90cfe04a9a862..0000000000000 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-dup-bound.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/call-generic-method-dup-bound.rs:18:44 - | -LL | const fn equals_self(t: &T) -> bool { - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/call-generic-method-dup-bound.rs:25:37 - | -LL | const fn equals_self2(t: &T) -> bool { - | ^^^^^^^^^ - -error: aborting due to 2 previous errors - diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.rs index 53778b3af3d4b..043939750a856 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.rs @@ -1,10 +1,9 @@ -// FIXME(effects) -// check-pass #![feature(const_trait_impl, effects)] pub const fn equals_self(t: &T) -> bool { *t == *t - // (remove this) ~^ ERROR can't compare + //~^ ERROR mismatched types + // FIXME(effects): diagnostic } fn main() {} diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.stderr new file mode 100644 index 0000000000000..5074c4a22610b --- /dev/null +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-fail.stderr @@ -0,0 +1,12 @@ +error[E0308]: mismatched types + --> $DIR/call-generic-method-fail.rs:4:5 + | +LL | *t == *t + | ^^^^^^^^ expected `host`, found `true` + | + = note: expected constant `host` + found constant `true` + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.rs index 09f35a277371e..abd5d2fdb393b 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.rs @@ -1,8 +1,8 @@ //! Basic test for calling methods on generic type parameters in `const fn`. -// known-bug: #110395 +// check-pass -#![feature(const_trait_impl)] +#![feature(const_trait_impl, effects)] struct S; diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr deleted file mode 100644 index 1f7cf689e9581..0000000000000 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/call-generic-method-pass.rs:18:32 - | -LL | const fn equals_self(t: &T) -> bool { - | ^^^^^^^^^ - -error: aborting due to 1 previous error - diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.rs index 8e4de57b019da..14d306fc31f6b 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.rs @@ -3,6 +3,7 @@ #![feature( associated_type_bounds, const_trait_impl, + effects, const_cmp, )] diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr index 4a9090d0b53dd..dd03ae98c6a9c 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr @@ -1,39 +1,16 @@ -error[E0635]: unknown feature `const_cmp` - --> $DIR/const-impl-trait.rs:6:5 +error[E0277]: can't compare `impl PartialEq + Destruct + Copy` with `impl PartialEq + Destruct + Copy` + --> $DIR/const-impl-trait.rs:28:17 | -LL | const_cmp, - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/const-impl-trait.rs:11:30 - | -LL | const fn cmp(a: &impl ~const PartialEq) -> bool { - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/const-impl-trait.rs:15:30 - | -LL | const fn wrap(x: impl ~const PartialEq + ~const Destruct) - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/const-impl-trait.rs:16:20 +LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `impl PartialEq + Destruct + Copy == impl PartialEq + Destruct + Copy` | -LL | -> impl ~const PartialEq + ~const Destruct - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/const-impl-trait.rs:23:29 + = help: the trait `PartialEq` is not implemented for `impl PartialEq + Destruct + Copy` +note: required by a bound in `Foo::{opaque#0}` + --> $DIR/const-impl-trait.rs:24:22 | LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy; - | ^^^^^^^^^ - -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/const-impl-trait.rs:27:29 - | -LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy { - | ^^^^^^^^^ + | ^^^^^^^^^^^^^^^^ required by this bound in `Foo::{opaque#0}` -error: aborting due to 6 previous errors +error: aborting due to 1 previous error -For more information about this error, try `rustc --explain E0635`. +For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs index 69098542b7e36..f781b8bd7d840 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs @@ -1,5 +1,5 @@ -// known-bug: #110395 -#![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)] +// check-pass +#![feature(const_trait_impl, const_cmp, const_default_impls, derive_const, effects)] pub struct A; diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr index 046dbae0eae7e..c30d15ddad845 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr @@ -1,15 +1,9 @@ -error[E0635]: unknown feature `const_cmp` - --> $DIR/derive-const-use.rs:2:30 - | -LL | #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)] - | ^^^^^^^^^ - error[E0635]: unknown feature `const_default_impls` - --> $DIR/derive-const-use.rs:2:41 + --> $DIR/derive-const-use.rs:3:5 | -LL | #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)] - | ^^^^^^^^^^^^^^^^^^^ +LL | const_default_impls, derive_const)] + | ^^^^^^^^^^^^^^^^^^^ -error: aborting due to 2 previous errors +error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0635`. diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.rs index 2a5d0176ba004..b479c967b0dab 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.rs @@ -1,7 +1,7 @@ -// known-bug: #110395 +// check-pass #![feature(derive_const)] -#![feature(const_trait_impl)] +#![feature(const_trait_impl, effects)] #[derive_const(PartialEq)] pub struct Reverse(T); diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr deleted file mode 100644 index 3a8c4833414b8..0000000000000 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr +++ /dev/null @@ -1,10 +0,0 @@ -error: ~const can only be applied to `#[const_trait]` traits - --> $DIR/derive-const-with-params.rs:6:16 - | -LL | #[derive_const(PartialEq)] - | ^^^^^^^^^ - | - = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: aborting due to 1 previous error - From e03c18b1b353a0953752d0cb4ea7aeb014f2384e Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Sun, 10 Dec 2023 10:16:40 +0000 Subject: [PATCH 04/13] fix host param for `PartialEq` --- .../src/traits/error_reporting/suggestions.rs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 95ffd07e39783..f7e8dc62a625d 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -3628,17 +3628,19 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> { is_derivable_trait && // Ensure all fields impl the trait. adt.all_fields().all(|field| { - let field_ty = field.ty(self.tcx, args); + let field_ty = ty::GenericArg::from(field.ty(self.tcx, args)); let trait_args = match diagnostic_name { sym::PartialEq | sym::PartialOrd => { Some(field_ty) } _ => None, }; + // Also add host param, if present + let host = self.tcx.generics_of(trait_pred.def_id()).host_effect_index.map(|idx| trait_pred.skip_binder().trait_ref.args[idx]); let trait_pred = trait_pred.map_bound_ref(|tr| ty::TraitPredicate { trait_ref: ty::TraitRef::new(self.tcx, trait_pred.def_id(), - [field_ty].into_iter().chain(trait_args), + [field_ty].into_iter().chain(trait_args).chain(host), ), ..*tr }); @@ -3659,6 +3661,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> { trait_pred.skip_binder().self_ty(), diagnostic_name, ), + // FIXME(effects, const_trait_impl) derive_const as suggestion? format!("#[derive({diagnostic_name})]\n"), Applicability::MaybeIncorrect, ); From 2f457d9d6085de41d112aeb1116761ce480427b6 Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Sun, 10 Dec 2023 10:17:00 +0000 Subject: [PATCH 05/13] filter out trailing effect param in `own_args_no_defaults` --- compiler/rustc_middle/src/ty/generics.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs index 12294b0a602ce..f0e63dfddda30 100644 --- a/compiler/rustc_middle/src/ty/generics.rs +++ b/compiler/rustc_middle/src/ty/generics.rs @@ -342,6 +342,8 @@ impl<'tcx> Generics { param.default_value(tcx).is_some_and(|default| { default.instantiate(tcx, args) == args[param.index as usize] }) + // filter out trailing effect params + || matches!(param.kind, GenericParamDefKind::Const { is_host_effect: true, .. }) }) .count(); own_params.end -= num_default_params; From d1f4bc5a19d2cddced73bb026c386081c7357819 Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Sun, 10 Dec 2023 10:17:28 +0000 Subject: [PATCH 06/13] Revert "Don't print host effect param in pretty path_generic_args" This reverts commit f1bf874fb13703d706fc8184407c6df12555d8e9. --- .../rustc_const_eval/src/util/type_name.rs | 1 - .../src/infer/error_reporting/mod.rs | 5 +-- .../infer/error_reporting/need_type_info.rs | 3 +- .../infer/error_reporting/note_and_explain.rs | 12 ++---- compiler/rustc_lint/src/context.rs | 1 - compiler/rustc_middle/src/ty/generics.rs | 12 ++---- compiler/rustc_middle/src/ty/print/mod.rs | 5 +-- compiler/rustc_middle/src/ty/print/pretty.rs | 42 ++++++++++++------- compiler/rustc_symbol_mangling/src/legacy.rs | 1 - compiler/rustc_symbol_mangling/src/v0.rs | 2 - .../call-generic-method-nonconst.stderr | 2 +- 11 files changed, 41 insertions(+), 45 deletions(-) diff --git a/compiler/rustc_const_eval/src/util/type_name.rs b/compiler/rustc_const_eval/src/util/type_name.rs index b6240906611a9..a82b65b19a882 100644 --- a/compiler/rustc_const_eval/src/util/type_name.rs +++ b/compiler/rustc_const_eval/src/util/type_name.rs @@ -120,7 +120,6 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, args: &[GenericArg<'tcx>], - _params: &[ty::GenericParamDef], ) -> Result<(), PrintError> { print_prefix(self)?; let args = diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs index 0004f16fc4e3f..745c3d195ada7 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs @@ -641,7 +641,6 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, _args: &[GenericArg<'tcx>], - _params: &[ty::GenericParamDef], ) -> Result<(), PrintError> { print_prefix(self) } @@ -1237,9 +1236,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { (&ty::Adt(def1, sub1), &ty::Adt(def2, sub2)) => { let did1 = def1.did(); let did2 = def2.did(); - let (sub_no_defaults_1, _) = + let sub_no_defaults_1 = self.tcx.generics_of(did1).own_args_no_defaults(self.tcx, sub1); - let (sub_no_defaults_2, _) = + let sub_no_defaults_2 = self.tcx.generics_of(did2).own_args_no_defaults(self.tcx, sub2); let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new()); let path1 = self.tcx.def_path_str(did1); diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs index b8dc42b73cdf1..8fe6c1b0d86fd 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs @@ -757,7 +757,6 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> { .tcx .generics_of(def.did()) .own_args_no_defaults(self.tcx, args) - .0 .iter() .map(|&arg| self.arg_cost(arg)) .sum::() @@ -1186,7 +1185,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> { } let args = self.infcx.resolve_vars_if_possible(args); let generic_args = - &generics.own_args_no_defaults(tcx, args).0[generics.own_counts().lifetimes..]; + &generics.own_args_no_defaults(tcx, args)[generics.own_counts().lifetimes..]; let span = match expr.kind { ExprKind::MethodCall(path, ..) => path.ident.span, _ => expr.span, diff --git a/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs b/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs index e2e9102a61a7d..b93fe02aaeab0 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs @@ -116,7 +116,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { // FIXME: extract this logic for use in other diagnostics. let (trait_ref, assoc_args) = proj.trait_ref_and_own_args(tcx); let item_name = tcx.item_name(proj.def_id); - let item_args = self.format_generic_args(proj.def_id, assoc_args); + let item_args = self.format_generic_args(assoc_args); // Here, we try to see if there's an existing // trait implementation that matches the one that @@ -775,7 +775,7 @@ fn foo(&self) -> Self::T { String::new() } let span = Span::new(pos, pos, span.ctxt(), span.parent()); (span, format!(", {} = {}", assoc.ident(tcx), ty)) } else { - let item_args = self.format_generic_args(assoc.def_id, assoc_args); + let item_args = self.format_generic_args(assoc_args); (span.shrink_to_hi(), format!("<{}{} = {}>", assoc.ident(tcx), item_args, ty)) }; diag.span_suggestion_verbose(span, msg(), sugg, MaybeIncorrect); @@ -784,13 +784,9 @@ fn foo(&self) -> Self::T { String::new() } false } - pub fn format_generic_args( - &self, - assoc_def_id: DefId, - args: &[ty::GenericArg<'tcx>], - ) -> String { + pub fn format_generic_args(&self, args: &[ty::GenericArg<'tcx>]) -> String { FmtPrinter::print_string(self.tcx, hir::def::Namespace::TypeNS, |cx| { - cx.path_generic_args(|_| Ok(()), args, &self.infcx.tcx.generics_of(assoc_def_id).params) + cx.path_generic_args(|_| Ok(()), args) }) .expect("could not write to `String`.") } diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index e3bda0828cb41..024e542d4afe4 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -1285,7 +1285,6 @@ impl<'tcx> LateContext<'tcx> { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, _args: &[GenericArg<'tcx>], - _params: &[ty::GenericParamDef], ) -> Result<(), PrintError> { print_prefix(self) } diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs index f0e63dfddda30..4a4a9db1bb354 100644 --- a/compiler/rustc_middle/src/ty/generics.rs +++ b/compiler/rustc_middle/src/ty/generics.rs @@ -320,11 +320,9 @@ impl<'tcx> Generics { &'tcx self, tcx: TyCtxt<'tcx>, args: &'tcx [ty::GenericArg<'tcx>], - ) -> (&'tcx [ty::GenericArg<'tcx>], &'tcx [ty::GenericParamDef]) { - let mut own_args = self.parent_count..self.count(); - let mut own_params = 0..self.params.len(); + ) -> &'tcx [ty::GenericArg<'tcx>] { + let mut own_params = self.parent_count..self.count(); if self.has_self && self.parent.is_none() { - own_args.start = 1; own_params.start = 1; } @@ -334,7 +332,7 @@ impl<'tcx> Generics { // of semantic equivalence. While not ideal, that's // good enough for now as this should only be used // for diagnostics anyways. - let num_default_params = self + own_params.end -= self .params .iter() .rev() @@ -346,10 +344,8 @@ impl<'tcx> Generics { || matches!(param.kind, GenericParamDefKind::Const { is_host_effect: true, .. }) }) .count(); - own_params.end -= num_default_params; - own_args.end -= num_default_params; - (&args[own_args], &self.params[own_params]) + &args[own_params] } /// Returns the args corresponding to the generic parameters of this item, excluding `Self`. diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs index 948246c64e296..5e09154789a79 100644 --- a/compiler/rustc_middle/src/ty/print/mod.rs +++ b/compiler/rustc_middle/src/ty/print/mod.rs @@ -83,7 +83,6 @@ pub trait Printer<'tcx>: Sized { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, args: &[GenericArg<'tcx>], - params: &[ty::GenericParamDef], ) -> Result<(), PrintError>; // Defaults (should not be overridden): @@ -142,12 +141,10 @@ pub trait Printer<'tcx>: Sized { // on top of the same path, but without its own generics. _ => { if !generics.params.is_empty() && args.len() >= generics.count() { - let (args, params) = - generics.own_args_no_defaults(self.tcx(), args); + let args = generics.own_args_no_defaults(self.tcx(), args); return self.path_generic_args( |cx| cx.print_def_path(def_id, parent_args), args, - params, ); } } diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index fd53111001b7c..f3ff9b0ba4b91 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -19,6 +19,7 @@ use rustc_hir::LangItem; use rustc_session::config::TrimmedDefPaths; use rustc_session::cstore::{ExternCrate, ExternCrateSource}; use rustc_session::Limit; +use rustc_span::sym; use rustc_span::symbol::{kw, Ident, Symbol}; use rustc_span::FileNameDisplayPreference; use rustc_target::abi::Size; @@ -966,7 +967,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write { define_scoped_cx!(cx); // Get the (single) generic ty (the args) of this FnOnce trait ref. let generics = tcx.generics_of(trait_ref.def_id); - let (own_args, _) = generics.own_args_no_defaults(tcx, trait_ref.args); + let own_args = generics.own_args_no_defaults(tcx, trait_ref.args); match (entry.return_ty, own_args[0].expect_ty()) { // We can only print `impl Fn() -> ()` if we have a tuple of args and we recorded @@ -1032,7 +1033,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write { p!(print(trait_ref.print_only_trait_name())); let generics = tcx.generics_of(trait_ref.def_id); - let (own_args, _) = generics.own_args_no_defaults(tcx, trait_ref.args); + let own_args = generics.own_args_no_defaults(tcx, trait_ref.args); if !own_args.is_empty() || !assoc_items.is_empty() { let mut first = true; @@ -1184,7 +1185,6 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write { ) }, &alias_ty.args[1..], - &self.tcx().generics_of(alias_ty.def_id).params, ) } @@ -1233,7 +1233,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write { let dummy_cx = Ty::new_fresh(cx.tcx(), 0); let principal = principal.with_self_ty(cx.tcx(), dummy_cx); - let (args, _) = cx + let args = cx .tcx() .generics_of(principal.def_id) .own_args_no_defaults(cx.tcx(), principal.args); @@ -2031,26 +2031,40 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, args: &[GenericArg<'tcx>], - params: &[ty::GenericParamDef], ) -> Result<(), PrintError> { print_prefix(self)?; let tcx = self.tcx; - let verbose = tcx.sess.verbose(); - let mut args = args - .iter() - .copied() - .zip(params) + + let args = args.iter().copied(); + + let args: Vec<_> = if !tcx.sess.verbose() { + // skip host param as those are printed as `~const` + args.filter(|arg| match arg.unpack() { + // FIXME(effects) there should be a better way than just matching the name + GenericArgKind::Const(c) + if tcx.features().effects + && matches!( + c.kind(), + ty::ConstKind::Param(ty::ParamConst { name: sym::host, .. }) + ) => + { + false + } + _ => true, + }) + .collect() + } else { // If -Zverbose is passed, we should print the host parameter instead // of eating it. - .filter(|(_, param)| verbose || !param.is_host_effect()) - .peekable(); + args.collect() + }; - if args.peek().is_some() { + if !args.is_empty() { if self.in_value { write!(self, "::")?; } - self.generic_delimiters(|cx| cx.comma_sep(args.map(|(arg, _)| arg))) + self.generic_delimiters(|cx| cx.comma_sep(args.into_iter())) } else { Ok(()) } diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs index 14cd46cb062f6..0178ff53b24a3 100644 --- a/compiler/rustc_symbol_mangling/src/legacy.rs +++ b/compiler/rustc_symbol_mangling/src/legacy.rs @@ -342,7 +342,6 @@ impl<'tcx> Printer<'tcx> for SymbolPrinter<'tcx> { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, args: &[GenericArg<'tcx>], - _params: &[ty::GenericParamDef], ) -> Result<(), PrintError> { print_prefix(self)?; diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs index 112e06a0dc270..e002e345ae689 100644 --- a/compiler/rustc_symbol_mangling/src/v0.rs +++ b/compiler/rustc_symbol_mangling/src/v0.rs @@ -298,7 +298,6 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> { ) }, args, - &self.tcx.generics_of(impl_def_id).params, )?; } else { self.push_disambiguator(key.disambiguated_data.disambiguator as u64); @@ -801,7 +800,6 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> { &mut self, print_prefix: impl FnOnce(&mut Self) -> Result<(), PrintError>, args: &[GenericArg<'tcx>], - _params: &[ty::GenericParamDef], ) -> Result<(), PrintError> { // Don't print any regions if they're all erased. let print_regions = args.iter().any(|arg| match arg.unpack() { diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr index aea9a39b26107..dd11305a35be6 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr @@ -1,4 +1,4 @@ -error[E0277]: the trait bound `S: ~const Foo` is not satisfied +error[E0277]: the trait bound `S: ~const Foo` is not satisfied --> $DIR/call-generic-method-nonconst.rs:23:34 | LL | pub const EQ: bool = equals_self(&S); From d464dd07ed83cc25ee3e568c98e3d4e26ff364ae Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Sun, 10 Dec 2023 10:42:34 +0000 Subject: [PATCH 07/13] fix tests --- compiler/rustc_middle/src/ty/print/pretty.rs | 3 ++- tests/ui/consts/fn_trait_refs.stderr | 8 +----- .../call-generic-method-nonconst.rs | 3 +-- .../call-generic-method-nonconst.stderr | 2 +- .../const-impl-trait.stderr | 16 +++++++++-- .../const_derives/derive-const-use.rs | 3 ++- .../const_derives/derive-const-use.stderr | 27 ++++++++++++++++--- tests/ui/suggestions/invalid-bin-op.stderr | 4 --- 8 files changed, 44 insertions(+), 22 deletions(-) diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index f3ff9b0ba4b91..a34799c8f46ab 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -2896,7 +2896,8 @@ define_print_and_forward_display! { TraitPredPrintModifiersAndPath<'tcx> { if let Some(idx) = cx.tcx().generics_of(self.0.trait_ref.def_id).host_effect_index { - if self.0.trait_ref.args.const_at(idx) != cx.tcx().consts.true_ { + let arg = self.0.trait_ref.args.const_at(idx); + if arg != cx.tcx().consts.true_ && !arg.has_infer() { p!("~const "); } } diff --git a/tests/ui/consts/fn_trait_refs.stderr b/tests/ui/consts/fn_trait_refs.stderr index 3d82837d53040..e5ebe1d852861 100644 --- a/tests/ui/consts/fn_trait_refs.stderr +++ b/tests/ui/consts/fn_trait_refs.stderr @@ -4,12 +4,6 @@ error[E0635]: unknown feature `const_fn_trait_ref_impls` LL | #![feature(const_fn_trait_ref_impls)] | ^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0635]: unknown feature `const_cmp` - --> $DIR/fn_trait_refs.rs:8:12 - | -LL | #![feature(const_cmp)] - | ^^^^^^^^^ - error: ~const can only be applied to `#[const_trait]` traits --> $DIR/fn_trait_refs.rs:15:15 | @@ -80,6 +74,6 @@ LL | T: ~const FnMut<()> + ~const Destruct, | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` -error: aborting due to 12 previous errors +error: aborting due to 11 previous errors For more information about this error, try `rustc --explain E0635`. diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs index b9331caaf8efb..76bc738123d39 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs @@ -21,7 +21,6 @@ const fn equals_self(t: &T) -> bool { // it not using the impl. pub const EQ: bool = equals_self(&S); -//~^ ERROR -// FIXME(effects) the diagnostics here isn't ideal, we shouldn't get `` +//~^ ERROR: the trait bound `S: ~const Foo` is not satisfied fn main() {} diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr index dd11305a35be6..aea9a39b26107 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr @@ -1,4 +1,4 @@ -error[E0277]: the trait bound `S: ~const Foo` is not satisfied +error[E0277]: the trait bound `S: ~const Foo` is not satisfied --> $DIR/call-generic-method-nonconst.rs:23:34 | LL | pub const EQ: bool = equals_self(&S); diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr index dd03ae98c6a9c..ddedf8f1d8d27 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-trait.stderr @@ -4,13 +4,25 @@ error[E0277]: can't compare `impl PartialEq + Destruct + Copy` with `impl Partia LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `impl PartialEq + Destruct + Copy == impl PartialEq + Destruct + Copy` | - = help: the trait `PartialEq` is not implemented for `impl PartialEq + Destruct + Copy` + = help: the trait `~const PartialEq` is not implemented for `impl PartialEq + Destruct + Copy` note: required by a bound in `Foo::{opaque#0}` --> $DIR/const-impl-trait.rs:24:22 | LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy; | ^^^^^^^^^^^^^^^^ required by this bound in `Foo::{opaque#0}` -error: aborting due to 1 previous error +error[E0277]: can't drop `impl PartialEq + Destruct + Copy` + --> $DIR/const-impl-trait.rs:28:17 + | +LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const Destruct` is not implemented for `impl PartialEq + Destruct + Copy` + | +note: required by a bound in `Foo::{opaque#0}` + --> $DIR/const-impl-trait.rs:24:41 + | +LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy; + | ^^^^^^^^^^^^^^^ required by this bound in `Foo::{opaque#0}` + +error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs index f781b8bd7d840..42d7283699fae 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs @@ -1,4 +1,5 @@ -// check-pass +// known-bug: #110395 + #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const, effects)] pub struct A; diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr index c30d15ddad845..c561f80653c9f 100644 --- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr +++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr @@ -1,9 +1,28 @@ error[E0635]: unknown feature `const_default_impls` - --> $DIR/derive-const-use.rs:3:5 + --> $DIR/derive-const-use.rs:3:41 | -LL | const_default_impls, derive_const)] - | ^^^^^^^^^^^^^^^^^^^ +LL | #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const, effects)] + | ^^^^^^^^^^^^^^^^^^^ -error: aborting due to 1 previous error +error: const `impl` for trait `Default` which is not marked with `#[const_trait]` + --> $DIR/derive-const-use.rs:7:12 + | +LL | impl const Default for A { + | ^^^^^^^ + | + = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const` + = note: adding a non-const method body in the future would be a breaking change + +error: const `impl` for trait `Default` which is not marked with `#[const_trait]` + --> $DIR/derive-const-use.rs:15:16 + | +LL | #[derive_const(Default, PartialEq)] + | ^^^^^^^ + | + = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const` + = note: adding a non-const method body in the future would be a breaking change + = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0635`. diff --git a/tests/ui/suggestions/invalid-bin-op.stderr b/tests/ui/suggestions/invalid-bin-op.stderr index 018250c8c1b60..2bd745c645a1c 100644 --- a/tests/ui/suggestions/invalid-bin-op.stderr +++ b/tests/ui/suggestions/invalid-bin-op.stderr @@ -16,10 +16,6 @@ help: consider annotating `S` with `#[derive(PartialEq)]` LL + #[derive(PartialEq)] LL | struct S(T); | -help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement - | -LL | pub fn foo(s: S, t: S) where S: PartialEq { - | +++++++++++++++++++++ error: aborting due to 1 previous error From de8f4acbf7ce5586c52e2cd5168e3e1571ea37aa Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Sun, 10 Dec 2023 10:53:57 +0000 Subject: [PATCH 08/13] clean up leftover FIXME --- compiler/rustc_middle/src/ty/generics.rs | 6 ++-- compiler/rustc_middle/src/ty/print/pretty.rs | 29 +------------------- 2 files changed, 5 insertions(+), 30 deletions(-) diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs index 4a4a9db1bb354..c3699b114c411 100644 --- a/compiler/rustc_middle/src/ty/generics.rs +++ b/compiler/rustc_middle/src/ty/generics.rs @@ -326,6 +326,8 @@ impl<'tcx> Generics { own_params.start = 1; } + let verbose = tcx.sess.verbose(); + // Filter the default arguments. // // This currently uses structural equality instead @@ -340,8 +342,8 @@ impl<'tcx> Generics { param.default_value(tcx).is_some_and(|default| { default.instantiate(tcx, args) == args[param.index as usize] }) - // filter out trailing effect params - || matches!(param.kind, GenericParamDefKind::Const { is_host_effect: true, .. }) + // filter out trailing effect params, if we're not in `-Zverbose`. + || (!verbose && matches!(param.kind, GenericParamDefKind::Const { is_host_effect: true, .. })) }) .count(); diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index a34799c8f46ab..c25b9eee38cf9 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -19,7 +19,6 @@ use rustc_hir::LangItem; use rustc_session::config::TrimmedDefPaths; use rustc_session::cstore::{ExternCrate, ExternCrateSource}; use rustc_session::Limit; -use rustc_span::sym; use rustc_span::symbol::{kw, Ident, Symbol}; use rustc_span::FileNameDisplayPreference; use rustc_target::abi::Size; @@ -2034,37 +2033,11 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> { ) -> Result<(), PrintError> { print_prefix(self)?; - let tcx = self.tcx; - - let args = args.iter().copied(); - - let args: Vec<_> = if !tcx.sess.verbose() { - // skip host param as those are printed as `~const` - args.filter(|arg| match arg.unpack() { - // FIXME(effects) there should be a better way than just matching the name - GenericArgKind::Const(c) - if tcx.features().effects - && matches!( - c.kind(), - ty::ConstKind::Param(ty::ParamConst { name: sym::host, .. }) - ) => - { - false - } - _ => true, - }) - .collect() - } else { - // If -Zverbose is passed, we should print the host parameter instead - // of eating it. - args.collect() - }; - if !args.is_empty() { if self.in_value { write!(self, "::")?; } - self.generic_delimiters(|cx| cx.comma_sep(args.into_iter())) + self.generic_delimiters(|cx| cx.comma_sep(args.iter().copied())) } else { Ok(()) } From c4c35551d8d63c97d7a03ff302409f2dc5616dc6 Mon Sep 17 00:00:00 2001 From: Deadbeef Date: Sun, 10 Dec 2023 13:06:18 +0000 Subject: [PATCH 09/13] fix clippy --- compiler/rustc_middle/src/hir/map/mod.rs | 16 ++++----- compiler/rustc_middle/src/ty/util.rs | 3 +- src/tools/clippy/clippy_lints/src/derive.rs | 4 +-- .../src/implied_bounds_in_impls.rs | 4 +++ .../src/loops/explicit_iter_loop.rs | 2 +- .../src/needless_pass_by_value.rs | 1 + src/tools/clippy/clippy_utils/src/ty.rs | 34 +++++++++++++------ 7 files changed, 40 insertions(+), 24 deletions(-) diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index f407d30ac82a3..8c55066d782d7 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -336,7 +336,8 @@ impl<'hir> Map<'hir> { /// Returns the `BodyOwnerKind` of this `LocalDefId`. /// /// Panics if `LocalDefId` does not have an associated body. - pub fn body_owner_kind(self, def_id: LocalDefId) -> BodyOwnerKind { + pub fn body_owner_kind(self, def_id: impl Into) -> BodyOwnerKind { + let def_id = def_id.into(); match self.tcx.def_kind(def_id) { DefKind::Const | DefKind::AssocConst | DefKind::AnonConst => { BodyOwnerKind::Const { inline: false } @@ -356,20 +357,17 @@ impl<'hir> Map<'hir> { /// This should only be used for determining the context of a body, a return /// value of `Some` does not always suggest that the owner of the body is `const`, /// just that it has to be checked as if it were. - pub fn body_const_context(self, def_id: LocalDefId) -> Option { + pub fn body_const_context(self, def_id: impl Into) -> Option { + let def_id = def_id.into(); let ccx = match self.body_owner_kind(def_id) { BodyOwnerKind::Const { inline } => ConstContext::Const { inline }, BodyOwnerKind::Static(mt) => ConstContext::Static(mt), - BodyOwnerKind::Fn if self.tcx.is_constructor(def_id.to_def_id()) => return None, - BodyOwnerKind::Fn | BodyOwnerKind::Closure - if self.tcx.is_const_fn_raw(def_id.to_def_id()) => - { - ConstContext::ConstFn - } - BodyOwnerKind::Fn if self.tcx.is_const_default_method(def_id.to_def_id()) => { + BodyOwnerKind::Fn if self.tcx.is_constructor(def_id) => return None, + BodyOwnerKind::Fn | BodyOwnerKind::Closure if self.tcx.is_const_fn_raw(def_id) => { ConstContext::ConstFn } + BodyOwnerKind::Fn if self.tcx.is_const_default_method(def_id) => ConstContext::ConstFn, BodyOwnerKind::Fn | BodyOwnerKind::Closure => return None, }; diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs index 1da090a7e46ee..8b1d33848eab3 100644 --- a/compiler/rustc_middle/src/ty/util.rs +++ b/compiler/rustc_middle/src/ty/util.rs @@ -782,7 +782,8 @@ impl<'tcx> TyCtxt<'tcx> { || self.extern_crate(key.as_def_id()).is_some_and(|e| e.is_direct()) } - pub fn expected_host_effect_param_for_body(self, def_id: LocalDefId) -> ty::Const<'tcx> { + pub fn expected_host_effect_param_for_body(self, def_id: impl Into) -> ty::Const<'tcx> { + let def_id = def_id.into(); // FIXME(effects): This is suspicious and should probably not be done, // especially now that we enforce host effects and then properly handle // effect vars during fallback. diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs index 61faaa10b8a43..d8abe411030b6 100644 --- a/src/tools/clippy/clippy_lints/src/derive.rs +++ b/src/tools/clippy/clippy_lints/src/derive.rs @@ -450,12 +450,12 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r && let Some(def_id) = trait_ref.trait_def_id() && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id) && let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id) - && !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]) + && !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, adt.did(),&[]) // If all of our fields implement `Eq`, we can implement `Eq` too && adt .all_fields() .map(|f| f.ty(cx.tcx, args)) - .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[])) + .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, adt.did(), &[])) { span_lint_and_sugg( cx, diff --git a/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs b/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs index 9a66cbde53c0f..4811691c80d1e 100644 --- a/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs +++ b/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs @@ -194,6 +194,10 @@ fn is_same_generics<'tcx>( .enumerate() .skip(1) // skip `Self` implicit arg .all(|(arg_index, arg)| { + if [implied_by_generics.host_effect_index, implied_generics.host_effect_index].contains(&Some(arg_index)) { + // skip host effect params in determining whether generics are same + return true; + } if let Some(ty) = arg.as_type() { if let &ty::Param(ty::ParamTy { index, .. }) = ty.kind() // `index == 0` means that it's referring to `Self`, diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs index 1c2b7a169fc39..c7980060807c3 100644 --- a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs @@ -118,7 +118,7 @@ fn is_ref_iterable<'tcx>( .liberate_late_bound_regions(fn_id, cx.tcx.fn_sig(fn_id).skip_binder()) && let &[req_self_ty, req_res_ty] = &**sig.inputs_and_output && let param_env = cx.tcx.param_env(fn_id) - && implements_trait_with_env(cx.tcx, param_env, req_self_ty, trait_id, &[]) + && implements_trait_with_env(cx.tcx, param_env, req_self_ty, trait_id, fn_id, &[]) && let Some(into_iter_ty) = make_normalized_projection_with_regions(cx.tcx, param_env, trait_id, sym!(IntoIter), [req_self_ty]) && let req_res_ty = normalize_with_regions(cx.tcx, param_env, req_res_ty) 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 27da44812eb1a..2c5c3dcaa7528 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 @@ -186,6 +186,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { cx.param_env, ty, t, + None, [Option::>::None], ) }) diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs index 1e748a46922cb..868c92f2f54d8 100644 --- a/src/tools/clippy/clippy_utils/src/ty.rs +++ b/src/tools/clippy/clippy_utils/src/ty.rs @@ -214,7 +214,8 @@ pub fn implements_trait<'tcx>( trait_id: DefId, args: &[GenericArg<'tcx>], ) -> bool { - implements_trait_with_env_from_iter(cx.tcx, cx.param_env, ty, trait_id, args.iter().map(|&x| Some(x))) + let callee_id = cx.enclosing_body.map(|body| cx.tcx.hir().body_owner(body).owner.to_def_id()); + implements_trait_with_env_from_iter(cx.tcx, cx.param_env, ty, trait_id, callee_id, args.iter().map(|&x| Some(x))) } /// Same as `implements_trait` but allows using a `ParamEnv` different from the lint context. @@ -223,9 +224,10 @@ pub fn implements_trait_with_env<'tcx>( param_env: ParamEnv<'tcx>, ty: Ty<'tcx>, trait_id: DefId, + callee_id: DefId, args: &[GenericArg<'tcx>], ) -> bool { - implements_trait_with_env_from_iter(tcx, param_env, ty, trait_id, args.iter().map(|&x| Some(x))) + implements_trait_with_env_from_iter(tcx, param_env, ty, trait_id, Some(callee_id), args.iter().map(|&x| Some(x))) } /// Same as `implements_trait_from_env` but takes the arguments as an iterator. @@ -234,6 +236,7 @@ pub fn implements_trait_with_env_from_iter<'tcx>( param_env: ParamEnv<'tcx>, ty: Ty<'tcx>, trait_id: DefId, + callee_id: Option, args: impl IntoIterator>>>, ) -> bool { // Clippy shouldn't have infer types @@ -245,20 +248,29 @@ pub fn implements_trait_with_env_from_iter<'tcx>( } let infcx = tcx.infer_ctxt().build(); + let args = args.into_iter().map(|arg| { + arg.into().unwrap_or_else(|| { + let orig = TypeVariableOrigin { + kind: TypeVariableOriginKind::MiscVariable, + span: DUMMY_SP, + }; + infcx.next_ty_var(orig).into() + }) + }).collect::>(); + + // If an effect arg was not specified, we need to specify it. + let effect_arg = if tcx.generics_of(trait_id).host_effect_index.is_some_and(|x| args.get(x - 1).is_none()) { + Some(GenericArg::from(callee_id.map(|def_id| tcx.expected_host_effect_param_for_body(def_id)).unwrap_or(tcx.consts.true_))) + } else { + None + }; + let trait_ref = TraitRef::new( tcx, trait_id, Some(GenericArg::from(ty)) .into_iter() - .chain(args.into_iter().map(|arg| { - arg.into().unwrap_or_else(|| { - let orig = TypeVariableOrigin { - kind: TypeVariableOriginKind::MiscVariable, - span: DUMMY_SP, - }; - infcx.next_ty_var(orig).into() - }) - })), + .chain(args).chain(effect_arg), ); debug_assert_matches!( From f481596ee4e761182f20eaf1b67d4431cd2d5556 Mon Sep 17 00:00:00 2001 From: Eric Huss Date: Sun, 10 Dec 2023 09:34:13 -0800 Subject: [PATCH 10/13] Remove edition umbrella features. --- .../src/error_codes/E0705.md | 4 +- compiler/rustc_expand/messages.ftl | 3 - compiler/rustc_expand/src/config.rs | 74 +--- compiler/rustc_expand/src/errors.rs | 10 - compiler/rustc_feature/src/accepted.rs | 325 +++++++------- compiler/rustc_feature/src/lib.rs | 3 +- compiler/rustc_feature/src/removed.rs | 145 +++---- compiler/rustc_feature/src/unstable.rs | 399 +++++++++--------- compiler/rustc_span/src/edition.rs | 10 - compiler/rustc_span/src/symbol.rs | 3 - .../rustfmt/tests/source/issue-2927-2.rs | 2 +- src/tools/rustfmt/tests/source/issue-2927.rs | 2 +- .../rustfmt/tests/target/issue-2927-2.rs | 2 +- src/tools/rustfmt/tests/target/issue-2927.rs | 2 +- tests/ui/editions/edition-feature-ok.rs | 5 - .../ui/editions/edition-feature-redundant.rs | 7 - .../editions/edition-feature-redundant.stderr | 9 - tests/ui/editions/epoch-gate-feature.rs | 15 - tests/ui/error-codes/E0705.rs | 10 - tests/ui/error-codes/E0705.stderr | 9 - .../proc-macro/custom-attr-only-one-derive.rs | 2 - .../edition-lint-fully-qualified-paths.fixed | 1 - .../edition-lint-fully-qualified-paths.rs | 1 - .../edition-lint-fully-qualified-paths.stderr | 8 +- .../edition-lint-nested-empty-paths.fixed | 1 - .../edition-lint-nested-empty-paths.rs | 1 - .../edition-lint-nested-empty-paths.stderr | 12 +- .../rust-2018/edition-lint-nested-paths.fixed | 1 - .../ui/rust-2018/edition-lint-nested-paths.rs | 1 - .../edition-lint-nested-paths.stderr | 10 +- tests/ui/rust-2018/edition-lint-paths.fixed | 1 - tests/ui/rust-2018/edition-lint-paths.rs | 1 - tests/ui/rust-2018/edition-lint-paths.stderr | 20 +- .../ui/rust-2018/extern-crate-idiomatic.fixed | 1 - tests/ui/rust-2018/extern-crate-idiomatic.rs | 1 - ...extern-crate-referenced-by-self-path.fixed | 1 - .../extern-crate-referenced-by-self-path.rs | 1 - tests/ui/rust-2018/extern-crate-rename.fixed | 1 - tests/ui/rust-2018/extern-crate-rename.rs | 1 - tests/ui/rust-2018/extern-crate-rename.stderr | 4 +- tests/ui/rust-2018/extern-crate-submod.fixed | 1 - tests/ui/rust-2018/extern-crate-submod.rs | 1 - tests/ui/rust-2018/extern-crate-submod.stderr | 4 +- tests/ui/rust-2018/issue-51008-1.rs | 2 - tests/ui/rust-2018/issue-51008.rs | 2 - .../ui/rust-2018/proc-macro-crate-in-paths.rs | 1 - .../suggestions-not-always-applicable.fixed | 1 - .../suggestions-not-always-applicable.rs | 1 - tests/ui/tool_lints_2018_preview.rs | 1 - 49 files changed, 471 insertions(+), 652 deletions(-) delete mode 100644 tests/ui/editions/edition-feature-ok.rs delete mode 100644 tests/ui/editions/edition-feature-redundant.rs delete mode 100644 tests/ui/editions/edition-feature-redundant.stderr delete mode 100644 tests/ui/editions/epoch-gate-feature.rs delete mode 100644 tests/ui/error-codes/E0705.rs delete mode 100644 tests/ui/error-codes/E0705.stderr diff --git a/compiler/rustc_error_codes/src/error_codes/E0705.md b/compiler/rustc_error_codes/src/error_codes/E0705.md index eb76d1836fcb7..317f3a47effae 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0705.md +++ b/compiler/rustc_error_codes/src/error_codes/E0705.md @@ -1,9 +1,11 @@ +#### Note: this error code is no longer emitted by the compiler. + A `#![feature]` attribute was declared for a feature that is stable in the current edition, but not in all editions. Erroneous code example: -```rust2018,compile_fail,E0705 +```compile_fail #![feature(rust_2018_preview)] #![feature(test_2018_feature)] // error: the feature // `test_2018_feature` is diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl index fc3f7b1d749d0..475dd348e7b63 100644 --- a/compiler/rustc_expand/messages.ftl +++ b/compiler/rustc_expand/messages.ftl @@ -35,9 +35,6 @@ expand_explain_doc_comment_outer = expand_expr_repeat_no_syntax_vars = attempted to repeat an expression containing no syntax variables matched as repeating at this depth -expand_feature_included_in_edition = - the feature `{$feature}` is included in the Rust {$edition} edition - expand_feature_not_allowed = the feature `{$name}` is not in the list of allowed features diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs index 5ccef343b1723..ac819e366178b 100644 --- a/compiler/rustc_expand/src/config.rs +++ b/compiler/rustc_expand/src/config.rs @@ -1,8 +1,8 @@ //! Conditional compilation stripping. use crate::errors::{ - FeatureIncludedInEdition, FeatureNotAllowed, FeatureRemoved, FeatureRemovedReason, InvalidCfg, - MalformedFeatureAttribute, MalformedFeatureAttributeHelp, RemoveExprNotSupported, + FeatureNotAllowed, FeatureRemoved, FeatureRemovedReason, InvalidCfg, MalformedFeatureAttribute, + MalformedFeatureAttributeHelp, RemoveExprNotSupported, }; use rustc_ast::ptr::P; use rustc_ast::token::{Delimiter, Token, TokenKind}; @@ -13,13 +13,11 @@ use rustc_ast::NodeId; use rustc_ast::{self as ast, AttrStyle, Attribute, HasAttrs, HasTokens, MetaItem}; use rustc_attr as attr; use rustc_data_structures::flat_map_in_place::FlatMapInPlace; -use rustc_data_structures::fx::FxHashSet; use rustc_feature::Features; use rustc_feature::{ACCEPTED_FEATURES, REMOVED_FEATURES, UNSTABLE_FEATURES}; use rustc_parse::validate_attr; use rustc_session::parse::feature_err; use rustc_session::Session; -use rustc_span::edition::ALL_EDITIONS; use rustc_span::symbol::{sym, Symbol}; use rustc_span::Span; use thin_vec::ThinVec; @@ -48,42 +46,6 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) - let mut features = Features::default(); - // The edition from `--edition`. - let crate_edition = sess.edition(); - - // The maximum of (a) the edition from `--edition` and (b) any edition - // umbrella feature-gates declared in the code. - // - E.g. if `crate_edition` is 2015 but `rust_2018_preview` is present, - // `feature_edition` is 2018 - let mut features_edition = crate_edition; - for attr in krate_attrs { - for mi in feature_list(attr) { - if mi.is_word() { - let name = mi.name_or_empty(); - let edition = ALL_EDITIONS.iter().find(|e| name == e.feature_name()).copied(); - if let Some(edition) = edition - && edition > features_edition - { - features_edition = edition; - } - } - } - } - - // Enable edition-dependent features based on `features_edition`. - // - E.g. enable `test_2018_feature` if `features_edition` is 2018 or higher - let mut edition_enabled_features = FxHashSet::default(); - for f in UNSTABLE_FEATURES { - if let Some(edition) = f.feature.edition - && edition <= features_edition - { - // FIXME(Manishearth) there is currently no way to set lib features by - // edition. - edition_enabled_features.insert(f.feature.name); - (f.set_enabled)(&mut features); - } - } - // Process all features declared in the code. for attr in krate_attrs { for mi in feature_list(attr) { @@ -108,38 +70,6 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) - } }; - // If the declared feature is an edition umbrella feature-gate, - // warn if it was redundant w.r.t. `crate_edition`. - // - E.g. warn if `rust_2018_preview` is declared when - // `crate_edition` is 2018 - // - E.g. don't warn if `rust_2018_preview` is declared when - // `crate_edition` is 2015. - if let Some(&edition) = ALL_EDITIONS.iter().find(|e| name == e.feature_name()) { - if edition <= crate_edition { - sess.emit_warning(FeatureIncludedInEdition { - span: mi.span(), - feature: name, - edition, - }); - } - features.set_declared_lang_feature(name, mi.span(), None); - continue; - } - - // If the declared feature is edition-dependent and was already - // enabled due to `feature_edition`, give a warning. - // - E.g. warn if `test_2018_feature` is declared when - // `feature_edition` is 2018 or higher. - if edition_enabled_features.contains(&name) { - sess.emit_warning(FeatureIncludedInEdition { - span: mi.span(), - feature: name, - edition: features_edition, - }); - features.set_declared_lang_feature(name, mi.span(), None); - continue; - } - // If the declared feature has been removed, issue an error. if let Some(f) = REMOVED_FEATURES.iter().find(|f| name == f.feature.name) { sess.emit_err(FeatureRemoved { diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs index 6e919a8fa9f2f..2b43fae6852a1 100644 --- a/compiler/rustc_expand/src/errors.rs +++ b/compiler/rustc_expand/src/errors.rs @@ -1,7 +1,6 @@ use rustc_ast::ast; use rustc_macros::Diagnostic; use rustc_session::Limit; -use rustc_span::edition::Edition; use rustc_span::symbol::{Ident, MacroRulesNormalizedIdent}; use rustc_span::{Span, Symbol}; use std::borrow::Cow; @@ -168,15 +167,6 @@ pub(crate) struct TakesNoArguments<'a> { pub name: &'a str, } -#[derive(Diagnostic)] -#[diag(expand_feature_included_in_edition, code = "E0705")] -pub(crate) struct FeatureIncludedInEdition { - #[primary_span] - pub span: Span, - pub feature: Symbol, - pub edition: Edition, -} - #[derive(Diagnostic)] #[diag(expand_feature_removed, code = "E0557")] pub(crate) struct FeatureRemoved<'a> { diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs index 94e7914459321..4993112089a60 100644 --- a/compiler/rustc_feature/src/accepted.rs +++ b/compiler/rustc_feature/src/accepted.rs @@ -5,7 +5,7 @@ use rustc_span::symbol::sym; macro_rules! declare_features { ($( - $(#[doc = $doc:tt])* (accepted, $feature:ident, $ver:expr, $issue:expr, None), + $(#[doc = $doc:tt])* (accepted, $feature:ident, $ver:expr, $issue:expr), )+) => { /// Formerly unstable features that have now been accepted (stabilized). pub const ACCEPTED_FEATURES: &[Feature] = &[ @@ -13,7 +13,6 @@ macro_rules! declare_features { name: sym::$feature, since: $ver, issue: to_nonzero($issue), - edition: None, }),+ ]; } @@ -27,10 +26,10 @@ declare_features! ( /// A temporary feature gate used to enable parser extensions needed /// to bootstrap fix for #5723. - (accepted, issue_5723_bootstrap, "1.0.0", None, None), + (accepted, issue_5723_bootstrap, "1.0.0", None), /// These are used to test this portion of the compiler, /// they don't actually mean anything. - (accepted, test_accepted_feature, "1.0.0", None, None), + (accepted, test_accepted_feature, "1.0.0", None), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! @@ -44,338 +43,338 @@ declare_features! ( // ------------------------------------------------------------------------- /// Allows `#[target_feature(...)]` on aarch64 platforms - (accepted, aarch64_target_feature, "1.61.0", Some(44839), None), + (accepted, aarch64_target_feature, "1.61.0", Some(44839)), /// Allows using the `efiapi` ABI. - (accepted, abi_efiapi, "1.68.0", Some(65815), None), + (accepted, abi_efiapi, "1.68.0", Some(65815)), /// Allows the sysV64 ABI to be specified on all platforms /// instead of just the platforms on which it is the C ABI. - (accepted, abi_sysv64, "1.24.0", Some(36167), None), + (accepted, abi_sysv64, "1.24.0", Some(36167)), /// Allows using the `thiscall` ABI. - (accepted, abi_thiscall, "1.73.0", None, None), + (accepted, abi_thiscall, "1.73.0", None), /// Allows using ADX intrinsics from `core::arch::{x86, x86_64}`. - (accepted, adx_target_feature, "1.61.0", Some(44839), None), + (accepted, adx_target_feature, "1.61.0", Some(44839)), /// Allows explicit discriminants on non-unit enum variants. - (accepted, arbitrary_enum_discriminant, "1.66.0", Some(60553), None), + (accepted, arbitrary_enum_discriminant, "1.66.0", Some(60553)), /// Allows using `sym` operands in inline assembly. - (accepted, asm_sym, "1.66.0", Some(93333), None), + (accepted, asm_sym, "1.66.0", Some(93333)), /// Allows the definition of associated constants in `trait` or `impl` blocks. - (accepted, associated_consts, "1.20.0", Some(29646), None), + (accepted, associated_consts, "1.20.0", Some(29646)), /// Allows using associated `type`s in `trait`s. - (accepted, associated_types, "1.0.0", None, None), + (accepted, associated_types, "1.0.0", None), /// Allows free and inherent `async fn`s, `async` blocks, and `.await` expressions. - (accepted, async_await, "1.39.0", Some(50547), None), + (accepted, async_await, "1.39.0", Some(50547)), /// Allows async functions to be declared, implemented, and used in traits. - (accepted, async_fn_in_trait, "1.75.0", Some(91611), None), + (accepted, async_fn_in_trait, "1.75.0", Some(91611)), /// Allows all literals in attribute lists and values of key-value pairs. - (accepted, attr_literals, "1.30.0", Some(34981), None), + (accepted, attr_literals, "1.30.0", Some(34981)), /// Allows overloading augmented assignment operations like `a += b`. - (accepted, augmented_assignments, "1.8.0", Some(28235), None), + (accepted, augmented_assignments, "1.8.0", Some(28235)), /// Allows mixing bind-by-move in patterns and references to those identifiers in guards. - (accepted, bind_by_move_pattern_guards, "1.39.0", Some(15287), None), + (accepted, bind_by_move_pattern_guards, "1.39.0", Some(15287)), /// Allows bindings in the subpattern of a binding pattern. /// For example, you can write `x @ Some(y)`. - (accepted, bindings_after_at, "1.56.0", Some(65490), None), + (accepted, bindings_after_at, "1.56.0", Some(65490)), /// Allows empty structs and enum variants with braces. - (accepted, braced_empty_structs, "1.8.0", Some(29720), None), + (accepted, braced_empty_structs, "1.8.0", Some(29720)), /// Allows `c"foo"` literals. - (accepted, c_str_literals, "CURRENT_RUSTC_VERSION", Some(105723), None), + (accepted, c_str_literals, "CURRENT_RUSTC_VERSION", Some(105723)), /// Allows `#[cfg_attr(predicate, multiple, attributes, here)]`. - (accepted, cfg_attr_multi, "1.33.0", Some(54881), None), + (accepted, cfg_attr_multi, "1.33.0", Some(54881)), /// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests. - (accepted, cfg_doctest, "1.40.0", Some(62210), None), + (accepted, cfg_doctest, "1.40.0", Some(62210)), /// Enables `#[cfg(panic = "...")]` config key. - (accepted, cfg_panic, "1.60.0", Some(77443), None), + (accepted, cfg_panic, "1.60.0", Some(77443)), /// Allows `cfg(target_feature = "...")`. - (accepted, cfg_target_feature, "1.27.0", Some(29717), None), + (accepted, cfg_target_feature, "1.27.0", Some(29717)), /// Allows `cfg(target_vendor = "...")`. - (accepted, cfg_target_vendor, "1.33.0", Some(29718), None), + (accepted, cfg_target_vendor, "1.33.0", Some(29718)), /// Allows implementing `Clone` for closures where possible (RFC 2132). - (accepted, clone_closures, "1.26.0", Some(44490), None), + (accepted, clone_closures, "1.26.0", Some(44490)), /// Allows coercing non capturing closures to function pointers. - (accepted, closure_to_fn_coercion, "1.19.0", Some(39817), None), + (accepted, closure_to_fn_coercion, "1.19.0", Some(39817)), /// Allows using the CMPXCHG16B target feature. - (accepted, cmpxchg16b_target_feature, "1.69.0", Some(44839), None), + (accepted, cmpxchg16b_target_feature, "1.69.0", Some(44839)), /// Allows usage of the `compile_error!` macro. - (accepted, compile_error, "1.20.0", Some(40872), None), + (accepted, compile_error, "1.20.0", Some(40872)), /// Allows `impl Trait` in function return types. - (accepted, conservative_impl_trait, "1.26.0", Some(34511), None), + (accepted, conservative_impl_trait, "1.26.0", Some(34511)), /// Allows calling constructor functions in `const fn`. - (accepted, const_constructor, "1.40.0", Some(61456), None), + (accepted, const_constructor, "1.40.0", Some(61456)), /// Allows using and casting function pointers in a `const fn`. - (accepted, const_fn_fn_ptr_basics, "1.61.0", Some(57563), None), + (accepted, const_fn_fn_ptr_basics, "1.61.0", Some(57563)), /// Allows trait bounds in `const fn`. - (accepted, const_fn_trait_bound, "1.61.0", Some(93706), None), + (accepted, const_fn_trait_bound, "1.61.0", Some(93706)), /// Allows calling `transmute` in const fn - (accepted, const_fn_transmute, "1.56.0", Some(53605), None), + (accepted, const_fn_transmute, "1.56.0", Some(53605)), /// Allows accessing fields of unions inside `const` functions. - (accepted, const_fn_union, "1.56.0", Some(51909), None), + (accepted, const_fn_union, "1.56.0", Some(51909)), /// Allows unsizing coercions in `const fn`. - (accepted, const_fn_unsize, "1.54.0", Some(64992), None), + (accepted, const_fn_unsize, "1.54.0", Some(64992)), /// Allows const generics to have default values (e.g. `struct Foo(...);`). - (accepted, const_generics_defaults, "1.59.0", Some(44580), None), + (accepted, const_generics_defaults, "1.59.0", Some(44580)), /// Allows the use of `if` and `match` in constants. - (accepted, const_if_match, "1.46.0", Some(49146), None), + (accepted, const_if_match, "1.46.0", Some(49146)), /// Allows argument and return position `impl Trait` in a `const fn`. - (accepted, const_impl_trait, "1.61.0", Some(77463), None), + (accepted, const_impl_trait, "1.61.0", Some(77463)), /// Allows indexing into constant arrays. - (accepted, const_indexing, "1.26.0", Some(29947), None), + (accepted, const_indexing, "1.26.0", Some(29947)), /// Allows let bindings, assignments and destructuring in `const` functions and constants. /// As long as control flow is not implemented in const eval, `&&` and `||` may not be used /// at the same time as let bindings. - (accepted, const_let, "1.33.0", Some(48821), None), + (accepted, const_let, "1.33.0", Some(48821)), /// Allows the use of `loop` and `while` in constants. - (accepted, const_loop, "1.46.0", Some(52000), None), + (accepted, const_loop, "1.46.0", Some(52000)), /// Allows panicking during const eval (producing compile-time errors). - (accepted, const_panic, "1.57.0", Some(51999), None), + (accepted, const_panic, "1.57.0", Some(51999)), /// Allows dereferencing raw pointers during const eval. - (accepted, const_raw_ptr_deref, "1.58.0", Some(51911), None), + (accepted, const_raw_ptr_deref, "1.58.0", Some(51911)), /// Allows implementing `Copy` for closures where possible (RFC 2132). - (accepted, copy_closures, "1.26.0", Some(44490), None), + (accepted, copy_closures, "1.26.0", Some(44490)), /// Allows `crate` in paths. - (accepted, crate_in_paths, "1.30.0", Some(45477), None), + (accepted, crate_in_paths, "1.30.0", Some(45477)), /// Allows using `#[debugger_visualizer]` attribute. - (accepted, debugger_visualizer, "1.71.0", Some(95939), None), + (accepted, debugger_visualizer, "1.71.0", Some(95939)), /// Allows rustc to inject a default alloc_error_handler - (accepted, default_alloc_error_handler, "1.68.0", Some(66741), None), + (accepted, default_alloc_error_handler, "1.68.0", Some(66741)), /// Allows using assigning a default type to type parameters in algebraic data type definitions. - (accepted, default_type_params, "1.0.0", None, None), + (accepted, default_type_params, "1.0.0", None), /// Allows `#[deprecated]` attribute. - (accepted, deprecated, "1.9.0", Some(29935), None), + (accepted, deprecated, "1.9.0", Some(29935)), /// Allows `#[derive(Default)]` and `#[default]` on enums. - (accepted, derive_default_enum, "1.62.0", Some(86985), None), + (accepted, derive_default_enum, "1.62.0", Some(86985)), /// Allows the use of destructuring assignments. - (accepted, destructuring_assignment, "1.59.0", Some(71126), None), + (accepted, destructuring_assignment, "1.59.0", Some(71126)), /// Allows `#[doc(alias = "...")]`. - (accepted, doc_alias, "1.48.0", Some(50146), None), + (accepted, doc_alias, "1.48.0", Some(50146)), /// Allows `..` in tuple (struct) patterns. - (accepted, dotdot_in_tuple_patterns, "1.14.0", Some(33627), None), + (accepted, dotdot_in_tuple_patterns, "1.14.0", Some(33627)), /// Allows `..=` in patterns (RFC 1192). - (accepted, dotdoteq_in_patterns, "1.26.0", Some(28237), None), + (accepted, dotdoteq_in_patterns, "1.26.0", Some(28237)), /// Allows `Drop` types in constants (RFC 1440). - (accepted, drop_types_in_const, "1.22.0", Some(33156), None), + (accepted, drop_types_in_const, "1.22.0", Some(33156)), /// Allows using `dyn Trait` as a syntax for trait objects. - (accepted, dyn_trait, "1.27.0", Some(44662), None), + (accepted, dyn_trait, "1.27.0", Some(44662)), /// Allows integer match exhaustiveness checking (RFC 2591). - (accepted, exhaustive_integer_patterns, "1.33.0", Some(50907), None), + (accepted, exhaustive_integer_patterns, "1.33.0", Some(50907)), /// Allows explicit generic arguments specification with `impl Trait` present. - (accepted, explicit_generic_args_with_impl_trait, "1.63.0", Some(83701), None), + (accepted, explicit_generic_args_with_impl_trait, "1.63.0", Some(83701)), /// Allows arbitrary expressions in key-value attributes at parse time. - (accepted, extended_key_value_attributes, "1.54.0", Some(78835), None), + (accepted, extended_key_value_attributes, "1.54.0", Some(78835)), /// Allows resolving absolute paths as paths from other crates. - (accepted, extern_absolute_paths, "1.30.0", Some(44660), None), + (accepted, extern_absolute_paths, "1.30.0", Some(44660)), /// Allows `extern crate foo as bar;`. This puts `bar` into extern prelude. - (accepted, extern_crate_item_prelude, "1.31.0", Some(55599), None), + (accepted, extern_crate_item_prelude, "1.31.0", Some(55599)), /// Allows `extern crate self as foo;`. /// This puts local crate root into extern prelude under name `foo`. - (accepted, extern_crate_self, "1.34.0", Some(56409), None), + (accepted, extern_crate_self, "1.34.0", Some(56409)), /// Allows access to crate names passed via `--extern` through prelude. - (accepted, extern_prelude, "1.30.0", Some(44660), None), + (accepted, extern_prelude, "1.30.0", Some(44660)), /// Allows using F16C intrinsics from `core::arch::{x86, x86_64}`. - (accepted, f16c_target_feature, "1.68.0", Some(44839), None), + (accepted, f16c_target_feature, "1.68.0", Some(44839)), /// Allows field shorthands (`x` meaning `x: x`) in struct literal expressions. - (accepted, field_init_shorthand, "1.17.0", Some(37340), None), + (accepted, field_init_shorthand, "1.17.0", Some(37340)), /// Allows `#[must_use]` on functions, and introduces must-use operators (RFC 1940). - (accepted, fn_must_use, "1.27.0", Some(43302), None), + (accepted, fn_must_use, "1.27.0", Some(43302)), /// Allows capturing variables in scope using format_args! - (accepted, format_args_capture, "1.58.0", Some(67984), None), + (accepted, format_args_capture, "1.58.0", Some(67984)), /// Allows associated types to be generic, e.g., `type Foo;` (RFC 1598). - (accepted, generic_associated_types, "1.65.0", Some(44265), None), + (accepted, generic_associated_types, "1.65.0", Some(44265)), /// Allows attributes on lifetime/type formal parameters in generics (RFC 1327). - (accepted, generic_param_attrs, "1.27.0", Some(48848), None), + (accepted, generic_param_attrs, "1.27.0", Some(48848)), /// Allows the `#[global_allocator]` attribute. - (accepted, global_allocator, "1.28.0", Some(27389), None), + (accepted, global_allocator, "1.28.0", Some(27389)), // FIXME: explain `globs`. - (accepted, globs, "1.0.0", None, None), + (accepted, globs, "1.0.0", None), /// Allows using `..=X` as a pattern. - (accepted, half_open_range_patterns, "1.66.0", Some(67264), None), + (accepted, half_open_range_patterns, "1.66.0", Some(67264)), /// Allows using the `u128` and `i128` types. - (accepted, i128_type, "1.26.0", Some(35118), None), + (accepted, i128_type, "1.26.0", Some(35118)), /// Allows the use of `if let` expressions. - (accepted, if_let, "1.0.0", None, None), + (accepted, if_let, "1.0.0", None), /// Allows top level or-patterns (`p | q`) in `if let` and `while let`. - (accepted, if_while_or_patterns, "1.33.0", Some(48215), None), + (accepted, if_while_or_patterns, "1.33.0", Some(48215)), /// Allows lifetime elision in `impl` headers. For example: /// + `impl Iterator for &mut Iterator` /// + `impl Debug for Foo<'_>` - (accepted, impl_header_lifetime_elision, "1.31.0", Some(15872), None), + (accepted, impl_header_lifetime_elision, "1.31.0", Some(15872)), /// Allows referencing `Self` and projections in impl-trait. - (accepted, impl_trait_projections, "1.74.0", Some(103532), None), + (accepted, impl_trait_projections, "1.74.0", Some(103532)), /// Allows using `a..=b` and `..=b` as inclusive range syntaxes. - (accepted, inclusive_range_syntax, "1.26.0", Some(28237), None), + (accepted, inclusive_range_syntax, "1.26.0", Some(28237)), /// Allows inferring outlives requirements (RFC 2093). - (accepted, infer_outlives_requirements, "1.30.0", Some(44493), None), + (accepted, infer_outlives_requirements, "1.30.0", Some(44493)), /// Allows irrefutable patterns in `if let` and `while let` statements (RFC 2086). - (accepted, irrefutable_let_patterns, "1.33.0", Some(44495), None), + (accepted, irrefutable_let_patterns, "1.33.0", Some(44495)), /// Allows `#[instruction_set(_)]` attribute. - (accepted, isa_attribute, "1.67.0", Some(74727), None), + (accepted, isa_attribute, "1.67.0", Some(74727)), /// Allows some increased flexibility in the name resolution rules, /// especially around globs and shadowing (RFC 1560). - (accepted, item_like_imports, "1.15.0", Some(35120), None), + (accepted, item_like_imports, "1.15.0", Some(35120)), /// Allows `'a: { break 'a; }`. - (accepted, label_break_value, "1.65.0", Some(48594), None), + (accepted, label_break_value, "1.65.0", Some(48594)), /// Allows `let...else` statements. - (accepted, let_else, "1.65.0", Some(87335), None), + (accepted, let_else, "1.65.0", Some(87335)), /// Allows `break {expr}` with a value inside `loop`s. - (accepted, loop_break_value, "1.19.0", Some(37339), None), + (accepted, loop_break_value, "1.19.0", Some(37339)), /// Allows use of `?` as the Kleene "at most one" operator in macros. - (accepted, macro_at_most_once_rep, "1.32.0", Some(48075), None), + (accepted, macro_at_most_once_rep, "1.32.0", Some(48075)), /// Allows macro attributes to observe output of `#[derive]`. - (accepted, macro_attributes_in_derive_output, "1.57.0", Some(81119), None), + (accepted, macro_attributes_in_derive_output, "1.57.0", Some(81119)), /// Allows use of the `:lifetime` macro fragment specifier. - (accepted, macro_lifetime_matcher, "1.27.0", Some(34303), None), + (accepted, macro_lifetime_matcher, "1.27.0", Some(34303)), /// Allows use of the `:literal` macro fragment specifier (RFC 1576). - (accepted, macro_literal_matcher, "1.32.0", Some(35625), None), + (accepted, macro_literal_matcher, "1.32.0", Some(35625)), /// Allows `macro_rules!` items. - (accepted, macro_rules, "1.0.0", None, None), + (accepted, macro_rules, "1.0.0", None), /// Allows use of the `:vis` macro fragment specifier - (accepted, macro_vis_matcher, "1.30.0", Some(41022), None), + (accepted, macro_vis_matcher, "1.30.0", Some(41022)), /// Allows macro invocations in `extern {}` blocks. - (accepted, macros_in_extern, "1.40.0", Some(49476), None), + (accepted, macros_in_extern, "1.40.0", Some(49476)), /// Allows '|' at beginning of match arms (RFC 1925). - (accepted, match_beginning_vert, "1.25.0", Some(44101), None), + (accepted, match_beginning_vert, "1.25.0", Some(44101)), /// Allows default match binding modes (RFC 2005). - (accepted, match_default_bindings, "1.26.0", Some(42640), None), + (accepted, match_default_bindings, "1.26.0", Some(42640)), /// Allows `impl Trait` with multiple unrelated lifetimes. - (accepted, member_constraints, "1.54.0", Some(61997), None), + (accepted, member_constraints, "1.54.0", Some(61997)), /// Allows the definition of `const fn` functions. - (accepted, min_const_fn, "1.31.0", Some(53555), None), + (accepted, min_const_fn, "1.31.0", Some(53555)), /// The smallest useful subset of const generics. - (accepted, min_const_generics, "1.51.0", Some(74878), None), + (accepted, min_const_generics, "1.51.0", Some(74878)), /// Allows calling `const unsafe fn` inside `unsafe` blocks in `const fn` functions. - (accepted, min_const_unsafe_fn, "1.33.0", Some(55607), None), + (accepted, min_const_unsafe_fn, "1.33.0", Some(55607)), /// Allows using `Self` and associated types in struct expressions and patterns. - (accepted, more_struct_aliases, "1.16.0", Some(37544), None), + (accepted, more_struct_aliases, "1.16.0", Some(37544)), /// Allows using the MOVBE target feature. - (accepted, movbe_target_feature, "1.70.0", Some(44839), None), + (accepted, movbe_target_feature, "1.70.0", Some(44839)), /// Allows patterns with concurrent by-move and by-ref bindings. /// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref. - (accepted, move_ref_pattern, "1.49.0", Some(68354), None), + (accepted, move_ref_pattern, "1.49.0", Some(68354)), /// Allows specifying modifiers in the link attribute: `#[link(modifiers = "...")]` - (accepted, native_link_modifiers, "1.61.0", Some(81490), None), + (accepted, native_link_modifiers, "1.61.0", Some(81490)), /// Allows specifying the bundle link modifier - (accepted, native_link_modifiers_bundle, "1.63.0", Some(81490), None), + (accepted, native_link_modifiers_bundle, "1.63.0", Some(81490)), /// Allows specifying the verbatim link modifier - (accepted, native_link_modifiers_verbatim, "1.67.0", Some(81490), None), + (accepted, native_link_modifiers_verbatim, "1.67.0", Some(81490)), /// Allows specifying the whole-archive link modifier - (accepted, native_link_modifiers_whole_archive, "1.61.0", Some(81490), None), + (accepted, native_link_modifiers_whole_archive, "1.61.0", Some(81490)), /// Allows using non lexical lifetimes (RFC 2094). - (accepted, nll, "1.63.0", Some(43234), None), + (accepted, nll, "1.63.0", Some(43234)), /// Allows using `#![no_std]`. - (accepted, no_std, "1.6.0", None, None), + (accepted, no_std, "1.6.0", None), /// Allows defining identifiers beyond ASCII. - (accepted, non_ascii_idents, "1.53.0", Some(55467), None), + (accepted, non_ascii_idents, "1.53.0", Some(55467)), /// Allows future-proofing enums/structs with the `#[non_exhaustive]` attribute (RFC 2008). - (accepted, non_exhaustive, "1.40.0", Some(44109), None), + (accepted, non_exhaustive, "1.40.0", Some(44109)), /// Allows `foo.rs` as an alternative to `foo/mod.rs`. - (accepted, non_modrs_mods, "1.30.0", Some(44660), None), + (accepted, non_modrs_mods, "1.30.0", Some(44660)), /// Allows the use of or-patterns (e.g., `0 | 1`). - (accepted, or_patterns, "1.53.0", Some(54883), None), + (accepted, or_patterns, "1.53.0", Some(54883)), /// Allows using `+bundle,+whole-archive` link modifiers with native libs. - (accepted, packed_bundled_libs, "1.74.0", Some(108081), None), + (accepted, packed_bundled_libs, "1.74.0", Some(108081)), /// Allows annotating functions conforming to `fn(&PanicInfo) -> !` with `#[panic_handler]`. /// This defines the behavior of panics. - (accepted, panic_handler, "1.30.0", Some(44489), None), + (accepted, panic_handler, "1.30.0", Some(44489)), /// Allows attributes in formal function parameters. - (accepted, param_attrs, "1.39.0", Some(60406), None), + (accepted, param_attrs, "1.39.0", Some(60406)), /// Allows parentheses in patterns. - (accepted, pattern_parentheses, "1.31.0", Some(51087), None), + (accepted, pattern_parentheses, "1.31.0", Some(51087)), /// Allows procedural macros in `proc-macro` crates. - (accepted, proc_macro, "1.29.0", Some(38356), None), + (accepted, proc_macro, "1.29.0", Some(38356)), /// Allows multi-segment paths in attributes and derives. - (accepted, proc_macro_path_invoc, "1.30.0", Some(38356), None), + (accepted, proc_macro_path_invoc, "1.30.0", Some(38356)), /// Allows `pub(restricted)` visibilities (RFC 1422). - (accepted, pub_restricted, "1.18.0", Some(32409), None), + (accepted, pub_restricted, "1.18.0", Some(32409)), /// Allows use of the postfix `?` operator in expressions. - (accepted, question_mark, "1.13.0", Some(31436), None), + (accepted, question_mark, "1.13.0", Some(31436)), /// Allows the use of raw-dylibs (RFC 2627). - (accepted, raw_dylib, "1.71.0", Some(58713), None), + (accepted, raw_dylib, "1.71.0", Some(58713)), /// Allows keywords to be escaped for use as identifiers. - (accepted, raw_identifiers, "1.30.0", Some(48589), None), + (accepted, raw_identifiers, "1.30.0", Some(48589)), /// Allows relaxing the coherence rules such that /// `impl ForeignTrait for ForeignType` is permitted. - (accepted, re_rebalance_coherence, "1.41.0", Some(55437), None), + (accepted, re_rebalance_coherence, "1.41.0", Some(55437)), /// Allows numeric fields in struct expressions and patterns. - (accepted, relaxed_adts, "1.19.0", Some(35626), None), + (accepted, relaxed_adts, "1.19.0", Some(35626)), /// Lessens the requirements for structs to implement `Unsize`. - (accepted, relaxed_struct_unsize, "1.58.0", Some(81793), None), + (accepted, relaxed_struct_unsize, "1.58.0", Some(81793)), /// Allows `repr(align(16))` struct attribute (RFC 1358). - (accepted, repr_align, "1.25.0", Some(33626), None), + (accepted, repr_align, "1.25.0", Some(33626)), /// Allows using `#[repr(align(X))]` on enums with equivalent semantics /// to wrapping an enum in a wrapper struct with `#[repr(align(X))]`. - (accepted, repr_align_enum, "1.37.0", Some(57996), None), + (accepted, repr_align_enum, "1.37.0", Some(57996)), /// Allows `#[repr(packed(N))]` attribute on structs. - (accepted, repr_packed, "1.33.0", Some(33158), None), + (accepted, repr_packed, "1.33.0", Some(33158)), /// Allows `#[repr(transparent)]` attribute on newtype structs. - (accepted, repr_transparent, "1.28.0", Some(43036), None), + (accepted, repr_transparent, "1.28.0", Some(43036)), /// Allows return-position `impl Trait` in traits. - (accepted, return_position_impl_trait_in_trait, "1.75.0", Some(91611), None), + (accepted, return_position_impl_trait_in_trait, "1.75.0", Some(91611)), /// Allows code like `let x: &'static u32 = &42` to work (RFC 1414). - (accepted, rvalue_static_promotion, "1.21.0", Some(38865), None), + (accepted, rvalue_static_promotion, "1.21.0", Some(38865)), /// Allows `Self` in type definitions (RFC 2300). - (accepted, self_in_typedefs, "1.32.0", Some(49303), None), + (accepted, self_in_typedefs, "1.32.0", Some(49303)), /// Allows `Self` struct constructor (RFC 2302). - (accepted, self_struct_ctor, "1.32.0", Some(51994), None), + (accepted, self_struct_ctor, "1.32.0", Some(51994)), /// Allows using subslice patterns, `[a, .., b]` and `[a, xs @ .., b]`. - (accepted, slice_patterns, "1.42.0", Some(62254), None), + (accepted, slice_patterns, "1.42.0", Some(62254)), /// Allows use of `&foo[a..b]` as a slicing syntax. - (accepted, slicing_syntax, "1.0.0", None, None), + (accepted, slicing_syntax, "1.0.0", None), /// Allows elision of `'static` lifetimes in `static`s and `const`s. - (accepted, static_in_const, "1.17.0", Some(35897), None), + (accepted, static_in_const, "1.17.0", Some(35897)), /// Allows the definition recursive static items. - (accepted, static_recursion, "1.17.0", Some(29719), None), + (accepted, static_recursion, "1.17.0", Some(29719)), /// Allows attributes on struct literal fields. - (accepted, struct_field_attributes, "1.20.0", Some(38814), None), + (accepted, struct_field_attributes, "1.20.0", Some(38814)), /// Allows struct variants `Foo { baz: u8, .. }` in enums (RFC 418). - (accepted, struct_variant, "1.0.0", None, None), + (accepted, struct_variant, "1.0.0", None), /// Allows `#[target_feature(...)]`. - (accepted, target_feature, "1.27.0", None, None), + (accepted, target_feature, "1.27.0", None), /// Allows `fn main()` with return types which implements `Termination` (RFC 1937). - (accepted, termination_trait, "1.26.0", Some(43301), None), + (accepted, termination_trait, "1.26.0", Some(43301)), /// Allows `#[test]` functions where the return type implements `Termination` (RFC 1937). - (accepted, termination_trait_test, "1.27.0", Some(48854), None), + (accepted, termination_trait_test, "1.27.0", Some(48854)), /// Allows attributes scoped to tools. - (accepted, tool_attributes, "1.30.0", Some(44690), None), + (accepted, tool_attributes, "1.30.0", Some(44690)), /// Allows scoped lints. - (accepted, tool_lints, "1.31.0", Some(44690), None), + (accepted, tool_lints, "1.31.0", Some(44690)), /// Allows `#[track_caller]` to be used which provides /// accurate caller location reporting during panic (RFC 2091). - (accepted, track_caller, "1.46.0", Some(47809), None), + (accepted, track_caller, "1.46.0", Some(47809)), /// Allows dyn upcasting trait objects via supertraits. /// Dyn upcasting is casting, e.g., `dyn Foo -> dyn Bar` where `Foo: Bar`. - (accepted, trait_upcasting, "CURRENT_RUSTC_VERSION", Some(65991), None), + (accepted, trait_upcasting, "CURRENT_RUSTC_VERSION", Some(65991)), /// Allows #[repr(transparent)] on univariant enums (RFC 2645). - (accepted, transparent_enums, "1.42.0", Some(60405), None), + (accepted, transparent_enums, "1.42.0", Some(60405)), /// Allows indexing tuples. - (accepted, tuple_indexing, "1.0.0", None, None), + (accepted, tuple_indexing, "1.0.0", None), /// Allows paths to enum variants on type aliases including `Self`. - (accepted, type_alias_enum_variants, "1.37.0", Some(49683), None), + (accepted, type_alias_enum_variants, "1.37.0", Some(49683)), /// Allows macros to appear in the type position. - (accepted, type_macros, "1.13.0", Some(27245), None), + (accepted, type_macros, "1.13.0", Some(27245)), /// Allows `const _: TYPE = VALUE`. - (accepted, underscore_const_names, "1.37.0", Some(54912), None), + (accepted, underscore_const_names, "1.37.0", Some(54912)), /// Allows `use path as _;` and `extern crate c as _;`. - (accepted, underscore_imports, "1.33.0", Some(48216), None), + (accepted, underscore_imports, "1.33.0", Some(48216)), /// Allows `'_` placeholder lifetimes. - (accepted, underscore_lifetimes, "1.26.0", Some(44524), None), + (accepted, underscore_lifetimes, "1.26.0", Some(44524)), /// Allows `use x::y;` to search `x` in the current scope. - (accepted, uniform_paths, "1.32.0", Some(53130), None), + (accepted, uniform_paths, "1.32.0", Some(53130)), /// Allows `impl Trait` in function arguments. - (accepted, universal_impl_trait, "1.26.0", Some(34511), None), + (accepted, universal_impl_trait, "1.26.0", Some(34511)), /// Allows arbitrary delimited token streams in non-macro attributes. - (accepted, unrestricted_attribute_tokens, "1.34.0", Some(55208), None), + (accepted, unrestricted_attribute_tokens, "1.34.0", Some(55208)), /// The `unsafe_op_in_unsafe_fn` lint (allowed by default): no longer treat an unsafe function as an unsafe block. - (accepted, unsafe_block_in_unsafe_fn, "1.52.0", Some(71668), None), + (accepted, unsafe_block_in_unsafe_fn, "1.52.0", Some(71668)), /// Allows importing and reexporting macros with `use`, /// enables macro modularization in general. - (accepted, use_extern_macros, "1.30.0", Some(35896), None), + (accepted, use_extern_macros, "1.30.0", Some(35896)), /// Allows nested groups in `use` items (RFC 2128). - (accepted, use_nested_groups, "1.25.0", Some(44494), None), + (accepted, use_nested_groups, "1.25.0", Some(44494)), /// Allows `#[used]` to preserve symbols (see llvm.compiler.used). - (accepted, used, "1.30.0", Some(40289), None), + (accepted, used, "1.30.0", Some(40289)), /// Allows the use of `while let` expressions. - (accepted, while_let, "1.0.0", None, None), + (accepted, while_let, "1.0.0", None), /// Allows `#![windows_subsystem]`. - (accepted, windows_subsystem, "1.18.0", Some(37499), None), + (accepted, windows_subsystem, "1.18.0", Some(37499)), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! diff --git a/compiler/rustc_feature/src/lib.rs b/compiler/rustc_feature/src/lib.rs index 73d51d9f80e6e..cd1d9b13daa15 100644 --- a/compiler/rustc_feature/src/lib.rs +++ b/compiler/rustc_feature/src/lib.rs @@ -26,7 +26,7 @@ mod unstable; #[cfg(test)] mod tests; -use rustc_span::{edition::Edition, symbol::Symbol}; +use rustc_span::symbol::Symbol; use std::num::NonZeroU32; #[derive(Debug, Clone)] @@ -34,7 +34,6 @@ pub struct Feature { pub name: Symbol, pub since: &'static str, issue: Option, - pub edition: Option, } #[derive(Copy, Clone, Debug)] diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs index c0d3fc3fae0f6..0d9b8b344cfa9 100644 --- a/compiler/rustc_feature/src/removed.rs +++ b/compiler/rustc_feature/src/removed.rs @@ -10,7 +10,7 @@ pub struct RemovedFeature { macro_rules! declare_features { ($( - $(#[doc = $doc:tt])* (removed, $feature:ident, $ver:expr, $issue:expr, None, $reason:expr), + $(#[doc = $doc:tt])* (removed, $feature:ident, $ver:expr, $issue:expr, $reason:expr), )+) => { /// Formerly unstable features that have now been removed. pub const REMOVED_FEATURES: &[RemovedFeature] = &[ @@ -19,7 +19,6 @@ macro_rules! declare_features { name: sym::$feature, since: $ver, issue: to_nonzero($issue), - edition: None, }, reason: $reason }),+ @@ -33,176 +32,178 @@ declare_features! ( // feature-group-start: removed features // ------------------------------------------------------------------------- - (removed, advanced_slice_patterns, "1.0.0", Some(62254), None, + (removed, advanced_slice_patterns, "1.0.0", Some(62254), Some("merged into `#![feature(slice_patterns)]`")), - (removed, allocator, "1.0.0", None, None, None), + (removed, allocator, "1.0.0", None, None), /// Allows a test to fail without failing the whole suite. - (removed, allow_fail, "1.19.0", Some(46488), None, Some("removed due to no clear use cases")), - (removed, await_macro, "1.38.0", Some(50547), None, + (removed, allow_fail, "1.19.0", Some(46488), Some("removed due to no clear use cases")), + (removed, await_macro, "1.38.0", Some(50547), Some("subsumed by `.await` syntax")), /// Allows using the `box $expr` syntax. - (removed, box_syntax, "1.70.0", Some(49733), None, Some("replaced with `#[rustc_box]`")), + (removed, box_syntax, "1.70.0", Some(49733), Some("replaced with `#[rustc_box]`")), /// Allows capturing disjoint fields in a closure/coroutine (RFC 2229). - (removed, capture_disjoint_fields, "1.49.0", Some(53488), None, Some("stabilized in Rust 2021")), + (removed, capture_disjoint_fields, "1.49.0", Some(53488), Some("stabilized in Rust 2021")), /// Allows comparing raw pointers during const eval. - (removed, const_compare_raw_pointers, "1.46.0", Some(53020), None, + (removed, const_compare_raw_pointers, "1.46.0", Some(53020), Some("cannot be allowed in const eval in any meaningful way")), /// Allows limiting the evaluation steps of const expressions - (removed, const_eval_limit, "1.43.0", Some(67217), None, Some("removed the limit entirely")), + (removed, const_eval_limit, "1.43.0", Some(67217), Some("removed the limit entirely")), /// Allows non-trivial generic constants which have to be manually propagated upwards. - (removed, const_evaluatable_checked, "1.48.0", Some(76560), None, Some("renamed to `generic_const_exprs`")), + (removed, const_evaluatable_checked, "1.48.0", Some(76560), Some("renamed to `generic_const_exprs`")), /// Allows the definition of `const` functions with some advanced features. - (removed, const_fn, "1.54.0", Some(57563), None, + (removed, const_fn, "1.54.0", Some(57563), Some("split into finer-grained feature gates")), /// Allows const generic types (e.g. `struct Foo(...);`). - (removed, const_generics, "1.34.0", Some(44580), None, + (removed, const_generics, "1.34.0", Some(44580), Some("removed in favor of `#![feature(adt_const_params)]` and `#![feature(generic_const_exprs)]`")), /// Allows `[x; N]` where `x` is a constant (RFC 2203). - (removed, const_in_array_repeat_expressions, "1.37.0", Some(49147), None, + (removed, const_in_array_repeat_expressions, "1.37.0", Some(49147), Some("removed due to causing promotable bugs")), /// Allows casting raw pointers to `usize` during const eval. - (removed, const_raw_ptr_to_usize_cast, "1.55.0", Some(51910), None, + (removed, const_raw_ptr_to_usize_cast, "1.55.0", Some(51910), Some("at compile-time, pointers do not have an integer value, so these casts cannot be properly supported")), /// Allows `T: ?const Trait` syntax in bounds. - (removed, const_trait_bound_opt_out, "1.42.0", Some(67794), None, + (removed, const_trait_bound_opt_out, "1.42.0", Some(67794), Some("Removed in favor of `~const` bound in #![feature(const_trait_impl)]")), /// Allows using `crate` as visibility modifier, synonymous with `pub(crate)`. - (removed, crate_visibility_modifier, "1.63.0", Some(53120), None, Some("removed in favor of `pub(crate)`")), + (removed, crate_visibility_modifier, "1.63.0", Some(53120), Some("removed in favor of `pub(crate)`")), /// Allows using custom attributes (RFC 572). - (removed, custom_attribute, "1.0.0", Some(29642), None, + (removed, custom_attribute, "1.0.0", Some(29642), Some("removed in favor of `#![register_tool]` and `#![register_attr]`")), /// Allows the use of `#[derive(Anything)]` as sugar for `#[derive_Anything]`. - (removed, custom_derive, "1.32.0", Some(29644), None, + (removed, custom_derive, "1.32.0", Some(29644), Some("subsumed by `#[proc_macro_derive]`")), /// Allows using `#[doc(keyword = "...")]`. - (removed, doc_keyword, "1.28.0", Some(51315), None, + (removed, doc_keyword, "1.28.0", Some(51315), Some("merged into `#![feature(rustdoc_internals)]`")), /// Allows using `doc(primitive)` without a future-incompat warning. - (removed, doc_primitive, "1.56.0", Some(88070), None, + (removed, doc_primitive, "1.56.0", Some(88070), Some("merged into `#![feature(rustdoc_internals)]`")), /// Allows `#[doc(spotlight)]`. /// The attribute was renamed to `#[doc(notable_trait)]` /// and the feature to `doc_notable_trait`. - (removed, doc_spotlight, "1.22.0", Some(45040), None, + (removed, doc_spotlight, "1.22.0", Some(45040), Some("renamed to `doc_notable_trait`")), /// Allows using `#[unsafe_destructor_blind_to_params]` (RFC 1238). - (removed, dropck_parametricity, "1.38.0", Some(28498), None, None), + (removed, dropck_parametricity, "1.38.0", Some(28498), None), /// Allows defining `existential type`s. - (removed, existential_type, "1.38.0", Some(63063), None, + (removed, existential_type, "1.38.0", Some(63063), Some("removed in favor of `#![feature(type_alias_impl_trait)]`")), /// Paths of the form: `extern::foo::bar` - (removed, extern_in_paths, "1.33.0", Some(55600), None, + (removed, extern_in_paths, "1.33.0", Some(55600), Some("subsumed by `::foo::bar` paths")), /// Allows `#[doc(include = "some-file")]`. - (removed, external_doc, "1.54.0", Some(44732), None, + (removed, external_doc, "1.54.0", Some(44732), Some("use #[doc = include_str!(\"filename\")] instead, which handles macro invocations")), /// Allows generators to be cloned. - (removed, generator_clone, "1.65.0", Some(95360), None, Some("renamed to `coroutine_clone`")), + (removed, generator_clone, "1.65.0", Some(95360), Some("renamed to `coroutine_clone`")), /// Allows defining generators. - (removed, generators, "1.21.0", Some(43122), None, Some("renamed to `coroutines`")), + (removed, generators, "1.21.0", Some(43122), Some("renamed to `coroutines`")), /// Allows `impl Trait` in bindings (`let`, `const`, `static`). - (removed, impl_trait_in_bindings, "1.55.0", Some(63065), None, + (removed, impl_trait_in_bindings, "1.55.0", Some(63065), Some("the implementation was not maintainable, the feature may get reintroduced once the current refactorings are done")), - (removed, import_shadowing, "1.0.0", None, None, None), + (removed, import_shadowing, "1.0.0", None, None), /// Allows in-band quantification of lifetime bindings (e.g., `fn foo(x: &'a u8) -> &'a u8`). - (removed, in_band_lifetimes, "1.23.0", Some(44524), None, + (removed, in_band_lifetimes, "1.23.0", Some(44524), Some("removed due to unsolved ergonomic questions and added lifetime resolution complexity")), /// Allows inferring `'static` outlives requirements (RFC 2093). - (removed, infer_static_outlives_requirements, "1.63.0", Some(54185), None, + (removed, infer_static_outlives_requirements, "1.63.0", Some(54185), Some("removed as it caused some confusion and discussion was inactive for years")), /// Lazily evaluate constants. This allows constants to depend on type parameters. - (removed, lazy_normalization_consts, "1.46.0", Some(72219), None, Some("superseded by `generic_const_exprs`")), + (removed, lazy_normalization_consts, "1.46.0", Some(72219), Some("superseded by `generic_const_exprs`")), /// Allows using the `#[link_args]` attribute. - (removed, link_args, "1.53.0", Some(29596), None, + (removed, link_args, "1.53.0", Some(29596), Some("removed in favor of using `-C link-arg=ARG` on command line, \ which is available from cargo build scripts with `cargo:rustc-link-arg` now")), - (removed, macro_reexport, "1.0.0", Some(29638), None, + (removed, macro_reexport, "1.0.0", Some(29638), Some("subsumed by `pub use`")), /// Allows using `#[main]` to replace the entrypoint `#[lang = "start"]` calls. - (removed, main, "1.53.0", Some(29634), None, None), - (removed, managed_boxes, "1.0.0", None, None, None), + (removed, main, "1.53.0", Some(29634), None), + (removed, managed_boxes, "1.0.0", None, None), /// Allows the use of type alias impl trait in function return positions - (removed, min_type_alias_impl_trait, "1.56.0", Some(63063), None, + (removed, min_type_alias_impl_trait, "1.56.0", Some(63063), Some("removed in favor of full type_alias_impl_trait")), - (removed, needs_allocator, "1.4.0", Some(27389), None, + (removed, needs_allocator, "1.4.0", Some(27389), Some("subsumed by `#![feature(allocator_internals)]`")), /// Allows use of unary negate on unsigned integers, e.g., -e for e: u8 - (removed, negate_unsigned, "1.0.0", Some(29645), None, None), + (removed, negate_unsigned, "1.0.0", Some(29645), None), /// Allows `#[no_coverage]` on functions. /// The feature was renamed to `coverage_attribute` and the attribute to `#[coverage(on|off)]` - (removed, no_coverage, "1.74.0", Some(84605), None, Some("renamed to `coverage_attribute`")), + (removed, no_coverage, "1.74.0", Some(84605), Some("renamed to `coverage_attribute`")), /// Allows `#[no_debug]`. - (removed, no_debug, "1.43.0", Some(29721), None, Some("removed due to lack of demand")), + (removed, no_debug, "1.43.0", Some(29721), Some("removed due to lack of demand")), /// Note: this feature was previously recorded in a separate /// `STABLE_REMOVED` list because it, uniquely, was once stable but was /// then removed. But there was no utility storing it separately, so now /// it's in this list. - (removed, no_stack_check, "1.0.0", None, None, None), + (removed, no_stack_check, "1.0.0", None, None), /// Allows using `#[on_unimplemented(..)]` on traits. /// (Moved to `rustc_attrs`.) - (removed, on_unimplemented, "1.40.0", None, None, None), + (removed, on_unimplemented, "1.40.0", None, None), /// A way to temporarily opt out of opt-in copy. This will *never* be accepted. - (removed, opt_out_copy, "1.0.0", None, None, None), + (removed, opt_out_copy, "1.0.0", None, None), /// Allows features specific to OIBIT (now called auto traits). /// Renamed to `auto_traits`. - (removed, optin_builtin_traits, "1.0.0", Some(13231), None, + (removed, optin_builtin_traits, "1.0.0", Some(13231), Some("renamed to `auto_traits`")), /// Allows overlapping impls of marker traits. - (removed, overlapping_marker_traits, "1.42.0", Some(29864), None, + (removed, overlapping_marker_traits, "1.42.0", Some(29864), Some("removed in favor of `#![feature(marker_trait_attr)]`")), - (removed, panic_implementation, "1.28.0", Some(44489), None, + (removed, panic_implementation, "1.28.0", Some(44489), Some("subsumed by `#[panic_handler]`")), /// Allows using `#![plugin(myplugin)]`. - (removed, plugin, "1.75.0", Some(29597), None, + (removed, plugin, "1.75.0", Some(29597), Some("plugins are no longer supported")), /// Allows using `#[plugin_registrar]` on functions. - (removed, plugin_registrar, "1.54.0", Some(29597), None, + (removed, plugin_registrar, "1.54.0", Some(29597), Some("plugins are no longer supported")), /// Allows exhaustive integer pattern matching with `usize::MAX`/`isize::MIN`/`isize::MAX`. - (removed, precise_pointer_size_matching, "1.32.0", Some(56354), None, + (removed, precise_pointer_size_matching, "1.32.0", Some(56354), Some("removed in favor of half-open ranges")), - (removed, proc_macro_expr, "1.27.0", Some(54727), None, + (removed, proc_macro_expr, "1.27.0", Some(54727), Some("subsumed by `#![feature(proc_macro_hygiene)]`")), - (removed, proc_macro_gen, "1.27.0", Some(54727), None, + (removed, proc_macro_gen, "1.27.0", Some(54727), Some("subsumed by `#![feature(proc_macro_hygiene)]`")), - (removed, proc_macro_mod, "1.27.0", Some(54727), None, + (removed, proc_macro_mod, "1.27.0", Some(54727), Some("subsumed by `#![feature(proc_macro_hygiene)]`")), - (removed, proc_macro_non_items, "1.27.0", Some(54727), None, + (removed, proc_macro_non_items, "1.27.0", Some(54727), Some("subsumed by `#![feature(proc_macro_hygiene)]`")), - (removed, pub_macro_rules, "1.53.0", Some(78855), None, + (removed, pub_macro_rules, "1.53.0", Some(78855), Some("removed due to being incomplete, in particular it does not work across crates")), - (removed, pushpop_unsafe, "1.2.0", None, None, None), - (removed, quad_precision_float, "1.0.0", None, None, None), - (removed, quote, "1.33.0", Some(29601), None, None), - (removed, reflect, "1.0.0", Some(27749), None, None), + (removed, pushpop_unsafe, "1.2.0", None, None), + (removed, quad_precision_float, "1.0.0", None, None), + (removed, quote, "1.33.0", Some(29601), None), + (removed, reflect, "1.0.0", Some(27749), None), /// Allows using the `#[register_attr]` attribute. - (removed, register_attr, "1.65.0", Some(66080), None, + (removed, register_attr, "1.65.0", Some(66080), Some("removed in favor of `#![register_tool]`")), + (removed, rust_2018_preview, "CURRENT_RUSTC_VERSION", None, + Some("2018 Edition preview is no longer relevant")), /// Allows using the macros: /// + `__diagnostic_used` /// + `__register_diagnostic` /// +`__build_diagnostic_array` - (removed, rustc_diagnostic_macros, "1.38.0", None, None, None), + (removed, rustc_diagnostic_macros, "1.38.0", None, None), /// Allows identifying crates that contain sanitizer runtimes. - (removed, sanitizer_runtime, "1.17.0", None, None, None), - (removed, simd, "1.0.0", Some(27731), None, + (removed, sanitizer_runtime, "1.17.0", None, None), + (removed, simd, "1.0.0", Some(27731), Some("removed in favor of `#[repr(simd)]`")), /// Allows `#[link(kind = "static-nobundle", ...)]`. - (removed, static_nobundle, "1.16.0", Some(37403), None, + (removed, static_nobundle, "1.16.0", Some(37403), Some(r#"subsumed by `#[link(kind = "static", modifiers = "-bundle", ...)]`"#)), - (removed, struct_inherit, "1.0.0", None, None, None), - (removed, test_removed_feature, "1.0.0", None, None, None), + (removed, struct_inherit, "1.0.0", None, None), + (removed, test_removed_feature, "1.0.0", None, None), /// Allows using items which are missing stability attributes - (removed, unmarked_api, "1.0.0", None, None, None), - (removed, unsafe_no_drop_flag, "1.0.0", None, None, None), + (removed, unmarked_api, "1.0.0", None, None), + (removed, unsafe_no_drop_flag, "1.0.0", None, None), /// Allows `union` fields that don't implement `Copy` as long as they don't have any drop glue. - (removed, untagged_unions, "1.13.0", Some(55149), None, + (removed, untagged_unions, "1.13.0", Some(55149), Some("unions with `Copy` and `ManuallyDrop` fields are stable; there is no intent to stabilize more")), /// Allows `#[unwind(..)]`. /// /// Permits specifying whether a function should permit unwinding or abort on unwind. - (removed, unwind_attributes, "1.56.0", Some(58760), None, Some("use the C-unwind ABI instead")), - (removed, visible_private_types, "1.0.0", None, None, None), + (removed, unwind_attributes, "1.56.0", Some(58760), Some("use the C-unwind ABI instead")), + (removed, visible_private_types, "1.0.0", None, None), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs index 365a16e68383f..bbf5e03117572 100644 --- a/compiler/rustc_feature/src/unstable.rs +++ b/compiler/rustc_feature/src/unstable.rs @@ -3,7 +3,6 @@ use super::{to_nonzero, Feature}; use rustc_data_structures::fx::FxHashSet; -use rustc_span::edition::Edition; use rustc_span::symbol::{sym, Symbol}; use rustc_span::Span; @@ -33,7 +32,7 @@ macro_rules! status_to_enum { macro_rules! declare_features { ($( - $(#[doc = $doc:tt])* ($status:ident, $feature:ident, $ver:expr, $issue:expr, $edition:expr), + $(#[doc = $doc:tt])* ($status:ident, $feature:ident, $ver:expr, $issue:expr), )+) => { /// Unstable language features that are being implemented or being /// considered for acceptance (stabilization) or removal. @@ -43,7 +42,6 @@ macro_rules! declare_features { name: sym::$feature, since: $ver, issue: to_nonzero($issue), - edition: $edition, }, // Sets this feature's corresponding bool within `features`. set_enabled: |features| features.$feature = true, @@ -102,8 +100,7 @@ macro_rules! declare_features { self.declared_features.contains(&feature) } - /// Is the given feature active, i.e. declared or automatically - /// enabled due to the edition? + /// Is the given feature active (enabled by the user)? /// /// Panics if the symbol doesn't correspond to a declared feature. pub fn active(&self, feature: Symbol) -> bool { @@ -179,58 +176,56 @@ declare_features! ( // no-tracking-issue-start /// Allows using the `unadjusted` ABI; perma-unstable. - (internal, abi_unadjusted, "1.16.0", None, None), + (internal, abi_unadjusted, "1.16.0", None), /// Allows using the `vectorcall` ABI. - (unstable, abi_vectorcall, "1.7.0", None, None), + (unstable, abi_vectorcall, "1.7.0", None), /// Allows using `#![needs_allocator]`, an implementation detail of `#[global_allocator]`. - (internal, allocator_internals, "1.20.0", None, None), + (internal, allocator_internals, "1.20.0", None), /// Allows using `#[allow_internal_unsafe]`. This is an /// attribute on `macro_rules!` and can't use the attribute handling /// below (it has to be checked before expansion possibly makes /// macros disappear). - (internal, allow_internal_unsafe, "1.0.0", None, None), + (internal, allow_internal_unsafe, "1.0.0", None), /// Allows using `#[allow_internal_unstable]`. This is an /// attribute on `macro_rules!` and can't use the attribute handling /// below (it has to be checked before expansion possibly makes /// macros disappear). - (internal, allow_internal_unstable, "1.0.0", None, None), + (internal, allow_internal_unstable, "1.0.0", None), /// Allows using anonymous lifetimes in argument-position impl-trait. - (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None, None), + (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None), /// Allows identifying the `compiler_builtins` crate. - (internal, compiler_builtins, "1.13.0", None, None), + (internal, compiler_builtins, "1.13.0", None), /// Allows writing custom MIR - (internal, custom_mir, "1.65.0", None, None), + (internal, custom_mir, "1.65.0", None), /// Outputs useful `assert!` messages - (unstable, generic_assert, "1.63.0", None, None), + (unstable, generic_assert, "1.63.0", None), /// Allows using the `rust-intrinsic`'s "ABI". - (internal, intrinsics, "1.0.0", None, None), + (internal, intrinsics, "1.0.0", None), /// Allows using `#[lang = ".."]` attribute for linking items to special compiler logic. - (internal, lang_items, "1.0.0", None, None), + (internal, lang_items, "1.0.0", None), /// Changes `impl Trait` to capture all lifetimes in scope. - (unstable, lifetime_capture_rules_2024, "CURRENT_RUSTC_VERSION", None, None), + (unstable, lifetime_capture_rules_2024, "CURRENT_RUSTC_VERSION", None), /// Allows `#[link(..., cfg(..))]`; perma-unstable per #37406 - (unstable, link_cfg, "1.14.0", None, None), + (unstable, link_cfg, "1.14.0", None), /// Allows the `multiple_supertrait_upcastable` lint. - (unstable, multiple_supertrait_upcastable, "1.69.0", None, None), + (unstable, multiple_supertrait_upcastable, "1.69.0", None), /// Allow negative trait bounds. This is an internal-only feature for testing the trait solver! - (incomplete, negative_bounds, "1.71.0", None, None), + (incomplete, negative_bounds, "1.71.0", None), /// Allows using `#[omit_gdb_pretty_printer_section]`. - (internal, omit_gdb_pretty_printer_section, "1.5.0", None, None), + (internal, omit_gdb_pretty_printer_section, "1.5.0", None), /// Allows using `#[prelude_import]` on glob `use` items. - (internal, prelude_import, "1.2.0", None, None), + (internal, prelude_import, "1.2.0", None), /// Used to identify crates that contain the profiler runtime. - (internal, profiler_runtime, "1.18.0", None, None), + (internal, profiler_runtime, "1.18.0", None), /// Allows using `rustc_*` attributes (RFC 572). - (internal, rustc_attrs, "1.0.0", None, None), + (internal, rustc_attrs, "1.0.0", None), /// Allows using the `#[stable]` and `#[unstable]` attributes. - (internal, staged_api, "1.0.0", None, None), - /// Added for testing E0705; perma-unstable. - (internal, test_2018_feature, "1.31.0", None, Some(Edition::Edition2018)), + (internal, staged_api, "1.0.0", None), /// Added for testing unstable lints; perma-unstable. - (internal, test_unstable_lint, "1.60.0", None, None), + (internal, test_unstable_lint, "1.60.0", None), /// Use for stable + negative coherence and strict coherence depending on trait's /// rustc_strict_coherence value. - (unstable, with_negative_coherence, "1.60.0", None, None), + (unstable, with_negative_coherence, "1.60.0", None), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! @@ -246,44 +241,44 @@ declare_features! ( /// Allows features specific to auto traits. /// Renamed from `optin_builtin_traits`. - (unstable, auto_traits, "1.50.0", Some(13231), None), + (unstable, auto_traits, "1.50.0", Some(13231)), /// Allows using `box` in patterns (RFC 469). - (unstable, box_patterns, "1.0.0", Some(29641), None), + (unstable, box_patterns, "1.0.0", Some(29641)), /// Allows `#[doc(notable_trait)]`. /// Renamed from `doc_spotlight`. - (unstable, doc_notable_trait, "1.52.0", Some(45040), None), + (unstable, doc_notable_trait, "1.52.0", Some(45040)), /// Allows using the `may_dangle` attribute (RFC 1327). - (unstable, dropck_eyepatch, "1.10.0", Some(34761), None), + (unstable, dropck_eyepatch, "1.10.0", Some(34761)), /// Allows using the `#[fundamental]` attribute. - (unstable, fundamental, "1.0.0", Some(29635), None), + (unstable, fundamental, "1.0.0", Some(29635)), /// Allows using `#[link_name="llvm.*"]`. - (internal, link_llvm_intrinsics, "1.0.0", Some(29602), None), + (internal, link_llvm_intrinsics, "1.0.0", Some(29602)), /// Allows using the `#[linkage = ".."]` attribute. - (unstable, linkage, "1.0.0", Some(29603), None), + (unstable, linkage, "1.0.0", Some(29603)), /// Allows declaring with `#![needs_panic_runtime]` that a panic runtime is needed. - (internal, needs_panic_runtime, "1.10.0", Some(32837), None), + (internal, needs_panic_runtime, "1.10.0", Some(32837)), /// Allows using the `#![panic_runtime]` attribute. - (internal, panic_runtime, "1.10.0", Some(32837), None), + (internal, panic_runtime, "1.10.0", Some(32837)), /// Allows `extern "platform-intrinsic" { ... }`. - (internal, platform_intrinsics, "1.4.0", Some(27731), None), + (internal, platform_intrinsics, "1.4.0", Some(27731)), /// Allows using `#[rustc_allow_const_fn_unstable]`. /// This is an attribute on `const fn` for the same /// purpose as `#[allow_internal_unstable]`. - (internal, rustc_allow_const_fn_unstable, "1.49.0", Some(69399), None), + (internal, rustc_allow_const_fn_unstable, "1.49.0", Some(69399)), /// Allows using compiler's own crates. - (unstable, rustc_private, "1.0.0", Some(27812), None), + (unstable, rustc_private, "1.0.0", Some(27812)), /// Allows using internal rustdoc features like `doc(keyword)`. - (internal, rustdoc_internals, "1.58.0", Some(90418), None), + (internal, rustdoc_internals, "1.58.0", Some(90418)), /// Allows using the `rustdoc::missing_doc_code_examples` lint - (unstable, rustdoc_missing_doc_code_examples, "1.31.0", Some(101730), None), + (unstable, rustdoc_missing_doc_code_examples, "1.31.0", Some(101730)), /// Allows using `#[start]` on a function indicating that it is the program entrypoint. - (unstable, start, "1.0.0", Some(29633), None), + (unstable, start, "1.0.0", Some(29633)), /// Allows using `#[structural_match]` which indicates that a type is structurally matchable. /// FIXME: Subsumed by trait `StructuralPartialEq`, cannot move to removed until a library /// feature with the same name exists. - (unstable, structural_match, "1.8.0", Some(31434), None), + (unstable, structural_match, "1.8.0", Some(31434)), /// Allows using the `rust-call` ABI. - (unstable, unboxed_closures, "1.0.0", Some(29625), None), + (unstable, unboxed_closures, "1.0.0", Some(29625)), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! @@ -299,21 +294,21 @@ declare_features! ( // FIXME: Document these and merge with the list below. // Unstable `#[target_feature]` directives. - (unstable, aarch64_ver_target_feature, "1.27.0", Some(44839), None), - (unstable, arm_target_feature, "1.27.0", Some(44839), None), - (unstable, avx512_target_feature, "1.27.0", Some(44839), None), - (unstable, bpf_target_feature, "1.54.0", Some(44839), None), - (unstable, csky_target_feature, "1.73.0", Some(44839), None), - (unstable, ermsb_target_feature, "1.49.0", Some(44839), None), - (unstable, hexagon_target_feature, "1.27.0", Some(44839), None), - (unstable, loongarch_target_feature, "1.73.0", Some(44839), None), - (unstable, mips_target_feature, "1.27.0", Some(44839), None), - (unstable, powerpc_target_feature, "1.27.0", Some(44839), None), - (unstable, riscv_target_feature, "1.45.0", Some(44839), None), - (unstable, rtm_target_feature, "1.35.0", Some(44839), None), - (unstable, sse4a_target_feature, "1.27.0", Some(44839), None), - (unstable, tbm_target_feature, "1.27.0", Some(44839), None), - (unstable, wasm_target_feature, "1.30.0", Some(44839), None), + (unstable, aarch64_ver_target_feature, "1.27.0", Some(44839)), + (unstable, arm_target_feature, "1.27.0", Some(44839)), + (unstable, avx512_target_feature, "1.27.0", Some(44839)), + (unstable, bpf_target_feature, "1.54.0", Some(44839)), + (unstable, csky_target_feature, "1.73.0", Some(44839)), + (unstable, ermsb_target_feature, "1.49.0", Some(44839)), + (unstable, hexagon_target_feature, "1.27.0", Some(44839)), + (unstable, loongarch_target_feature, "1.73.0", Some(44839)), + (unstable, mips_target_feature, "1.27.0", Some(44839)), + (unstable, powerpc_target_feature, "1.27.0", Some(44839)), + (unstable, riscv_target_feature, "1.45.0", Some(44839)), + (unstable, rtm_target_feature, "1.35.0", Some(44839)), + (unstable, sse4a_target_feature, "1.27.0", Some(44839)), + (unstable, tbm_target_feature, "1.27.0", Some(44839)), + (unstable, wasm_target_feature, "1.30.0", Some(44839)), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! @@ -327,295 +322,295 @@ declare_features! ( // ------------------------------------------------------------------------- /// Allows using the `amdgpu-kernel` ABI. - (unstable, abi_amdgpu_kernel, "1.29.0", Some(51575), None), + (unstable, abi_amdgpu_kernel, "1.29.0", Some(51575)), /// Allows `extern "avr-interrupt" fn()` and `extern "avr-non-blocking-interrupt" fn()`. - (unstable, abi_avr_interrupt, "1.45.0", Some(69664), None), + (unstable, abi_avr_interrupt, "1.45.0", Some(69664)), /// Allows `extern "C-cmse-nonsecure-call" fn()`. - (unstable, abi_c_cmse_nonsecure_call, "1.51.0", Some(81391), None), + (unstable, abi_c_cmse_nonsecure_call, "1.51.0", Some(81391)), /// Allows `extern "msp430-interrupt" fn()`. - (unstable, abi_msp430_interrupt, "1.16.0", Some(38487), None), + (unstable, abi_msp430_interrupt, "1.16.0", Some(38487)), /// Allows `extern "ptx-*" fn()`. - (unstable, abi_ptx, "1.15.0", Some(38788), None), + (unstable, abi_ptx, "1.15.0", Some(38788)), /// Allows `extern "riscv-interrupt-m" fn()` and `extern "riscv-interrupt-s" fn()`. - (unstable, abi_riscv_interrupt, "1.73.0", Some(111889), None), + (unstable, abi_riscv_interrupt, "1.73.0", Some(111889)), /// Allows `extern "x86-interrupt" fn()`. - (unstable, abi_x86_interrupt, "1.17.0", Some(40180), None), + (unstable, abi_x86_interrupt, "1.17.0", Some(40180)), /// Allows additional const parameter types, such as `&'static str` or user defined types - (incomplete, adt_const_params, "1.56.0", Some(95174), None), + (incomplete, adt_const_params, "1.56.0", Some(95174)), /// Allows defining an `#[alloc_error_handler]`. - (unstable, alloc_error_handler, "1.29.0", Some(51540), None), + (unstable, alloc_error_handler, "1.29.0", Some(51540)), /// Allows trait methods with arbitrary self types. - (unstable, arbitrary_self_types, "1.23.0", Some(44874), None), + (unstable, arbitrary_self_types, "1.23.0", Some(44874)), /// Allows using `const` operands in inline assembly. - (unstable, asm_const, "1.58.0", Some(93332), None), + (unstable, asm_const, "1.58.0", Some(93332)), /// Enables experimental inline assembly support for additional architectures. - (unstable, asm_experimental_arch, "1.58.0", Some(93335), None), + (unstable, asm_experimental_arch, "1.58.0", Some(93335)), /// Allows the `may_unwind` option in inline assembly. - (unstable, asm_unwind, "1.58.0", Some(93334), None), + (unstable, asm_unwind, "1.58.0", Some(93334)), /// Allows users to enforce equality of associated constants `TraitImpl`. - (unstable, associated_const_equality, "1.58.0", Some(92827), None), + (unstable, associated_const_equality, "1.58.0", Some(92827)), /// Allows the user of associated type bounds. - (unstable, associated_type_bounds, "1.34.0", Some(52662), None), + (unstable, associated_type_bounds, "1.34.0", Some(52662)), /// Allows associated type defaults. - (unstable, associated_type_defaults, "1.2.0", Some(29661), None), + (unstable, associated_type_defaults, "1.2.0", Some(29661)), /// Allows `async || body` closures. - (unstable, async_closure, "1.37.0", Some(62290), None), + (unstable, async_closure, "1.37.0", Some(62290)), /// Allows `#[track_caller]` on async functions. - (unstable, async_fn_track_caller, "1.73.0", Some(110011), None), + (unstable, async_fn_track_caller, "1.73.0", Some(110011)), /// Allows builtin # foo() syntax - (unstable, builtin_syntax, "1.71.0", Some(110680), None), + (unstable, builtin_syntax, "1.71.0", Some(110680)), /// Treat `extern "C"` function as nounwind. - (unstable, c_unwind, "1.52.0", Some(74990), None), + (unstable, c_unwind, "1.52.0", Some(74990)), /// Allows using C-variadics. - (unstable, c_variadic, "1.34.0", Some(44930), None), + (unstable, c_variadic, "1.34.0", Some(44930)), /// Allows the use of `#[cfg(overflow_checks)` to check if integer overflow behaviour. - (unstable, cfg_overflow_checks, "1.71.0", Some(111466), None), + (unstable, cfg_overflow_checks, "1.71.0", Some(111466)), /// Provides the relocation model information as cfg entry - (unstable, cfg_relocation_model, "1.73.0", Some(114929), None), + (unstable, cfg_relocation_model, "1.73.0", Some(114929)), /// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used. - (unstable, cfg_sanitize, "1.41.0", Some(39699), None), + (unstable, cfg_sanitize, "1.41.0", Some(39699)), /// Allows `cfg(target_abi = "...")`. - (unstable, cfg_target_abi, "1.55.0", Some(80970), None), + (unstable, cfg_target_abi, "1.55.0", Some(80970)), /// Allows `cfg(target(abi = "..."))`. - (unstable, cfg_target_compact, "1.63.0", Some(96901), None), + (unstable, cfg_target_compact, "1.63.0", Some(96901)), /// Allows `cfg(target_has_atomic_load_store = "...")`. - (unstable, cfg_target_has_atomic, "1.60.0", Some(94039), None), + (unstable, cfg_target_has_atomic, "1.60.0", Some(94039)), /// Allows `cfg(target_has_atomic_equal_alignment = "...")`. - (unstable, cfg_target_has_atomic_equal_alignment, "1.60.0", Some(93822), None), + (unstable, cfg_target_has_atomic_equal_alignment, "1.60.0", Some(93822)), /// Allows `cfg(target_thread_local)`. - (unstable, cfg_target_thread_local, "1.7.0", Some(29594), None), + (unstable, cfg_target_thread_local, "1.7.0", Some(29594)), /// Allow conditional compilation depending on rust version - (unstable, cfg_version, "1.45.0", Some(64796), None), + (unstable, cfg_version, "1.45.0", Some(64796)), /// Allows to use the `#[cfi_encoding = ""]` attribute. - (unstable, cfi_encoding, "1.71.0", Some(89653), None), + (unstable, cfi_encoding, "1.71.0", Some(89653)), /// Allows `for<...>` on closures and coroutines. - (unstable, closure_lifetime_binder, "1.64.0", Some(97362), None), + (unstable, closure_lifetime_binder, "1.64.0", Some(97362)), /// Allows `#[track_caller]` on closures and coroutines. - (unstable, closure_track_caller, "1.57.0", Some(87417), None), + (unstable, closure_track_caller, "1.57.0", Some(87417)), /// Allows to use the `#[cmse_nonsecure_entry]` attribute. - (unstable, cmse_nonsecure_entry, "1.48.0", Some(75835), None), + (unstable, cmse_nonsecure_entry, "1.48.0", Some(75835)), /// Allows use of the `#[collapse_debuginfo]` attribute. - (unstable, collapse_debuginfo, "1.65.0", Some(100758), None), + (unstable, collapse_debuginfo, "1.65.0", Some(100758)), /// Allows `async {}` expressions in const contexts. - (unstable, const_async_blocks, "1.53.0", Some(85368), None), + (unstable, const_async_blocks, "1.53.0", Some(85368)), /// Allows `const || {}` closures in const contexts. - (incomplete, const_closures, "1.68.0", Some(106003), None), + (incomplete, const_closures, "1.68.0", Some(106003)), /// Allows the definition of `const extern fn` and `const unsafe extern fn`. - (unstable, const_extern_fn, "1.40.0", Some(64926), None), + (unstable, const_extern_fn, "1.40.0", Some(64926)), /// Allows basic arithmetic on floating point types in a `const fn`. - (unstable, const_fn_floating_point_arithmetic, "1.48.0", Some(57241), None), + (unstable, const_fn_floating_point_arithmetic, "1.48.0", Some(57241)), /// Allows `for _ in _` loops in const contexts. - (unstable, const_for, "1.56.0", Some(87575), None), + (unstable, const_for, "1.56.0", Some(87575)), /// Allows using `&mut` in constant functions. - (unstable, const_mut_refs, "1.41.0", Some(57349), None), + (unstable, const_mut_refs, "1.41.0", Some(57349)), /// Be more precise when looking for live drops in a const context. - (unstable, const_precise_live_drops, "1.46.0", Some(73255), None), + (unstable, const_precise_live_drops, "1.46.0", Some(73255)), /// Allows references to types with interior mutability within constants - (unstable, const_refs_to_cell, "1.51.0", Some(80384), None), + (unstable, const_refs_to_cell, "1.51.0", Some(80384)), /// Allows `impl const Trait for T` syntax. - (unstable, const_trait_impl, "1.42.0", Some(67792), None), + (unstable, const_trait_impl, "1.42.0", Some(67792)), /// Allows the `?` operator in const contexts. - (unstable, const_try, "1.56.0", Some(74935), None), + (unstable, const_try, "1.56.0", Some(74935)), /// Allows coroutines to be cloned. - (unstable, coroutine_clone, "1.65.0", Some(95360), None), + (unstable, coroutine_clone, "1.65.0", Some(95360)), /// Allows defining coroutines. - (unstable, coroutines, "1.21.0", Some(43122), None), + (unstable, coroutines, "1.21.0", Some(43122)), /// Allows function attribute `#[coverage(on/off)]`, to control coverage /// instrumentation of that function. - (unstable, coverage_attribute, "1.74.0", Some(84605), None), + (unstable, coverage_attribute, "1.74.0", Some(84605)), /// Allows users to provide classes for fenced code block using `class:classname`. - (unstable, custom_code_classes_in_docs, "1.74.0", Some(79483), None), + (unstable, custom_code_classes_in_docs, "1.74.0", Some(79483)), /// Allows non-builtin attributes in inner attribute position. - (unstable, custom_inner_attributes, "1.30.0", Some(54726), None), + (unstable, custom_inner_attributes, "1.30.0", Some(54726)), /// Allows custom test frameworks with `#![test_runner]` and `#[test_case]`. - (unstable, custom_test_frameworks, "1.30.0", Some(50297), None), + (unstable, custom_test_frameworks, "1.30.0", Some(50297)), /// Allows declarative macros 2.0 (`macro`). - (unstable, decl_macro, "1.17.0", Some(39412), None), + (unstable, decl_macro, "1.17.0", Some(39412)), /// Allows default type parameters to influence type inference. - (unstable, default_type_parameter_fallback, "1.3.0", Some(27336), None), + (unstable, default_type_parameter_fallback, "1.3.0", Some(27336)), /// Allows using `#[deprecated_safe]` to deprecate the safeness of a function or trait - (unstable, deprecated_safe, "1.61.0", Some(94978), None), + (unstable, deprecated_safe, "1.61.0", Some(94978)), /// Allows having using `suggestion` in the `#[deprecated]` attribute. - (unstable, deprecated_suggestion, "1.61.0", Some(94785), None), + (unstable, deprecated_suggestion, "1.61.0", Some(94785)), /// Allows using the `#[diagnostic]` attribute tool namespace - (unstable, diagnostic_namespace, "1.73.0", Some(111996), None), + (unstable, diagnostic_namespace, "1.73.0", Some(111996)), /// Controls errors in trait implementations. - (unstable, do_not_recommend, "1.67.0", Some(51992), None), + (unstable, do_not_recommend, "1.67.0", Some(51992)), /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`. - (unstable, doc_auto_cfg, "1.58.0", Some(43781), None), + (unstable, doc_auto_cfg, "1.58.0", Some(43781)), /// Allows `#[doc(cfg(...))]`. - (unstable, doc_cfg, "1.21.0", Some(43781), None), + (unstable, doc_cfg, "1.21.0", Some(43781)), /// Allows `#[doc(cfg_hide(...))]`. - (unstable, doc_cfg_hide, "1.57.0", Some(43781), None), + (unstable, doc_cfg_hide, "1.57.0", Some(43781)), /// Allows `#[doc(masked)]`. - (unstable, doc_masked, "1.21.0", Some(44027), None), + (unstable, doc_masked, "1.21.0", Some(44027)), /// Allows `dyn* Trait` objects. - (incomplete, dyn_star, "1.65.0", Some(102425), None), + (incomplete, dyn_star, "1.65.0", Some(102425)), // Uses generic effect parameters for ~const bounds - (unstable, effects, "1.72.0", Some(102090), None), + (unstable, effects, "1.72.0", Some(102090)), /// Allows `X..Y` patterns. - (unstable, exclusive_range_pattern, "1.11.0", Some(37854), None), + (unstable, exclusive_range_pattern, "1.11.0", Some(37854)), /// Allows exhaustive pattern matching on types that contain uninhabited types. - (unstable, exhaustive_patterns, "1.13.0", Some(51085), None), + (unstable, exhaustive_patterns, "1.13.0", Some(51085)), /// Allows explicit tail calls via `become` expression. - (incomplete, explicit_tail_calls, "1.72.0", Some(112788), None), + (incomplete, explicit_tail_calls, "1.72.0", Some(112788)), /// Allows using `efiapi`, `sysv64` and `win64` as calling convention /// for functions with varargs. - (unstable, extended_varargs_abi_support, "1.65.0", Some(100189), None), + (unstable, extended_varargs_abi_support, "1.65.0", Some(100189)), /// Allows defining `extern type`s. - (unstable, extern_types, "1.23.0", Some(43467), None), + (unstable, extern_types, "1.23.0", Some(43467)), /// Allows the use of `#[ffi_const]` on foreign functions. - (unstable, ffi_const, "1.45.0", Some(58328), None), + (unstable, ffi_const, "1.45.0", Some(58328)), /// Allows the use of `#[ffi_pure]` on foreign functions. - (unstable, ffi_pure, "1.45.0", Some(58329), None), + (unstable, ffi_pure, "1.45.0", Some(58329)), /// Allows using `#[ffi_returns_twice]` on foreign functions. - (unstable, ffi_returns_twice, "1.34.0", Some(58314), None), + (unstable, ffi_returns_twice, "1.34.0", Some(58314)), /// Allows using `#[repr(align(...))]` on function items - (unstable, fn_align, "1.53.0", Some(82232), None), + (unstable, fn_align, "1.53.0", Some(82232)), /// Support delegating implementation of functions to other already implemented functions. - (incomplete, fn_delegation, "CURRENT_RUSTC_VERSION", Some(118212), None), + (incomplete, fn_delegation, "CURRENT_RUSTC_VERSION", Some(118212)), /// Allows defining gen blocks and `gen fn`. - (unstable, gen_blocks, "1.75.0", Some(117078), None), + (unstable, gen_blocks, "1.75.0", Some(117078)), /// Infer generic args for both consts and types. - (unstable, generic_arg_infer, "1.55.0", Some(85077), None), + (unstable, generic_arg_infer, "1.55.0", Some(85077)), /// An extension to the `generic_associated_types` feature, allowing incomplete features. - (incomplete, generic_associated_types_extended, "1.61.0", Some(95451), None), + (incomplete, generic_associated_types_extended, "1.61.0", Some(95451)), /// Allows non-trivial generic constants which have to have wfness manually propagated to callers - (incomplete, generic_const_exprs, "1.56.0", Some(76560), None), + (incomplete, generic_const_exprs, "1.56.0", Some(76560)), /// Allows generic parameters and where-clauses on free & associated const items. - (incomplete, generic_const_items, "1.73.0", Some(113521), None), + (incomplete, generic_const_items, "1.73.0", Some(113521)), /// Allows using `..=X` as a patterns in slices. - (unstable, half_open_range_patterns_in_slices, "1.66.0", Some(67264), None), + (unstable, half_open_range_patterns_in_slices, "1.66.0", Some(67264)), /// Allows `if let` guard in match arms. - (unstable, if_let_guard, "1.47.0", Some(51114), None), + (unstable, if_let_guard, "1.47.0", Some(51114)), /// Allows `impl Trait` to be used inside associated types (RFC 2515). - (unstable, impl_trait_in_assoc_type, "1.70.0", Some(63063), None), + (unstable, impl_trait_in_assoc_type, "1.70.0", Some(63063)), /// Allows `impl Trait` as output type in `Fn` traits in return position of functions. - (unstable, impl_trait_in_fn_trait_return, "1.64.0", Some(99697), None), + (unstable, impl_trait_in_fn_trait_return, "1.64.0", Some(99697)), /// Allows using imported `main` function - (unstable, imported_main, "1.53.0", Some(28937), None), + (unstable, imported_main, "1.53.0", Some(28937)), /// Allows associated types in inherent impls. - (incomplete, inherent_associated_types, "1.52.0", Some(8995), None), + (incomplete, inherent_associated_types, "1.52.0", Some(8995)), /// Allow anonymous constants from an inline `const` block - (unstable, inline_const, "1.49.0", Some(76001), None), + (unstable, inline_const, "1.49.0", Some(76001)), /// Allow anonymous constants from an inline `const` block in pattern position - (incomplete, inline_const_pat, "1.58.0", Some(76001), None), + (incomplete, inline_const_pat, "1.58.0", Some(76001)), /// Allows using `pointer` and `reference` in intra-doc links - (unstable, intra_doc_pointers, "1.51.0", Some(80896), None), + (unstable, intra_doc_pointers, "1.51.0", Some(80896)), // Allows setting the threshold for the `large_assignments` lint. - (unstable, large_assignments, "1.52.0", Some(83518), None), + (unstable, large_assignments, "1.52.0", Some(83518)), /// Allow to have type alias types for inter-crate use. - (incomplete, lazy_type_alias, "1.72.0", Some(112792), None), + (incomplete, lazy_type_alias, "1.72.0", Some(112792)), /// Allows `if/while p && let q = r && ...` chains. - (unstable, let_chains, "1.37.0", Some(53667), None), + (unstable, let_chains, "1.37.0", Some(53667)), /// Allows using `#[link(kind = "link-arg", name = "...")]` /// to pass custom arguments to the linker. - (unstable, link_arg_attribute, "CURRENT_RUSTC_VERSION", Some(99427), None), + (unstable, link_arg_attribute, "CURRENT_RUSTC_VERSION", Some(99427)), /// Allows using `reason` in lint attributes and the `#[expect(lint)]` lint check. - (unstable, lint_reasons, "1.31.0", Some(54503), None), + (unstable, lint_reasons, "1.31.0", Some(54503)), /// Give access to additional metadata about declarative macro meta-variables. - (unstable, macro_metavar_expr, "1.61.0", Some(83527), None), + (unstable, macro_metavar_expr, "1.61.0", Some(83527)), /// Allows `#[marker]` on certain traits allowing overlapping implementations. - (unstable, marker_trait_attr, "1.30.0", Some(29864), None), + (unstable, marker_trait_attr, "1.30.0", Some(29864)), /// A minimal, sound subset of specialization intended to be used by the /// standard library until the soundness issues with specialization /// are fixed. - (unstable, min_specialization, "1.7.0", Some(31844), None), + (unstable, min_specialization, "1.7.0", Some(31844)), /// Allows qualified paths in struct expressions, struct patterns and tuple struct patterns. - (unstable, more_qualified_paths, "1.54.0", Some(86935), None), + (unstable, more_qualified_paths, "1.54.0", Some(86935)), /// Allows the `#[must_not_suspend]` attribute. - (unstable, must_not_suspend, "1.57.0", Some(83310), None), + (unstable, must_not_suspend, "1.57.0", Some(83310)), /// Allows using `#[naked]` on functions. - (unstable, naked_functions, "1.9.0", Some(32408), None), + (unstable, naked_functions, "1.9.0", Some(32408)), /// Allows specifying the as-needed link modifier - (unstable, native_link_modifiers_as_needed, "1.53.0", Some(81490), None), + (unstable, native_link_modifiers_as_needed, "1.53.0", Some(81490)), /// Allow negative trait implementations. - (unstable, negative_impls, "1.44.0", Some(68318), None), + (unstable, negative_impls, "1.44.0", Some(68318)), /// Allows the `!` pattern. - (incomplete, never_patterns, "CURRENT_RUSTC_VERSION", Some(118155), None), + (incomplete, never_patterns, "CURRENT_RUSTC_VERSION", Some(118155)), /// Allows the `!` type. Does not imply 'exhaustive_patterns' (below) any more. - (unstable, never_type, "1.13.0", Some(35121), None), + (unstable, never_type, "1.13.0", Some(35121)), /// Allows diverging expressions to fall back to `!` rather than `()`. - (unstable, never_type_fallback, "1.41.0", Some(65992), None), + (unstable, never_type_fallback, "1.41.0", Some(65992)), /// Allows `#![no_core]`. - (unstable, no_core, "1.3.0", Some(29639), None), + (unstable, no_core, "1.3.0", Some(29639)), /// Allows the use of `no_sanitize` attribute. - (unstable, no_sanitize, "1.42.0", Some(39699), None), + (unstable, no_sanitize, "1.42.0", Some(39699)), /// Allows using the `non_exhaustive_omitted_patterns` lint. - (unstable, non_exhaustive_omitted_patterns_lint, "1.57.0", Some(89554), None), + (unstable, non_exhaustive_omitted_patterns_lint, "1.57.0", Some(89554)), /// Allows `for` binders in where-clauses - (incomplete, non_lifetime_binders, "1.69.0", Some(108185), None), + (incomplete, non_lifetime_binders, "1.69.0", Some(108185)), /// Allows making `dyn Trait` well-formed even if `Trait` is not object safe. /// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and /// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden. - (unstable, object_safe_for_dispatch, "1.40.0", Some(43561), None), + (unstable, object_safe_for_dispatch, "1.40.0", Some(43561)), /// Allows using enums in offset_of! - (unstable, offset_of_enum, "1.75.0", Some(106655), None), + (unstable, offset_of_enum, "1.75.0", Some(106655)), /// Allows using `#[optimize(X)]`. - (unstable, optimize_attribute, "1.34.0", Some(54882), None), + (unstable, optimize_attribute, "1.34.0", Some(54882)), /// Allows macro attributes on expressions, statements and non-inline modules. - (unstable, proc_macro_hygiene, "1.30.0", Some(54727), None), + (unstable, proc_macro_hygiene, "1.30.0", Some(54727)), /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions. - (unstable, raw_ref_op, "1.41.0", Some(64490), None), + (unstable, raw_ref_op, "1.41.0", Some(64490)), /// Allows using the `#[register_tool]` attribute. - (unstable, register_tool, "1.41.0", Some(66079), None), + (unstable, register_tool, "1.41.0", Some(66079)), /// Allows the `#[repr(i128)]` attribute for enums. - (incomplete, repr128, "1.16.0", Some(56071), None), + (incomplete, repr128, "1.16.0", Some(56071)), /// Allows `repr(simd)` and importing the various simd intrinsics. - (unstable, repr_simd, "1.4.0", Some(27731), None), + (unstable, repr_simd, "1.4.0", Some(27731)), /// Allows bounding the return type of AFIT/RPITIT. - (incomplete, return_type_notation, "1.70.0", Some(109417), None), + (incomplete, return_type_notation, "1.70.0", Some(109417)), /// Allows `extern "rust-cold"`. - (unstable, rust_cold_cc, "1.63.0", Some(97544), None), + (unstable, rust_cold_cc, "1.63.0", Some(97544)), /// Allows the use of SIMD types in functions declared in `extern` blocks. - (unstable, simd_ffi, "1.0.0", Some(27731), None), + (unstable, simd_ffi, "1.0.0", Some(27731)), /// Allows specialization of implementations (RFC 1210). - (incomplete, specialization, "1.7.0", Some(31844), None), + (incomplete, specialization, "1.7.0", Some(31844)), /// Allows attributes on expressions and non-item statements. - (unstable, stmt_expr_attributes, "1.6.0", Some(15701), None), + (unstable, stmt_expr_attributes, "1.6.0", Some(15701)), /// Allows lints part of the strict provenance effort. - (unstable, strict_provenance, "1.61.0", Some(95228), None), + (unstable, strict_provenance, "1.61.0", Some(95228)), /// Allows string patterns to dereference values to match them. - (unstable, string_deref_patterns, "1.67.0", Some(87121), None), + (unstable, string_deref_patterns, "1.67.0", Some(87121)), /// Allows the use of `#[target_feature]` on safe functions. - (unstable, target_feature_11, "1.45.0", Some(69098), None), + (unstable, target_feature_11, "1.45.0", Some(69098)), /// Allows using `#[thread_local]` on `static` items. - (unstable, thread_local, "1.0.0", Some(29594), None), + (unstable, thread_local, "1.0.0", Some(29594)), /// Allows defining `trait X = A + B;` alias items. - (unstable, trait_alias, "1.24.0", Some(41517), None), + (unstable, trait_alias, "1.24.0", Some(41517)), /// Allows for transmuting between arrays with sizes that contain generic consts. - (unstable, transmute_generic_consts, "1.70.0", Some(109929), None), + (unstable, transmute_generic_consts, "1.70.0", Some(109929)), /// Allows #[repr(transparent)] on unions (RFC 2645). - (unstable, transparent_unions, "1.37.0", Some(60405), None), + (unstable, transparent_unions, "1.37.0", Some(60405)), /// Allows inconsistent bounds in where clauses. - (unstable, trivial_bounds, "1.28.0", Some(48214), None), + (unstable, trivial_bounds, "1.28.0", Some(48214)), /// Allows using `try {...}` expressions. - (unstable, try_blocks, "1.29.0", Some(31436), None), + (unstable, try_blocks, "1.29.0", Some(31436)), /// Allows `impl Trait` to be used inside type aliases (RFC 2515). - (unstable, type_alias_impl_trait, "1.38.0", Some(63063), None), + (unstable, type_alias_impl_trait, "1.38.0", Some(63063)), /// Allows the use of type ascription in expressions. - (unstable, type_ascription, "1.6.0", Some(23416), None), + (unstable, type_ascription, "1.6.0", Some(23416)), /// Allows creation of instances of a struct by moving fields that have /// not changed from prior instances of the same struct (RFC #2528) - (unstable, type_changing_struct_update, "1.58.0", Some(86555), None), + (unstable, type_changing_struct_update, "1.58.0", Some(86555)), /// Allows using type privacy lints (`private_interfaces`, `private_bounds`, `unnameable_types`). - (unstable, type_privacy_lints, "1.72.0", Some(48054), None), + (unstable, type_privacy_lints, "1.72.0", Some(48054)), /// Enables rustc to generate code that instructs libstd to NOT ignore SIGPIPE. - (unstable, unix_sigpipe, "1.65.0", Some(97889), None), + (unstable, unix_sigpipe, "1.65.0", Some(97889)), /// Allows unnamed fields of struct and union type - (incomplete, unnamed_fields, "1.74.0", Some(49804), None), + (incomplete, unnamed_fields, "1.74.0", Some(49804)), /// Allows unsized fn parameters. - (unstable, unsized_fn_params, "1.49.0", Some(48055), None), + (unstable, unsized_fn_params, "1.49.0", Some(48055)), /// Allows unsized rvalues at arguments and parameters. - (incomplete, unsized_locals, "1.30.0", Some(48055), None), + (incomplete, unsized_locals, "1.30.0", Some(48055)), /// Allows unsized tuple coercion. - (unstable, unsized_tuple_coercion, "1.20.0", Some(42877), None), + (unstable, unsized_tuple_coercion, "1.20.0", Some(42877)), /// Allows using the `#[used(linker)]` (or `#[used(compiler)]`) attribute. - (unstable, used_with_arg, "1.60.0", Some(93798), None), + (unstable, used_with_arg, "1.60.0", Some(93798)), /// Allows `extern "wasm" fn` - (unstable, wasm_abi, "1.53.0", Some(83788), None), + (unstable, wasm_abi, "1.53.0", Some(83788)), /// Allows `do yeet` expressions - (unstable, yeet_expr, "1.62.0", Some(96373), None), + (unstable, yeet_expr, "1.62.0", Some(96373)), // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way. // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! diff --git a/compiler/rustc_span/src/edition.rs b/compiler/rustc_span/src/edition.rs index 608b8c24bde8b..78ac61fa31db9 100644 --- a/compiler/rustc_span/src/edition.rs +++ b/compiler/rustc_span/src/edition.rs @@ -1,4 +1,3 @@ -use crate::symbol::{sym, Symbol}; use std::fmt; use std::str::FromStr; @@ -58,15 +57,6 @@ impl Edition { } } - pub fn feature_name(self) -> Symbol { - match self { - Edition::Edition2015 => sym::rust_2015_preview, - Edition::Edition2018 => sym::rust_2018_preview, - Edition::Edition2021 => sym::rust_2021_preview, - Edition::Edition2024 => sym::rust_2024_preview, - } - } - pub fn is_stable(self) -> bool { match self { Edition::Edition2015 => true, diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 9ad76b74c3853..f3c5138716d49 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1350,13 +1350,10 @@ symbols! { rtm_target_feature, rust, rust_2015, - rust_2015_preview, rust_2018, rust_2018_preview, rust_2021, - rust_2021_preview, rust_2024, - rust_2024_preview, rust_begin_unwind, rust_cold_cc, rust_eh_catch_typeinfo, diff --git a/src/tools/rustfmt/tests/source/issue-2927-2.rs b/src/tools/rustfmt/tests/source/issue-2927-2.rs index d87761fdc9c37..07afef38cf5a9 100644 --- a/src/tools/rustfmt/tests/source/issue-2927-2.rs +++ b/src/tools/rustfmt/tests/source/issue-2927-2.rs @@ -1,5 +1,5 @@ // rustfmt-edition: 2015 -#![feature(rust_2018_preview, uniform_paths)] +#![feature(uniform_paths)] use futures::prelude::*; use http_03::cli::Cli; use hyper::{service::service_fn_ok, Body, Response, Server}; diff --git a/src/tools/rustfmt/tests/source/issue-2927.rs b/src/tools/rustfmt/tests/source/issue-2927.rs index a7df32084f3b6..c7ec7bb085550 100644 --- a/src/tools/rustfmt/tests/source/issue-2927.rs +++ b/src/tools/rustfmt/tests/source/issue-2927.rs @@ -1,5 +1,5 @@ // rustfmt-edition: 2018 -#![feature(rust_2018_preview, uniform_paths)] +#![feature(uniform_paths)] use futures::prelude::*; use http_03::cli::Cli; use hyper::{service::service_fn_ok, Body, Response, Server}; diff --git a/src/tools/rustfmt/tests/target/issue-2927-2.rs b/src/tools/rustfmt/tests/target/issue-2927-2.rs index e895783ba8bb4..46e0bf0e989e6 100644 --- a/src/tools/rustfmt/tests/target/issue-2927-2.rs +++ b/src/tools/rustfmt/tests/target/issue-2927-2.rs @@ -1,5 +1,5 @@ // rustfmt-edition: 2015 -#![feature(rust_2018_preview, uniform_paths)] +#![feature(uniform_paths)] use futures::prelude::*; use http_03::cli::Cli; use hyper::{service::service_fn_ok, Body, Response, Server}; diff --git a/src/tools/rustfmt/tests/target/issue-2927.rs b/src/tools/rustfmt/tests/target/issue-2927.rs index 3267be28d7b70..56afc2d3e40aa 100644 --- a/src/tools/rustfmt/tests/target/issue-2927.rs +++ b/src/tools/rustfmt/tests/target/issue-2927.rs @@ -1,5 +1,5 @@ // rustfmt-edition: 2018 -#![feature(rust_2018_preview, uniform_paths)] +#![feature(uniform_paths)] use ::log::{error, info, log}; use futures::prelude::*; use http_03::cli::Cli; diff --git a/tests/ui/editions/edition-feature-ok.rs b/tests/ui/editions/edition-feature-ok.rs deleted file mode 100644 index 69242fd715cef..0000000000000 --- a/tests/ui/editions/edition-feature-ok.rs +++ /dev/null @@ -1,5 +0,0 @@ -// check-pass - -#![feature(rust_2018_preview)] - -fn main() {} diff --git a/tests/ui/editions/edition-feature-redundant.rs b/tests/ui/editions/edition-feature-redundant.rs deleted file mode 100644 index 1049a2da8fd1c..0000000000000 --- a/tests/ui/editions/edition-feature-redundant.rs +++ /dev/null @@ -1,7 +0,0 @@ -// edition:2018 -// check-pass - -#![feature(rust_2018_preview)] -//~^ WARN the feature `rust_2018_preview` is included in the Rust 2018 edition - -fn main() {} diff --git a/tests/ui/editions/edition-feature-redundant.stderr b/tests/ui/editions/edition-feature-redundant.stderr deleted file mode 100644 index b11e616d7f2e9..0000000000000 --- a/tests/ui/editions/edition-feature-redundant.stderr +++ /dev/null @@ -1,9 +0,0 @@ -warning[E0705]: the feature `rust_2018_preview` is included in the Rust 2018 edition - --> $DIR/edition-feature-redundant.rs:4:12 - | -LL | #![feature(rust_2018_preview)] - | ^^^^^^^^^^^^^^^^^ - -warning: 1 warning emitted - -For more information about this error, try `rustc --explain E0705`. diff --git a/tests/ui/editions/epoch-gate-feature.rs b/tests/ui/editions/epoch-gate-feature.rs deleted file mode 100644 index 5f7feb5347bea..0000000000000 --- a/tests/ui/editions/epoch-gate-feature.rs +++ /dev/null @@ -1,15 +0,0 @@ -// run-pass - -#![allow(dead_code)] -#![allow(unused_variables)] -// Checks if the correct registers are being used to pass arguments -// when the sysv64 ABI is specified. - -#![feature(rust_2018_preview)] - -pub trait Foo {} - -// should compile without the dyn trait feature flag -fn foo(x: &dyn Foo) {} - -pub fn main() {} diff --git a/tests/ui/error-codes/E0705.rs b/tests/ui/error-codes/E0705.rs deleted file mode 100644 index 05abcb629b1c8..0000000000000 --- a/tests/ui/error-codes/E0705.rs +++ /dev/null @@ -1,10 +0,0 @@ -// check-pass - -// This is a stub feature that doesn't control anything, so to make tidy happy, -// gate-test-test_2018_feature - -#![feature(test_2018_feature)] -//~^ WARN the feature `test_2018_feature` is included in the Rust 2018 edition -#![feature(rust_2018_preview)] - -fn main() {} diff --git a/tests/ui/error-codes/E0705.stderr b/tests/ui/error-codes/E0705.stderr deleted file mode 100644 index 6fa843158bbf1..0000000000000 --- a/tests/ui/error-codes/E0705.stderr +++ /dev/null @@ -1,9 +0,0 @@ -warning[E0705]: the feature `test_2018_feature` is included in the Rust 2018 edition - --> $DIR/E0705.rs:6:12 - | -LL | #![feature(test_2018_feature)] - | ^^^^^^^^^^^^^^^^^ - -warning: 1 warning emitted - -For more information about this error, try `rustc --explain E0705`. diff --git a/tests/ui/proc-macro/custom-attr-only-one-derive.rs b/tests/ui/proc-macro/custom-attr-only-one-derive.rs index 2cd5b487301ce..901394384d545 100644 --- a/tests/ui/proc-macro/custom-attr-only-one-derive.rs +++ b/tests/ui/proc-macro/custom-attr-only-one-derive.rs @@ -1,8 +1,6 @@ // run-pass // aux-build:custom-attr-only-one-derive.rs -#![feature(rust_2018_preview)] - #[macro_use] extern crate custom_attr_only_one_derive; diff --git a/tests/ui/rust-2018/edition-lint-fully-qualified-paths.fixed b/tests/ui/rust-2018/edition-lint-fully-qualified-paths.fixed index ede0c2e8eaf03..3bfa6d2c25410 100644 --- a/tests/ui/rust-2018/edition-lint-fully-qualified-paths.fixed +++ b/tests/ui/rust-2018/edition-lint-fully-qualified-paths.fixed @@ -1,6 +1,5 @@ // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] mod foo { diff --git a/tests/ui/rust-2018/edition-lint-fully-qualified-paths.rs b/tests/ui/rust-2018/edition-lint-fully-qualified-paths.rs index 48b091ddb45ed..14039626545c3 100644 --- a/tests/ui/rust-2018/edition-lint-fully-qualified-paths.rs +++ b/tests/ui/rust-2018/edition-lint-fully-qualified-paths.rs @@ -1,6 +1,5 @@ // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] mod foo { diff --git a/tests/ui/rust-2018/edition-lint-fully-qualified-paths.stderr b/tests/ui/rust-2018/edition-lint-fully-qualified-paths.stderr index c0a322edcd647..036b9ccab4f3b 100644 --- a/tests/ui/rust-2018/edition-lint-fully-qualified-paths.stderr +++ b/tests/ui/rust-2018/edition-lint-fully-qualified-paths.stderr @@ -1,5 +1,5 @@ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-fully-qualified-paths.rs:19:25 + --> $DIR/edition-lint-fully-qualified-paths.rs:18:25 | LL | let _: ::Bar = (); | ^^^^^^^^^^ help: use `crate`: `crate::foo::Foo` @@ -7,13 +7,13 @@ LL | let _: ::Bar = (); = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018! = note: for more information, see issue #53130 note: the lint level is defined here - --> $DIR/edition-lint-fully-qualified-paths.rs:4:9 + --> $DIR/edition-lint-fully-qualified-paths.rs:3:9 | LL | #![deny(absolute_paths_not_starting_with_crate)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-fully-qualified-paths.rs:19:25 + --> $DIR/edition-lint-fully-qualified-paths.rs:18:25 | LL | let _: ::Bar = (); | ^^^^^^^^^^ help: use `crate`: `crate::foo::Foo` @@ -23,7 +23,7 @@ LL | let _: ::Bar = (); = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-fully-qualified-paths.rs:25:13 + --> $DIR/edition-lint-fully-qualified-paths.rs:24:13 | LL | let _: <::foo::Baz as foo::Foo>::Bar = (); | ^^^^^^^^^^ help: use `crate`: `crate::foo::Baz` diff --git a/tests/ui/rust-2018/edition-lint-nested-empty-paths.fixed b/tests/ui/rust-2018/edition-lint-nested-empty-paths.fixed index f25d46ce30d0a..fd23e9f5562b8 100644 --- a/tests/ui/rust-2018/edition-lint-nested-empty-paths.fixed +++ b/tests/ui/rust-2018/edition-lint-nested-empty-paths.fixed @@ -1,6 +1,5 @@ // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] #![allow(unused_imports)] #![allow(dead_code)] diff --git a/tests/ui/rust-2018/edition-lint-nested-empty-paths.rs b/tests/ui/rust-2018/edition-lint-nested-empty-paths.rs index 9be1680c1ce74..f3fb012a5842e 100644 --- a/tests/ui/rust-2018/edition-lint-nested-empty-paths.rs +++ b/tests/ui/rust-2018/edition-lint-nested-empty-paths.rs @@ -1,6 +1,5 @@ // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] #![allow(unused_imports)] #![allow(dead_code)] diff --git a/tests/ui/rust-2018/edition-lint-nested-empty-paths.stderr b/tests/ui/rust-2018/edition-lint-nested-empty-paths.stderr index 041572be84411..4174c2fa9adf2 100644 --- a/tests/ui/rust-2018/edition-lint-nested-empty-paths.stderr +++ b/tests/ui/rust-2018/edition-lint-nested-empty-paths.stderr @@ -1,5 +1,5 @@ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-empty-paths.rs:17:5 + --> $DIR/edition-lint-nested-empty-paths.rs:16:5 | LL | use foo::{bar::{baz::{}}}; | ^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{bar::{baz::{}}}` @@ -7,13 +7,13 @@ LL | use foo::{bar::{baz::{}}}; = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018! = note: for more information, see issue #53130 note: the lint level is defined here - --> $DIR/edition-lint-nested-empty-paths.rs:4:9 + --> $DIR/edition-lint-nested-empty-paths.rs:3:9 | LL | #![deny(absolute_paths_not_starting_with_crate)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-empty-paths.rs:21:5 + --> $DIR/edition-lint-nested-empty-paths.rs:20:5 | LL | use foo::{bar::{XX, baz::{}}}; | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{bar::{XX, baz::{}}}` @@ -22,7 +22,7 @@ LL | use foo::{bar::{XX, baz::{}}}; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-empty-paths.rs:21:5 + --> $DIR/edition-lint-nested-empty-paths.rs:20:5 | LL | use foo::{bar::{XX, baz::{}}}; | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{bar::{XX, baz::{}}}` @@ -32,7 +32,7 @@ LL | use foo::{bar::{XX, baz::{}}}; = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-empty-paths.rs:27:5 + --> $DIR/edition-lint-nested-empty-paths.rs:26:5 | LL | use foo::{bar::{baz::{}, baz1::{}}}; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{bar::{baz::{}, baz1::{}}}` @@ -41,7 +41,7 @@ LL | use foo::{bar::{baz::{}, baz1::{}}}; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-empty-paths.rs:27:5 + --> $DIR/edition-lint-nested-empty-paths.rs:26:5 | LL | use foo::{bar::{baz::{}, baz1::{}}}; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{bar::{baz::{}, baz1::{}}}` diff --git a/tests/ui/rust-2018/edition-lint-nested-paths.fixed b/tests/ui/rust-2018/edition-lint-nested-paths.fixed index a04937ae8ee3b..0e47e70bb02ab 100644 --- a/tests/ui/rust-2018/edition-lint-nested-paths.fixed +++ b/tests/ui/rust-2018/edition-lint-nested-paths.fixed @@ -1,6 +1,5 @@ // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] use crate::foo::{a, b}; diff --git a/tests/ui/rust-2018/edition-lint-nested-paths.rs b/tests/ui/rust-2018/edition-lint-nested-paths.rs index e622a8e24be63..d261c10e36dbe 100644 --- a/tests/ui/rust-2018/edition-lint-nested-paths.rs +++ b/tests/ui/rust-2018/edition-lint-nested-paths.rs @@ -1,6 +1,5 @@ // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] use foo::{a, b}; diff --git a/tests/ui/rust-2018/edition-lint-nested-paths.stderr b/tests/ui/rust-2018/edition-lint-nested-paths.stderr index 4a70bb7e5c875..d059a2533a903 100644 --- a/tests/ui/rust-2018/edition-lint-nested-paths.stderr +++ b/tests/ui/rust-2018/edition-lint-nested-paths.stderr @@ -1,5 +1,5 @@ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-paths.rs:6:5 + --> $DIR/edition-lint-nested-paths.rs:5:5 | LL | use foo::{a, b}; | ^^^^^^^^^^^ help: use `crate`: `crate::foo::{a, b}` @@ -7,13 +7,13 @@ LL | use foo::{a, b}; = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018! = note: for more information, see issue #53130 note: the lint level is defined here - --> $DIR/edition-lint-nested-paths.rs:4:9 + --> $DIR/edition-lint-nested-paths.rs:3:9 | LL | #![deny(absolute_paths_not_starting_with_crate)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-paths.rs:6:5 + --> $DIR/edition-lint-nested-paths.rs:5:5 | LL | use foo::{a, b}; | ^^^^^^^^^^^ help: use `crate`: `crate::foo::{a, b}` @@ -23,7 +23,7 @@ LL | use foo::{a, b}; = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-paths.rs:23:13 + --> $DIR/edition-lint-nested-paths.rs:22:13 | LL | use foo::{self as x, c}; | ^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{self as x, c}` @@ -32,7 +32,7 @@ LL | use foo::{self as x, c}; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-nested-paths.rs:23:13 + --> $DIR/edition-lint-nested-paths.rs:22:13 | LL | use foo::{self as x, c}; | ^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::{self as x, c}` diff --git a/tests/ui/rust-2018/edition-lint-paths.fixed b/tests/ui/rust-2018/edition-lint-paths.fixed index 47f82c51daeaa..5057453c92699 100644 --- a/tests/ui/rust-2018/edition-lint-paths.fixed +++ b/tests/ui/rust-2018/edition-lint-paths.fixed @@ -1,7 +1,6 @@ // aux-build:edition-lint-paths.rs // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] #![allow(unused)] diff --git a/tests/ui/rust-2018/edition-lint-paths.rs b/tests/ui/rust-2018/edition-lint-paths.rs index e278983da4a90..2c4a070ce8397 100644 --- a/tests/ui/rust-2018/edition-lint-paths.rs +++ b/tests/ui/rust-2018/edition-lint-paths.rs @@ -1,7 +1,6 @@ // aux-build:edition-lint-paths.rs // run-rustfix -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] #![allow(unused)] diff --git a/tests/ui/rust-2018/edition-lint-paths.stderr b/tests/ui/rust-2018/edition-lint-paths.stderr index fde17338d98a7..553a3bfdaa8c7 100644 --- a/tests/ui/rust-2018/edition-lint-paths.stderr +++ b/tests/ui/rust-2018/edition-lint-paths.stderr @@ -1,5 +1,5 @@ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:12:9 + --> $DIR/edition-lint-paths.rs:11:9 | LL | use bar::Bar; | ^^^^^^^^ help: use `crate`: `crate::bar::Bar` @@ -7,13 +7,13 @@ LL | use bar::Bar; = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018! = note: for more information, see issue #53130 note: the lint level is defined here - --> $DIR/edition-lint-paths.rs:5:9 + --> $DIR/edition-lint-paths.rs:4:9 | LL | #![deny(absolute_paths_not_starting_with_crate)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:19:9 + --> $DIR/edition-lint-paths.rs:18:9 | LL | use bar; | ^^^ help: use `crate`: `crate::bar` @@ -22,7 +22,7 @@ LL | use bar; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:25:9 + --> $DIR/edition-lint-paths.rs:24:9 | LL | use {main, Bar as SomethingElse}; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::{main, Bar as SomethingElse}` @@ -31,7 +31,7 @@ LL | use {main, Bar as SomethingElse}; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:25:9 + --> $DIR/edition-lint-paths.rs:24:9 | LL | use {main, Bar as SomethingElse}; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::{main, Bar as SomethingElse}` @@ -41,7 +41,7 @@ LL | use {main, Bar as SomethingElse}; = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:25:9 + --> $DIR/edition-lint-paths.rs:24:9 | LL | use {main, Bar as SomethingElse}; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::{main, Bar as SomethingElse}` @@ -51,7 +51,7 @@ LL | use {main, Bar as SomethingElse}; = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:40:5 + --> $DIR/edition-lint-paths.rs:39:5 | LL | use bar::Bar; | ^^^^^^^^ help: use `crate`: `crate::bar::Bar` @@ -60,7 +60,7 @@ LL | use bar::Bar; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:52:9 + --> $DIR/edition-lint-paths.rs:51:9 | LL | use *; | ^ help: use `crate`: `crate::*` @@ -69,7 +69,7 @@ LL | use *; = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:57:6 + --> $DIR/edition-lint-paths.rs:56:6 | LL | impl ::foo::SomeTrait for u32 {} | ^^^^^^^^^^^^^^^^ help: use `crate`: `crate::foo::SomeTrait` @@ -78,7 +78,7 @@ LL | impl ::foo::SomeTrait for u32 {} = note: for more information, see issue #53130 error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/edition-lint-paths.rs:62:13 + --> $DIR/edition-lint-paths.rs:61:13 | LL | let x = ::bar::Bar; | ^^^^^^^^^^ help: use `crate`: `crate::bar::Bar` diff --git a/tests/ui/rust-2018/extern-crate-idiomatic.fixed b/tests/ui/rust-2018/extern-crate-idiomatic.fixed index 3111b1dabcbfd..6a0639099b145 100644 --- a/tests/ui/rust-2018/extern-crate-idiomatic.fixed +++ b/tests/ui/rust-2018/extern-crate-idiomatic.fixed @@ -6,7 +6,6 @@ // The "normal case". Ideally we would remove the `extern crate` here, // but we don't. -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; diff --git a/tests/ui/rust-2018/extern-crate-idiomatic.rs b/tests/ui/rust-2018/extern-crate-idiomatic.rs index 3111b1dabcbfd..6a0639099b145 100644 --- a/tests/ui/rust-2018/extern-crate-idiomatic.rs +++ b/tests/ui/rust-2018/extern-crate-idiomatic.rs @@ -6,7 +6,6 @@ // The "normal case". Ideally we would remove the `extern crate` here, // but we don't. -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; diff --git a/tests/ui/rust-2018/extern-crate-referenced-by-self-path.fixed b/tests/ui/rust-2018/extern-crate-referenced-by-self-path.fixed index 11b9a67ed7030..c4a3dd9415c29 100644 --- a/tests/ui/rust-2018/extern-crate-referenced-by-self-path.fixed +++ b/tests/ui/rust-2018/extern-crate-referenced-by-self-path.fixed @@ -6,7 +6,6 @@ // rather than being accessed directly. Unless we rewrite that path, // we can't drop the extern crate. -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; diff --git a/tests/ui/rust-2018/extern-crate-referenced-by-self-path.rs b/tests/ui/rust-2018/extern-crate-referenced-by-self-path.rs index 11b9a67ed7030..c4a3dd9415c29 100644 --- a/tests/ui/rust-2018/extern-crate-referenced-by-self-path.rs +++ b/tests/ui/rust-2018/extern-crate-referenced-by-self-path.rs @@ -6,7 +6,6 @@ // rather than being accessed directly. Unless we rewrite that path, // we can't drop the extern crate. -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; diff --git a/tests/ui/rust-2018/extern-crate-rename.fixed b/tests/ui/rust-2018/extern-crate-rename.fixed index ea832ef3e7d70..5e2bf64a2e28b 100644 --- a/tests/ui/rust-2018/extern-crate-rename.fixed +++ b/tests/ui/rust-2018/extern-crate-rename.fixed @@ -4,7 +4,6 @@ // Oddball: crate is renamed, making it harder for us to rewrite // paths. We don't (and we leave the `extern crate` in place). -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths as my_crate; diff --git a/tests/ui/rust-2018/extern-crate-rename.rs b/tests/ui/rust-2018/extern-crate-rename.rs index b1f617dd88478..290fcd6b7db7f 100644 --- a/tests/ui/rust-2018/extern-crate-rename.rs +++ b/tests/ui/rust-2018/extern-crate-rename.rs @@ -4,7 +4,6 @@ // Oddball: crate is renamed, making it harder for us to rewrite // paths. We don't (and we leave the `extern crate` in place). -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths as my_crate; diff --git a/tests/ui/rust-2018/extern-crate-rename.stderr b/tests/ui/rust-2018/extern-crate-rename.stderr index 36986c89c62bc..6b2512080309c 100644 --- a/tests/ui/rust-2018/extern-crate-rename.stderr +++ b/tests/ui/rust-2018/extern-crate-rename.stderr @@ -1,5 +1,5 @@ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/extern-crate-rename.rs:12:5 + --> $DIR/extern-crate-rename.rs:11:5 | LL | use my_crate::foo; | ^^^^^^^^^^^^^ help: use `crate`: `crate::my_crate::foo` @@ -7,7 +7,7 @@ LL | use my_crate::foo; = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018! = note: for more information, see issue #53130 note: the lint level is defined here - --> $DIR/extern-crate-rename.rs:8:9 + --> $DIR/extern-crate-rename.rs:7:9 | LL | #![deny(absolute_paths_not_starting_with_crate)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/ui/rust-2018/extern-crate-submod.fixed b/tests/ui/rust-2018/extern-crate-submod.fixed index 9b0b0dd8ee1d4..dd31710414cd4 100644 --- a/tests/ui/rust-2018/extern-crate-submod.fixed +++ b/tests/ui/rust-2018/extern-crate-submod.fixed @@ -5,7 +5,6 @@ // us to rewrite paths. We don't (and we leave the `extern crate` in // place). -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] mod m { diff --git a/tests/ui/rust-2018/extern-crate-submod.rs b/tests/ui/rust-2018/extern-crate-submod.rs index dfce9128c5114..cb0cd7a833136 100644 --- a/tests/ui/rust-2018/extern-crate-submod.rs +++ b/tests/ui/rust-2018/extern-crate-submod.rs @@ -5,7 +5,6 @@ // us to rewrite paths. We don't (and we leave the `extern crate` in // place). -#![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] mod m { diff --git a/tests/ui/rust-2018/extern-crate-submod.stderr b/tests/ui/rust-2018/extern-crate-submod.stderr index 85e26d72a673b..0d45d32d568b2 100644 --- a/tests/ui/rust-2018/extern-crate-submod.stderr +++ b/tests/ui/rust-2018/extern-crate-submod.stderr @@ -1,5 +1,5 @@ error: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition - --> $DIR/extern-crate-submod.rs:19:5 + --> $DIR/extern-crate-submod.rs:18:5 | LL | use m::edition_lint_paths::foo; | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `crate`: `crate::m::edition_lint_paths::foo` @@ -7,7 +7,7 @@ LL | use m::edition_lint_paths::foo; = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2018! = note: for more information, see issue #53130 note: the lint level is defined here - --> $DIR/extern-crate-submod.rs:9:9 + --> $DIR/extern-crate-submod.rs:8:9 | LL | #![deny(absolute_paths_not_starting_with_crate)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/ui/rust-2018/issue-51008-1.rs b/tests/ui/rust-2018/issue-51008-1.rs index 8ae5e82784625..da7b8ef65c566 100644 --- a/tests/ui/rust-2018/issue-51008-1.rs +++ b/tests/ui/rust-2018/issue-51008-1.rs @@ -4,8 +4,6 @@ // // run-pass -#![feature(rust_2018_preview)] - trait A { } diff --git a/tests/ui/rust-2018/issue-51008.rs b/tests/ui/rust-2018/issue-51008.rs index b62609e329dd3..56517b9adee65 100644 --- a/tests/ui/rust-2018/issue-51008.rs +++ b/tests/ui/rust-2018/issue-51008.rs @@ -4,8 +4,6 @@ // // run-pass -#![feature(rust_2018_preview)] - trait A { } diff --git a/tests/ui/rust-2018/proc-macro-crate-in-paths.rs b/tests/ui/rust-2018/proc-macro-crate-in-paths.rs index 2d4cb6514ec2c..37e00a3936e7a 100644 --- a/tests/ui/rust-2018/proc-macro-crate-in-paths.rs +++ b/tests/ui/rust-2018/proc-macro-crate-in-paths.rs @@ -4,7 +4,6 @@ #![crate_type = "proc-macro"] #![deny(rust_2018_compatibility)] -#![feature(rust_2018_preview)] extern crate proc_macro; diff --git a/tests/ui/rust-2018/suggestions-not-always-applicable.fixed b/tests/ui/rust-2018/suggestions-not-always-applicable.fixed index f5afbad9f78fe..d9e39a3b748a0 100644 --- a/tests/ui/rust-2018/suggestions-not-always-applicable.fixed +++ b/tests/ui/rust-2018/suggestions-not-always-applicable.fixed @@ -4,7 +4,6 @@ // rustfix-only-machine-applicable // check-pass -#![feature(rust_2018_preview)] #![warn(rust_2018_compatibility)] extern crate suggestions_not_always_applicable as foo; diff --git a/tests/ui/rust-2018/suggestions-not-always-applicable.rs b/tests/ui/rust-2018/suggestions-not-always-applicable.rs index f5afbad9f78fe..d9e39a3b748a0 100644 --- a/tests/ui/rust-2018/suggestions-not-always-applicable.rs +++ b/tests/ui/rust-2018/suggestions-not-always-applicable.rs @@ -4,7 +4,6 @@ // rustfix-only-machine-applicable // check-pass -#![feature(rust_2018_preview)] #![warn(rust_2018_compatibility)] extern crate suggestions_not_always_applicable as foo; diff --git a/tests/ui/tool_lints_2018_preview.rs b/tests/ui/tool_lints_2018_preview.rs index 190f0b99dc888..e467d34376f78 100644 --- a/tests/ui/tool_lints_2018_preview.rs +++ b/tests/ui/tool_lints_2018_preview.rs @@ -1,6 +1,5 @@ // run-pass -#![feature(rust_2018_preview)] #![deny(unknown_lints)] #[allow(clippy::almost_swapped)] From af8dfde7f952ac35192bfcea0c665d669237cd97 Mon Sep 17 00:00:00 2001 From: Alex Saveau Date: Sun, 6 Aug 2023 11:35:24 +0100 Subject: [PATCH 11/13] Remove an allocation in min_stack Signed-off-by: Alex Saveau --- library/std/src/sys_common/thread.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/std/src/sys_common/thread.rs b/library/std/src/sys_common/thread.rs index 76466b2b37beb..8f5624bbce9da 100644 --- a/library/std/src/sys_common/thread.rs +++ b/library/std/src/sys_common/thread.rs @@ -8,7 +8,7 @@ pub fn min_stack() -> usize { 0 => {} n => return n - 1, } - let amt = env::var("RUST_MIN_STACK").ok().and_then(|s| s.parse().ok()); + let amt = env::var_os("RUST_MIN_STACK").and_then(|s| s.to_str().and_then(|s| s.parse().ok())); let amt = amt.unwrap_or(imp::DEFAULT_MIN_STACK_SIZE); // 0 is our sentinel value, so ensure that we'll never see 0 after From 92b84f849a63af6454845452ee8a5567d6956302 Mon Sep 17 00:00:00 2001 From: Michael Howell Date: Sun, 10 Dec 2023 16:05:18 -0700 Subject: [PATCH 12/13] rustdoc-search: do not treat associated type names as types Before: http://notriddle.com/rustdoc-html-demo-6/tor-before/tor_config/ After: http://notriddle.com/rustdoc-html-demo-6/tor-after/tor_config/ Profile: http://notriddle.com/rustdoc-html-demo-6/tor-profile/ As a bit of background information: in type-based queries, a type name that does not exist gets treated as a generic type variable. This causes a counterintuitive behavior in the `tor_config` crate, which has a trait with an associated type variable called `T`. This isn't a searchable concrete type, but its name still gets stored in the typeNameIdMap, as a convenient way to intern its name. --- src/librustdoc/html/static/js/search.js | 33 ++++++----- tests/rustdoc-js/enum-variant-not-type.js | 70 +++++++++++++++++++++++ tests/rustdoc-js/enum-variant-not-type.rs | 14 +++++ 3 files changed, 104 insertions(+), 13 deletions(-) create mode 100644 tests/rustdoc-js/enum-variant-not-type.js create mode 100644 tests/rustdoc-js/enum-variant-not-type.rs diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js index 8f68796ad26b8..832ac42711209 100644 --- a/src/librustdoc/html/static/js/search.js +++ b/src/librustdoc/html/static/js/search.js @@ -243,7 +243,7 @@ function initSearch(rawSearchIndex) { * Map from normalized type names to integers. Used to make type search * more efficient. * - * @type {Map} + * @type {Map} */ let typeNameIdMap; const ALIASES = new Map(); @@ -270,19 +270,22 @@ function initSearch(rawSearchIndex) { * get the same ID. * * @param {string} name + * @param {boolean} isAssocType - True if this is an assoc type * * @returns {integer} */ - function buildTypeMapIndex(name) { + function buildTypeMapIndex(name, isAssocType) { if (name === "" || name === null) { return null; } if (typeNameIdMap.has(name)) { - return typeNameIdMap.get(name); + const obj = typeNameIdMap.get(name); + obj.assocOnly = isAssocType && obj.assocOnly; + return obj.id; } else { const id = typeNameIdMap.size; - typeNameIdMap.set(name, id); + typeNameIdMap.set(name, {id, assocOnly: isAssocType}); return id; } } @@ -2129,17 +2132,20 @@ function initSearch(rawSearchIndex) { * See `buildTypeMapIndex` for more information. * * @param {QueryElement} elem + * @param {boolean} isAssocType */ - function convertNameToId(elem) { - if (typeNameIdMap.has(elem.pathLast)) { - elem.id = typeNameIdMap.get(elem.pathLast); + function convertNameToId(elem, isAssocType) { + if (typeNameIdMap.has(elem.pathLast) && + (isAssocType || !typeNameIdMap.get(elem.pathLast).assocOnly)) { + elem.id = typeNameIdMap.get(elem.pathLast).id; } else if (!parsedQuery.literalSearch) { let match = null; let matchDist = maxEditDistance + 1; let matchName = ""; - for (const [name, id] of typeNameIdMap) { + for (const [name, {id, assocOnly}] of typeNameIdMap) { const dist = editDistance(name, elem.pathLast, maxEditDistance); - if (dist <= matchDist && dist <= maxEditDistance) { + if (dist <= matchDist && dist <= maxEditDistance && + (isAssocType || !assocOnly)) { if (dist === matchDist && matchName > name) { continue; } @@ -2206,12 +2212,13 @@ function initSearch(rawSearchIndex) { name, " does not exist", ]; + return [null, []]; } for (const elem2 of constraints) { convertNameToId(elem2); } - return [typeNameIdMap.get(name), constraints]; + return [typeNameIdMap.get(name).id, constraints]; }) ); } @@ -2720,7 +2727,7 @@ ${item.displayPath}${name}\ * * @param {RawFunctionType} type */ - function buildItemSearchType(type, lowercasePaths) { + function buildItemSearchType(type, lowercasePaths, isAssocType) { const PATH_INDEX_DATA = 0; const GENERICS_DATA = 1; const BINDINGS_DATA = 2; @@ -2749,7 +2756,7 @@ ${item.displayPath}${name}\ // // As a result, the key should never have generics on it. return [ - buildItemSearchType(assocType, lowercasePaths).id, + buildItemSearchType(assocType, lowercasePaths, true).id, buildItemSearchTypeAll(constraints, lowercasePaths), ]; })); @@ -2780,7 +2787,7 @@ ${item.displayPath}${name}\ } const item = lowercasePaths[pathIndex - 1]; return { - id: buildTypeMapIndex(item.name), + id: buildTypeMapIndex(item.name, isAssocType), ty: item.ty, path: item.path, generics, diff --git a/tests/rustdoc-js/enum-variant-not-type.js b/tests/rustdoc-js/enum-variant-not-type.js new file mode 100644 index 0000000000000..b0f1ec666583d --- /dev/null +++ b/tests/rustdoc-js/enum-variant-not-type.js @@ -0,0 +1,70 @@ +const EXPECTED = [ + { + 'query': 'T -> T', + 'correction': null, + 'others': [ + { + 'path': 'enum_variant_not_type', + 'name': 'my_fn', + }, + { + 'path': 'enum_variant_not_type::AutoCorrectConfounder', + 'name': 'assoc_type_acts_like_generic', + }, + ], + }, + { + 'query': 'InsertUnnecessarilyLongTypeNameHere -> InsertUnnecessarilyLongTypeNameHere', + 'correction': null, + 'others': [ + { + 'path': 'enum_variant_not_type', + 'name': 'my_fn', + }, + { + 'path': 'enum_variant_not_type::AutoCorrectConfounder', + 'name': 'assoc_type_acts_like_generic', + }, + ], + }, + { + 'query': 'InsertUnnecessarilyLongTypeNameHere', + 'correction': null, + 'others': [ + { + 'path': 'enum_variant_not_type::AutoCorrectConfounder', + 'name': 'InsertUnnecessarilyLongTypeNameHere', + }, + ], + }, + { + 'query': 'InsertUnnecessarilyLongTypeNameHereX', + 'correction': null, + 'others': [ + { + 'path': 'enum_variant_not_type::AutoCorrectConfounder', + 'name': 'InsertUnnecessarilyLongTypeNameHere', + }, + ], + }, + { + 'query': 'T', + 'correction': null, + 'others': [ + { + 'path': 'enum_variant_not_type::MyTrait', + 'name': 'T', + }, + ], + }, + { + 'query': 'T', + 'correction': null, + 'others': [ + { + 'path': 'enum_variant_not_type::MyTrait', + 'name': 'T', + }, + ], + }, +]; diff --git a/tests/rustdoc-js/enum-variant-not-type.rs b/tests/rustdoc-js/enum-variant-not-type.rs new file mode 100644 index 0000000000000..421bddf628946 --- /dev/null +++ b/tests/rustdoc-js/enum-variant-not-type.rs @@ -0,0 +1,14 @@ +pub trait MyTrait { + // Reduced from `arti` crate. + // https://tpo.pages.torproject.net/core/doc/rust/tor_config/list_builder/trait.DirectDefaultEmptyListBuilderAccessors.html#associatedtype.T + type T; + fn not_appearing(&self) -> Option<&Self::T>; +} + +pub fn my_fn(t: X) -> X { t } + +pub trait AutoCorrectConfounder { + type InsertUnnecessarilyLongTypeNameHere; + fn assoc_type_acts_like_generic(&self, x: &Self::InsertUnnecessarilyLongTypeNameHere) + -> Option<&Self::InsertUnnecessarilyLongTypeNameHere>; +} From 7162cb95500a066da51bc8ba7929809ec02bc835 Mon Sep 17 00:00:00 2001 From: Michael Howell Date: Sun, 10 Dec 2023 20:53:53 -0700 Subject: [PATCH 13/13] rustdoc-search: fix fast path unboxing bindings --- src/librustdoc/html/static/js/search.js | 2 +- tests/rustdoc-js/assoc-type.js | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js index 832ac42711209..a521bf66bedd8 100644 --- a/src/librustdoc/html/static/js/search.js +++ b/src/librustdoc/html/static/js/search.js @@ -1433,7 +1433,7 @@ function initSearch(rawSearchIndex) { return true; } } else if (unifyFunctionTypes( - fnType.generics, + [...fnType.generics, ...Array.from(fnType.bindings.values()).flat() ], queryElems, whereClause, mgens ? new Map(mgens) : null, diff --git a/tests/rustdoc-js/assoc-type.js b/tests/rustdoc-js/assoc-type.js index cc3afaa17c07d..47776656e32c2 100644 --- a/tests/rustdoc-js/assoc-type.js +++ b/tests/rustdoc-js/assoc-type.js @@ -19,6 +19,17 @@ const EXPECTED = [ { 'path': 'assoc_type::my', 'name': 'other_fn' }, ], }, + { + 'query': 'something', + 'correction': null, + 'others': [ + { 'path': 'assoc_type', 'name': 'Something' }, + ], + 'in_args': [ + { 'path': 'assoc_type', 'name': 'my_fn' }, + { 'path': 'assoc_type::my', 'name': 'other_fn' }, + ], + }, // if I write an explicit binding, only it shows up { 'query': 'iterator -> u32',