Fast-path some relations via strict equality

compiler-errors · compiler-errors · commit 3a5bf11dab2d · 2022-11-19T06:02:55.000Z
diff --git a/compiler/rustc_hir_analysis/src/check/dropck.rs b/compiler/rustc_hir_analysis/src/check/dropck.rs
@@ -248,6 +248,10 @@ impl<'tcx> TypeRelation<'tcx> for SimpleEqRelation<'tcx> {
         self.param_env
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        true
+    }
+
     fn tag(&self) -> &'static str {
         "dropck::SimpleEqRelation"
     }
diff --git a/compiler/rustc_infer/src/infer/combine.rs b/compiler/rustc_infer/src/infer/combine.rs
@@ -525,6 +525,10 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
         self.param_env
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        false
+    }
+
     fn tag(&self) -> &'static str {
         "Generalizer"
     }
@@ -802,6 +806,10 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
         self.param_env
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        false
+    }
+
     fn tag(&self) -> &'static str {
         "ConstInferUnifier"
     }
diff --git a/compiler/rustc_infer/src/infer/equate.rs b/compiler/rustc_infer/src/infer/equate.rs
@@ -32,6 +32,10 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
         self.fields.tcx()
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        true
+    }
+
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
         self.fields.param_env
     }
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -2945,6 +2945,10 @@ impl<'tcx> TypeRelation<'tcx> for SameTypeModuloInfer<'_, 'tcx> {
         "SameTypeModuloInfer"
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        true
+    }
+
     fn a_is_expected(&self) -> bool {
         true
     }
diff --git a/compiler/rustc_infer/src/infer/glb.rs b/compiler/rustc_infer/src/infer/glb.rs
@@ -34,6 +34,10 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
         self.fields.tcx()
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        true
+    }
+
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
         self.fields.param_env
     }
diff --git a/compiler/rustc_infer/src/infer/lub.rs b/compiler/rustc_infer/src/infer/lub.rs
@@ -34,6 +34,10 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
         self.fields.tcx()
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        true
+    }
+
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
         self.fields.param_env
     }
diff --git a/compiler/rustc_infer/src/infer/nll_relate/mod.rs b/compiler/rustc_infer/src/infer/nll_relate/mod.rs
@@ -535,6 +535,10 @@ where
         self.delegate.param_env()
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        false
+    }
+
     fn tag(&self) -> &'static str {
         "nll::subtype"
     }
@@ -901,6 +905,10 @@ where
         self.delegate.param_env()
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        false
+    }
+
     fn tag(&self) -> &'static str {
         "nll::generalizer"
     }
diff --git a/compiler/rustc_infer/src/infer/outlives/test_type_match.rs b/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
@@ -142,6 +142,9 @@ impl<'tcx> TypeRelation<'tcx> for Match<'tcx> {
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
         self.param_env
     }
+    fn fast_equate_combine(&self) -> bool {
+        false
+    }
     fn a_is_expected(&self) -> bool {
         true
     } // irrelevant
diff --git a/compiler/rustc_infer/src/infer/sub.rs b/compiler/rustc_infer/src/infer/sub.rs
@@ -43,6 +43,10 @@ impl<'tcx> TypeRelation<'tcx> for Sub<'_, '_, 'tcx> {
         self.fields.param_env
     }
 
+    fn fast_equate_combine(&self) -> bool {
+        true
+    }
+
     fn a_is_expected(&self) -> bool {
         self.a_is_expected
     }
diff --git a/compiler/rustc_middle/src/ty/_match.rs b/compiler/rustc_middle/src/ty/_match.rs
@@ -39,6 +39,9 @@ impl<'tcx> TypeRelation<'tcx> for Match<'tcx> {
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
         self.param_env
     }
+    fn fast_equate_combine(&self) -> bool {
+        false
+    }
     fn a_is_expected(&self) -> bool {
         true
     } // irrelevant
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
@@ -28,6 +28,9 @@ pub trait TypeRelation<'tcx>: Sized {
     /// Returns a static string we can use for printouts.
     fn tag(&self) -> &'static str;
 
