Bring #31486 and #31586 into release-3.5 (#31634)

* Defer union or intersection property type normalization (#31486)

* Defer union or intersection property type normalization

* Accept moved span

* Update user baselines (#31615)

* Cache widened types (#31586)

* Cache widened types

* Fix lint

* Accept LKG

Author: weswigham

lib/tsc.js

@@ -30321,7 +30321,19 @@ var ts;
             }
             return anyType;
         }
+        function getTypeOfSymbolWithDeferredType(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                ts.Debug.assertDefined(links.deferralParent);
+                ts.Debug.assertDefined(links.deferralConstituents);
+                links.type = links.deferralParent.flags & 1048576 ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents);
+            }
+            return links.type;
+        }
         function getTypeOfSymbol(symbol) {
+            if (ts.getCheckFlags(symbol) & 65536) {
+                return getTypeOfSymbolWithDeferredType(symbol);
+            }
             if (ts.getCheckFlags(symbol) & 1) {
                 return getTypeOfInstantiatedSymbol(symbol);
             }
@@ -32062,7 +32074,14 @@ var ts;
             }
             result.declarations = declarations;
             result.nameType = nameType;
-            result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
+            if (propTypes.length > 2) {
+                result.checkFlags |= 65536;
+                result.deferralParent = containingType;
+                result.deferralConstituents = propTypes;
+            }
+            else {
+                result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
+            }
             return result;
         }
         function getUnionOrIntersectionProperty(type, name) {
@@ -35596,8 +35615,8 @@ var ts;
             }
             return false;
         }
-        function isIgnoredJsxProperty(source, sourceProp, targetMemberType) {
-            return ts.getObjectFlags(source) & 4096 && !(isUnhyphenatedJsxName(sourceProp.escapedName) || targetMemberType);
+        function isIgnoredJsxProperty(source, sourceProp) {
+            return ts.getObjectFlags(source) & 4096 && !isUnhyphenatedJsxName(sourceProp.escapedName);
         }
         function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
             var errorInfo;
@@ -36546,6 +36565,43 @@ var ts;
                 }
                 return result || properties;
             }
+            function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors) {
+                var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48);
+                var source = getTypeOfSourceProperty(sourceProp);
+                if (ts.getCheckFlags(targetProp) & 65536 && !getSymbolLinks(targetProp).type) {
+                    var links = getSymbolLinks(targetProp);
+                    ts.Debug.assertDefined(links.deferralParent);
+                    ts.Debug.assertDefined(links.deferralConstituents);
+                    var unionParent = !!(links.deferralParent.flags & 1048576);
+                    var result_6 = unionParent ? 0 : -1;
+                    var targetTypes = links.deferralConstituents;
+                    for (var _i = 0, targetTypes_3 = targetTypes; _i < targetTypes_3.length; _i++) {
+                        var targetType = targetTypes_3[_i];
+                        var related = isRelatedTo(source, targetType, false, undefined, !unionParent);
+                        if (!unionParent) {
+                            if (!related) {
+                                return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
+                            }
+                            result_6 &= related;
+                        }
+                        else {
+                            if (related) {
+                                return related;
+                            }
+                        }
+                    }
+                    if (unionParent && !result_6 && targetIsOptional) {
+                        result_6 = isRelatedTo(source, undefinedType);
+                    }
+                    if (unionParent && !result_6 && reportErrors) {
+                        return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
+                    }
+                    return result_6;
+                }
+                else {
+                    return isRelatedTo(source, addOptionality(getTypeOfSymbol(targetProp), targetIsOptional), reportErrors);
+                }
+            }
             function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors) {
                 var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp);
                 var targetPropFlags = ts.getDeclarationModifierFlagsFromSymbol(targetProp);
@@ -36583,7 +36639,7 @@ var ts;
                     }
                     return 0;
                 }
-                var related = isRelatedTo(getTypeOfSourceProperty(sourceProp), addOptionality(getTypeOfSymbol(targetProp), !!(ts.getCheckFlags(targetProp) & 48)), reportErrors);
+                var related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors);
                 if (!related) {
                     if (reportErrors) {
                         reportError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
@@ -36684,9 +36740,6 @@ var ts;
                     if (!(targetProp.flags & 4194304)) {
                         var sourceProp = getPropertyOfType(source, targetProp.escapedName);
                         if (sourceProp && sourceProp !== targetProp) {
-                            if (isIgnoredJsxProperty(source, sourceProp, getTypeOfSymbol(targetProp))) {
-                                continue;
-                            }
                             var related = propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSymbol, reportErrors);
                             if (!related) {
                                 return 0;
@@ -36805,7 +36858,7 @@ var ts;
                 var result = -1;
                 for (var _i = 0, _a = getPropertiesOfObjectType(source); _i < _a.length; _i++) {
                     var prop = _a[_i];
-                    if (isIgnoredJsxProperty(source, prop, undefined)) {
+                    if (isIgnoredJsxProperty(source, prop)) {
                         continue;
                     }
                     if (prop.nameType && prop.nameType.flags & 8192) {
@@ -37494,23 +37547,31 @@ var ts;
         }
         function getWidenedTypeWithContext(type, context) {
             if (ts.getObjectFlags(type) & 393216) {
+                if (context === undefined && type.widened) {
+                    return type.widened;
+                }
+                var result = void 0;
                 if (type.flags & 98304) {
-                    return anyType;
+                    result = anyType;
                 }
-                if (isObjectLiteralType(type)) {
-                    return getWidenedTypeOfObjectLiteral(type, context);
+                else if (isObjectLiteralType(type)) {
+                    result = getWidenedTypeOfObjectLiteral(type, context);
                 }
-                if (type.flags & 1048576) {
+                else if (type.flags & 1048576) {
                     var unionContext_1 = context || createWideningContext(undefined, undefined, type.types);
                     var widenedTypes = ts.sameMap(type.types, function (t) { return t.flags & 98304 ? t : getWidenedTypeWithContext(t, unionContext_1); });
-                    return getUnionType(widenedTypes, ts.some(widenedTypes, isEmptyObjectType) ? 2 : 1);
+                    result = getUnionType(widenedTypes, ts.some(widenedTypes, isEmptyObjectType) ? 2 : 1);
+                }
+                else if (type.flags & 2097152) {
+                    result = getIntersectionType(ts.sameMap(type.types, getWidenedType));
                 }
-                if (type.flags & 2097152) {
-                    return getIntersectionType(ts.sameMap(type.types, getWidenedType));
+                else if (isArrayType(type) || isTupleType(type)) {
+                    result = createTypeReference(type.target, ts.sameMap(type.typeArguments, getWidenedType));
                 }
-                if (isArrayType(type) || isTupleType(type)) {
-                    return createTypeReference(type.target, ts.sameMap(type.typeArguments, getWidenedType));
+                if (result && context === undefined) {
+                    type.widened = result;
                 }
+                return result || type;
             }
             return type;
         }
@@ -45984,10 +46045,10 @@ var ts;
                     case 249:
                     case 252:
                     case 251:
-                        var result_6 = 0;
+                        var result_7 = 0;
                         var target = resolveAlias(getSymbolOfNode(d));
-                        ts.forEach(target.declarations, function (d) { result_6 |= getDeclarationSpaces(d); });
-                        return result_6;
+                        ts.forEach(target.declarations, function (d) { result_7 |= getDeclarationSpaces(d); });
+                        return result_7;
                     case 238:
                     case 187:
                     case 240:
@@ -73263,13 +73324,13 @@ var ts;
             }
             var oldSourceFile = oldProgram && oldProgram.getSourceFile(containingFile);
             if (oldSourceFile !== file && file.resolvedModules) {
-                var result_7 = [];
+                var result_8 = [];
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
                     var resolvedModule = file.resolvedModules.get(moduleName);
-                    result_7.push(resolvedModule);
+                    result_8.push(resolvedModule);
                 }
-                return result_7;
+                return result_8;
             }
             var unknownModuleNames;
             var result;