Auto merge of #131226 - nnethercote:rustc_infer-cleanups, r=lcnr

`rustc_infer` cleanups
Various small improvements I found while reading over this code.
r? `@lcnr`

Author: bors

compiler/rustc_errors/src/lib.rs

@@ -925,18 +925,6 @@ impl<'a> DiagCtxtHandle<'a> {
 self.inner.borrow_mut().emit_stashed_diagnostics()
 }
 
-/// This excludes lint errors, and delayed bugs.
-#[inline]
-pubfnerr_count_excluding_lint_errs(&self) -> usize{
-let inner = self.inner.borrow();
- inner.err_guars.len()
- + inner
-.stashed_diagnostics
-.values()
-.filter(|(diag, guar)| guar.is_some() && diag.is_lint.is_none())
-.count()
-}
-
 /// This excludes delayed bugs.
 #[inline]
 pubfnerr_count(&self) -> usize{

compiler/rustc_infer/src/errors/mod.rs compiler/rustc_infer/src/errors.rscompiler/rustc_infer/src/errors/mod.rs renamed to compiler/rustc_infer/src/errors.rs

@@ -82,7 +82,6 @@ impl<'tcx> InferCtxt<'tcx> {
 reported_trait_errors:self.reported_trait_errors.clone(),
 reported_signature_mismatch:self.reported_signature_mismatch.clone(),
 tainted_by_errors:self.tainted_by_errors.clone(),
-err_count_on_creation:self.err_count_on_creation,
 universe:self.universe.clone(),
  intercrate,
 next_trait_solver:self.next_trait_solver,
@@ -382,21 +381,7 @@ impl<'tcx> ToTrace<'tcx> for ty::GenericArg<'tcx> {
 (GenericArgKind::Const(a),GenericArgKind::Const(b)) => {
 ValuePairs::Terms(ExpectedFound::new(true, a.into(), b.into()))
 }
-
-(
-GenericArgKind::Lifetime(_),
-GenericArgKind::Type(_) | GenericArgKind::Const(_),
-)
- | (
-GenericArgKind::Type(_),
-GenericArgKind::Lifetime(_) | GenericArgKind::Const(_),
-)
- | (
-GenericArgKind::Const(_),
-GenericArgKind::Lifetime(_) | GenericArgKind::Type(_),
-) => {
-bug!("relating different kinds: {a:?} {b:?}")
-}
+ _ => bug!("relating different kinds: {a:?} {b:?}"),
 },
 }
 }

compiler/rustc_infer/src/infer/at.rs

@@ -14,7 +14,8 @@ use region_constraints::{
 GenericKind,RegionConstraintCollector,RegionConstraintStorage,VarInfos,VerifyBound,
 };
 pubuse relate::StructurallyRelateAliases;
-pubuse relate::combine::{CombineFields,PredicateEmittingRelation};
+use relate::combine::CombineFields;
+pubuse relate::combine::PredicateEmittingRelation;
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::{FxHashSet,FxIndexMap};
 use rustc_data_structures::sync::Lrc;
@@ -50,23 +51,22 @@ use snapshot::undo_log::InferCtxtUndoLogs;
 use tracing::{debug, instrument};
 use type_variable::TypeVariableOrigin;
 
-usecrate::infer::relate::RelateResult;
 usecrate::traits::{self,ObligationCause,ObligationInspector,PredicateObligation,TraitEngine};
 
 pubmod at;
 pubmod canonical;
 mod context;
-pubmod free_regions;
+mod free_regions;
 mod freshen;
 mod lexical_region_resolve;
-pubmod opaque_types;
+mod opaque_types;
 pubmod outlives;
 mod projection;
 pubmod region_constraints;
 pubmod relate;
 pubmod resolve;
 pub(crate)mod snapshot;
-pubmod type_variable;
+mod type_variable;
 
 #[must_use]
 #[derive(Debug)]
@@ -76,8 +76,7 @@ pub struct InferOk<'tcx, T> {
 }
 pubtypeInferResult<'tcx,T> = Result<InferOk<'tcx,T>,TypeError<'tcx>>;
 
