add AnonConstKind to non_trivial_const_arg diagnostics

Author: dvtkrlbs

compiler/rustc_resolve/messages.ftl

@@ -120,7 +120,7 @@ resolve_const_param_in_enum_discriminant =
     const parameters may not be used in enum discriminant values
 
 resolve_const_param_in_non_trivial_anon_const =
-    const parameters may only be used as standalone arguments here, i.e. `{$name}`
+    const parameters may only be used as standalone arguments in {$place}, i.e. `{$name}`
 
 resolve_constructor_private_if_any_field_private =
     a constructor is private if any of the fields is private

compiler/rustc_resolve/src/diagnostics.rs

@@ -1007,7 +1007,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ResolutionError::ParamInTyOfConstParam { name } => {
                 self.dcx().create_err(errs::ParamInTyOfConstParam { span, name })
             }
-            ResolutionError::ParamInNonTrivialAnonConst { name, param_kind: is_type } => {
+            ResolutionError::ParamInNonTrivialAnonConst { name, param_kind: is_type , place} => {
                 self.dcx().create_err(errs::ParamInNonTrivialAnonConst {
                     span,
                     name,
@@ -1017,6 +1017,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         .sess
                         .is_nightly_build()
                         .then_some(errs::ParamInNonTrivialAnonConstHelp),
+                    place: place.unwrap(),
                 })
             }
             ResolutionError::ParamInEnumDiscriminant { name, param_kind: is_type } => self

compiler/rustc_resolve/src/errors.rs

@@ -6,7 +6,7 @@ use rustc_errors::{
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
-use crate::late::PatternSource;
+use crate::late::{PatternSource, AnonConstKind};
 use crate::{Res, fluent_generated as fluent};
 
 #[derive(Diagnostic)]
@@ -387,6 +387,7 @@ pub(crate) struct ParamInNonTrivialAnonConst {
     pub(crate) param_kind: ParamKindInNonTrivialAnonConst,
     #[subdiagnostic]
     pub(crate) help: Option<ParamInNonTrivialAnonConstHelp>,
+    pub(crate) place: AnonConstKind
 }
 
 #[derive(Subdiagnostic)]

compiler/rustc_resolve/src/ident.rs

@@ -1239,7 +1239,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 res_err = Some((span, CannotCaptureDynamicEnvironmentInFnItem));
                             }
                         }
-                        RibKind::ConstantItem(_, item) => {
+                        RibKind::ConstantItem(_, item, _) => {
                             // Still doesn't deal with upvars
                             if let Some(span) = finalize {
                                 let (span, resolution_error) = match item {
@@ -1340,7 +1340,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             }
                         }
 
-                        RibKind::ConstantItem(trivial, _) => {
+                        RibKind::ConstantItem(trivial, _, kind) => {
                             if let ConstantHasGenerics::No(cause) = trivial {
                                 // HACK(min_const_generics): If we encounter `Self` in an anonymous
                                 // constant we can't easily tell if it's generic at this stage, so
@@ -1371,6 +1371,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                                     name: rib_ident.name,
                                                     param_kind:
                                                         ParamKindInNonTrivialAnonConst::Type,
+                                                    place: kind,
+
                                                 }
                                             }
                                         };
@@ -1431,7 +1433,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             }
                         }
 
