temporary hacks

Author: lcnr

compiler/rustc_hir_typeck/src/method/mod.rs

@@ -494,6 +494,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
+        // HACK: TODO
+        let self_ty = {
+            let infer = self.infcx.next_ty_var(span);
+            self.demand_eqtype(span, infer, self_ty);
+            self.select_obligations_where_possible(|_| {});
+            self.resolve_vars_if_possible(infer)
+        };
+
         let pick = self.probe_for_name(
             probe::Mode::Path,
             method_name,

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -33,7 +33,7 @@ impl<'tcx> InferCtxt<'tcx> {
     /// This is *not* expected to be used anywhere except for an implementation of
     /// `TypeRelation`. Do not use this, and instead please use `At::eq`, for all
     /// other usecases (i.e. setting the value of a type var).
-    #[instrument(level = "debug", skip(self, relation))]
+    #[instrument(level = "debug", skip(self, relation), fields(structurally_relate_aliases = ?relation.structurally_relate_aliases()))]
     pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'tcx>>>(
         &self,
         relation: &mut R,

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -243,8 +243,9 @@ where
         }
 
         match source {
-            GoalSource::ImplWhereBound => PathKind::Coinductive,
+            GoalSource::ImplWhereBound | GoalSource::AliasWellFormed => PathKind::Coinductive,
             _ => PathKind::Inductive,
+            
         }
     }
 

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -34,10 +34,11 @@ where
         match goal.predicate.alias.kind(cx) {
             ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
                 let candidates = self.assemble_and_evaluate_candidates(goal);
+                let trait_ref = goal.predicate.alias.trait_ref(cx);
                 let (_, proven_via) =
                     self.probe(|_| ProbeKind::ShadowedEnvProbing).enter_coinductively(|ecx| {
                         let trait_goal: Goal<I, ty::TraitPredicate<I>> =
-                            goal.with(cx, goal.predicate.alias.trait_ref(cx));
+                            goal.with(cx, trait_ref);
                         ecx.compute_trait_goal(trait_goal)
                     })?;
                 self.merge_candidates(proven_via, candidates, |ecx| {
@@ -46,6 +47,7 @@ where
                             goal,
                             goal.predicate.alias,
                         );
+                        this.add_goal(GoalSource::AliasWellFormed, goal.with(cx, trait_ref));
                         this.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
                     })
                 })

compiler/rustc_type_ir/src/solve/mod.rs

@@ -75,6 +75,9 @@ pub enum GoalSource {
     /// Predicate required for an alias projection to be well-formed.
     /// This is used in two places: projecting to an opaque whose hidden type
     /// is already registered in the opaque type storage, and for rigid projections.
+    ///
+    /// FIXME(-Znext-solver=coinductive): Explain how and why this
+    /// changes whether cycles are coinductive.
     AliasWellFormed,
 }