Auto merge of rust-lang#103991 - matthiaskrgr:rollup-tj53nte, r=matth…

…iaskrgr

Rollup of 7 pull requests

Successful merges:

 - rust-lang#103868 (Use `TraitEngine` (by itself) less)
 - rust-lang#103878 (Fix artifact version/channel detection for stable)
 - rust-lang#103946 (Cleanup bind_pattern args)
 - rust-lang#103956 (Make mir opt unused file check blessable)
 - rust-lang#103977 (LLVM 16: Switch to using MemoryEffects)
 - rust-lang#103980 (rustdoc: simplify search results CSS and DOM)
 - rust-lang#103984 (Refactor tcx mk_const parameters.)

Failed merges:

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

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -23,7 +23,6 @@ use rustc_span::hygiene::DesugaringKind;
 use rustc_span::symbol::sym;
 use rustc_span::{BytePos, Span, Symbol};
 use rustc_trait_selection::infer::InferCtxtExt;
-use rustc_trait_selection::traits::TraitEngineExt as _;
 
 use crate::borrow_set::TwoPhaseActivation;
 use crate::borrowck_errors;
@@ -613,24 +612,20 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  else { return; };
  // Try to find predicates on *generic params* that would allow copying `ty`
  let infcx = tcx.infer_ctxt().build();
- let mut fulfill_cx = <dyn rustc_infer::traits::TraitEngine<'_>>::new(infcx.tcx);
-
  let copy_did = infcx.tcx.lang_items().copy_trait().unwrap();
  let cause = ObligationCause::new(
  span,
  self.mir_hir_id(),
  rustc_infer::traits::ObligationCauseCode::MiscObligation,
  );
- fulfill_cx.register_bound(
+ let errors = rustc_trait_selection::traits::fully_solve_bound(
  &infcx,
+ cause,
  self.param_env,
  // Erase any region vids from the type, which may not be resolved
  infcx.tcx.erase_regions(ty),
  copy_did,
- cause,
  );
- // Select all, including ambiguous predicates
- let errors = fulfill_cx.select_all_or_error(&infcx);
 
  // Only emit suggestion if all required predicates are on generic
  let predicates: Result<Vec<_>, _> = errors

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -4,15 +4,15 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_hir::OpaqueTyOrigin;
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_infer::infer::{DefiningAnchor, InferCtxt};
-use rustc_infer::traits::{Obligation, ObligationCause, TraitEngine};
+use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts};
 use rustc_middle::ty::visit::TypeVisitable;
 use rustc_middle::ty::{
  self, OpaqueHiddenType, OpaqueTypeKey, ToPredicate, Ty, TyCtxt, TypeFoldable,
 };
 use rustc_span::Span;
 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
-use rustc_trait_selection::traits::TraitEngineExt as _;
+use rustc_trait_selection::traits::ObligationCtxt;
 
 use super::RegionInferenceContext;
 
@@ -252,48 +252,45 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
  // type-alias-impl-trait/issue-67844-nested-opaque.rs
  let infcx =
  self.tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bubble).build();
+ let ocx = ObligationCtxt::new(&infcx);
  // Require the hidden type to be well-formed with only the generics of the opaque type.
  // Defining use functions may have more bounds than the opaque type, which is ok, as long as the
  // hidden type is well formed even without those bounds.
  let predicate = ty::Binder::dummy(ty::PredicateKind::WellFormed(definition_ty.into()))
  .to_predicate(infcx.tcx);
- let mut fulfillment_cx = <dyn TraitEngine<'tcx>>::new(infcx.tcx);
 
  let id_substs = InternalSubsts::identity_for_item(self.tcx, def_id.to_def_id());
 
  // Require that the hidden type actually fulfills all the bounds of the opaque type, even without
  // the bounds that the function supplies.
  let opaque_ty = self.tcx.mk_opaque(def_id.to_def_id(), id_substs);