-                        RibKind::ConstantItem(trivial, _) => {
+                        RibKind::ConstantItem(trivial, _, kind) => {
                             if let ConstantHasGenerics::No(cause) = trivial {
                                 if let Some(span) = finalize {
                                     let error = match cause {
@@ -1447,6 +1449,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                                 param_kind: ParamKindInNonTrivialAnonConst::Const {
                                                     name: rib_ident.name,
                                                 },
+                                                place: kind,
                                             }
                                         }
                                     };

compiler/rustc_resolve/src/late.rs

@@ -64,7 +64,7 @@ pub(crate) enum PatternSource {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum IsRepeatExpr {
+pub(crate) enum IsRepeatExpr {
     No,
     Yes,
 }
@@ -74,13 +74,28 @@ struct IsNeverPattern;
 /// Describes whether an `AnonConst` is a type level const arg or
 /// some other form of anon const (i.e. inline consts or enum discriminants)
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum AnonConstKind {
+pub(crate) enum AnonConstKind {
     EnumDiscriminant,
     FieldDefaultValue,
     InlineConst,
     ConstArg(IsRepeatExpr),
 }
 
+impl IntoDiagArg for AnonConstKind {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        DiagArgValue::Str(Cow::Borrowed(match self {
+            AnonConstKind::EnumDiscriminant => "enum discriminant",
+            AnonConstKind::FieldDefaultValue => "field default value",
+            AnonConstKind::InlineConst => "inline const",
+            AnonConstKind::ConstArg(is_repeat_expr) => match is_repeat_expr {
+                    IsRepeatExpr::No => "array repeat expression",
+                    IsRepeatExpr::Yes => "const generic args",
+                }
+            },
+        ))
+    }
+}
+
 impl PatternSource {
     fn descr(self) -> &'static str {
         match self {
@@ -214,7 +229,7 @@ pub(crate) enum RibKind<'ra> {
     ///
     /// The item may reference generic parameters in trivial constant expressions.
     /// All other constants aren't allowed to use generic params at all.
-    ConstantItem(ConstantHasGenerics, Option<(Ident, ConstantItemKind)>),
+    ConstantItem(ConstantHasGenerics, Option<(Ident, ConstantItemKind)>, Option<AnonConstKind>),
 
     /// We passed through a module item.
     Module(Module<'ra>),
@@ -2989,19 +3004,21 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         &mut self,
         is_repeat: IsRepeatExpr,
         may_use_generics: ConstantHasGenerics,
+        anon_const_kind: Option<AnonConstKind>,
         item: Option<(Ident, ConstantItemKind)>,
         f: impl FnOnce(&mut Self),
     ) {
         let f = |this: &mut Self| {
-            this.with_rib(ValueNS, RibKind::ConstantItem(may_use_generics, item), |this| {
+            this.with_rib(ValueNS, RibKind::ConstantItem(may_use_generics, item, anon_const_kind), |this| {
                 this.with_rib(
                     TypeNS,
                     RibKind::ConstantItem(
                         may_use_generics.force_yes_if(is_repeat == IsRepeatExpr::Yes),
                         item,
+                        anon_const_kind,
                     ),
                     |this| {
-                        this.with_label_rib(RibKind::ConstantItem(may_use_generics, item), f);
+                        this.with_label_rib(RibKind::ConstantItem(may_use_generics, item, anon_const_kind), f);
                     },
                 )
             })
@@ -3518,7 +3535,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
     fn resolve_const_body(&mut self, expr: &'ast Expr, item: Option<(Ident, ConstantItemKind)>) {
         self.with_lifetime_rib(LifetimeRibKind::Elided(LifetimeRes::Infer), |this| {
-            this.with_constant_rib(IsRepeatExpr::No, ConstantHasGenerics::Yes, item, |this| {
+            this.with_constant_rib(IsRepeatExpr::No, ConstantHasGenerics::Yes, None, item, |this| {
                 this.visit_expr(expr)
             });
         })
@@ -4728,7 +4745,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             }
         };
 
-        self.with_constant_rib(is_repeat_expr, may_use_generics, None, |this| {
+        self.with_constant_rib(is_repeat_expr, may_use_generics, Some(anon_const_kind), None, |this| {
             this.with_lifetime_rib(LifetimeRibKind::Elided(LifetimeRes::Infer), |this| {
                 resolve_expr(this);
             });

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -33,8 +33,7 @@ use tracing::debug;
 use super::NoConstantGenericsReason;
 use crate::diagnostics::{ImportSuggestion, LabelSuggestion, TypoSuggestion};
 use crate::late::{
-    AliasPossibility, LateResolutionVisitor, LifetimeBinderKind, LifetimeRes, LifetimeRibKind,
-    LifetimeUseSet, QSelf, RibKind,
+    AliasPossibility, AnonConstKind, LateResolutionVisitor, LifetimeBinderKind, LifetimeRes, LifetimeRibKind, LifetimeUseSet, QSelf, RibKind
 };
 use crate::ty::fast_reject::SimplifiedType;
 use crate::{
@@ -3344,6 +3343,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                             .sess
                             .is_nightly_build()
                             .then_some(errors::ParamInNonTrivialAnonConstHelp),
+                        place: AnonConstKind::InlineConst,
                     })
                     .emit();
             }

compiler/rustc_resolve/src/lib.rs

@@ -97,6 +97,7 @@ pub mod rustdoc;
 pub use macros::registered_tools_ast;
 
 use crate::ref_mut::{CmCell, CmRefCell};
+use crate::late::AnonConstKind;
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
@@ -301,7 +302,7 @@ enum ResolutionError<'ra> {
     /// generic parameters must not be used inside const evaluations.
     ///
     /// This error is only emitted when using `min_const_generics`.
-    ParamInNonTrivialAnonConst { name: Symbol, param_kind: ParamKindInNonTrivialAnonConst },
+    ParamInNonTrivialAnonConst { name: Symbol, param_kind: ParamKindInNonTrivialAnonConst, place: Option<AnonConstKind> },
     /// generic parameters must not be used inside enum discriminants.
     ///
     /// This error is emitted even with `generic_const_exprs`.