always define opaque types outside of trait solver

Author: lcnr

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -160,7 +160,7 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef
  use rustc_type_ir::sty::TyKind::*;
  match (source.kind(), target.kind()) {
  (&Ref(r_a, _, mutbl_a), Ref(r_b, _, mutbl_b))
- if infcx.at(&cause, param_env).eq(DefineOpaqueTypes::No, r_a, *r_b).is_ok()
+ if infcx.at(&cause, param_env).eq(DefineOpaqueTypes::Yes, r_a, *r_b).is_ok()
  && mutbl_a == *mutbl_b => {}
  (&RawPtr(tm_a), &RawPtr(tm_b)) if tm_a.mutbl == tm_b.mutbl => (),
  (&Adt(def_a, substs_a), &Adt(def_b, substs_b))
@@ -205,7 +205,7 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef
  }
 
  if let Ok(ok) =
- infcx.at(&cause, param_env).eq(DefineOpaqueTypes::No, ty_a, ty_b)
+ infcx.at(&cause, param_env).eq(DefineOpaqueTypes::Yes, ty_a, ty_b)
  {
  if ok.obligations.is_empty() {
  create_err(
@@ -427,7 +427,7 @@ pub fn coerce_unsized_info<'tcx>(tcx: TyCtxt<'tcx>, impl_did: LocalDefId) -> Coe
  // we may have to evaluate constraint
  // expressions in the course of execution.)
  // See e.g., #41936.
- if let Ok(ok) = infcx.at(&cause, param_env).eq(DefineOpaqueTypes::No, a, b) {
+ if let Ok(ok) = infcx.at(&cause, param_env).eq(DefineOpaqueTypes::Yes, a, b) {
  if ok.obligations.is_empty() {
  return None;
  }

compiler/rustc_hir_typeck/src/callee.rs

@@ -787,7 +787,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  if let Some(idx) = generics.host_effect_index {
  let param = callee_substs.const_at(idx);
  let cause = self.misc(span);
- match self.at(&cause, self.param_env).eq(infer::DefineOpaqueTypes::No, effect, param) {
+ match self.at(&cause, self.param_env).eq(infer::DefineOpaqueTypes::Yes, effect, param) {
  Ok(infer::InferOk { obligations, value: () }) => {
  self.register_predicates(obligations);
  }

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1127,7 +1127,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // are the same function and their parameters have a LUB.
  match self.commit_if_ok(|_| {
  self.at(cause, self.param_env).lub(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  prev_ty,
  new_ty,
  )
@@ -1181,7 +1181,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let sig = self
  .at(cause, self.param_env)
  .trace(prev_ty, new_ty)
- .lub(DefineOpaqueTypes::No, a_sig, b_sig)
+ .lub(DefineOpaqueTypes::Yes, a_sig, b_sig)
  .map(|ok| self.register_infer_ok_obligations(ok))?;
 
  // Reify both sides and return the reified fn pointer type.
@@ -1270,7 +1270,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
  return self
  .commit_if_ok(|_| {
- self.at(cause, self.param_env).lub(DefineOpaqueTypes::No, prev_ty, new_ty)
+ self.at(cause, self.param_env).lub(DefineOpaqueTypes::Yes, prev_ty, new_ty)
  })
  .map(|ok| self.register_infer_ok_obligations(ok));
  }
@@ -1283,7 +1283,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  Err(e)
  } else {
  self.commit_if_ok(|_| {
- self.at(cause, self.param_env).lub(DefineOpaqueTypes::No, prev_ty, new_ty)
+ self.at(cause, self.param_env).lub(DefineOpaqueTypes::Yes, prev_ty, new_ty)
  })
  .map(|ok| self.register_infer_ok_obligations(ok))
  }

compiler/rustc_hir_typeck/src/demand.rs

@@ -387,7 +387,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // what our ideal rcvr ty would look like.
  let _ = self
  .at(&ObligationCause::dummy(), self.param_env)
- .eq(DefineOpaqueTypes::No, method.sig.inputs()[idx + 1], arg_ty)
+ .eq(DefineOpaqueTypes::Yes, method.sig.inputs()[idx + 1], arg_ty)
  .ok()?;
  self.select_obligations_where_possible(|errs| {
  // Yeet the errors, we're already reporting errors.
@@ -449,7 +449,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  .ok()
  .and_then(|method| {
  let _ = self.at(&ObligationCause::dummy(), self.param_env)
- .eq(DefineOpaqueTypes::No, ideal_rcvr_ty, expected_ty)
+ .eq(DefineOpaqueTypes::Yes, ideal_rcvr_ty, expected_ty)
  .ok()?;
  Some(method)
  });

compiler/rustc_hir_typeck/src/expr.rs

@@ -1736,7 +1736,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let target_ty = self.field_ty(base_expr.span, f, substs);
  let cause = self.misc(base_expr.span);
  match self.at(&cause, self.param_env).sup(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  target_ty,
  fru_ty,
  ) {

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -564,7 +564,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let span = self.tcx.hir().body(body_id).value.span;
  let ok = self
  .at(&self.misc(span), self.param_env)
- .eq(DefineOpaqueTypes::No, interior, witness)
+ .eq(DefineOpaqueTypes::Yes, interior, witness)
  .expect("Failed to unify generator interior type");
  let mut obligations = ok.obligations;
 
@@ -1400,7 +1400,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let impl_ty = self.normalize(span, tcx.type_of(impl_def_id).subst(tcx, substs));
  let self_ty = self.normalize(span, self_ty);
  match self.at(&self.misc(span), self.param_env).eq(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  impl_ty,
  self_ty,
  ) {

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -296,7 +296,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // 3. Check if the formal type is a supertype of the checked one
  // and register any such obligations for future type checks
  let supertype_error = self.at(&self.misc(provided_arg.span), self.param_env).sup(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  formal_input_ty,
  coerced_ty,
  );
@@ -591,7 +591,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // Using probe here, since we don't want this subtyping to affect inference.
  let subtyping_error = self.probe(|_| {
  self.at(&self.misc(arg_span), self.param_env)
- .sup(DefineOpaqueTypes::No, formal_input_ty, coerced_ty)
+ .sup(DefineOpaqueTypes::Yes, formal_input_ty, coerced_ty)
  .err()
  });
 

compiler/rustc_hir_typeck/src/generator_interior/mod.rs

@@ -327,7 +327,7 @@ pub fn resolve_interior<'a, 'tcx>(
 
  // Unify the type variable inside the generator with the new witness
  match fcx.at(&fcx.misc(body.value.span), fcx.param_env).eq(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  interior,
  witness,
  ) {

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -502,7 +502,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
  substs,
  })),
  );
- match self.at(&cause, self.param_env).sup(DefineOpaqueTypes::No, method_self_ty, self_ty) {
+ match self.at(&cause, self.param_env).sup(DefineOpaqueTypes::Yes, method_self_ty, self_ty) {
  Ok(InferOk { obligations, value: () }) => {
  self.register_predicates(obligations);
  }

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -936,7 +936,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  if let Some(self_ty) = self_ty {
  if self
  .at(&ObligationCause::dummy(), self.param_env)
- .sup(DefineOpaqueTypes::No, fty.inputs()[0], self_ty)
+ .sup(DefineOpaqueTypes::Yes, fty.inputs()[0], self_ty)
  .is_err()
  {
  return false;
@@ -1455,7 +1455,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  }
  TraitCandidate(trait_ref) => self.probe(|_| {
  let _ = self.at(&ObligationCause::dummy(), self.param_env).sup(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  candidate.xform_self_ty,
  self_ty,
  );
@@ -1486,7 +1486,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  self.probe(|_| {
  // First check that the self type can be related.
  let sub_obligations = match self.at(&ObligationCause::dummy(), self.param_env).sup(
- DefineOpaqueTypes::No,
+ DefineOpaqueTypes::Yes,
  probe.xform_self_ty,
  self_ty,
  ) {
@@ -1698,7 +1698,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  if let ProbeResult::Match = result
  && self
  .at(&ObligationCause::dummy(), self.param_env)
- .sup(DefineOpaqueTypes::No, return_ty, xform_ret_ty)
+ .sup(DefineOpaqueTypes::Yes, return_ty, xform_ret_ty)
  .is_err()
  {
  result = ProbeResult::BadReturnType;