- match infcx
- .at(&ObligationCause::misc(instantiated_ty.span, body_id), param_env)
- .eq(opaque_ty, definition_ty)
- {
- Ok(infer_ok) => {
- for obligation in infer_ok.obligations {
- fulfillment_cx.register_predicate_obligation(&infcx, obligation);
- }
- }
- Err(err) => {
- infcx
- .err_ctxt()
- .report_mismatched_types(
- &ObligationCause::misc(instantiated_ty.span, body_id),
- opaque_ty,
- definition_ty,
- err,
- )
- .emit();
- }
+ if let Err(err) = ocx.eq(
+ &ObligationCause::misc(instantiated_ty.span, body_id),
+ param_env,
+ opaque_ty,
+ definition_ty,
+ ) {
+ infcx
+ .err_ctxt()
+ .report_mismatched_types(
+ &ObligationCause::misc(instantiated_ty.span, body_id),
+ opaque_ty,
+ definition_ty,
+ err,
+ )
+ .emit();
  }
 
- fulfillment_cx.register_predicate_obligation(
- &infcx,
- Obligation::misc(instantiated_ty.span, body_id, param_env, predicate),
- );
+ ocx.register_obligation(Obligation::misc(
+ instantiated_ty.span,
+ body_id,
+ param_env,
+ predicate,
+ ));
 
  // Check that all obligations are satisfied by the implementation's
  // version.
- let errors = fulfillment_cx.select_all_or_error(&infcx);
+ let errors = ocx.select_all_or_error();
 
  // This is still required for many(half of the tests in ui/type-alias-impl-trait)
  // tests to pass

compiler/rustc_codegen_llvm/src/asm.rs

@@ -285,13 +285,13 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
  let mut attrs = SmallVec::<[_; 2]>::new();
  if options.contains(InlineAsmOptions::PURE) {
  if options.contains(InlineAsmOptions::NOMEM) {
- attrs.push(llvm::AttributeKind::ReadNone.create_attr(self.cx.llcx));
+ attrs.push(llvm::MemoryEffects::None.create_attr(self.cx.llcx));
  } else if options.contains(InlineAsmOptions::READONLY) {
- attrs.push(llvm::AttributeKind::ReadOnly.create_attr(self.cx.llcx));
+ attrs.push(llvm::MemoryEffects::ReadOnly.create_attr(self.cx.llcx));
  }
  attrs.push(llvm::AttributeKind::WillReturn.create_attr(self.cx.llcx));
  } else if options.contains(InlineAsmOptions::NOMEM) {
- attrs.push(llvm::AttributeKind::InaccessibleMemOnly.create_attr(self.cx.llcx));
+ attrs.push(llvm::MemoryEffects::InaccessibleMemOnly.create_attr(self.cx.llcx));
  } else {
  // LLVM doesn't have an attribute to represent ReadOnly + SideEffect
  }

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -13,7 +13,7 @@ use smallvec::SmallVec;
 
 use crate::attributes;
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::{self, AllocKindFlags, Attribute, AttributeKind, AttributePlace};
+use crate::llvm::{self, AllocKindFlags, Attribute, AttributeKind, AttributePlace, MemoryEffects};
 use crate::llvm_util;
 pub use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr};
 
