Backport PR #19010: Type relations cache: Add a failsafe in case of infinite types (#19022)

Author: T-Gro

src/Compiler/Checking/TypeRelations.fs

@@ -28,8 +28,12 @@ type CanCoerce =
 [<Struct; NoComparison>]
 type TTypeCacheKey =
     | TTypeCacheKey of TypeStructure * TypeStructure * CanCoerce
-    static member FromStrippedTypes(ty1, ty2, canCoerce) =
-        TTypeCacheKey(getTypeStructure ty1, getTypeStructure ty2, canCoerce)
+    static member TryGetFromStrippedTypes(ty1, ty2, canCoerce) =
+        let t1, t2 = getTypeStructure ty1, getTypeStructure ty2
+        if t1.IsPossiblyInfinite || t2.IsPossiblyInfinite then
+            ValueNone
+        else
+            ValueSome (TTypeCacheKey(t1, t2, canCoerce))
 
 let getTypeSubsumptionCache =
     let factory (g: TcGlobals) =
@@ -157,8 +161,10 @@ let rec TypeFeasiblySubsumesType ndeep (g: TcGlobals) (amap: ImportMap) m (ty1:
                     List.exists (TypeFeasiblySubsumesType (ndeep + 1) g amap m ty1 NoCoerce) interfaces
 
     if g.langVersion.SupportsFeature LanguageFeature.UseTypeSubsumptionCache then
-        let key = TTypeCacheKey.FromStrippedTypes(ty1, ty2, canCoerce)
-        (getTypeSubsumptionCache g).GetOrAdd(key, fun _ -> checkSubsumes ty1 ty2)
+        match TTypeCacheKey.TryGetFromStrippedTypes(ty1, ty2, canCoerce) with
+        | ValueSome key ->
+            (getTypeSubsumptionCache g).GetOrAdd(key, fun _ -> checkSubsumes ty1 ty2)
+        | _ -> checkSubsumes ty1 ty2
     else
         checkSubsumes ty1 ty2
 

src/Compiler/Utilities/TypeHashing.fs

@@ -401,7 +401,9 @@ module StructuralUtilities =
         | MeasureRational of int * int
         | NeverEqual of never: NeverEqual
 
-    type TypeStructure = TypeStructure of ImmutableArray<TypeToken>
+    type TypeStructure =
+        | TypeStructure of TypeToken[]
+        | PossiblyInfinite of never: NeverEqual
 
     let inline toNullnessToken (n: Nullness) =
         match n.TryEvaluate() with
@@ -464,6 +466,15 @@ module StructuralUtilities =
             | TType_measure m -> yield! accumulateMeasure m
         }
 
+    // If the sequence got too long, just drop it, we could be dealing with an infinite type.
+    let private toTypeStructure tokens =
+        let tokens = tokens |> Seq.truncate 256 |> Array.ofSeq
+
+        if tokens.Length = 256 then
+            PossiblyInfinite NeverEqual.Singleton
+        else
+            TypeStructure tokens
+
     /// Get the full structure of a type as a sequence of tokens, suitable for equality
     let getTypeStructure =
-        Extras.WeakMap.getOrCreate (fun ty -> accumulateTType ty |> ImmutableArray.ofSeq |> TypeStructure)
+        Extras.WeakMap.getOrCreate (fun ty -> accumulateTType ty |> toTypeStructure)