-pubtypeUnitResult<'tcx> = RelateResult<'tcx,()>;// "unify result"
-pubtypeFixupResult<T> = Result<T,FixupError>;// "fixup result"
+pub(crate)typeFixupResult<T> = Result<T,FixupError>;// "fixup result"
 
 pub(crate)typeUnificationTable<'a,'tcx,T> = ut::UnificationTable<
  ut::InPlace<T,&'amut ut::UnificationStorage<T>,&'amutInferCtxtUndoLogs<'tcx>>,
@@ -202,7 +201,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
 }
 
 #[inline]
-pubfnopaque_types(&mutself) -> opaque_types::OpaqueTypeTable<'_,'tcx>{
+fnopaque_types(&mutself) -> opaque_types::OpaqueTypeTable<'_,'tcx>{
 self.opaque_type_storage.with_log(&mutself.undo_log)
 }
 
@@ -280,27 +279,14 @@ pub struct InferCtxt<'tcx> {
 pubreported_signature_mismatch:RefCell<FxHashSet<(Span,Option<Span>)>>,
 
 /// When an error occurs, we want to avoid reporting "derived"
-/// errors that are due to this original failure. Normally, we
-/// handle this with the `err_count_on_creation` count, which
-/// basically just tracks how many errors were reported when we
-/// started type-checking a fn and checks to see if any new errors
-/// have been reported since then. Not great, but it works.
-///
-/// However, when errors originated in other passes -- notably
-/// resolve -- this heuristic breaks down. Therefore, we have this
-/// auxiliary flag that one can set whenever one creates a
-/// type-error that is due to an error in a prior pass.
+/// errors that are due to this original failure. We have this
+/// flag that one can set whenever one creates a type-error that
+/// is due to an error in a prior pass.
 ///
 /// Don't read this flag directly, call `is_tainted_by_errors()`
 /// and `set_tainted_by_errors()`.
 tainted_by_errors:Cell<Option<ErrorGuaranteed>>,
 
-/// Track how many errors were reported when this infcx is created.
-/// If the number of errors increases, that's also a sign (like
-/// `tainted_by_errors`) to avoid reporting certain kinds of errors.
-// FIXME(matthewjasper) Merge into `tainted_by_errors`
-err_count_on_creation:usize,
-
 /// What is the innermost universe we have created? Starts out as
 /// `UniverseIndex::root()` but grows from there as we enter
 /// universal quantifiers.
@@ -509,46 +495,41 @@ pub enum NllRegionVariableOrigin {
 },
 }
 
-// FIXME(eddyb) investigate overlap between this and `TyOrConstInferVar`.
 #[derive(Copy,Clone,Debug)]
-pubenumFixupError{
-UnresolvedIntTy(IntVid),
-UnresolvedFloatTy(FloatVid),
-UnresolvedTy(TyVid),
-UnresolvedConst(ConstVid),
-UnresolvedEffect(EffectVid),
-}
-
-/// See the `region_obligations` field for more information.
-#[derive(Clone,Debug)]
-pubstructRegionObligation<'tcx>{
-pubsub_region: ty::Region<'tcx>,
-pubsup_type:Ty<'tcx>,
-puborigin:SubregionOrigin<'tcx>,
+pubstructFixupError{
+unresolved:TyOrConstInferVar,
 }
 
 impl fmt::DisplayforFixupError{
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
-useself::FixupError::*;
+useTyOrConstInferVar::*;
 
-match*self{
-UnresolvedIntTy(_) => write!(
+matchself.unresolved{
+TyInt(_) => write!(
  f,
 "cannot determine the type of this integer; \
  add a suffix to specify the type explicitly"
 ),
-UnresolvedFloatTy(_) => write!(
+TyFloat(_) => write!(
  f,
 "cannot determine the type of this number; \
  add a suffix to specify the type explicitly"
 ),
-UnresolvedTy(_) => write!(f,"unconstrained type"),
-UnresolvedConst(_) => write!(f,"unconstrained const value"),
-UnresolvedEffect(_) => write!(f,"unconstrained effect value"),
+Ty(_) => write!(f,"unconstrained type"),
+Const(_) => write!(f,"unconstrained const value"),
+Effect(_) => write!(f,"unconstrained effect value"),
 }
 }
 }
 
+/// See the `region_obligations` field for more information.
+#[derive(Clone,Debug)]
+pubstructRegionObligation<'tcx>{
+pubsub_region: ty::Region<'tcx>,
+pubsup_type:Ty<'tcx>,
+puborigin:SubregionOrigin<'tcx>,
+}
+
 /// Used to configure inference contexts before their creation.
 pubstructInferCtxtBuilder<'tcx>{
 tcx:TyCtxt<'tcx>,
@@ -588,14 +569,6 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
 self
 }
 