+    /// Returns whether or not structural equality can be used to fast-path this relation
+    fn fast_equate_combine(&self) -> bool;
+
     /// Returns `true` if the value `a` is the "expected" type in the
     /// relation. Just affects error messages.
     fn a_is_expected(&self) -> bool;
@@ -140,6 +143,10 @@ pub fn relate_substs<'tcx, R: TypeRelation<'tcx>>(
     a_subst: SubstsRef<'tcx>,
     b_subst: SubstsRef<'tcx>,
 ) -> RelateResult<'tcx, SubstsRef<'tcx>> {
+    if relation.fast_equate_combine() && a_subst == b_subst {
+        return Ok(a_subst);
+    }
+
     relation.tcx().mk_substs(iter::zip(a_subst, b_subst).map(|(a, b)| {
         relation.relate_with_variance(ty::Invariant, ty::VarianceDiagInfo::default(), a, b)
     }))
@@ -152,6 +159,10 @@ pub fn relate_substs_with_variances<'tcx, R: TypeRelation<'tcx>>(
     a_subst: SubstsRef<'tcx>,
     b_subst: SubstsRef<'tcx>,
 ) -> RelateResult<'tcx, SubstsRef<'tcx>> {
+    if relation.fast_equate_combine() && a_subst == b_subst {
+        return Ok(a_subst);
+    }
+
     let tcx = relation.tcx();
 
     let mut cached_ty = None;
@@ -345,7 +356,7 @@ impl<'tcx> Relate<'tcx> for ty::ExistentialTraitRef<'tcx> {
     }
 }
 
-#[derive(Copy, Debug, Clone, TypeFoldable, TypeVisitable)]
+#[derive(Copy, Debug, Clone, PartialEq, Eq, TypeFoldable, TypeVisitable)]
 struct GeneratorWitness<'tcx>(&'tcx ty::List<Ty<'tcx>>);
 
 impl<'tcx> Relate<'tcx> for GeneratorWitness<'tcx> {
@@ -354,6 +365,10 @@ impl<'tcx> Relate<'tcx> for GeneratorWitness<'tcx> {
         a: GeneratorWitness<'tcx>,
         b: GeneratorWitness<'tcx>,
     ) -> RelateResult<'tcx, GeneratorWitness<'tcx>> {
+        if relation.fast_equate_combine() && a == b {
+            return Ok(a);
+        }
+
         assert_eq!(a.0.len(), b.0.len());
         let tcx = relation.tcx();
         let types = tcx.mk_type_list(iter::zip(a.0, b.0).map(|(a, b)| relation.relate(a, b)))?;
@@ -655,6 +670,10 @@ impl<'tcx> Relate<'tcx> for &'tcx ty::List<ty::Binder<'tcx, ty::ExistentialPredi
         a: Self,
         b: Self,
     ) -> RelateResult<'tcx, Self> {
+        if relation.fast_equate_combine() && a == b {
+            return Ok(a);
+        }
+
         let tcx = relation.tcx();
 
         // FIXME: this is wasteful, but want to do a perf run to see how slow it is.
