Auto merge of #111402 - matthiaskrgr:rollup-28cqfz5, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - #97320 (Stabilize const_ptr_read)
 - #110770 (Limit lifetime of format_args!() with inlined args.)
 - #111021 (Move some tests)
 - #111215 (Various changes to name resolution of anon consts)
 - #111242 (support set `rpath` option  for each target independently)
 - #111282 (Remove some `assume`s from slice iterators that don't do anything)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_ast/src/ast.rs

@@ -120,6 +120,12 @@ impl Path {
  pub fn is_global(&self) -> bool {
  !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
  }
+
+ /// If this path is a single identifier with no arguments, does not ensure
+ /// that the path resolves to a const param, the caller should check this.
+ pub fn is_potential_trivial_const_arg(&self) -> bool {
+ self.segments.len() == 1 && self.segments[0].args.is_none()
+ }
 }
 
 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
@@ -1154,7 +1160,9 @@ impl Expr {
  ///
  /// If this is not the case, name resolution does not resolve `N` when using
  /// `min_const_generics` as more complex expressions are not supported.
- pub fn is_potential_trivial_const_param(&self) -> bool {
+ ///
+ /// Does not ensure that the path resolves to a const param, the caller should check this.
+ pub fn is_potential_trivial_const_arg(&self) -> bool {
  let this = if let ExprKind::Block(block, None) = &self.kind
  && block.stmts.len() == 1
  && let StmtKind::Expr(expr) = &block.stmts[0].kind
@@ -1165,8 +1173,7 @@ impl Expr {
  };
 
  if let ExprKind::Path(None, path) = &this.kind
- && path.segments.len() == 1
- && path.segments[0].args.is_none()
+ && path.is_potential_trivial_const_arg()
  {
  true
  } else {

compiler/rustc_ast/src/visit.rs

@@ -188,6 +188,9 @@ pub trait Visitor<'ast>: Sized {
  fn visit_variant(&mut self, v: &'ast Variant) {
  walk_variant(self, v)
  }
+ fn visit_variant_discr(&mut self, discr: &'ast AnonConst) {
+ self.visit_anon_const(discr);
+ }
  fn visit_label(&mut self, label: &'ast Label) {
  walk_label(self, label)
  }
@@ -380,7 +383,7 @@ where
  visitor.visit_ident(variant.ident);
  visitor.visit_vis(&variant.vis);
  visitor.visit_variant_data(&variant.data);
- walk_list!(visitor, visit_anon_const, &variant.disr_expr);
+ walk_list!(visitor, visit_variant_discr, &variant.disr_expr);
  walk_list!(visitor, visit_attribute, &variant.attrs);
 }
 

compiler/rustc_ast_lowering/src/format.rs

@@ -446,7 +446,30 @@ fn expand_format_args<'hir>(
  && argmap.iter().enumerate().all(|(i, (&(j, _), _))| i == j)
  && arguments.iter().skip(1).all(|arg| !may_contain_yield_point(&arg.expr));
 
- let args = if use_simple_array {
+ let args = if arguments.is_empty() {
+ // Generate:
+ // &<core::fmt::Argument>::none()
+ //
+ // Note:
+ // `none()` just returns `[]`. We use `none()` rather than `[]` to limit the lifetime.
+ //
+ // This makes sure that this still fails to compile, even when the argument is inlined:
+ //
+ // ```
+ // let f = format_args!("{}", "a");
+ // println!("{f}"); // error E0716
+ // ```
+ //
+ // Cases where keeping the object around is allowed, such as `format_args!("a")`,
+ // are handled above by the `allow_const` case.
+ let none_fn = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
+ macsp,
+ hir::LangItem::FormatArgument,
+ sym::none,
+ ));
+ let none = ctx.expr_call(macsp, none_fn, &[]);
+ ctx.expr(macsp, hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Not, none))
+ } else if use_simple_array {
  // Generate:
  // &[
  // <core::fmt::Argument>::new_display(&arg0),

compiler/rustc_ast_lowering/src/lib.rs

@@ -1190,13 +1190,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  // parsing. We try to resolve that ambiguity by attempting resolution in both the
  // type and value namespaces. If we resolved the path in the value namespace, we
  // transform it into a generic const argument.
- TyKind::Path(qself, path) => {
+ TyKind::Path(None, path) => {
  if let Some(res) = self
  .resolver
  .get_partial_res(ty.id)
  .and_then(|partial_res| partial_res.full_res())
  {
- if !res.matches_ns(Namespace::TypeNS) {
+ if !res.matches_ns(Namespace::TypeNS)
+ && path.is_potential_trivial_const_arg()
+ {
  debug!(
  "lower_generic_arg: Lowering type argument as const argument: {:?}",
  ty,
@@ -1218,7 +1220,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
  let path_expr = Expr {
  id: ty.id,
- kind: ExprKind::Path(qself.clone(), path.clone()),
+ kind: ExprKind::Path(None, path.clone()),
  span,
  attrs: AttrVec::new(),
  tokens: None,

compiler/rustc_error_codes/src/error_codes/E0771.md

@@ -1,9 +1,11 @@
+#### Note: this error code is no longer emitted by the compiler
+
 A non-`'static` lifetime was used in a const generic. This is currently not
 allowed.
 
 Erroneous code example:
 
-```compile_fail,E0771
+```compile_fail,E0770
 #![feature(adt_const_params)]
 
 fn function_with_str<'a, const STRING: &'a str>() {} // error!

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -51,7 +51,15 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
  // of a const parameter type, e.g. `struct Foo<const N: usize, const M: [u8; N]>` is not allowed.
  None
  } else if tcx.lazy_normalization() {
- if let Some(param_id) = tcx.hir().opt_const_param_default_param_def_id(hir_id) {
+ let parent_node = tcx.hir().get_parent(hir_id);
+ if let Node::Variant(Variant { disr_expr: Some(constant), .. }) = parent_node
+ && constant.hir_id == hir_id
+ {
+ // enum variant discriminants are not allowed to use any kind of generics
+ None
+ } else if let Some(param_id) =
+ tcx.hir().opt_const_param_default_param_def_id(hir_id)
+ {
  // If the def_id we are calling generics_of on is an anon ct default i.e:
  //
  // struct Foo<const N: usize = { .. }>;
@@ -94,15 +102,15 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
  has_self: generics.has_self,
  has_late_bound_regions: generics.has_late_bound_regions,
  };
+ } else {
+ // HACK(eddyb) this provides the correct generics when
+ // `feature(generic_const_expressions)` is enabled, so that const expressions
+ // used with const generics, e.g. `Foo<{N+1}>`, can work at all.
+ //
+ // Note that we do not supply the parent generics when using
+ // `min_const_generics`.
+ Some(parent_def_id.to_def_id())
  }
-
- // HACK(eddyb) this provides the correct generics when
- // `feature(generic_const_expressions)` is enabled, so that const expressions
- // used with const generics, e.g. `Foo<{N+1}>`, can work at all.
- //
- // Note that we do not supply the parent generics when using
- // `min_const_generics`.
- Some(parent_def_id.to_def_id())
  } else {
  let parent_node = tcx.hir().get_parent(hir_id);
  match parent_node {
@@ -115,11 +123,6 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
  {
  Some(parent_def_id.to_def_id())
  }
- Node::Variant(Variant { disr_expr: Some(constant), .. })
- if constant.hir_id == hir_id =>
- {
- Some(parent_def_id.to_def_id())
- }
  Node::Expr(&Expr { kind: ExprKind::ConstBlock(_), .. }) => {
  Some(tcx.typeck_root_def_id(def_id.to_def_id()))
  }

compiler/rustc_resolve/messages.ftl

@@ -145,6 +145,15 @@ resolve_param_in_ty_of_const_param =
  the type of const parameters must not depend on other generic parameters
  .label = the type must not depend on the parameter `{$name}`
 
+resolve_type_param_in_ty_of_const_param =
+ type parameters may not be used in the type of const parameters
+
+resolve_const_param_in_ty_of_const_param =
+ const parameters may not be used in the type of const parameters
+
+resolve_lifetime_param_in_ty_of_const_param =
+ lifetime parameters may not be used in the type of const parameters
+
 resolve_self_in_generic_param_default =
  generic parameters cannot use `Self` in their defaults
  .label = `Self` in generic parameter default
@@ -156,12 +165,15 @@ resolve_param_in_non_trivial_anon_const =
 resolve_param_in_non_trivial_anon_const_help =
  use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-resolve_param_in_non_trivial_anon_const_sub_type =
+resolve_type_param_in_non_trivial_anon_const =
  type parameters may not be used in const expressions
 
-resolve_param_in_non_trivial_anon_const_sub_non_type =
+resolve_const_param_in_non_trivial_anon_const =
  const parameters may only be used as standalone arguments, i.e. `{$name}`
 
+resolve_lifetime_param_in_non_trivial_anon_const =
+ lifetime parameters may not be used in const expressions
+
 resolve_unreachable_label =
  use of unreachable label `{$name}`
  .label = unreachable label `{$name}`
@@ -233,3 +245,16 @@ resolve_macro_use_extern_crate_self = `#[macro_use]` is not supported on `extern
 
 resolve_accessible_unsure = not sure whether the path is accessible or not
  .note = the type may have associated items, but we are currently not checking them
+
+resolve_param_in_enum_discriminant =
+ generic parameters may not be used in enum discriminant values
+ .label = cannot perform const operation using `{$name}`
+
+resolve_type_param_in_enum_discriminant =
+ type parameters may not be used in enum discriminant values
+
+resolve_const_param_in_enum_discriminant =
+ const parameters may not be used in enum discriminant values
+
+resolve_lifetime_param_in_enum_discriminant =
+ lifetime parameters may not be used in enum discriminant values

compiler/rustc_resolve/src/diagnostics.rs

@@ -864,25 +864,26 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  ResolutionError::ForwardDeclaredGenericParam => {
  self.tcx.sess.create_err(errs::ForwardDeclaredGenericParam { span })
  }
- ResolutionError::ParamInTyOfConstParam(name) => {
- self.tcx.sess.create_err(errs::ParamInTyOfConstParam { span, name })
- }
- ResolutionError::ParamInNonTrivialAnonConst { name, is_type } => {
+ ResolutionError::ParamInTyOfConstParam { name, param_kind: is_type } => self
+ .tcx
+ .sess
+ .create_err(errs::ParamInTyOfConstParam { span, name, param_kind: is_type }),
+ ResolutionError::ParamInNonTrivialAnonConst { name, param_kind: is_type } => {
  self.tcx.sess.create_err(errs::ParamInNonTrivialAnonConst {
  span,
  name,
- sub_is_type: if is_type {
- errs::ParamInNonTrivialAnonConstIsType::AType
- } else {
- errs::ParamInNonTrivialAnonConstIsType::NotAType { name }
- },
+ param_kind: is_type,
  help: self
  .tcx
  .sess
  .is_nightly_build()
  .then_some(errs::ParamInNonTrivialAnonConstHelp),
  })
  }
+ ResolutionError::ParamInEnumDiscriminant { name, param_kind: is_type } => self
+ .tcx
+ .sess
+ .create_err(errs::ParamInEnumDiscriminant { span, name, param_kind: is_type }),
  ResolutionError::SelfInGenericParamDefault => {
  self.tcx.sess.create_err(errs::SelfInGenericParamDefault { span })
  }

compiler/rustc_resolve/src/errors.rs

@@ -326,6 +326,18 @@ pub(crate) struct ParamInTyOfConstParam {
  #[label]
  pub(crate) span: Span,
  pub(crate) name: Symbol,
+ #[subdiagnostic]
+ pub(crate) param_kind: Option<ParamKindInTyOfConstParam>,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum ParamKindInTyOfConstParam {
+ #[note(resolve_type_param_in_ty_of_const_param)]
+ Type,
+ #[note(resolve_const_param_in_ty_of_const_param)]
+ Const,
+ #[note(resolve_lifetime_param_in_ty_of_const_param)]
+ Lifetime,
 }
 
 #[derive(Diagnostic)]
@@ -344,7 +356,7 @@ pub(crate) struct ParamInNonTrivialAnonConst {
  pub(crate) span: Span,
  pub(crate) name: Symbol,
  #[subdiagnostic]
- pub(crate) sub_is_type: ParamInNonTrivialAnonConstIsType,
+ pub(crate) param_kind: ParamKindInNonTrivialAnonConst,
  #[subdiagnostic]
  pub(crate) help: Option<ParamInNonTrivialAnonConstHelp>,
 }
@@ -354,11 +366,13 @@ pub(crate) struct ParamInNonTrivialAnonConst {
 pub(crate) struct ParamInNonTrivialAnonConstHelp;
 
 #[derive(Subdiagnostic)]
-pub(crate) enum ParamInNonTrivialAnonConstIsType {
- #[note(resolve_param_in_non_trivial_anon_const_sub_type)]
- AType,
- #[help(resolve_param_in_non_trivial_anon_const_sub_non_type)]
- NotAType { name: Symbol },
+pub(crate) enum ParamKindInNonTrivialAnonConst {
+ #[note(resolve_type_param_in_non_trivial_anon_const)]
+ Type,
+ #[help(resolve_const_param_in_non_trivial_anon_const)]
+ Const { name: Symbol },
+ #[note(resolve_lifetime_param_in_non_trivial_anon_const)]
+ Lifetime,
 }
 
 #[derive(Diagnostic)]
@@ -539,3 +553,24 @@ pub(crate) struct CfgAccessibleUnsure {
  #[primary_span]
  pub(crate) span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(resolve_param_in_enum_discriminant)]
+pub(crate) struct ParamInEnumDiscriminant {
+ #[primary_span]
+ #[label]
+ pub(crate) span: Span,
+ pub(crate) name: Symbol,
+ #[subdiagnostic]
+ pub(crate) param_kind: ParamKindInEnumDiscriminant,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum ParamKindInEnumDiscriminant {
+ #[note(resolve_type_param_in_enum_discriminant)]
+ Type,
+ #[note(resolve_const_param_in_enum_discriminant)]
+ Const,
+ #[note(resolve_lifetime_param_in_enum_discriminant)]
+ Lifetime,
+}