Rollup merge of rust-lang#102651 - oli-obk:non_region_things, r=lcnr

It's not about types or consts, but the lack of regions pulled out of rust-lang#101900 which adds a fourth kind of non-lifetime generic parameter, and the naming of these methods would get ridiculous.

Author: matthiaskrgr

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -236,7 +236,7 @@ pub(crate) fn type_check<'mir, 'tcx>(
  .unwrap();
  let mut hidden_type = infcx.resolve_vars_if_possible(decl.hidden_type);
  trace!("finalized opaque type {:?} to {:#?}", opaque_type_key, hidden_type.ty.kind());
- if hidden_type.has_infer_types_or_consts() {
+ if hidden_type.has_non_region_infer() {
  infcx.tcx.sess.delay_span_bug(
  decl.hidden_type.span,
  &format!("could not resolve {:#?}", hidden_type.ty.kind()),

compiler/rustc_hir_analysis/src/check/fn_ctxt/_impl.rs

@@ -91,14 +91,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
  ) -> Ty<'tcx> {
  // No Infer()? Nothing needs doing.
- if !ty.has_infer_types_or_consts() {
+ if !ty.has_non_region_infer() {
  debug!("no inference var, nothing needs doing");
  return ty;
  }
 
  // If `ty` is a type variable, see whether we already know what it is.
  ty = self.resolve_vars_if_possible(ty);
- if !ty.has_infer_types_or_consts() {
+ if !ty.has_non_region_infer() {
  debug!(?ty);
  return ty;
  }

compiler/rustc_hir_analysis/src/check/fn_ctxt/checks.rs

@@ -63,7 +63,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let get_operand_ty = |expr| {
  let ty = self.typeck_results.borrow().expr_ty_adjusted(expr);
  let ty = self.resolve_vars_if_possible(ty);
- if ty.has_infer_types_or_consts() {
+ if ty.has_non_region_infer() {
  assert!(self.is_tainted_by_errors());
  self.tcx.ty_error()
  } else {

compiler/rustc_hir_analysis/src/check/intrinsicck.rs

@@ -149,7 +149,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
  target_features: &FxHashSet<Symbol>,
  ) -> Option<InlineAsmType> {
  let ty = (self.get_operand_ty)(expr);
- if ty.has_infer_types_or_consts() {
+ if ty.has_non_region_infer() {
  bug!("inference variable in asm operand ty: {:?} {:?}", expr, ty);
  }
  let asm_ty_isize = match self.tcx.sess.target.pointer_width {

compiler/rustc_hir_analysis/src/check/op.rs

@@ -471,7 +471,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // This has nothing here because it means we did string
  // concatenation (e.g., "Hello " + "World!"). This means
  // we don't want the note in the else clause to be emitted
- } else if lhs_ty.has_param_types_or_consts() {
+ } else if lhs_ty.has_non_region_param() {
  // Look for a TraitPredicate in the Fulfillment errors,
  // and use it to generate a suggestion.
  //
@@ -657,7 +657,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  format!("cannot apply unary operator `{}`", op.as_str()),
  );
 
- if operand_ty.has_param_types_or_consts() {
+ if operand_ty.has_non_region_param() {
  let predicates = errors.iter().filter_map(|error| {
  error.obligation.predicate.to_opt_poly_trait_pred()
  });

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1428,9 +1428,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
  let substituted_pred = predicates.rebind(pred).subst(tcx, substs);
  // Don't check non-defaulted params, dependent defaults (including lifetimes)
  // or preds with multiple params.
- if substituted_pred.has_param_types_or_consts()
- || param_count.params.len() > 1
- || has_region
+ if substituted_pred.has_non_region_param() || param_count.params.len() > 1 || has_region
  {
  None
  } else if predicates.0.predicates.iter().any(|&(p, _)| p == substituted_pred) {

compiler/rustc_infer/src/infer/mod.rs

@@ -712,9 +712,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  ) -> bool {
  // Reject any attempt to unify two unevaluated constants that contain inference
  // variables, since inference variables in queries lead to ICEs.
- if a.substs.has_infer_types_or_consts()
- || b.substs.has_infer_types_or_consts()
- || param_env.has_infer_types_or_consts()
+ if a.substs.has_non_region_infer()
+ || b.substs.has_non_region_infer()
+ || param_env.has_non_region_infer()
  {
  debug!("a or b or param_env contain infer vars in its substs -> cannot unify");
  return false;
@@ -1734,7 +1734,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 
  // Postpone the evaluation of constants whose substs depend on inference
  // variables
- if substs.has_infer_types_or_consts() {
+ if substs.has_non_region_infer() {
  let ac = AbstractConst::new(self.tcx, unevaluated);
  match ac {
  Ok(None) => {
@@ -2072,21 +2072,17 @@ fn replace_param_and_infer_substs_with_placeholder<'tcx>(
 ) -> SubstsRef<'tcx> {
  tcx.mk_substs(substs.iter().enumerate().map(|(idx, arg)| {
  match arg.unpack() {
- GenericArgKind::Type(_)
- if arg.has_param_types_or_consts() || arg.has_infer_types_or_consts() =>
- {
+ GenericArgKind::Type(_) if arg.has_non_region_param() || arg.has_non_region_infer() => {
  tcx.mk_ty(ty::Placeholder(ty::PlaceholderType {
  universe: ty::UniverseIndex::ROOT,
  name: ty::BoundVar::from_usize(idx),
  }))
  .into()
  }
- GenericArgKind::Const(ct)
- if ct.has_infer_types_or_consts() || ct.has_param_types_or_consts() =>
- {
+ GenericArgKind::Const(ct) if ct.has_non_region_infer() || ct.has_non_region_param() => {
  let ty = ct.ty();
  // If the type references param or infer, replace that too...
- if ty.has_param_types_or_consts() || ty.has_infer_types_or_consts() {
+ if ty.has_non_region_param() || ty.has_non_region_infer() {
  bug!("const `{ct}`'s type should not reference params or types");
  }
  tcx.mk_const(ty::ConstS {

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

@@ -357,7 +357,7 @@ where
  // In NLL, we don't have type inference variables
  // floating around, so we can do this rather imprecise
  // variant of the occurs-check.
- assert!(!generalized_ty.has_infer_types_or_consts());
+ assert!(!generalized_ty.has_non_region_infer());
  }
 
  self.infcx.inner.borrow_mut().type_variables().instantiate(vid, generalized_ty);

compiler/rustc_infer/src/infer/resolve.rs

@@ -32,7 +32,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for OpportunisticVarResolver<'a, 'tcx> {
  }
 
  fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
- if !t.has_infer_types_or_consts() {
+ if !t.has_non_region_infer() {
  t // micro-optimize -- if there is nothing in this type that this fold affects...
  } else {
  let t = self.infcx.shallow_resolve(t);
@@ -41,7 +41,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for OpportunisticVarResolver<'a, 'tcx> {
  }
 
  fn fold_const(&mut self, ct: Const<'tcx>) -> Const<'tcx> {
- if !ct.has_infer_types_or_consts() {
+ if !ct.has_non_region_infer() {
  ct // micro-optimize -- if there is nothing in this const that this fold affects...
  } else {
  let ct = self.infcx.shallow_resolve(ct);

compiler/rustc_middle/src/mir/interpret/queries.rs

@@ -45,7 +45,7 @@ impl<'tcx> TyCtxt<'tcx> {
  //
  // When trying to evaluate constants containing inference variables,
  // use `Infcx::const_eval_resolve` instead.
- if ct.substs.has_infer_types_or_consts() {
+ if ct.substs.has_non_region_infer() {
  bug!("did not expect inference variables here");
  }
 
@@ -76,7 +76,7 @@ impl<'tcx> TyCtxt<'tcx> {
  //
  // When trying to evaluate constants containing inference variables,
  // use `Infcx::const_eval_resolve` instead.
- if ct.substs.has_infer_types_or_consts() {
+ if ct.substs.has_non_region_infer() {
  bug!("did not expect inference variables here");
  }