-pubfnwith_defining_opaque_types(
-mutself,
-defining_opaque_types:&'tcx ty::List<LocalDefId>,
-) -> Self{
-self.defining_opaque_types = defining_opaque_types;
-self
-}
-
 pubfnwith_next_trait_solver(mutself,next_trait_solver:bool) -> Self{
 self.next_trait_solver = next_trait_solver;
 self
@@ -624,14 +597,15 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
 /// the bound values in `C` to their instantiated values in `V`
 /// (in other words, `S(C) = V`).
 pubfnbuild_with_canonical<T>(
-self,
+mutself,
 span:Span,
 canonical:&Canonical<'tcx,T>,
 ) -> (InferCtxt<'tcx>,T,CanonicalVarValues<'tcx>)
 where
 T:TypeFoldable<TyCtxt<'tcx>>,
 {
-let infcx = self.with_defining_opaque_types(canonical.defining_opaque_types).build();
+self.defining_opaque_types = canonical.defining_opaque_types;
+let infcx = self.build();
 let(value, args) = infcx.instantiate_canonical(span, canonical);
 (infcx, value, args)
 }
@@ -657,7 +631,6 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
 reported_trait_errors:Default::default(),
 reported_signature_mismatch:Default::default(),
 tainted_by_errors:Cell::new(None),
-err_count_on_creation: tcx.dcx().err_count_excluding_lint_errs(),
 universe:Cell::new(ty::UniverseIndex::ROOT),
  intercrate,
  next_trait_solver,
@@ -919,28 +892,16 @@ impl<'tcx> InferCtxt<'tcx> {
  ty::Const::new_var(self.tcx, vid)
 }
 
-pubfnnext_const_var_id(&self,origin:ConstVariableOrigin) -> ConstVid{
-self.inner
-.borrow_mut()
-.const_unification_table()
-.new_key(ConstVariableValue::Unknown{ origin,universe:self.universe()})
-.vid
-}
-
-fnnext_int_var_id(&self) -> IntVid{
-self.inner.borrow_mut().int_unification_table().new_key(ty::IntVarValue::Unknown)
-}
-
 pubfnnext_int_var(&self) -> Ty<'tcx>{
-Ty::new_int_var(self.tcx,self.next_int_var_id())
-}
-
-fnnext_float_var_id(&self) -> FloatVid{
-self.inner.borrow_mut().float_unification_table().new_key(ty::FloatVarValue::Unknown)
+let next_int_var_id =
+self.inner.borrow_mut().int_unification_table().new_key(ty::IntVarValue::Unknown);
+Ty::new_int_var(self.tcx, next_int_var_id)
 }
 
 pubfnnext_float_var(&self) -> Ty<'tcx>{
-Ty::new_float_var(self.tcx,self.next_float_var_id())
+let next_float_var_id =
+self.inner.borrow_mut().float_unification_table().new_key(ty::FloatVarValue::Unknown);
+Ty::new_float_var(self.tcx, next_float_var_id)
 }
 
 /// Creates a fresh region variable with the next available index.
@@ -1353,7 +1314,7 @@ impl<'tcx> InferCtxt<'tcx> {
 }
 
 /// See the [`region_constraints::RegionConstraintCollector::verify_generic_bound`] method.