@@ -303,10 +303,10 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  to_add.push(AttributeKind::ReturnsTwice.create_attr(cx.llcx));
  }
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_PURE) {
- to_add.push(AttributeKind::ReadOnly.create_attr(cx.llcx));
+ to_add.push(MemoryEffects::ReadOnly.create_attr(cx.llcx));
  }
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_CONST) {
- to_add.push(AttributeKind::ReadNone.create_attr(cx.llcx));
+ to_add.push(MemoryEffects::None.create_attr(cx.llcx));
  }
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
  to_add.push(AttributeKind::Naked.create_attr(cx.llcx));

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -183,7 +183,6 @@ pub enum AttributeKind {
  OptimizeNone = 24,
  ReturnsTwice = 25,
  ReadNone = 26,
- InaccessibleMemOnly = 27,
  SanitizeHWAddress = 28,
  WillReturn = 29,
  StackProtectReq = 30,
@@ -590,6 +589,15 @@ pub enum ChecksumKind {
  SHA256,
 }
 
+/// LLVMRustMemoryEffects
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub enum MemoryEffects {
+ None,
+ ReadOnly,
+ InaccessibleMemOnly,
+}
+
 extern "C" {
  type Opaque;
 }
@@ -1175,6 +1183,7 @@ extern "C" {
  pub fn LLVMRustCreateUWTableAttr(C: &Context, async_: bool) -> &Attribute;
  pub fn LLVMRustCreateAllocSizeAttr(C: &Context, size_arg: u32) -> &Attribute;
  pub fn LLVMRustCreateAllocKindAttr(C: &Context, size_arg: u64) -> &Attribute;
+ pub fn LLVMRustCreateMemoryEffectsAttr(C: &Context, effects: MemoryEffects) -> &Attribute;
 
  // Operations on functions
  pub fn LLVMRustGetOrInsertFunction<'a>(

compiler/rustc_codegen_llvm/src/llvm/mod.rs

@@ -185,6 +185,13 @@ impl AttributeKind {
  }
 }
 
+impl MemoryEffects {
+ /// Create an LLVM Attribute with these memory effects.
+ pub fn create_attr(self, llcx: &Context) -> &Attribute {
+ unsafe { LLVMRustCreateMemoryEffectsAttr(llcx, self) }
+ }
+}
+
 pub fn set_section(llglobal: &Value, section_name: &str) {
  let section_name_cstr = CString::new(section_name).expect("unexpected CString error");
  unsafe {

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -13,11 +13,8 @@ use rustc_middle::ty::{self, adjustment::PointerCast, Instance, InstanceDef, Ty,
 use rustc_middle::ty::{Binder, TraitPredicate, TraitRef, TypeVisitable};
 use rustc_mir_dataflow::{self, Analysis};
 use rustc_span::{sym, Span, Symbol};
-use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
-use rustc_trait_selection::traits::{
- self, ObligationCauseCode, SelectionContext, TraitEngine, TraitEngineExt,
-};
+use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt, SelectionContext};
 
 use std::mem;
 use std::ops::Deref;
@@ -747,35 +744,26 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  // "non-const" check. This is required for correctness here.
  {
  let infcx = tcx.infer_ctxt().build();
- let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
+ let ocx = ObligationCtxt::new(&infcx);
+
  let predicates = tcx.predicates_of(callee).instantiate(tcx, substs);
  let hir_id = tcx
  .hir()
  .local_def_id_to_hir_id(self.body.source.def_id().expect_local());
- let cause = || {
- ObligationCause::new(
- terminator.source_info.span,
- hir_id,
- ObligationCauseCode::ItemObligation(callee),
- )
- };
- let normalized = infcx.partially_normalize_associated_types_in(
- cause(),
- param_env,
- predicates,
+ let cause = ObligationCause::new(
+ terminator.source_info.span,
+ hir_id,
+ ObligationCauseCode::ItemObligation(callee),
  );
-
- for p in normalized.obligations {
- fulfill_cx.register_predicate_obligation(&infcx, p);
- }
- for obligation in traits::predicates_for_generics(
- |_, _| cause(),
+ let normalized_predicates =
+ ocx.normalize(cause.clone(), param_env, predicates);
+ ocx.register_obligations(traits::predicates_for_generics(
+ |_, _| cause.clone(),
  self.param_env,
- normalized.value,
- ) {
- fulfill_cx.register_predicate_obligation(&infcx, obligation);
- }
- let errors = fulfill_cx.select_all_or_error(&infcx);
+ normalized_predicates,
+ ));
+
+ let errors = ocx.select_all_or_error();
  if !errors.is_empty() {
  infcx.err_ctxt().report_fulfillment_errors(&errors, None, false);
  }

compiler/rustc_hir_analysis/src/check/compare_method.rs

@@ -1655,13 +1655,10 @@ pub fn check_type_bounds<'tcx>(
  GenericParamDefKind::Const { .. } => {
  let bound_var = ty::BoundVariableKind::Const;
  bound_vars.push(bound_var);
- tcx.mk_const(ty::ConstS {
- ty: tcx.type_of(param.def_id),
- kind: ty::ConstKind::Bound(
- ty::INNERMOST,
- ty::BoundVar::from_usize(bound_vars.len() - 1),
- ),
- })
+ tcx.mk_const(
+ ty::ConstKind::Bound(ty::INNERMOST, ty::BoundVar::from_usize(bound_vars.len() - 1)),
+ tcx.type_of(param.def_id),
+ )
  .into()
  }
  });

compiler/rustc_hir_typeck/src/op.rs

@@ -19,7 +19,7 @@ use rustc_span::symbol::{sym, Ident};
 use rustc_span::Span;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::error_reporting::suggestions::TypeErrCtxtExt as _;
-use rustc_trait_selection::traits::{FulfillmentError, TraitEngine, TraitEngineExt};
+use rustc_trait_selection::traits::FulfillmentError;
 use rustc_type_ir::sty::TyKind::*;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
@@ -785,9 +785,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  other_ty_expr,
  expected,
  );
- let mut fulfill = <dyn TraitEngine<'_>>::new(self.tcx);
- fulfill.register_predicate_obligation(self, obligation);
- Err(fulfill.select_where_possible(&self.infcx))
+ Err(rustc_trait_selection::traits::fully_solve_obligation(self, obligation))
  }
  }
  }

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -773,10 +773,10 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
  self.fold_const(bound_to)
  } else {
  let var = self.canonical_var(info, const_var.into());
- self.tcx().mk_const(ty::ConstS {
- kind: ty::ConstKind::Bound(self.binder_index, var),
- ty: self.fold_ty(const_var.ty()),
- })
+ self.tcx().mk_const(
+ ty::ConstKind::Bound(self.binder_index, var),
+ self.fold_ty(const_var.ty()),
+ )
  }
  }
 }

