Auto merge of #158145 - JonathanBrouwer:rollup-89qzt8B, r=JonathanBrouwer

Rollup of 8 pull requests

Successful merges:

 - #158129 (ensure the new solver bootstraps on CI)
 - #158134 (Rename `lint-rust-version` to `hint-msrv`)
 - #157926 (Implement `#[diagnostic::on_unknown]` for modules.)
 - #158075 (Point to the unstable segment of an import path instead of to the whole path)
 - #158084 (`-Znext-solver` Emit error instead of ICE when combining {int, float} var with alias)
 - #158128 (std: use correct low surrogate range in Windows standard I/O code)
 - #158132 (std: correctly report file size on UWP)
 - #158138 (Remove redundant check for `#[loop_match]` and `#[const_continue]`)

Author: bors

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -460,6 +460,7 @@ fn parse_arg(
 
             (Mode::DiagnosticOnTypeError, sym::Found) => FormatArg::Found,
             (Mode::DiagnosticOnTypeError, sym::Expected) => FormatArg::Expected,
+            (Mode::DiagnosticOnUnknown, sym::Unresolved) => FormatArg::Unresolved,
 
             // Some diagnostic attributes can use `{This}` to refer to the annotated item.
             // For those that don't, we continue and maybe use it as a generic parameter.

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs

@@ -5,7 +5,7 @@ use rustc_session::lint::builtin::MISPLACED_DIAGNOSTIC_ATTRIBUTES;
 use crate::ShouldEmit;
 use crate::attributes::diagnostic::*;
 use crate::attributes::prelude::*;
-use crate::diagnostics::DiagnosticOnUnknownOnlyForImports;
+use crate::diagnostics::DiagnosticOnUnknownInvalidTarget;
 
 #[derive(Default)]
 pub(crate) struct OnUnknownParser {
@@ -29,11 +29,11 @@ impl OnUnknownParser {
         // Therefore, only do target checking if we can emit.
         let early = matches!(cx.should_emit, ShouldEmit::Nothing);
 
-        if !early && !matches!(cx.target, Target::Use) {
+        if !early && !matches!(cx.target, Target::Use | Target::Mod | Target::Crate) {
             let target_span = cx.target_span;
             cx.emit_lint(
                 MISPLACED_DIAGNOSTIC_ATTRIBUTES,
-                DiagnosticOnUnknownOnlyForImports { target_span },
+                DiagnosticOnUnknownInvalidTarget { target_span },
                 span,
             );
             return;

compiler/rustc_attr_parsing/src/attributes/loop_match.rs

@@ -13,7 +13,7 @@ impl NoArgsAttributeParser for LoopMatchParser {
 pub(crate) struct ConstContinueParser;
 impl NoArgsAttributeParser for ConstContinueParser {
     const PATH: &[Symbol] = &[sym::const_continue];
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Expression)]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Break)]);
     const STABILITY: AttributeStability = unstable!(loop_match);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::ConstContinue;
 }

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -295,9 +295,11 @@ pub(crate) struct DiagnosticOnMoveOnlyForAdt;
 pub(crate) struct DiagnosticOnUnimplementedOnlyForTraits;
 
 #[derive(Diagnostic)]
-#[diag("`#[diagnostic::on_unknown]` can only be applied to `use` statements")]
-pub(crate) struct DiagnosticOnUnknownOnlyForImports {
-    #[label("not an import")]
+#[diag(
+    "`#[diagnostic::on_unknown]` can only be applied to `use` statements and module declarations"
+)]
+pub(crate) struct DiagnosticOnUnknownInvalidTarget {
+    #[label("not an import or module")]
     pub target_span: Span,
 }
 

compiler/rustc_attr_parsing/src/target_checking.rs

@@ -527,5 +527,6 @@ pub(crate) const ALL_TARGETS: &'static [Policy] = {
         Allow(Target::Loop),
         Allow(Target::ForLoop),
         Allow(Target::While),