-pubfnverify_generic_bound(
+pub(crate)fnverify_generic_bound(
 &self,
 origin:SubregionOrigin<'tcx>,
 kind:GenericKind<'tcx>,

compiler/rustc_infer/src/infer/mod.rs

@@ -13,16 +13,15 @@ use rustc_middle::ty::{
 use rustc_span::Span;
 use tracing::{debug, instrument};
 
+usesuper::DefineOpaqueTypes;
 usecrate::errors::OpaqueHiddenTypeDiag;
 usecrate::infer::{InferCtxt,InferOk};
 usecrate::traits::{self,Obligation};
 
 mod table;
 
-pubtypeOpaqueTypeMap<'tcx> = FxIndexMap<OpaqueTypeKey<'tcx>,OpaqueTypeDecl<'tcx>>;
-pubuse table::{OpaqueTypeStorage,OpaqueTypeTable};
-
-usesuper::DefineOpaqueTypes;
+pub(crate)typeOpaqueTypeMap<'tcx> = FxIndexMap<OpaqueTypeKey<'tcx>,OpaqueTypeDecl<'tcx>>;
+pub(crate)use table::{OpaqueTypeStorage,OpaqueTypeTable};
 
 /// Information about the opaque types whose values we
 /// are inferring in this function (these are the `impl Trait` that
@@ -377,9 +376,9 @@ impl<'tcx> InferCtxt<'tcx> {
 ///
 /// We ignore any type parameters because impl trait values are assumed to
 /// capture all the in-scope type parameters.
-pubstructConstrainOpaqueTypeRegionVisitor<'tcx,OP:FnMut(ty::Region<'tcx>)>{
-pubtcx:TyCtxt<'tcx>,
-pubop:OP,
+structConstrainOpaqueTypeRegionVisitor<'tcx,OP:FnMut(ty::Region<'tcx>)>{
+tcx:TyCtxt<'tcx>,
+op:OP,
 }
 
 impl<'tcx,OP>TypeVisitor<TyCtxt<'tcx>>forConstrainOpaqueTypeRegionVisitor<'tcx,OP>
@@ -455,20 +454,6 @@ where
 }
 }
 
-pubenumUseKind{
-DefiningUse,
-OpaqueUse,
-}
-
-implUseKind{
-pubfnis_defining(self) -> bool{
-matchself{
-UseKind::DefiningUse => true,
-UseKind::OpaqueUse => false,
-}
-}
-}
-
 impl<'tcx>InferCtxt<'tcx>{
 #[instrument(skip(self), level = "debug")]
 fnregister_hidden_type(

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

@@ -7,7 +7,7 @@ use super::{OpaqueTypeDecl, OpaqueTypeMap};
 usecrate::infer::snapshot::undo_log::{InferCtxtUndoLogs,UndoLog};
 
 #[derive(Default,Debug,Clone)]
-pubstructOpaqueTypeStorage<'tcx>{
+pub(crate)structOpaqueTypeStorage<'tcx>{
 /// Opaque types found in explicit return types and their
 /// associated fresh inference variable. Writeback resolves these
 /// variables to get the concrete type, which can be used to
@@ -46,7 +46,7 @@ impl<'tcx> Drop for OpaqueTypeStorage<'tcx> {
 }
 }
 
-pubstructOpaqueTypeTable<'a,'tcx>{
+pub(crate)structOpaqueTypeTable<'a,'tcx>{
 storage:&'amutOpaqueTypeStorage<'tcx>,
 
 undo_log:&'amutInferCtxtUndoLogs<'tcx>,

compiler/rustc_infer/src/infer/opaque_types/table.rs

@@ -14,7 +14,7 @@ pub mod env;
 pubmod for_liveness;
 pubmod obligations;
 pubmod test_type_match;
-pubmod verify;
+pub(crate)mod verify;
 
 #[instrument(level = "debug", skip(param_env), ret)]
 pubfnexplicit_outlives_bounds<'tcx>(