Rollup of 19 pull requests

Cargo.lock

@@ -3853,8 +3853,6 @@ dependencies = [
  "icu_list",
  "icu_locale",
  "intl-memoizer",
- "rustc_ast",
- "rustc_ast_pretty",
  "rustc_baked_icu_data",
  "rustc_data_structures",
  "rustc_macros",
@@ -4186,7 +4184,6 @@ dependencies = [
 name = "rustc_lint_defs"
 version = "0.0.0"
 dependencies = [
- "rustc_ast",
  "rustc_data_structures",
  "rustc_error_messages",
  "rustc_hir_id",

compiler/rustc_abi/src/extern_abi.rs

@@ -261,6 +261,7 @@ impl StableOrd for ExternAbi {
 rustc_error_messages::into_diag_arg_using_display!(ExternAbi);
 
 #[cfg(feature = "nightly")]
+#[derive(Debug)]
 pub enum CVariadicStatus {
     NotSupported,
     Stable,

compiler/rustc_ast_lowering/src/asm.rs

@@ -5,7 +5,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::msg;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_session::parse::feature_err;
+use rustc_session::errors::feature_err;
 use rustc_span::{Span, sym};
 use rustc_target::asm;
 

compiler/rustc_ast_lowering/src/expr.rs

@@ -1693,7 +1693,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             && !self.tcx.features().coroutines()
             && !self.tcx.features().gen_blocks()
         {
-            rustc_session::parse::feature_err(
+            rustc_session::errors::feature_err(
                 &self.tcx.sess,
                 sym::yield_expr,
                 span,

compiler/rustc_ast_lowering/src/lib.rs

@@ -62,7 +62,7 @@ use rustc_macros::extension;
 use rustc_middle::hir::{self as mid_hir};
 use rustc_middle::span_bug;
 use rustc_middle::ty::{DelegationInfo, ResolverAstLowering, TyCtxt};
-use rustc_session::parse::add_feature_diagnostics;
+use rustc_session::errors::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
 use smallvec::SmallVec;

compiler/rustc_ast_lowering/src/path.rs

@@ -6,7 +6,7 @@ use rustc_hir::def::{DefKind, PartialRes, PerNS, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, GenericArg};
 use rustc_middle::{span_bug, ty};
-use rustc_session::parse::add_feature_diagnostics;
+use rustc_session::errors::add_feature_diagnostics;
 use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
 use smallvec::smallvec;
 use tracing::{debug, instrument};

compiler/rustc_ast_lowering/src/stability.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use rustc_abi::ExternAbi;
 use rustc_feature::Features;
 use rustc_session::Session;
-use rustc_session::parse::feature_err;
+use rustc_session::errors::feature_err;
 use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -30,11 +30,11 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{DiagCtxtHandle, Diagnostic, LintBuffer};
 use rustc_feature::Features;
 use rustc_session::Session;
+use rustc_session::errors::feature_err;
 use rustc_session::lint::builtin::{
     DEPRECATED_WHERE_CLAUSE_LOCATION, MISSING_ABI, MISSING_UNSAFE_ON_EXTERN,
     PATTERNS_IN_FNS_WITHOUT_BODY, UNUSED_VISIBILITIES,
 };
-use rustc_session::parse::feature_err;
 use rustc_span::{Ident, Span, kw, sym};
 use rustc_target::spec::{AbiMap, AbiMapping};
 use thin_vec::thin_vec;
@@ -762,12 +762,23 @@ impl<'a> AstValidator<'a> {
         match fn_ctxt {
             FnCtxt::Foreign => return,
             FnCtxt::Free | FnCtxt::Assoc(_) => {
-                if !self.sess.target.supports_c_variadic_definitions() {
-                    self.dcx().emit_err(errors::CVariadicNotSupported {
-                        variadic_span: variadic_param.span,
-                        target: &*self.sess.target.llvm_target,
-                    });
-                    return;
+                match self.sess.target.supports_c_variadic_definitions() {
+                    CVariadicStatus::NotSupported => {
+                        self.dcx().emit_err(errors::CVariadicNotSupported {
+                            variadic_span: variadic_param.span,
+                            target: &*self.sess.target.llvm_target,
+                        });
+                        return;
+                    }
+                    CVariadicStatus::Unstable { feature } if !self.features.enabled(feature) => {
+                        let msg =
+                            format!("C-variadic function definitions on this target are unstable");
+                        feature_err(&self.sess, feature, variadic_param.span, msg).emit();
+                        return;
+                    }
+                    CVariadicStatus::Unstable { .. } | CVariadicStatus::Stable => {
+                        /* fall through */
+                    }
                 }
 
                 match sig.header.ext {
@@ -1117,8 +1128,8 @@ fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericPara
             dcx.emit_err(errors::OutOfOrderParams {
                 spans: spans.clone(),
                 sugg_span: span,
-                param_ord,
-                max_param,
+                param_ord: param_ord.to_string(),
+                max_param: max_param.to_string(),
                 ordered_params: &ordered_params,
             });
         }

compiler/rustc_ast_passes/src/errors.rs

@@ -1,7 +1,6 @@
 //! Errors emitted by ast_passes.
 
 use rustc_abi::ExternAbi;
-use rustc_ast::ParamKindOrd;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee, Subdiagnostic};
 use rustc_macros::{Diagnostic, Subdiagnostic};
@@ -632,8 +631,8 @@ pub(crate) struct OutOfOrderParams<'a> {
         applicability = "machine-applicable"
     )]
     pub sugg_span: Span,
-    pub param_ord: &'a ParamKindOrd,
-    pub max_param: &'a ParamKindOrd,
+    pub param_ord: String,
+    pub max_param: String,
     pub ordered_params: &'a str,
 }
 

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -6,7 +6,7 @@ use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Feat
 use rustc_hir::Attribute;
 use rustc_hir::attrs::AttributeKind;
 use rustc_session::Session;
-use rustc_session::parse::{feature_err, feature_warn};
+use rustc_session::errors::{feature_err, feature_warn};
 use rustc_span::{Span, Spanned, Symbol, sym};
 use thin_vec::ThinVec;
 
@@ -510,6 +510,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(try_blocks_heterogeneous, "`try bikeshed` expression is experimental");
     gate_all!(unsafe_binders, "unsafe binder types are experimental");
     gate_all!(unsafe_fields, "`unsafe` fields are experimental");
+    gate_all!(view_types, "view types are experimental");
     gate_all!(where_clause_attrs, "attributes in `where` clause are unstable");
     gate_all!(yeet_expr, "`do yeet` expression is experimental");
     // tidy-alphabetical-end

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -13,8 +13,9 @@ use rustc_parse::parser::{ForceCollect, Parser, Recovery};
 use rustc_parse::{exp, parse_in};
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
+use rustc_session::errors::feature_err;
 use rustc_session::lint::builtin::UNEXPECTED_CFGS;
-use rustc_session::parse::{ParseSess, feature_err};
+use rustc_session::parse::ParseSess;
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 use thin_vec::ThinVec;
 

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -1,5 +1,5 @@
 use rustc_hir::attrs::{CoverageAttrKind, OptimizeAttr, RtsanSetting, SanitizerSet, UsedBy};
-use rustc_session::parse::feature_err;
+use rustc_session::errors::feature_err;
 use rustc_span::edition::Edition::Edition2024;
 
 use super::prelude::*;

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -1,4 +1,3 @@
-use rustc_errors::Diagnostic;
 use rustc_hir::attrs::{CrateType, WindowsSubsystemKind};
 use rustc_session::lint::builtin::UNKNOWN_CRATE_TYPES;
 use rustc_span::Symbol;
@@ -61,12 +60,8 @@ impl CombineAttributeParser for CrateTypeParser {
                 let span = n.value_span;
                 cx.emit_lint(
                     UNKNOWN_CRATE_TYPES,
-                    move |dcx, level| {
-                        UnknownCrateTypes {
-                            sugg: candidate
-                                .map(|s| UnknownCrateTypesSuggestion { span, snippet: s }),
-                        }
-                        .into_diag(dcx, level)
+                    UnknownCrateTypes {
+                        sugg: candidate.map(|s| UnknownCrateTypesSuggestion { span, snippet: s }),
                     },
                     span,
                 );

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

@@ -1,4 +1,3 @@
-use rustc_errors::Diagnostic;
 use rustc_feature::{AttributeTemplate, template};
 use rustc_hir::Target;
 use rustc_hir::attrs::AttributeKind;
@@ -26,7 +25,7 @@ impl SingleAttributeParser for DoNotRecommendParser {
         if !matches!(args, ArgParser::NoArgs) {
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                |dcx, level| crate::errors::DoNotRecommendDoesNotExpectArgs.into_diag(dcx, level),
+                crate::errors::DoNotRecommendDoesNotExpectArgs,
                 attr_span,
             );
         }
@@ -35,9 +34,7 @@ impl SingleAttributeParser for DoNotRecommendParser {
             let target_span = cx.target_span;
             cx.emit_lint(
                 MISPLACED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| {
-                    IncorrectDoNotRecommendLocation { target_span }.into_diag(dcx, level)
-                },
+                IncorrectDoNotRecommendLocation { target_span },
                 attr_span,
             );
             return None;

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

@@ -1,6 +1,6 @@
 use std::ops::Range;
 
-use rustc_errors::{Diagnostic, E0232};
+use rustc_errors::E0232;
 use rustc_hir::AttrPath;
 use rustc_hir::attrs::diagnostic::{
     Directive, FilterFormatString, Flag, FormatArg, FormatString, LitOrArg, Name, NameValue,
@@ -142,10 +142,7 @@ fn merge<T>(
             let first_span = *first_span;
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| {
-                    IgnoredDiagnosticOption { first_span, later_span, option_name }
-                        .into_diag(dcx, level)
-                },
+                IgnoredDiagnosticOption { first_span, later_span, option_name },
                 later_span,
             );
         }
@@ -169,33 +166,27 @@ fn parse_list<'p>(
             // if the user used non-metaitem syntax. See `ArgParser::from_attr_args`.
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| NonMetaItemDiagnosticAttribute.into_diag(dcx, level),
+                NonMetaItemDiagnosticAttribute,
                 list.span,
             );
         }
         ArgParser::NoArgs => {
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| {
-                    MissingOptionsForDiagnosticAttribute {
-                        attribute: mode.as_str(),
-                        options: mode.expected_options(),
-                    }
-                    .into_diag(dcx, level)
+                MissingOptionsForDiagnosticAttribute {
+                    attribute: mode.as_str(),
+                    options: mode.expected_options(),
                 },
                 span,
             );
         }
         ArgParser::NameValue(_) => {
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| {
-                    MalFormedDiagnosticAttributeLint {
-                        attribute: mode.as_str(),
-                        options: mode.allowed_options(),
-                        span,
-                    }
-                    .into_diag(dcx, level)
+                MalFormedDiagnosticAttributeLint {
+                    attribute: mode.as_str(),
+                    options: mode.allowed_options(),
+                    span,
                 },
                 span,
             );
@@ -223,13 +214,10 @@ fn parse_directive_items<'p>(
         macro malformed() {{
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| {
-                    MalFormedDiagnosticAttributeLint {
-                        attribute: mode.as_str(),
-                        options: mode.allowed_options(),
-                        span,
-                    }
-                    .into_diag(dcx, level)
+                MalFormedDiagnosticAttributeLint {
+                    attribute: mode.as_str(),
+                    options: mode.allowed_options(),
+                    span,
                 },
                 span,
             );
@@ -251,11 +239,11 @@ fn parse_directive_items<'p>(
             let first_span = $($first_span)*;
             cx.emit_lint(
                 MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| IgnoredDiagnosticOption {
+                IgnoredDiagnosticOption {
                     first_span,
                     later_span: span,
                     option_name: $name,
-                }.into_diag(dcx, level),
+                },
                 span,
             );
         }}
@@ -285,25 +273,18 @@ fn parse_directive_items<'p>(
                         | FormatWarning::PositionalArgument { span }
                         | FormatWarning::IndexedArgument { span }
                         | FormatWarning::DisallowedPlaceholder { span, .. }) = warning;
-                        cx.emit_lint(
-                            MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
-                            move |dcx, level| warning.into_diag(dcx, level),
-                            span,
-                        );
+                        cx.emit_lint(MALFORMED_DIAGNOSTIC_FORMAT_LITERALS, warning, span);
                     }
 
                     f
                 }
                 Err(e) => {
                     cx.emit_lint(
                         MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
-                        move |dcx, level| {
-                            WrappedParserError {
-                                description: &e.description,
-                                label: &e.label,
-                                span: slice_span(input.span, e.span.clone(), is_snippet),
-                            }
-                            .into_diag(dcx, level)
+                        WrappedParserError {
+                            description: e.description,
+                            label: e.label,
+                            span: slice_span(input.span, e.span.clone(), is_snippet),
                         },
                         input.span,
                     );

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

@@ -1,4 +1,3 @@
-use rustc_errors::Diagnostic;
 use rustc_hir::attrs::diagnostic::Directive;
 use rustc_session::lint::builtin::MISPLACED_DIAGNOSTIC_ATTRIBUTES;
 
@@ -30,9 +29,7 @@ impl AttributeParser for OnConstParser {
                 let target_span = cx.target_span;
                 cx.emit_lint(
                     MISPLACED_DIAGNOSTIC_ATTRIBUTES,
-                    move |dcx, level| {
-                        DiagnosticOnConstOnlyForTraitImpls { target_span }.into_diag(dcx, level)
-                    },
+                    DiagnosticOnConstOnlyForTraitImpls { target_span },
                     span,
                 );
                 return;

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

@@ -1,4 +1,3 @@
-use rustc_errors::Diagnostic;
 use rustc_feature::template;
 use rustc_hir::attrs::AttributeKind;
 use rustc_session::lint::builtin::MISPLACED_DIAGNOSTIC_ATTRIBUTES;
@@ -28,11 +27,7 @@ impl OnMoveParser {
         self.span = Some(span);
 
         if !matches!(cx.target, Target::Enum | Target::Struct | Target::Union) {
-            cx.emit_lint(
-                MISPLACED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| DiagnosticOnMoveOnlyForAdt.into_diag(dcx, level),
-                span,
-            );
+            cx.emit_lint(MISPLACED_DIAGNOSTIC_ATTRIBUTES, DiagnosticOnMoveOnlyForAdt, span);
             return;
         }
 

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

@@ -1,4 +1,3 @@
-use rustc_errors::Diagnostic;
 use rustc_hir::attrs::diagnostic::Directive;
 use rustc_session::lint::builtin::MISPLACED_DIAGNOSTIC_ATTRIBUTES;
 
@@ -20,7 +19,7 @@ impl OnUnimplementedParser {
         if !matches!(cx.target, Target::Trait) {
             cx.emit_lint(
                 MISPLACED_DIAGNOSTIC_ATTRIBUTES,
-                move |dcx, level| DiagnosticOnUnimplementedOnlyForTraits.into_diag(dcx, level),
+                DiagnosticOnUnimplementedOnlyForTraits,
                 span,
             );
             return;