Auto merge of rust-lang#126001 - fmease:rollup-c2h2zao, r=fmease

Rollup of 7 pull requests

Successful merges:

 - rust-lang#122192 (Do not try to reveal hidden types when trying to prove Freeze in the defining scope)
 - rust-lang#124840 (resolve: mark it undetermined if single import is not has any bindings)
 - rust-lang#125622 (Winnow private method candidates instead of assuming any candidate of the right name will apply)
 - rust-lang#125871 (Orphanck[old solver]: Consider opaque types to never cover type parameters)
 - rust-lang#125893 (Handle all GVN binops in a single place.)
 - rust-lang#125911 (delete bootstrap build before switching to bumped rustc)
 - rust-lang#125918 (Revert: create const block bodies in typeck via query feeding)

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

compiler/rustc_ast/src/ast.rs

@@ -1392,7 +1392,7 @@ pub enum ExprKind {
  /// An array (e.g, `[a, b, c, d]`).
  Array(ThinVec<P<Expr>>),
  /// Allow anonymous constants from an inline `const` block
- ConstBlock(P<Expr>),
+ ConstBlock(AnonConst),
  /// A function call
  ///
  /// The first field resolves to the function itself,

compiler/rustc_ast/src/mut_visit.rs

@@ -1411,7 +1411,7 @@ pub fn noop_visit_expr<T: MutVisitor>(
  match kind {
  ExprKind::Array(exprs) => visit_thin_exprs(exprs, vis),
  ExprKind::ConstBlock(anon_const) => {
- vis.visit_expr(anon_const);
+ vis.visit_anon_const(anon_const);
  }
  ExprKind::Repeat(expr, count) => {
  vis.visit_expr(expr);

compiler/rustc_ast/src/visit.rs

@@ -954,7 +954,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) -> V
  ExprKind::Array(subexpressions) => {
  walk_list!(visitor, visit_expr, subexpressions);
  }
- ExprKind::ConstBlock(anon_const) => try_visit!(visitor.visit_expr(anon_const)),
+ ExprKind::ConstBlock(anon_const) => try_visit!(visitor.visit_anon_const(anon_const)),
  ExprKind::Repeat(element, count) => {
  try_visit!(visitor.visit_expr(element));
  try_visit!(visitor.visit_anon_const(count));

compiler/rustc_ast_lowering/src/expr.rs

@@ -75,8 +75,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let kind = match &e.kind {
  ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
  ExprKind::ConstBlock(c) => {
- self.has_inline_consts = true;
- hir::ExprKind::ConstBlock(self.lower_expr(c))
+ let c = self.with_new_scopes(c.value.span, |this| hir::ConstBlock {
+ def_id: this.local_def_id(c.id),
+ hir_id: this.lower_node_id(c.id),
+ body: this.lower_const_body(c.value.span, Some(&c.value)),
+ });
+ hir::ExprKind::ConstBlock(c)
  }
  ExprKind::Repeat(expr, count) => {
  let expr = self.lower_expr(expr);

compiler/rustc_ast_lowering/src/index.rs

@@ -236,6 +236,14 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
  });
  }
 
+ fn visit_inline_const(&mut self, constant: &'hir ConstBlock) {
+ self.insert(DUMMY_SP, constant.hir_id, Node::ConstBlock(constant));
+
+ self.with_parent(constant.hir_id, |this| {
+ intravisit::walk_inline_const(this, constant);
+ });
+ }
+
  fn visit_expr(&mut self, expr: &'hir Expr<'hir>) {
  self.insert(expr.span, expr.hir_id, Node::Expr(expr));
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -96,8 +96,6 @@ struct LoweringContext<'a, 'hir> {
 
  /// Bodies inside the owner being lowered.
  bodies: Vec<(hir::ItemLocalId, &'hir hir::Body<'hir>)>,
- /// Whether there were inline consts that typeck will split out into bodies
- has_inline_consts: bool,
  /// Attributes inside the owner being lowered.
  attrs: SortedMap<hir::ItemLocalId, &'hir [Attribute]>,
  /// Collect items that were created by lowering the current owner.
@@ -160,7 +158,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  item_local_id_counter: hir::ItemLocalId::ZERO,
  node_id_to_local_id: Default::default(),
  trait_map: Default::default(),
- has_inline_consts: false,
 
  // Lowering state.
  catch_scope: None,
@@ -570,7 +567,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
  let current_attrs = std::mem::take(&mut self.attrs);
  let current_bodies = std::mem::take(&mut self.bodies);
- let current_has_inline_consts = std::mem::take(&mut self.has_inline_consts);
  let current_node_ids = std::mem::take(&mut self.node_id_to_local_id);
  let current_trait_map = std::mem::take(&mut self.trait_map);
  let current_owner =
@@ -597,7 +593,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
  self.attrs = current_attrs;
  self.bodies = current_bodies;
- self.has_inline_consts = current_has_inline_consts;
  self.node_id_to_local_id = current_node_ids;
  self.trait_map = current_trait_map;
  self.current_hir_id_owner = current_owner;
@@ -634,7 +629,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  let attrs = std::mem::take(&mut self.attrs);
  let mut bodies = std::mem::take(&mut self.bodies);
  let trait_map = std::mem::take(&mut self.trait_map);
- let has_inline_consts = std::mem::take(&mut self.has_inline_consts);
 
  #[cfg(debug_assertions)]
  for (id, attrs) in attrs.iter() {
@@ -652,7 +646,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  self.tcx.hash_owner_nodes(node, &bodies, &attrs);
  let num_nodes = self.item_local_id_counter.as_usize();
  let (nodes, parenting) = index::index_hir(self.tcx, node, &bodies, num_nodes);
- let nodes = hir::OwnerNodes { opt_hash_including_bodies, nodes, bodies, has_inline_consts };
+ let nodes = hir::OwnerNodes { opt_hash_including_bodies, nodes, bodies };
  let attrs = hir::AttributeMap { map: attrs, opt_hash: attrs_hash };
 
  self.arena.alloc(hir::OwnerInfo { nodes, parenting, attrs, trait_map })

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -380,9 +380,8 @@ impl<'a> State<'a> {
  ast::ExprKind::Array(exprs) => {
  self.print_expr_vec(exprs);
  }
- ast::ExprKind::ConstBlock(expr) => {
- self.word_space("const");
- self.print_expr(expr, FixupContext::default());
+ ast::ExprKind::ConstBlock(anon_const) => {
+ self.print_expr_anon_const(anon_const, attrs);
  }
  ast::ExprKind::Repeat(element, count) => {
  self.print_expr_repeat(element, count);

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -100,7 +100,33 @@ impl Qualif for HasMutInterior {
  }
 
  fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
- !ty.is_freeze(cx.tcx, cx.param_env)
+ // Avoid selecting for simple cases, such as builtin types.
+ if ty.is_trivially_freeze() {
+ return false;
+ }
+
+ // We do not use `ty.is_freeze` here, because that requires revealing opaque types, which
+ // requires borrowck, which in turn will invoke mir_const_qualifs again, causing a cycle error.
+ // Instead we invoke an obligation context manually, and provide the opaque type inference settings
+ // that allow the trait solver to just error out instead of cycling.
+ let freeze_def_id = cx.tcx.require_lang_item(LangItem::Freeze, Some(cx.body.span));
+
+ let obligation = Obligation::new(
+ cx.tcx,
+ ObligationCause::dummy_with_span(cx.body.span),
+ cx.param_env,
+ ty::TraitRef::new(cx.tcx, freeze_def_id, [ty::GenericArg::from(ty)]),
+ );
+
+ let infcx = cx
+ .tcx
+ .infer_ctxt()
+ .with_opaque_type_inference(cx.body.source.def_id().expect_local())
+ .build();
+ let ocx = ObligationCtxt::new(&infcx);
+ ocx.register_obligation(obligation);
+ let errors = ocx.select_all_or_error();
+ !errors.is_empty()
  }
 
  fn in_adt_inherently<'tcx>(

compiler/rustc_const_eval/src/const_eval/fn_queries.rs

@@ -38,6 +38,7 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {
  match node {
  hir::Node::Ctor(_)
  | hir::Node::AnonConst(_)
+ | hir::Node::ConstBlock(_)
  | hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Const(..), .. }) => {
  hir::Constness::Const
  }
@@ -56,7 +57,6 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {
  if is_const { hir::Constness::Const } else { hir::Constness::NotConst }
  }
  hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,
- hir::Node::Expr(e) if let hir::ExprKind::ConstBlock(_) = e.kind => hir::Constness::Const,
  _ => {
  if let Some(fn_kind) = node.fn_kind() {
  if fn_kind.constness() == hir::Constness::Const {

compiler/rustc_hir/src/hir.rs

@@ -907,9 +907,6 @@ pub struct OwnerNodes<'tcx> {
  pub nodes: IndexVec<ItemLocalId, ParentedNode<'tcx>>,
  /// Content of local bodies.
  pub bodies: SortedMap<ItemLocalId, &'tcx Body<'tcx>>,
- /// Whether the body contains inline constants that are created for the query system during typeck
- /// of the body.
- pub has_inline_consts: bool,
 }
 
 impl<'tcx> OwnerNodes<'tcx> {
@@ -1626,6 +1623,14 @@ pub struct AnonConst {
  pub span: Span,
 }
 
+/// An inline constant expression `const { something }`.
+#[derive(Copy, Clone, Debug, HashStable_Generic)]
+pub struct ConstBlock {
+ pub hir_id: HirId,
+ pub def_id: LocalDefId,
+ pub body: BodyId,
+}
+
 /// An expression.
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct Expr<'hir> {
@@ -1912,7 +1917,7 @@ pub fn is_range_literal(expr: &Expr<'_>) -> bool {
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum ExprKind<'hir> {
  /// Allow anonymous constants from an inline `const` block
- ConstBlock(&'hir Expr<'hir>),
+ ConstBlock(ConstBlock),
  /// An array (e.g., `[a, b, c, d]`).
  Array(&'hir [Expr<'hir>]),
  /// A function call.
@@ -3644,6 +3649,7 @@ pub enum Node<'hir> {
  Variant(&'hir Variant<'hir>),
  Field(&'hir FieldDef<'hir>),
  AnonConst(&'hir AnonConst),
+ ConstBlock(&'hir ConstBlock),
  Expr(&'hir Expr<'hir>),
  ExprField(&'hir ExprField<'hir>),
  Stmt(&'hir Stmt<'hir>),
@@ -3704,6 +3710,7 @@ impl<'hir> Node<'hir> {
  Node::PreciseCapturingNonLifetimeArg(a) => Some(a.ident),
  Node::Param(..)
  | Node::AnonConst(..)
+ | Node::ConstBlock(..)
  | Node::Expr(..)
  | Node::Stmt(..)
  | Node::Block(..)
@@ -3801,6 +3808,7 @@ impl<'hir> Node<'hir> {
  }
 
  Node::AnonConst(constant) => Some((constant.def_id, constant.body)),
+ Node::ConstBlock(constant) => Some((constant.def_id, constant.body)),
 
  _ => None,
  }
@@ -3869,6 +3877,7 @@ impl<'hir> Node<'hir> {
  expect_variant, &'hir Variant<'hir>, Node::Variant(n), n;
  expect_field, &'hir FieldDef<'hir>, Node::Field(n), n;
  expect_anon_const, &'hir AnonConst, Node::AnonConst(n), n;
+ expect_inline_const, &'hir ConstBlock, Node::ConstBlock(n), n;
  expect_expr, &'hir Expr<'hir>, Node::Expr(n), n;
  expect_expr_field, &'hir ExprField<'hir>, Node::ExprField(n), n;
  expect_stmt, &'hir Stmt<'hir>, Node::Stmt(n), n;

compiler/rustc_hir/src/intravisit.rs

@@ -344,6 +344,9 @@ pub trait Visitor<'v>: Sized {
  fn visit_anon_const(&mut self, c: &'v AnonConst) -> Self::Result {
  walk_anon_const(self, c)
  }
+ fn visit_inline_const(&mut self, c: &'v ConstBlock) -> Self::Result {
+ walk_inline_const(self, c)
+ }
  fn visit_expr(&mut self, ex: &'v Expr<'v>) -> Self::Result {
  walk_expr(self, ex)
  }
@@ -716,14 +719,22 @@ pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonCo
  visitor.visit_nested_body(constant.body)
 }
 
+pub fn walk_inline_const<'v, V: Visitor<'v>>(
+ visitor: &mut V,
+ constant: &'v ConstBlock,
+) -> V::Result {
+ try_visit!(visitor.visit_id(constant.hir_id));
+ visitor.visit_nested_body(constant.body)
+}
+
 pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>) -> V::Result {
  try_visit!(visitor.visit_id(expression.hir_id));
  match expression.kind {
  ExprKind::Array(subexpressions) => {
  walk_list!(visitor, visit_expr, subexpressions);
  }
  ExprKind::ConstBlock(ref const_block) => {
- try_visit!(visitor.visit_expr(const_block))
+ try_visit!(visitor.visit_inline_const(const_block))
  }
  ExprKind::Repeat(ref element, ref count) => {
  try_visit!(visitor.visit_expr(element));

compiler/rustc_hir/src/stable_hash_impls.rs

@@ -93,8 +93,7 @@ impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for OwnerNodes<'
  // `local_id_to_def_id` is also ignored because is dependent on the body, then just hashing
  // the body satisfies the condition of two nodes being different have different
  // `hash_stable` results.
- let OwnerNodes { opt_hash_including_bodies, nodes: _, bodies: _, has_inline_consts: _ } =
- *self;
+ let OwnerNodes { opt_hash_including_bodies, nodes: _, bodies: _ } = *self;
  opt_hash_including_bodies.unwrap().hash_stable(hcx, hasher);
  }
 }

compiler/rustc_hir_analysis/src/check/region.rs

@@ -407,14 +407,11 @@ fn resolve_expr<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, expr: &'tcx h
  match expr.kind {
  // Manually recurse over closures and inline consts, because they are the only
  // case of nested bodies that share the parent environment.
- hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
+ hir::ExprKind::Closure(&hir::Closure { body, .. })
+ | hir::ExprKind::ConstBlock(hir::ConstBlock { body, .. }) => {
  let body = visitor.tcx.hir().body(body);
  visitor.visit_body(body);
  }
- hir::ExprKind::ConstBlock(expr) => visitor.enter_body(expr.hir_id, |this| {
- this.cx.var_parent = None;
- resolve_local(this, None, Some(expr));
- }),
  hir::ExprKind::AssignOp(_, left_expr, right_expr) => {
  debug!(
  "resolve_expr - enabling pessimistic_yield, was previously {}",

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -177,10 +177,10 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
  }
  }
  }
- Node::Expr(&hir::Expr {
-  kind: hir::ExprKind::Closure { .. } | hir::ExprKind::ConstBlock { .. },
- ..
- }) => Some(tcx.typeck_root_def_id(def_id.to_def_id())),
+ Node::ConstBlock(_)
+ | Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure { .. }, .. }) => {
+ Some(tcx.typeck_root_def_id(def_id.to_def_id()))
+ }
  Node::Item(item) => match item.kind {
  ItemKind::OpaqueTy(&hir::OpaqueTy {
  origin:
@@ -415,7 +415,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
  }
 
  // provide junk type parameter defs for const blocks.
- if let Node::Expr(Expr { kind: ExprKind::ConstBlock(..), .. }) = node {
+ if let Node::ConstBlock(_) = node {
  own_params.push(ty::GenericParamDef {
  index: next_index(),
  name: Symbol::intern("<const_ty>"),

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -485,7 +485,8 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
  }
 
  Node::AnonConst(_) => anon_const_type_of(tcx, def_id),
- Node::Expr(&Expr { kind: ExprKind::ConstBlock(..), .. }) => {
+
+ Node::ConstBlock(_) => {
  let args = ty::GenericArgs::identity_for_item(tcx, def_id.to_def_id());
  args.as_inline_const().ty()
  }

compiler/rustc_hir_analysis/src/lib.rs

@@ -190,6 +190,10 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
  }
  });
 
+ // Freeze definitions as we don't add new ones at this point. This improves performance by
+ // allowing lock-free access to them.
+ tcx.untracked().definitions.freeze();
+
  // FIXME: Remove this when we implement creating `DefId`s
  // for anon constants during their parents' typeck.
  // Typeck all body owners in parallel will produce queries
@@ -201,10 +205,6 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
  }
  });
 
- // Freeze definitions as we don't add new ones at this point. This improves performance by
- // allowing lock-free access to them.
- tcx.untracked().definitions.freeze();
-
  tcx.ensure().check_unused_traits(());
 }
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -84,6 +84,7 @@ impl<'a> State<'a> {
  Node::ImplItem(a) => self.print_impl_item(a),
  Node::Variant(a) => self.print_variant(a),
  Node::AnonConst(a) => self.print_anon_const(a),
+ Node::ConstBlock(a) => self.print_inline_const(a),
  Node::Expr(a) => self.print_expr(a),
  Node::ExprField(a) => self.print_expr_field(a),
  Node::Stmt(a) => self.print_stmt(a),
@@ -1048,10 +1049,10 @@ impl<'a> State<'a> {
  self.end()
  }
 
- fn print_inline_const(&mut self, constant: &hir::Expr<'_>) {
+ fn print_inline_const(&mut self, constant: &hir::ConstBlock) {
  self.ibox(INDENT_UNIT);
  self.word_space("const");
- self.print_expr(constant);
+ self.ann.nested(self, Nested::Body(constant.body));
  self.end()
  }