+        Allow(Target::Break),
     ]
 };

compiler/rustc_errors/src/lib.rs

@@ -366,7 +366,7 @@ struct DiagCtxtInner {
     /// stored along side the main panic backtrace.
     ice_file: Option<PathBuf>,
 
-    /// Controlled by `-Z lint-rust-version`; this allows avoiding emitting lints which would raise MSRV.
+    /// Controlled by `-Z hint-msrv`; this allows avoiding emitting lints which would raise MSRV.
     msrv: Option<RustcVersion>,
 }
 

compiler/rustc_expand/src/base.rs

@@ -1376,7 +1376,7 @@ impl<'a> ExtCtxt<'a> {
     pub fn std_path(&self, components: &[Symbol]) -> Vec<Ident> {
         let def_site = self.with_def_site_ctxt(DUMMY_SP);
         iter::once(Ident::new(kw::DollarCrate, def_site))
-            .chain(components.iter().map(|&s| Ident::with_dummy_span(s)))
+            .chain(components.iter().map(|&s| Ident::new(s, def_site)))
             .collect()
     }
     pub fn def_site_path(&self, components: &[Symbol]) -> Vec<Ident> {

compiler/rustc_hir/src/attrs/diagnostic.rs

@@ -92,7 +92,7 @@ pub struct CustomDiagnostic {
 }
 
 impl CustomDiagnostic {
-    fn update(&mut self, di: &Directive, args: &FormatArgs) {
+    pub fn update(&mut self, di: &Directive, args: &FormatArgs) {
         if self.message.is_none() {
             self.message = di.message.as_ref().map(|m| m.1.format(args));
         }
@@ -153,6 +153,9 @@ impl FormatString {
                 Piece::Arg(FormatArg::Found) => ret.push_str(&args.found),
                 Piece::Arg(FormatArg::Expected) => ret.push_str(&args.expected),
 
+                // only for on_unknown
+                Piece::Arg(FormatArg::Unresolved) => ret.push_str(&args.unresolved),
+
                 // It's only `rustc_onunimplemented` from here
                 Piece::Arg(FormatArg::ThisPath) => ret.push_str(&args.this_path),
                 Piece::Arg(FormatArg::ThisResolved) => {
@@ -215,6 +218,7 @@ pub struct FormatArgs {
     pub this_path: String = String::new(),
     pub found: String = String::new(),
     pub expected: String = String::new(),
+    pub unresolved: String = String::new(),
     pub item_context: &'static str = "",
     pub generic_args: Vec<(Symbol, String)> = Vec::new(),
 }
@@ -248,6 +252,8 @@ pub enum FormatArg {
     Found,
     /// {Expected} in diagnostic::on_type_error
     Expected,
+    /// {Unresolved} in diagnostic::on_unknown
+    Unresolved,
 }
 
 /// Represents the `on` filter in `#[rustc_on_unimplemented]`.

compiler/rustc_hir/src/target.rs

@@ -70,6 +70,7 @@ pub enum Target {
     ForLoop,
     While,
     Loop,
+    Break,
 }
 
 impl Display for Target {
@@ -119,7 +120,8 @@ impl Target {
             | Target::Delegation { .. }
             | Target::Loop
             | Target::While
-            | Target::ForLoop => false,
+            | Target::ForLoop
+            | Target::Break => false,
         }
     }
 
@@ -265,6 +267,7 @@ impl Target {
             ast::ExprKind::ForLoop { .. } => Self::ForLoop,
             ast::ExprKind::Loop(..) => Self::Loop,
             ast::ExprKind::While(..) => Self::While,
+            ast::ExprKind::Break(..) => Self::Break,
             _ => Self::Expression,
         }
     }
@@ -319,6 +322,7 @@ impl Target {
             Target::Loop => "loop",
             Target::ForLoop => "for loop",
             Target::While => "while loop",
+            Target::Break => "break expression",
         }
     }
 
@@ -373,6 +377,7 @@ impl Target {
             Target::ForLoop => "for loops",
             Target::Loop => "loops",
             Target::While => "while loops",
+            Target::Break => "break expressions",
         }
     }
 }

compiler/rustc_passes/src/check_attr.rs

@@ -193,12 +193,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::Inline(kind, attr_span) => {
                 self.check_inline(hir_id, *attr_span, kind, target)
             }
-            AttributeKind::LoopMatch(attr_span) => {
-                self.check_loop_match(hir_id, *attr_span, target)
-            }
-            AttributeKind::ConstContinue(attr_span) => {
-                self.check_const_continue(hir_id, *attr_span, target)
-            }
             AttributeKind::AllowInternalUnsafe(attr_span)
             | AttributeKind::AllowInternalUnstable(.., attr_span) => {
                 self.check_macro_only_attr(*attr_span, span, target, attrs)
@@ -218,7 +212,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             &AttributeKind::RustcPubTransparent(attr_span) => {
                 self.check_rustc_pub_transparent(attr_span, span, attrs)
             }
-            AttributeKind::RustcAlign { .. } => {}
             AttributeKind::Naked(..) => self.check_naked(hir_id, target),
             AttributeKind::TrackCaller(attr_span) => {
                 self.check_track_caller(hir_id, *attr_span, attrs, target)
@@ -262,6 +255,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::Cold => (),
             AttributeKind::CollapseDebugInfo(..) => (),
             AttributeKind::CompilerBuiltins => (),
+            AttributeKind::ConstContinue(..) => {}
             AttributeKind::Coroutine => (),
             AttributeKind::Coverage(..) => (),
             AttributeKind::CrateName { .. } => (),
@@ -286,6 +280,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::LinkOrdinal { .. } => (),
             AttributeKind::LinkSection { .. } => (),
             AttributeKind::Linkage(..) => (),
+            AttributeKind::LoopMatch(..) => {}
             AttributeKind::MacroEscape => (),
             AttributeKind::MacroUse { .. } => (),
             AttributeKind::Marker => (),
@@ -317,6 +312,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             // handled below this loop and elsewhere
             AttributeKind::Repr { .. } => (),
             AttributeKind::RustcAbi { .. } => (),
+            AttributeKind::RustcAlign { .. } => {}
             AttributeKind::RustcAllocator => (),
             AttributeKind::RustcAllocatorZeroed => (),
             AttributeKind::RustcAllocatorZeroedVariant { .. } => (),
@@ -891,7 +887,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             | Target::Delegation { .. }
             | Target::Loop
             | Target::ForLoop
-            | Target::While => None,
+            | Target::While
+            | Target::Break => None,
         } {
             self.tcx.dcx().emit_err(diagnostics::DocAliasBadLocation { span, location });
             return;
@@ -1662,30 +1659,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 .emit_err(diagnostics::BothOptimizeNoneAndInline { optimize_span, inline_span });
         }
     }
-
-    fn check_loop_match(&self, hir_id: HirId, attr_span: Span, target: Target) {
-        let node_span = self.tcx.hir_span(hir_id);
-
-        if !matches!(target, Target::Expression) {
-            return; // Handled in target checking during attr parse
-        }
-
-        if !matches!(self.tcx.hir_expect_expr(hir_id).kind, hir::ExprKind::Loop(..)) {
-            self.dcx().emit_err(diagnostics::LoopMatchAttr { attr_span, node_span });
-        };
-    }
-
-    fn check_const_continue(&self, hir_id: HirId, attr_span: Span, target: Target) {
-        let node_span = self.tcx.hir_span(hir_id);
-
-        if !matches!(target, Target::Expression) {
-            return; // Handled in target checking during attr parse
-        }
-
-        if !matches!(self.tcx.hir_expect_expr(hir_id).kind, hir::ExprKind::Break(..)) {
-            self.dcx().emit_err(diagnostics::ConstContinueAttr { attr_span, node_span });
-        };
-    }
 }
 
 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {