Detect comparisons between large unions or intersections

If their multiplied size is greater than 1E7 (chosen based on the repro
in microsoft#41517), then we'll expend a large amount of time and memory
comparing them, so alert the user instead.

Fixes microsoft#41517

Author: amcasey

src/compiler/checker.ts

@@ -16889,10 +16889,9 @@ namespace ts {
                 if (source === target) return Ternary.True;
 
                 if (relation === identityRelation) {
-                    return isIdenticalTo(source, target);
+                    return isIdenticalTo(source, target, reportErrors);
                 }
 
-
                 // We fastpath comparing a type parameter to exactly its constraint, as this is _super_ common,
                 // and otherwise, for type parameters in large unions, causes us to need to compare the union to itself,
                 // as we break down the _target_ union first, _then_ get the source constraint - so for every
@@ -16953,6 +16952,10 @@ namespace ts {
                     return Ternary.False;
                 }
 
+                if (areUnionsOrIntersectionsTooLarge(source, target, reportErrors)) {
+                    return Ternary.False;
+                }
+
                 let result = Ternary.False;
                 const saveErrorInfo = captureErrorCalculationState();
 
@@ -17088,11 +17091,30 @@ namespace ts {
                 }
             }
 
-            function isIdenticalTo(source: Type, target: Type): Ternary {
+            function areUnionsOrIntersectionsTooLarge(source: Type, target: Type, reportErrors: boolean) {
+                if ((source.flags & TypeFlags.UnionOrIntersection) && (target.flags & TypeFlags.UnionOrIntersection)) {
+                    const sourceSize = (source as UnionOrIntersectionType).types.length;
+                    const targetSize = (target as UnionOrIntersectionType).types.length;
+                    if (sourceSize * targetSize > 1E7) {
+                        if (reportErrors) {
+                            tracing.instant(tracing.Phase.CheckTypes, "areUnionsOrIntersectionsTooLarge_DepthLimit", { sourceId: source.id, sourceSize, targetId: target.id, targetSize });
+                            reportError(Diagnostics.Expression_requires_comparison_of_excessively_large_unions_or_intersections);
+                        }
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            function isIdenticalTo(source: Type, target: Type, reportErrors: boolean): Ternary {
                 const flags = source.flags & target.flags;
                 if (!(flags & TypeFlags.Substructure)) {
                     return Ternary.False;
                 }
+                if (areUnionsOrIntersectionsTooLarge(source, target, reportErrors)) {
+                    return Ternary.False;
+                }
                 if (flags & TypeFlags.UnionOrIntersection) {
                     let result = eachTypeRelatedToSomeType(<UnionOrIntersectionType>source, <UnionOrIntersectionType>target);
                     if (result) {

src/compiler/diagnosticMessages.json

@@ -3211,6 +3211,10 @@
         "category": "Error",
         "code": 2796
     },
+    "Expression requires comparison of excessively large unions or intersections.": {
+        "category": "Error",
+        "code": 2797
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",