Rollup of 18 pull requests

compiler/rustc_ast_lowering/src/expr/closure.rs

@@ -6,8 +6,8 @@ use rustc_hir::HirId;
 use rustc_span::{Span, span_bug};
 
 use super::{LoweringContext, MoveExprState};
-use crate::FnDeclKind;
 use crate::diagnostics::{ClosureCannotBeStatic, CoroutineTooManyParameters};
+use crate::{DiscardParams, FnDeclKind};
 
 impl<'hir> LoweringContext<'_, 'hir> {
     // Entry point for `ExprKind::Closure`. Plain closures go through
@@ -133,6 +133,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             binder,
             capture_clause,
             closure_id,
+            expr_hir_id,
             constness,
             movability,
             decl,
@@ -159,6 +160,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         binder: &ClosureBinder,
         capture_clause: CaptureBy,
         closure_id: NodeId,
+        closure_hir_id: HirId,
         constness: Const,
         movability: Movability,
         decl: &FnDecl,
@@ -205,7 +207,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let bound_generic_params = self.lower_lifetime_binder(closure_id, generic_params);
         // Lower outside new scope to preserve `is_in_loop_condition`.
-        let fn_decl = self.lower_fn_decl(decl, closure_id, FnDeclKind::Closure, None);
+        let fn_decl = self.lower_fn_decl(
+            decl,
+            closure_id,
+            closure_hir_id,
+            FnDeclKind::Closure,
+            None,
+            DiscardParams::No,
+        );
 
         let c = self.arena.alloc(hir::Closure {
             def_id: closure_def_id,
@@ -328,7 +337,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // We need to lower the declaration outside the new scope, because we
         // have to conserve the state of being inside a loop condition for the
         // closure argument types.
-        let fn_decl = self.lower_fn_decl(&decl, closure_id, FnDeclKind::Closure, None);
+        let fn_decl = self.lower_fn_decl(
+            &decl,
+            closure_id,
+            closure_hir_id,
+            FnDeclKind::Closure,
+            None,
+            DiscardParams::No,
+        );
 
         if let Const::Yes(span) = constness {
             self.dcx().span_err(span, "const coroutines are not supported");

compiler/rustc_ast_lowering/src/item.rs

@@ -19,8 +19,8 @@ use super::diagnostics::{
 };
 use super::stability::{enabled_names, gate_unstable_abi};
 use super::{
-    FnDeclKind, GenericArgsMode, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
-    RelaxedBoundForbiddenReason, RelaxedBoundPolicy,
+    DiscardParams, FnDeclKind, GenericArgsMode, ImplTraitContext, ImplTraitPosition,
+    LoweringContext, ParamMode, RelaxedBoundForbiddenReason, RelaxedBoundPolicy,
 };
 use crate::diagnostics::{ConstComptimeFn, ResolvingRestrictionKind, RestrictionAncestorOnly};
 
@@ -278,7 +278,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                     let itctx = ImplTraitContext::Universal;
                     let (generics, decl) = this.lower_generics(generics, itctx, |this| {
-                        this.lower_fn_decl(decl, id, FnDeclKind::Fn, coroutine_marker)
+                        this.lower_fn_decl(
+                            decl,
+                            id,
+                            hir_id,
+                            FnDeclKind::Fn,
+                            coroutine_marker,
+                            if body.is_none() { DiscardParams::Yes } else { DiscardParams::No },
+                        )
                     });
                     let sig = hir::FnSig {
                         decl,
@@ -616,7 +623,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, (decl, fn_args)) = self.lower_generics(generics, itctx, |this| {
                     (
                         // Disallow `impl Trait` in foreign items.
-                        this.lower_fn_decl(fdec, i.id, FnDeclKind::ExternFn, None),
+                        // Parameters are discarded because foreign functions don't have a body
+                        this.lower_fn_decl(
+                            fdec,
+                            i.id,
+                            hir_id,
+                            FnDeclKind::ExternFn,
+                            None,
+                            DiscardParams::Yes,
+                        ),
                         this.lower_fn_params_to_idents(fdec),
                     )
                 });
@@ -838,9 +853,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     generics,
                     sig,
                     i.id,
+                    hir_id,
                     FnDeclKind::Trait,
                     sig.header.coroutine_marker,
                     attrs,
+                    // Parameters are discarded for functions without a body
+                    DiscardParams::Yes,
                 );
                 if define_opaque.is_some() {
                     self.dcx().span_err(
@@ -878,9 +896,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     generics,
                     sig,
                     i.id,
+                    hir_id,
                     FnDeclKind::Trait,
                     sig.header.coroutine_marker,
                     attrs,
+                    DiscardParams::No,
                 );
                 self.lower_define_opaque(hir_id, &define_opaque);
                 (
@@ -1088,9 +1108,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     generics,
                     sig,
                     i.id,
+                    hir_id,
                     if is_in_trait_impl { FnDeclKind::Impl } else { FnDeclKind::Inherent },
                     sig.header.coroutine_marker,
                     attrs,
+                    if body.is_none() { DiscardParams::Yes } else { DiscardParams::No },
                 );
                 self.lower_define_opaque(hir_id, &define_opaque);
 
@@ -1533,15 +1555,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         generics: &Generics,
         sig: &FnSig,
-        id: NodeId,
+        node_id: NodeId,
+        hir_id: HirId,
         kind: FnDeclKind,
         coroutine_marker: Option<CoroutineMarker>,
         attrs: &[rustc_attr_ir::Attribute],
+        discard_params: DiscardParams,
     ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) {
         let header = self.lower_fn_header(sig.header, hir::Safety::Safe, attrs);
         let itctx = ImplTraitContext::Universal;
         let (generics, decl) = self.lower_generics(generics, itctx, |this| {
-            this.lower_fn_decl(&sig.decl, id, kind, coroutine_marker)
+            this.lower_fn_decl(&sig.decl, node_id, hir_id, kind, coroutine_marker, discard_params)
         });
         (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })
     }

compiler/rustc_ast_lowering/src/lib.rs

@@ -807,6 +807,14 @@ enum GenericArgsMode {
     Silence,
 }
 
+#[derive(Debug, Copy, Clone)]
+enum DiscardParams {
+    /// Should be used for functions without a body. Lowers the attributes on the parameter and then discards them.
+    Yes,
+    /// Should be used for functions with a body. Does not lower the attributes, as lowering of the parameters is done by `lower_body`.
+    No,
+}
+
 impl<'hir> LoweringContext<'_, 'hir> {
     fn create_def(
         &mut self,
@@ -1547,14 +1555,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::TyKind::Path(path)
             }
             TyKind::FnPtr(f) => {
+                let hir_id = self.lower_node_id(t.id);
                 let generic_params = self.lower_lifetime_binder(t.id, &f.generic_params);
-                hir::TyKind::FnPtr(self.arena.alloc(hir::FnPtrTy {
+                let kind = hir::TyKind::FnPtr(self.arena.alloc(hir::FnPtrTy {
                     generic_params,
                     safety: self.lower_safety(f.safety, hir::Safety::Safe),
                     abi: self.lower_extern(f.ext),
-                    decl: self.lower_fn_decl(&f.decl, t.id, FnDeclKind::Pointer, None),
+                    decl: self.lower_fn_decl(
+                        &f.decl,
+                        t.id,
+                        hir_id,
+                        FnDeclKind::Pointer,
+                        None,
+                        DiscardParams::Yes,
+                    ),
                     param_idents: self.lower_fn_params_to_idents(&f.decl),
-                }))
+                }));
+                return hir::Ty { kind, span: self.lower_span(t.span), hir_id };
             }
             TyKind::UnsafeBinder(f) => {
                 let generic_params = self.lower_lifetime_binder(t.id, &f.generic_params);
@@ -1900,18 +1917,26 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ///
     /// `decl`: the unlowered (AST) function declaration.
     ///
-    /// `fn_node_id`: `impl Trait` arguments are lowered into generic parameters on the given
-    /// `NodeId`.
+    /// `fn_node_id`: Node Id of the function.
+    ///
+    /// `fn_hir_id`: Hir Id of the function. Used for attribute parsing.
+    ///
+    /// `kind`: The kind of function.
     ///
-    /// `transform_return_type`: if `Some`, applies some conversion to the return type, such as is
-    /// needed for `async fn` and `gen fn`. See [`CoroutineKind`] for more details.
+    /// `coro`: If the function is a coroutine, information about the coroutine.
+    ///
+    /// `discard_params`: if `DiscardParams::Yes`, the parameters are lowered and then discarded. Set this to `DiscardParams::Yes`
+    /// for functions without bodies, as attributes on parameters are otherwise not validated.
+    /// Set this to `DiscardParams::No` for functions with bodies, as lowering of the parameters is done by `lower_body`.
     #[instrument(level = "debug", skip(self))]
     fn lower_fn_decl(
         &mut self,
         decl: &FnDecl,
         fn_node_id: NodeId,
+        fn_hir_id: HirId,
         kind: FnDeclKind,
         coro: Option<CoroutineMarker>,
+        discard_params: DiscardParams,
     ) -> &'hir hir::FnDecl<'hir> {
         let c_variadic = decl.c_variadic();
         let mut splatted = decl.splatted();
@@ -1926,6 +1951,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
             inputs = &inputs[..inputs.len() - 1];
         }
         let inputs = self.arena.alloc_from_iter(inputs.iter().map(|param| {
+            if let DiscardParams::Yes = discard_params {
+                // FIXME This uses `fn_hir_id`, which is not correct, it should use the parameter hir id instead
+                // The parameter is currently not lowered for functions without bodies, so there is no place to store the lowered hir id
+                // This should be fixed by storing function parameters in the `hir::FnSig` instead of `hir::Body`
+                self.lower_attrs(fn_hir_id, &param.attrs, param.span, Target::Param);
+            }
             let itctx = match kind {
                 FnDeclKind::Fn | FnDeclKind::Inherent | FnDeclKind::Impl | FnDeclKind::Trait => {
                     ImplTraitContext::Universal

compiler/rustc_driver_impl/src/lib.rs

@@ -184,14 +184,24 @@ pub fn compiler_entrypoint(at_args: &[String], callbacks: &mut (dyn Callbacks +
 
     let args = args::arg_expand_all(&default_early_dcx, at_args);
 
+    // For the purposes of checking that an --edition was passed, we only emit a message if the only
+    // argument passed to rustc is a file name.
+    let warn_unspecified_edition = match &args[..] {
+        [] => false,
+        // We explicitly don't emit the note if we're consuming code from stdin, or passing non-file
+        // flags. This can happen on some cargo invocations too.
+        [name] if name.starts_with("-") => false,
+        [_] => true,
+        _ => false,
+    };
     let (matches, help_only) = match handle_options(&default_early_dcx, &args) {
         HandledOptions::None => return,
         HandledOptions::Normal(matches) => (matches, false),
         HandledOptions::HelpOnly(matches) => (matches, true),
     };
 
-    let sopts = config::build_session_options(&mut default_early_dcx, &matches);
-    // fully initialize ice path static once unstable options are available as context
+    let sopts =
+        config::build_session_options(&mut default_early_dcx, &matches, warn_unspecified_edition);
     let ice_file = ice_path_with_config(Some(&sopts.unstable_opts)).clone();
 
     if let Some(ref code) = matches.opt_str("explain") {

compiler/rustc_error_messages/src/lib.rs

@@ -216,6 +216,12 @@ impl From<Span> for MultiSpan {
     }
 }
 
+impl From<Option<Span>> for MultiSpan {
+    fn from(span: Option<Span>) -> MultiSpan {
+        MultiSpan::from_spans(span.into_iter().collect())
+    }
+}
+
 impl From<Vec<Span>> for MultiSpan {
     fn from(spans: Vec<Span>) -> MultiSpan {
         MultiSpan::from_spans(spans)

compiler/rustc_interface/src/tests.rs

@@ -42,7 +42,7 @@ where
 {
     let mut early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
     let matches = optgroups().parse(args).unwrap();
-    let sessopts = build_session_options(&mut early_dcx, &matches);
+    let sessopts = build_session_options(&mut early_dcx, &matches, true);
     let target = rustc_session::config::build_target_config(
         &early_dcx,
         &sessopts.target_triple,
@@ -942,7 +942,7 @@ fn test_edition_parsing() {
     let mut early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
 
     let matches = optgroups().parse(&["--edition=2018".to_string()]).unwrap();
-    let sessopts = build_session_options(&mut early_dcx, &matches);
+    let sessopts = build_session_options(&mut early_dcx, &matches, false);
     assert!(sessopts.edition == Edition::Edition2018)
 }
 
@@ -953,7 +953,7 @@ fn test_assumptions_on_binders_enables_next_solver_globally() {
 
     // `-Zassumptions-on-binders` alone enables the next solver globally.
     let matches = optgroups().parse(&["-Zassumptions-on-binders".to_string()]).unwrap();
-    let opts = build_session_options(&mut early_dcx, &matches);
+    let opts = build_session_options(&mut early_dcx, &matches, false);
     assert!(opts.unstable_opts.assumptions_on_binders);
     assert_eq!(opts.unstable_opts.next_solver, globally);
 
@@ -964,7 +964,7 @@ fn test_assumptions_on_binders_enables_next_solver_globally() {
         ["-Znext-solver=coherence".to_string(), "-Zassumptions-on-binders".to_string()],
     ] {
         let matches = optgroups().parse(&args).unwrap();
-        let opts = build_session_options(&mut early_dcx, &matches);
+        let opts = build_session_options(&mut early_dcx, &matches, false);
         assert!(opts.unstable_opts.assumptions_on_binders);
         assert_eq!(opts.unstable_opts.next_solver, globally);
     }
@@ -977,7 +977,7 @@ fn test_assumptions_on_binders_enables_next_solver_globally() {
         ["-Znext-solver=no".to_string(), "-Zassumptions-on-binders".to_string()],
     ] {
         let matches = optgroups().parse(&args).unwrap();
-        let opts = build_session_options(&mut early_dcx, &matches);
+        let opts = build_session_options(&mut early_dcx, &matches, false);
         assert!(opts.unstable_opts.assumptions_on_binders);
         assert_eq!(opts.unstable_opts.next_solver, globally);
     }

compiler/rustc_lint_defs/src/builtin.rs

@@ -137,6 +137,7 @@ pub mod hardwired {
             UNREACHABLE_PATTERNS,
             UNSAFE_ATTR_OUTSIDE_UNSAFE,
             UNSAFE_OP_IN_UNSAFE_FN,
+            UNSTABLE_IMPORTS,
             UNSTABLE_NAME_COLLISIONS,
             UNSTABLE_SYNTAX_PRE_EXPANSION,
             UNSUPPORTED_CALLING_CONVENTIONS,
@@ -5857,3 +5858,28 @@ declare_lint! {
     "`repr(C, align)` types nested inside `repr(C, packed)` types \
     do not always have a C-compatible layout",
 }
+
+declare_lint! {
+    /// The `unstable_imports` lints detects imports that go through unstable modules.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use core::intrinsics::transmute;
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Previous versions of Rust accidentally allowed certain imports through unstable modules
+    /// because stability information of modules was not correctly accounted for if the imported
+    /// item was stable itself.
+    pub UNSTABLE_IMPORTS,
+    Deny,
+    "lints on accidentally allowed unstable imports",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: fcw!(FutureReleaseError # 163160),
+        report_in_deps: true,
+    };
+}

compiler/rustc_macros/src/diagnostics/subdiagnostic.rs

@@ -315,7 +315,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
                     let binding = info.binding.binding.clone();
                     // FIXME(#100717): support `Option<Span>` on `primary_span` like in the
                     // diagnostic derive
-                    if !matches!(info.ty, FieldInnerTy::Plain(_)) {
+                    if !matches!(info.ty, FieldInnerTy::Plain(_) | FieldInnerTy::Option(_)) {
                         throw_invalid_attr!(attr, |diag| {
                             let diag = diag.note("there must be exactly one primary span");
 

compiler/rustc_passes/src/stability.rs

@@ -19,8 +19,8 @@ use rustc_hir::{
     UsePath, Variant,
 };
 use rustc_lint_defs::builtin::{
-    DEPRECATED, DUPLICATE_FEATURES, INEFFECTIVE_UNSTABLE_REEXPORTS,
-    INEFFECTIVE_UNSTABLE_TRAIT_IMPL, STABLE_FEATURES,
+    DUPLICATE_FEATURES, INEFFECTIVE_UNSTABLE_REEXPORTS, INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
+    STABLE_FEATURES, UNSTABLE_IMPORTS,
 };
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::lib_features::{FeatureStability, LibFeatures};
@@ -1079,7 +1079,7 @@ impl<'tcx> Checker<'tcx> {
                             suggestion,
                         };
                         self.tcx.emit_node_span_lint(
-                            DEPRECATED,
+                            UNSTABLE_IMPORTS,
                             id,
                             method_span.unwrap_or(span),
                             diag,