@@ -799,9 +818,9 @@ impl<'tcx> Relate<'tcx> for ty::TraitPredicate<'tcx> {
         b: ty::TraitPredicate<'tcx>,
     ) -> RelateResult<'tcx, ty::TraitPredicate<'tcx>> {
         Ok(ty::TraitPredicate {
-            trait_ref: relation.relate(a.trait_ref, b.trait_ref)?,
             constness: relation.relate(a.constness, b.constness)?,
             polarity: relation.relate(a.polarity, b.polarity)?,
+            trait_ref: relation.relate(a.trait_ref, b.trait_ref)?,
         })
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -248,6 +248,10 @@ impl<'tcx> TypeRelation<'tcx> for SimpleEqRelation<'tcx> {`
`248`	`248`	`self.param_env`
`249`	`249`	`}`
`250`	`250`
	`251`	`+ fn fast_equate_combine(&self) -> bool {`
	`252`	`+ true`
	`253`	`+ }`
	`254`	`+`
`251`	`255`	`fn tag(&self) -> &'static str {`
`252`	`256`	`"dropck::SimpleEqRelation"`
`253`	`257`	`}`
Original file line number	Diff line number	Diff line change
`@@ -525,6 +525,10 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {`
`525`	`525`	`self.param_env`
`526`	`526`	`}`
`527`	`527`
	`528`	`+ fn fast_equate_combine(&self) -> bool {`
	`529`	`+ false`
	`530`	`+ }`
	`531`	`+`
`528`	`532`	`fn tag(&self) -> &'static str {`
`529`	`533`	`"Generalizer"`
`530`	`534`	`}`
`@@ -802,6 +806,10 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {`
`802`	`806`	`self.param_env`
`803`	`807`	`}`
`804`	`808`
	`809`	`+ fn fast_equate_combine(&self) -> bool {`
	`810`	`+ false`
	`811`	`+ }`
	`812`	`+`
`805`	`813`	`fn tag(&self) -> &'static str {`
`806`	`814`	`"ConstInferUnifier"`
`807`	`815`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,10 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {`
`32`	`32`	`self.fields.tcx()`
`33`	`33`	`}`
`34`	`34`
	`35`	`+ fn fast_equate_combine(&self) -> bool {`
	`36`	`+ true`
	`37`	`+ }`
	`38`	`+`
`35`	`39`	`fn param_env(&self) -> ty::ParamEnv<'tcx> {`
`36`	`40`	`self.fields.param_env`
`37`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2945,6 +2945,10 @@ impl<'tcx> TypeRelation<'tcx> for SameTypeModuloInfer<'_, 'tcx> {`
`2945`	`2945`	`"SameTypeModuloInfer"`
`2946`	`2946`	`}`
`2947`	`2947`
	`2948`	`+ fn fast_equate_combine(&self) -> bool {`
	`2949`	`+ true`
	`2950`	`+ }`
	`2951`	`+`
`2948`	`2952`	`fn a_is_expected(&self) -> bool {`
`2949`	`2953`	`true`
`2950`	`2954`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,10 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {`
`34`	`34`	`self.fields.tcx()`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ fn fast_equate_combine(&self) -> bool {`
	`38`	`+ true`
	`39`	`+ }`
	`40`	`+`
`37`	`41`	`fn param_env(&self) -> ty::ParamEnv<'tcx> {`
`38`	`42`	`self.fields.param_env`
`39`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -535,6 +535,10 @@ where`
`535`	`535`	`self.delegate.param_env()`
`536`	`536`	`}`
`537`	`537`
	`538`	`+ fn fast_equate_combine(&self) -> bool {`
	`539`	`+ false`
	`540`	`+ }`
	`541`	`+`
`538`	`542`	`fn tag(&self) -> &'static str {`
`539`	`543`	`"nll::subtype"`
`540`	`544`	`}`
`@@ -901,6 +905,10 @@ where`
`901`	`905`	`self.delegate.param_env()`
`902`	`906`	`}`
`903`	`907`
	`908`	`+ fn fast_equate_combine(&self) -> bool {`
	`909`	`+ false`
	`910`	`+ }`
	`911`	`+`
`904`	`912`	`fn tag(&self) -> &'static str {`
`905`	`913`	`"nll::generalizer"`
`906`	`914`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,10 @@ impl<'tcx> TypeRelation<'tcx> for Sub<'_, '_, 'tcx> {`
`43`	`43`	`self.fields.param_env`
`44`	`44`	`}`
`45`	`45`
	`46`	`+ fn fast_equate_combine(&self) -> bool {`
	`47`	`+ true`
	`48`	`+ }`
	`49`	`+`
`46`	`50`	`fn a_is_expected(&self) -> bool {`
`47`	`51`	`self.a_is_expected`
`48`	`52`	`}`