compiler/rustc_infer/src/infer/canonical/mod.rs

@@ -147,12 +147,7 @@ impl<'tcx> InferCtxt<'tcx> {
  CanonicalVarKind::PlaceholderConst(ty::PlaceholderConst { universe, name }, ty) => {
  let universe_mapped = universe_map(universe);
  let placeholder_mapped = ty::PlaceholderConst { universe: universe_mapped, name };
- self.tcx
- .mk_const(ty::ConstS {
- kind: ty::ConstKind::Placeholder(placeholder_mapped),
- ty,
- })
- .into()
+ self.tcx.mk_const(ty::ConstKind::Placeholder(placeholder_mapped), ty).into()
  }
  }
  }

compiler/rustc_infer/src/infer/combine.rs

@@ -741,10 +741,10 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
  substs,
  substs,
  )?;
- Ok(self.tcx().mk_const(ty::ConstS {
- ty: c.ty(),
- kind: ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),
- }))
+ Ok(self.tcx().mk_const(
+ ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),
+ c.ty(),
+ ))
  }
  _ => relate::super_relate_consts(self, c, c),
  }
@@ -955,10 +955,10 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
  substs,
  )?;
 
- Ok(self.tcx().mk_const(ty::ConstS {
- ty: c.ty(),
- kind: ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),
- }))
+ Ok(self.tcx().mk_const(
+ ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),
+ c.ty(),
+ ))
  }
  _ => relate::super_relate_consts(self, c, c),
  }

compiler/rustc_infer/src/infer/higher_ranked/mod.rs

@@ -94,13 +94,13 @@ impl<'tcx> InferCtxt<'tcx> {
  }))
  },
  consts: &mut |bound_var: ty::BoundVar, ty| {
- self.tcx.mk_const(ty::ConstS {
- kind: ty::ConstKind::Placeholder(ty::PlaceholderConst {
+ self.tcx.mk_const(
+ ty::ConstKind::Placeholder(ty::PlaceholderConst {
  universe: next_universe,
  name: bound_var,
  }),
  ty,
- })
+ )
  },
  };