tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/checker-type-operators.d.ts

@@ -107,3 +107,5 @@ export declare function isMemberOfStringMapping(c: Checker, source: Type, target
 export type { TupleType, UnionType };
 /** The generic mapped type an instantiated mapped type came from, or the type itself. */
 export declare function mappedTypeTarget(t: MappedType): MappedType;
+/** The key of the member of a conditional type instantiation's distribution for one constituent (shared-results.ts). */
+export declare function distributedKey(root: number, typeArguments: readonly Type[], alias: TypeAlias | undefined, tag: number, constituent: Type): string;

package/dist/api/compiler/checker-type-operators.js

@@ -5,9 +5,9 @@ import { getTypeOfPropertyOfContextualType } from './checker-contextual.js';
 import { checkDeprecatedIndexedAccess } from './checker-deprecation.js';
 import { isSelfTypeAccess, markPropertyAsReferenced } from './checker-unused.js';
 import { getName, getQuestionToken, getType, getSymbol, getDotDotDotToken, getElements, getExpression, getText, } from './ast.js';
-import { cachedTypeKey, ConditionalRoot, ConditionalType, IndexInfo, StringMappingType, appendTypeMapping, prependTypeMapping, newTypeMapper, ReferenceArgs, } from './checker-types.js';
+import { cachedTypeKey, ConditionalRoot, ConditionalType, IndexInfo, ConditionalResultKey, DistributedConditional, StringMappingType, appendTypeMapping, prependTypeMapping, newTypeMapper, ReferenceArgs, getMappedType, getNonDistributedTypeParameter, } from './checker-types.js';
 import { aliasKey, createArrayTypeEx, createTupleTypeEx, everyType, filterType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getRegularTypeOfLiteralType, getStringLiteralType, getTemplateLiteralType, getTotalFixedElementCount, getTypeArguments, getUnionType, getUnionTypeEx, isArrayType, isEmptyAnonymousObjectType, isErrorType, isGenericStringLikeType, isGenericTupleType, isPatternLiteralType, isReadonlyArrayType, isTupleType, mapType, mapTypeEx, intersectTypes, mapTypeWithAlias, newIndexType, newIndexedAccessType, newObjectType, newSubstitutionType, setStructuredTypeMembers, someType, tupleTargetOf, typeListKey, typesOf, typeListHash, } from './checker-type-factory.js';
-import { appendIndexInfo, getApparentType, getApplicableIndexInfo, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getPropertyOfObjectType, getIndexInfosOfType, getPropertiesOfType, getPropertyOfType, getReducedApparentType, getReducedType, getBaseConstraintOfType, getIndexTypeOfType, hasPropertiesOfType, keepPropertiesOnly, memberResolutionFlags, } from './checker-members.js';
+import { appendIndexInfo, getApparentType, getApplicableIndexInfo, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getPropertyOfObjectType, getIndexInfosOfType, getPropertiesOfType, getPropertyOfType, getReducedApparentType, getReducedType, getBaseConstraintOfType, getIndexTypeOfType, hasPropertiesOfType, keepPropertiesOnly, } from './checker-members.js';
 import { getLateBoundSymbol, getSymbolOfDeclaration, popTypeResolution, pushTypeResolution, getParentOfSymbol, findResolutionCycleStartIndex, getFullyQualifiedName, } from './checker-symbols.js';
 import { getConstraintOfTypeParameter, getDeclaredTypeOfTypeParameter, getElementTypeOfArrayType, getInferTypeParameters, getOuterTypeParameters, hasNonCircularBaseConstraint, } from './checker-declared-types.js';
 import { addOptionality, getOptionalType, getTypeOfSymbol, getWriteTypeOfSymbol, isReadonlySymbol, removeMissingOrUndefinedType, } from './checker-symbol-types.js';
@@ -144,12 +144,7 @@ function getIndexTypeForGenericType(c, t, indexFlags) {
     return indexType;
 }
 export function getLiteralTypeFromProperties(c, t, include, includeOrigin) {
-    const key = 'props' +
-        t.id +
-        ':' +
-        include +
-        (includeOrigin ? 'o' : '') +
-        ((memberResolutionFlags(c, t) & 536870912 /* ObjectFlags.UnresolvedMembers */) !== 0 ? 'u' : '');
+    const key = 'props' + t.id + ':' + include + (includeOrigin ? 'o' : '');
     const cached = c.cachedTypes.get(key);
     if (cached !== undefined)
         return cached;
@@ -198,13 +193,13 @@ export function getLiteralTypeFromPropertyName(c, name) {
         return c.neverType;
     if (name.kind === 8 /* SyntaxKind.NumericLiteral */)
         return getRegularTypeOfLiteralType(c, checkExpression(c, name));
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         return getRegularTypeOfLiteralType(c, checkComputedPropertyName(c, name));
     if (name.kind === 79 /* SyntaxKind.Identifier */ ||
         name.kind === 10 /* SyntaxKind.StringLiteral */ ||
         name.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */)
         return getStringLiteralType(c, getText(name));
-    if (name.kind === 296 /* SyntaxKind.JsxNamespacedName */)
+    if (name.kind === 297 /* SyntaxKind.JsxNamespacedName */)
         return getStringLiteralType(c, nodeText(name));
     if (name.kind === 9 /* SyntaxKind.BigIntLiteral */)
         return getRegularTypeOfLiteralType(c, checkExpression(c, name));
@@ -352,6 +347,8 @@ export function getIndexedAccessTypeOrUndefinedEx(c, objectType, indexType, acce
         let t = c.indexedAccessTypes.get(key);
         if (t === undefined) {
             t = newIndexedAccessType(c, objectType, indexType, persistent);
+            if (c.indexedAccessKeyFlags !== undefined)
+                c.indexedAccessKeyFlags.set(t, accessFlags);
             t.alias = alias;
             c.indexedAccessTypes.set(key, t);
         }
@@ -382,7 +379,7 @@ export function getIndexedAccessTypeOrUndefinedEx(c, objectType, indexType, acce
 function shouldDeferIndexedAccessType(c, objectType, indexType, accessNode) {
     if (isGenericIndexType(c, indexType))
         return true;
-    if (accessNode !== undefined && accessNode.kind !== 200 /* SyntaxKind.IndexedAccessType */)
+    if (accessNode !== undefined && accessNode.kind !== 201 /* SyntaxKind.IndexedAccessType */)
         return (isGenericTupleType(objectType) &&
             !indexTypeLessThan(indexType, getTotalFixedElementCount(tupleTargetOf(objectType))));
     return ((isGenericObjectType(c, objectType) &&
@@ -439,7 +436,7 @@ export function getPropertyNameFromIndex(indexType) {
 }
 /** The type of the property `indexType` selects; reporting of access errors happens in element access checks. */
 function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexType, fullIndexType, accessNode, accessFlags) {
-    const accessExpression = accessNode !== undefined && accessNode.kind === 213 /* SyntaxKind.ElementAccessExpression */ ? accessNode : undefined;
+    const accessExpression = accessNode !== undefined && accessNode.kind === 214 /* SyntaxKind.ElementAccessExpression */ ? accessNode : undefined;
     const propName = accessNode !== undefined && accessNode.kind === 80 /* SyntaxKind.PrivateIdentifier */
         ? undefined
         : getPropertyNameFromIndex(indexType);
@@ -454,7 +451,7 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
             if (accessExpression !== undefined) {
                 markPropertyAsReferenced(c, prop, accessExpression, isSelfTypeAccess(c, getExpression(accessExpression), objectType.symbol));
                 if (isAssignmentToReadonlyEntity(c, accessExpression, prop, getAssignmentTargetKind(accessExpression))) {
-                    c.error(accessExpression.argumentExpression, 697 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property */, isLateBoundName(prop.name) ? symbolToString(c, prop) : prop.name);
+                    c.error(accessExpression.argumentExpression, 704 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property */, isLateBoundName(prop.name) ? symbolToString(c, prop) : prop.name);
                     return undefined;
                 }
                 if ((accessFlags & 8 /* AccessFlags.CacheSymbol */) !== 0)
@@ -466,7 +463,7 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
             // Each property an element access reads is narrowed by itself, as a reference to that property.
             if (accessExpression !== undefined && getAssignmentTargetKind(accessExpression) !== 1 /* AssignmentKind.Definite */)
                 return getFlowTypeOfReference(c, accessExpression, propType, propType, undefined);
-            if (accessNode !== undefined && accessNode.kind === 200 /* SyntaxKind.IndexedAccessType */ && containsMissing(c, propType))
+            if (accessNode !== undefined && accessNode.kind === 201 /* SyntaxKind.IndexedAccessType */ && containsMissing(c, propType))
                 return getUnionType(c, [propType, c.undefinedType]);
             return propType;
         }
@@ -478,13 +475,13 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
                 const indexNode = getIndexNodeForAccessExpression(accessNode);
                 if (isTupleType(objectType)) {
                     if (index < 0) {
-                        c.error(indexNode, 674 /* Diagnostics.A_tuple_type_cannot_be_indexed_with_a_negative_value */);
+                        c.error(indexNode, 681 /* Diagnostics.A_tuple_type_cannot_be_indexed_with_a_negative_value */);
                         return c.undefinedType;
                     }
-                    c.error(indexNode, 653 /* Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2 */, typeToString(c, objectType), String(tupleTargetOf(objectType).typeParameterCount()), propName);
+                    c.error(indexNode, 660 /* Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2 */, typeToString(c, objectType), String(tupleTargetOf(objectType).typeParameterCount()), propName);
                 }
                 else
-                    c.error(indexNode, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, typeToString(c, objectType));
+                    c.error(indexNode, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, typeToString(c, objectType));
             }
             if (index >= 0) {
                 errorIfWritingToReadonlyIndex(c, getIndexInfoOfType(c, objectType, c.numberType), objectType, accessExpression);
@@ -502,16 +499,16 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
             if ((accessFlags & 2 /* AccessFlags.NoIndexSignatures */) !== 0 && indexInfo.keyType !== c.numberType) {
                 if (accessExpression !== undefined) {
                     if ((accessFlags & 4 /* AccessFlags.Writing */) !== 0)
-                        c.error(accessExpression, 982 /* Diagnostics.Type_0_is_generic_and_can_only_be_indexed_for_reading */, typeToString(c, originalObjectType));
+                        c.error(accessExpression, 989 /* Diagnostics.Type_0_is_generic_and_can_only_be_indexed_for_reading */, typeToString(c, originalObjectType));
                     else
-                        c.error(accessExpression, 693 /* Diagnostics.Type_0_cannot_be_used_to_index_type_1 */, typeToString(c, indexType), typeToString(c, originalObjectType));
+                        c.error(accessExpression, 700 /* Diagnostics.Type_0_cannot_be_used_to_index_type_1 */, typeToString(c, indexType), typeToString(c, originalObjectType));
                 }
                 return undefined;
             }
             if (accessNode !== undefined &&
                 indexInfo.keyType === c.stringType &&
                 !isTypeAssignableToKind(c, indexType, 32 /* TypeFlags.String */ | 64 /* TypeFlags.Number */)) {
-                c.error(getIndexNodeForAccessExpression(accessNode), 695 /* Diagnostics.Type_0_cannot_be_used_as_an_index_type */, typeToString(c, indexType));
+                c.error(getIndexNodeForAccessExpression(accessNode), 702 /* Diagnostics.Type_0_cannot_be_used_as_an_index_type */, typeToString(c, indexType));
                 return (accessFlags & 1 /* AccessFlags.IncludeUndefined */) !== 0
                     ? getUnionType(c, [indexInfo.valueType, c.missingType])
                     : indexInfo.valueType;
@@ -534,7 +531,7 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
         if (accessExpression !== undefined && !isConstEnumObjectType(objectType)) {
             if (isObjectLiteralType(objectType)) {
                 if (c.noImplicitAny && (indexType.flags & (1024 /* TypeFlags.StringLiteral */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0) {
-                    c.error(accessExpression, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, getPropertyNameFromType(indexType), typeToString(c, objectType));
+                    c.error(accessExpression, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, getPropertyNameFromType(indexType), typeToString(c, objectType));
                     return c.undefinedType;
                 }
                 if ((indexType.flags & (64 /* TypeFlags.Number */ | 32 /* TypeFlags.String */)) !== 0) {
@@ -549,42 +546,42 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
                 ? c.globalThisSymbol.exports?.get(propName)
                 : undefined;
             if (globalSymbol !== undefined && (globalSymbol.flags & 418 /* SymbolFlags.BlockScoped */) !== 0)
-                c.error(accessExpression, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, typeToString(c, objectType));
+                c.error(accessExpression, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, typeToString(c, objectType));
             else if (c.noImplicitAny && (accessFlags & 128 /* AccessFlags.SuppressNoImplicitAnyError */) === 0) {
                 const argument = accessExpression.argumentExpression;
                 const objectText = typeToString(c, objectType);
                 const suggestion = propName !== undefined ? getSuggestionForNonexistentProperty(c, propName, objectType) : undefined;
                 if (propName !== undefined && typeHasStaticProperty(c, propName, objectType))
-                    c.error(accessExpression, 727 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead */, propName, objectText, objectText + '[' + getTextOfNodeFromSourceText(getSourceFileOfNode(argument).text, argument) + ']');
+                    c.error(accessExpression, 734 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead */, propName, objectText, objectText + '[' + getTextOfNodeFromSourceText(getSourceFileOfNode(argument).text, argument) + ']');
                 else if (getIndexTypeOfType(c, objectType, c.numberType) !== undefined)
-                    c.error(argument, 1687 /* Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number */);
+                    c.error(argument, 1706 /* Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number */);
                 else if (suggestion !== undefined)
-                    c.error(argument, 706 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, propName, objectText, suggestion.name);
+                    c.error(argument, 713 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, propName, objectText, suggestion.name);
                 else {
                     const methodSuggestion = getSuggestionForNonexistentIndexSignature(c, objectType, accessExpression, indexType);
                     if (methodSuggestion !== '') {
-                        c.error(accessExpression, 1723 /* Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1 */, objectText, methodSuggestion);
+                        c.error(accessExpression, 1742 /* Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1 */, objectText, methodSuggestion);
                         return undefined;
                     }
                     let head = undefined;
                     if ((indexType.flags & 32768 /* TypeFlags.EnumLiteral */) !== 0)
-                        head = createDiagnosticForNode(accessExpression, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                        head = createDiagnosticForNode(accessExpression, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                             '[' + typeToString(c, indexType) + ']',
                             objectText,
                         ]);
                     else if ((indexType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
-                        head = createDiagnosticForNode(accessExpression, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                        head = createDiagnosticForNode(accessExpression, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                             '[' + getFullyQualifiedName(c, indexType.symbol, accessExpression) + ']',
                             objectText,
                         ]);
                     else if ((indexType.flags & (1024 /* TypeFlags.StringLiteral */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0)
-                        head = createDiagnosticForNode(accessExpression, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                        head = createDiagnosticForNode(accessExpression, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                             getPropertyNameFromType(indexType),
                             objectText,
                         ]);
                     else if ((indexType.flags & (64 /* TypeFlags.Number */ | 32 /* TypeFlags.String */)) !== 0)
-                        head = createDiagnosticForNode(accessExpression, 1725 /* Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1 */, [typeToString(c, indexType), objectText]);
-                    const diagnostic = createDiagnosticForNode(accessExpression, 1724 /* Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1 */, [typeToString(c, fullIndexType), objectText]);
+                        head = createDiagnosticForNode(accessExpression, 1744 /* Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1 */, [typeToString(c, indexType), objectText]);
+                    const diagnostic = createDiagnosticForNode(accessExpression, 1743 /* Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1 */, [typeToString(c, fullIndexType), objectText]);
                     if (head !== undefined)
                         diagnostic.addMessageChain(head);
                     c.addDiagnostic(diagnostic);
@@ -601,11 +598,11 @@ function getPropertyTypeForIndexType(c, originalObjectType, objectType, indexTyp
         const indexNode = getIndexNodeForAccessExpression(accessNode);
         if (indexNode.kind !== 9 /* SyntaxKind.BigIntLiteral */ &&
             (indexType.flags & (1024 /* TypeFlags.StringLiteral */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0)
-            c.error(indexNode, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, getPropertyNameFromType(indexType), typeToString(c, objectType));
+            c.error(indexNode, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, getPropertyNameFromType(indexType), typeToString(c, objectType));
         else if ((indexType.flags & (32 /* TypeFlags.String */ | 64 /* TypeFlags.Number */)) !== 0)
-            c.error(indexNode, 694 /* Diagnostics.Type_0_has_no_matching_index_signature_for_type_1 */, typeToString(c, objectType), typeToString(c, indexType));
+            c.error(indexNode, 701 /* Diagnostics.Type_0_has_no_matching_index_signature_for_type_1 */, typeToString(c, objectType), typeToString(c, indexType));
         else
-            c.error(indexNode, 695 /* Diagnostics.Type_0_cannot_be_used_as_an_index_type */, indexNode.kind === 9 /* SyntaxKind.BigIntLiteral */ ? 'bigint' : typeToString(c, indexType));
+            c.error(indexNode, 702 /* Diagnostics.Type_0_cannot_be_used_as_an_index_type */, indexNode.kind === 9 /* SyntaxKind.BigIntLiteral */ ? 'bigint' : typeToString(c, indexType));
     }
     if ((indexType.flags & 1 /* TypeFlags.Any */) !== 0)
         return indexType;
@@ -616,7 +613,7 @@ function errorIfWritingToReadonlyIndex(c, indexInfo, objectType, accessExpressio
         indexInfo.isReadonly &&
         accessExpression !== undefined &&
         (isAssignmentTarget(accessExpression) || isDeleteTarget(accessExpression)))
-        c.error(accessExpression, 698 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, objectType));
+        c.error(accessExpression, 705 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, objectType));
 }
 /** `obj.get` or `obj.set` for keyed access to a type with such methods instead of an index signature. */
 function getSuggestionForNonexistentIndexSignature(c, objectType, expr, keyedType) {
@@ -632,7 +629,7 @@ function getSuggestionForNonexistentIndexSignature(c, objectType, expr, keyedTyp
     const target = getExpression(expr);
     if (target.kind === 79 /* SyntaxKind.Identifier */)
         return getText(target) + '.' + suggestedMethod;
-    if (target.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && isEntityNameExpression(target, false))
+    if (target.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && isEntityNameExpression(target, false))
         return getTextOfNodeFromSourceText(getSourceFileOfNode(target).text, target) + '.' + suggestedMethod;
     return suggestedMethod;
 }
@@ -648,11 +645,11 @@ function containsMissing(c, t) {
     return t === c.missingType || ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && typesOf(t)[0] === c.missingType);
 }
 function getIndexNodeForAccessExpression(accessNode) {
-    if (accessNode.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+    if (accessNode.kind === 214 /* SyntaxKind.ElementAccessExpression */)
         return accessNode.argumentExpression;
-    if (accessNode.kind === 200 /* SyntaxKind.IndexedAccessType */)
+    if (accessNode.kind === 201 /* SyntaxKind.IndexedAccessType */)
         return accessNode.indexType;
-    if (accessNode.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (accessNode.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         return getExpression(accessNode);
     return accessNode;
 }
@@ -771,10 +768,30 @@ export function getSimplifiedType(c, t, writing) {
         return getSimplifiedIndexedAccessType(c, t, writing);
     if ((t.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
         return getSimplifiedConditionalType(c, t, writing);
+    if ((t.flags & 2097152 /* TypeFlags.Index */) !== 0)
+        return getSimplifiedIndexType(c, t);
+    return t;
+}
+/** Simplifies `keyof` a generic mapped type with an `as` clause to the type of the keys it produces. */
+function getSimplifiedIndexType(c, t) {
+    const target = t.target;
+    if (isGenericMappedType(c, target) &&
+        getNameTypeFromMappedType(c, target) !== undefined &&
+        !isMappedTypeWithKeyofConstraintDeclaration(c, target))
+        return getIndexForMappedType(c, target, 0 /* IndexFlags.None */);
     return t;
 }
 /** Simplifies `T extends U ? T : never` and `T extends U ? never : T` when the outcome is known. */
 function getSimplifiedConditionalType(c, t, writing) {
+    const key = cachedTypeKey(writing ? 19 /* CachedTypeKind.SimplifiedConditionalForWriting */ : 18 /* CachedTypeKind.SimplifiedConditionalForReading */, t.id);
+    const cached = c.cachedTypesById.get(key);
+    if (cached !== undefined)
+        return cached;
+    const result = getSimplifiedConditionalTypeWorker(c, t, writing);
+    c.cachedTypesById.set(key, result);
+    return result;
+}
+function getSimplifiedConditionalTypeWorker(c, t, writing) {
     const checkType = t.checkType;
     const extendsType = t.extendsType;
     const trueType = getTrueTypeFromConditionalType(c, t);
@@ -1052,7 +1069,7 @@ function getConstraintDeclarationForMappedType(t) {
 export function isMappedTypeWithKeyofConstraintDeclaration(c, t) {
     const constraint = getConstraintDeclarationForMappedType(t);
     return (constraint !== undefined &&
-        constraint.kind === 199 /* SyntaxKind.TypeOperator */ &&
+        constraint.kind === 200 /* SyntaxKind.TypeOperator */ &&
         constraint.operator === 143 /* SyntaxKind.KeyOfKeyword */);
 }
 export function getModifiersTypeFromMappedType(c, t) {
@@ -1065,7 +1082,9 @@ export function getModifiersTypeFromMappedType(c, t) {
         else {
             const declaredType = getTypeFromMappedTypeNode(c, t.declaration);
             const constraint = getConstraintTypeFromMappedType(c, declaredType);
-            const extended = (constraint.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 ? getConstraintOfTypeParameter(c, constraint) : constraint;
+            const extended = (constraint.flags & 524288 /* TypeFlags.TypeParameter */) !== 0
+                ? getConstraintOfTypeParameter(c, getNonDistributedTypeParameter(constraint))
+                : constraint;
             side.modifiersType =
                 extended !== undefined && (extended.flags & 2097152 /* TypeFlags.Index */) !== 0
                     ? instantiateType(c, extended.target, t.mapper)
@@ -1088,11 +1107,12 @@ export function getActualTypeVariable(c, t) {
         return getActualTypeVariable(c, t.baseType);
     if ((t.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
         const access = t;
-        if ((access.objectType.flags & 16777216 /* TypeFlags.Substitution */) !== 0 ||
-            (access.indexType.flags & 16777216 /* TypeFlags.Substitution */) !== 0)
-            return getIndexedAccessType(c, getActualTypeVariable(c, access.objectType), getActualTypeVariable(c, access.indexType));
+        const objectType = getActualTypeVariable(c, access.objectType);
+        const indexType = getActualTypeVariable(c, access.indexType);
+        if (objectType !== access.objectType || indexType !== access.indexType)
+            return getIndexedAccessType(c, objectType, indexType);
     }
-    return t;
+    return getNonDistributedTypeParameter(t);
 }
 export function getMappedTypeNameTypeKind(c, t) {
     const nameType = getNameTypeFromMappedType(c, t);
@@ -1141,13 +1161,13 @@ export function resolveMappedTypeMembers(c, t) {
                 !isOptional &&
                 modifiersProp !== undefined &&
                 (modifiersProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0;
-            const lateFlag = modifiersProp !== undefined ? modifiersProp.checkFlags & 4096 /* CheckFlags.Late */ : 0;
+            const lateFlag = modifiersProp !== undefined ? modifiersProp.checkFlags & 32768 /* CheckFlags.Late */ : 0;
             const prop = c.newSymbol(4 /* SymbolFlags.Property */ | (isOptional ? 16777216 /* SymbolFlags.Optional */ : 0), propName);
             prop.checkFlags =
                 lateFlag |
-                    262144 /* CheckFlags.Mapped */ |
+                    2097152 /* CheckFlags.Mapped */ |
                     (isReadonly ? 8 /* CheckFlags.Readonly */ : 0) |
-                    (stripOptional ? 524288 /* CheckFlags.StripOptional */ : 0);
+                    (stripOptional ? 4194304 /* CheckFlags.StripOptional */ : 0);
             const symbolId = getSymbolId(prop);
             c.symbolContainingTypes.set(symbolId, t);
             c.symbolNameTypes.set(symbolId, propNameType);
@@ -1205,7 +1225,7 @@ export function getTypeOfMappedSymbol(c, symbol) {
         (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0 &&
         !maybeTypeOfKind(propType, 4 /* TypeFlags.Undefined */ | 16 /* TypeFlags.Void */))
         propType = getOptionalType(c, propType, true);
-    else if ((symbol.checkFlags & 524288 /* CheckFlags.StripOptional */) !== 0)
+    else if ((symbol.checkFlags & 4194304 /* CheckFlags.StripOptional */) !== 0)
         propType = removeMissingOrUndefinedType(c, propType);
     if (popTypeResolution(c)) {
         if (c.symbolTypes.get(id) === undefined)
@@ -1214,7 +1234,7 @@ export function getTypeOfMappedSymbol(c, symbol) {
     else {
         if (c.symbolTypes.get(id) === undefined)
             c.symbolTypes.set(id, c.errorType);
-        c.error(c.currentNode, 759 /* Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1 */, symbolToString(c, symbol), typeToString(c, mappedType));
+        c.error(c.currentNode, 766 /* Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1 */, symbolToString(c, symbol), typeToString(c, mappedType));
     }
     return c.symbolTypes.get(id);
 }
@@ -1329,7 +1349,7 @@ function instantiateMappedTypeTemplate(c, t, key, isOptional, mapper) {
         !maybeTypeOfKind(propType, 4 /* TypeFlags.Undefined */ | 16 /* TypeFlags.Void */))
         return getOptionalType(c, propType, true);
     if (c.strictNullChecks && (modifiers & 8 /* MappedTypeModifiers.ExcludeOptional */) !== 0 && isOptional)
-        return filterType(c, propType, (u) => (u.flags & 4 /* TypeFlags.Undefined */) === 0);
+        return removeMissingOrUndefinedType(c, propType);
     return propType;
 }
 export function instantiateReverseMappedType(c, t, mapper) {
@@ -1375,33 +1395,48 @@ export function getConditionalTypeInstantiation(c, t, mapper, forConstraint, ali
     if (result === undefined) {
         const newMapper = newTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
-        const distributionType = root.isDistributive ? getReducedType(c, newMapper.map(checkType)) : undefined;
+        const distributionType = root.isDistributive ? getReducedType(c, getMappedType(checkType, newMapper)) : undefined;
         // Distributive conditional types distribute over unions.
         if (distributionType !== undefined &&
             checkType !== distributionType &&
-            (distributionType.flags & (134217728 /* TypeFlags.Union */ | 262144 /* TypeFlags.Never */)) !== 0)
-            result = mapTypeWithAlias(c, distributionType, (u) => getConditionalType(c, root, prependTypeMapping(checkType, u, newMapper), forConstraint, undefined), alias);
+            (distributionType.flags & (134217728 /* TypeFlags.Union */ | 262144 /* TypeFlags.Never */)) !== 0) {
+            const distributed = c.distributedConditionals;
+            result = mapTypeWithAlias(c, distributionType, (u) => {
+                const member = getConditionalType(c, root, prependTypeMapping(checkType, u, newMapper), forConstraint, undefined);
+                // Sharing results (shared-results.ts) names a distributed member by the instantiation it is part of.
+                if (distributed !== undefined && (member.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+                    if (!distributed.has(member))
+                        distributed.set(member, new DistributedConditional(typeArguments.slice(), alias, tag, u));
+                    c.distributedByKey.set(distributedKey(root.node.id, typeArguments, alias, tag, u), member);
+                }
+                return member;
+            }, alias);
+        }
         else
             result = getConditionalType(c, root, newMapper, forConstraint, alias);
         root.instantiations.set(hash, typeArguments, alias, tag, result);
+        // Sharing results names a conditional type made for another root (a tail or nested root) by this instantiation.
+        const results = c.conditionalResults;
+        if (results !== undefined && (result.flags & 67108864 /* TypeFlags.Conditional */) !== 0 && !results.has(result))
+            results.set(result, new ConditionalResultKey(root, typeArguments.slice(), alias, tag));
     }
     return result;
 }
 function skipTypeParentheses(node) {
-    while (node.kind === 197 /* SyntaxKind.ParenthesizedType */)
+    while (node.kind === 198 /* SyntaxKind.ParenthesizedType */)
         node = getType(node);
     return node;
 }
 function isSimpleTupleType(node) {
-    if (node.kind !== 190 /* SyntaxKind.TupleType */)
+    if (node.kind !== 191 /* SyntaxKind.TupleType */)
         return false;
     const elements = getElements(node).nodes;
     if (elements.length === 0)
         return false;
     for (const e of elements) {
-        if (e.kind === 191 /* SyntaxKind.OptionalType */ || e.kind === 192 /* SyntaxKind.RestType */)
+        if (e.kind === 192 /* SyntaxKind.OptionalType */ || e.kind === 193 /* SyntaxKind.RestType */)
             return false;
-        if (e.kind === 203 /* SyntaxKind.NamedTupleMember */ &&
+        if (e.kind === 204 /* SyntaxKind.NamedTupleMember */ &&
             (getQuestionToken(e) !== undefined || getDotDotDotToken(e) !== undefined))
             return false;
     }
@@ -1434,7 +1469,7 @@ export function getConditionalType(c, root, mapper, forConstraint, alias) {
     // Loops over nested conditional types in the false branch and tail-recursive resolutions.
     for (;;) {
         if (tailCount === 1000) {
-            c.error(c.currentNode, 737 /* Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite */);
+            c.error(c.currentNode, 744 /* Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite */);
             return c.errorType;
         }
         const checkType = instantiateType(c, getActualTypeVariable(c, root.checkType), mapper);
@@ -1619,7 +1654,7 @@ function computeReferenceArgs(c, root) {
         (target.symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) === 0)
         return null;
     const node = skipTypeParentheses(conditionalNode(root).extendsType);
-    if (node.kind !== 184 /* SyntaxKind.TypeReference */)
+    if (node.kind !== 185 /* SyntaxKind.TypeReference */)
         return null;
     const argNodes = node.typeArguments?.nodes ?? [];
     const typeArgs = getTypeArguments(c, declared);
@@ -1642,7 +1677,7 @@ function computeReferenceArgs(c, root) {
         }
         if (kind === 3 /* ReferenceArgKind.Other */) {
             const inner = skipTypeParentheses(argNode);
-            if (inner.kind === 196 /* SyntaxKind.InferType */) {
+            if (inner.kind === 197 /* SyntaxKind.InferType */) {
                 const tp = root.inferTypeParameters.find((t) => t.symbol.declaration === inner.typeParameter);
                 if (tp !== undefined && declarationCount(tp.symbol) === 1 && !isReferencedInOtherArg(c, tp, argNodes, i)) {
                     kind = 1 /* ReferenceArgKind.Infer */;
@@ -1690,7 +1725,7 @@ function getTailRecursionRoot(c, newType, newMapper) {
     for (const t of newRoot.outerTypeParameters)
         typeArguments.push(typeParamMapper.map(t));
     const newRootMapper = newTypeMapper(newRoot.outerTypeParameters, typeArguments);
-    const newCheckType = newRoot.isDistributive ? newRootMapper.map(newRoot.checkType) : undefined;
+    const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : undefined;
     if (newCheckType === undefined ||
         newCheckType === newRoot.checkType ||
         (newCheckType.flags & (134217728 /* TypeFlags.Union */ | 262144 /* TypeFlags.Never */)) === 0)
@@ -1776,7 +1811,7 @@ export function getConstraintOfDistributiveConditionalType(c, t) {
 }
 /** Whether `source` matches the pattern of `target`, with placeholders related by `compareTypes`. */
 export function isTypeMatchedByTemplateLiteralType(c, source, target, compareTypes) {
-    const inferences = inferTypesFromTemplateLiteralType(c, source, target);
+    const inferences = inferTypesFromTemplateLiteralType(c, source, target, compareTypes);
     if (inferences === undefined)
         return false;
     const compare = compareTypes ?? ((s, t) => isTypeAssignableTo(c, s, t));
@@ -1840,3 +1875,15 @@ export function mappedTypeTarget(t) {
     const target = t.target;
     return target !== undefined ? target : t;
 }
+/** The key of the member of a conditional type instantiation's distribution for one constituent (shared-results.ts). */
+export function distributedKey(root, typeArguments, alias, tag, constituent) {
+    let key = root + ':' + tag + ':' + constituent.id + ':';
+    for (const t of typeArguments)
+        key += t.id + ',';
+    if (alias !== undefined) {
+        key += '@' + getSymbolId(alias.symbol);
+        for (const t of alias.typeArguments)
+            key += ',' + t.id;
+    }
+    return key;
+}

package/dist/api/compiler/checker-types.d.ts

@@ -120,8 +120,7 @@ export declare const enum ObjectFlags {
     IsClassInstanceClone = 67108864,
     IdenticalBaseTypeCalculated = 134217728,
     IdenticalBaseTypeExists = 268435456,
-    UnresolvedMembers = 536870912,
-    FromTypeNode = 1073741824,
+    FromTypeNode = 536870912,
     /**
      * The type keeps the state that is computed lazily in the checker's side tables instead of its
      * own fields, which stay unset (`sideOf`). Every type with `TSC_TS_SIDE_STATE=1`.
@@ -134,6 +133,9 @@ export declare const enum ObjectFlags {
     ContainsIntersections = 33554432,
     IsUnknownLikeUnionComputed = 67108864,
     IsUnknownLikeUnion = 134217728,
+    IsUniformEnumComputed = 268435456,
+    /** A primitive union in which no two literal constituents are comparable (`isUniformUnionType`). */
+    IsUniformEnum = 536870912,
     IsNeverIntersectionComputed = 33554432,
     IsNeverIntersection = 67108864,
     IsConstrainedTypeVariable = 134217728,
@@ -284,7 +286,9 @@ export declare const enum CachedTypeKind {
     RegularObjectLiteral = 14,
     PromisedTypeOfPromise = 15,
     Optional = 16,
-    OptionalProperty = 17
+    OptionalProperty = 17,
+    SimplifiedConditionalForReading = 18,
+    SimplifiedConditionalForWriting = 19
 }
 export declare function cachedTypeKey(kind: CachedTypeKind, id: number): number;
 /** The `cachedTypesByPair` key of two type ids and four bits, or -1 when an id is too large to pack. */
@@ -509,6 +513,38 @@ export declare class MemberNames {
     readonly tableOrder: number[];
     constructor(names: string[], positions: Map<string, number>, tableOrder: number[]);
 }
+/**
+ * The properties of the instantiations of one source without base types, as `getNamedMembers` orders them
+ * for `container`: the source positions of the named members in that order, and their names
+ * (`PropertyMembers`). The other members are skipped, so the named members are all of an instantiation's table.
+ */
+export declare class NamedMemberOrder {
+    readonly container: Symbol | undefined;
+    readonly positions: number[];
+    readonly names: MemberNames;
+    constructor(container: Symbol | undefined, positions: number[], names: MemberNames);
+}
+/**
+ * What the pending instantiations of a declared members table share whatever their mapper: the members in
+ * table order, which of them are named (the others are skipped), and the members whose resolved type keeps
+ * them under any instantiation (`keepsSymbolTypeUnderInstantiation`), found so far.
+ */
+export declare class DeclaredMemberPlan {
+    readonly table: SymbolTable;
+    /**
+     * Whether instantiations build the table eagerly: tsgo's table wouldn't be keyed by symbol names, or an
+     * own member could be replaced by an inherited one. The other fields are then incomplete.
+     */
+    readonly eager: boolean;
+    readonly members: Symbol[];
+    /** 1 for a named member, 0 for a skipped one, by position. */
+    readonly named: number[];
+    /** Bits by position: the member's type keeps it under instantiation. Set when found, never cleared. */
+    readonly keptByType: number[];
+    readonly hasOwnMembers: boolean;
+    readonly hasRequiredOwnMembers: boolean;
+    constructor(table: SymbolTable, eager: boolean, members: Symbol[], named: number[], hasOwnMembers: boolean, hasRequiredOwnMembers: boolean);
+}
 /** A type with members: object types, unions and intersections. */
 export declare class StructuredType extends Type {
     membersValue: SymbolTable | undefined;
@@ -558,6 +594,10 @@ export declare class InterfaceType extends TypeReference {
     declaredIndexInfos: IndexInfo[];
     /** Positions of the declared members by name, for lazily instantiated members of instantiations. */
     declaredMemberPositions: Map<string, number> | undefined;
+    /** The property order of instantiations (`NamedMemberOrder`); null where it can't be cached. */
+    namedMemberOrder: NamedMemberOrder | null | undefined;
+    /** What pending instantiations of the declared members share (`DeclaredMemberPlan`). */
+    declaredMemberPlan: DeclaredMemberPlan | undefined;
     /** The member states of the last pending instantiation of the type's members (`sharedStates`). */
     lastMemberStates: number[] | undefined;
     /** The property names of the last instantiation whose members table is built on demand. */
@@ -674,9 +714,22 @@ export declare class TypeParameter extends Type {
     target: Type | undefined;
     mapper: TypeMapper | undefined;
     isThisType: boolean;
+    /**
+     * A type parameter as referenced inside a distributive conditional type on it, which stands for each
+     * constituent in turn; its constraint is the type parameter it was made from (`getDistributedTypeParameter`).
+     */
+    isDistributed: boolean;
     resolvedDefaultType: Type | undefined;
+    /** The distributed form of this type parameter, made on first use. */
+    distributedType: TypeParameter | undefined;
     constructor(id: number, symbol: Symbol | undefined);
 }
+/** Whether `t` is the distributed form of a type parameter. */
+export declare function isDistributedTypeParameter(t: Type): boolean;
+/** The type parameter a distributed type parameter was made from; other types as they are. */
+export declare function getNonDistributedTypeParameter(t: Type): Type;
+/** What `mapper` maps `t` to, a distributed type parameter as the type parameter it was made from. */
+export declare function getMappedType(t: Type, mapper: TypeMapper): Type;
 /** `keyof T`. */
 export declare class IndexType extends Type {
     readonly target: Type;
@@ -852,6 +905,11 @@ export declare const enum TypeMapperKind {
 }
 /** Maps type parameters to types. Subclasses replace tsgo's function mappers. */
 export declare abstract class TypeMapper {
+    /**
+     * A number for the mapper, unique among the mappers this thread creates (until it wraps at 2^31), so the
+     * stack of active mappers can be searched by id instead of by reference.
+     */
+    readonly id: number;
     abstract map(type: Type): Type;
     kind(): TypeMapperKind;
     /** Whether the mapper only maps a `this` type parameter. */
@@ -964,6 +1022,8 @@ export declare class SymbolLinks implements ProgramLifetime {
     set typeParametersChecked(value: boolean);
     get enumChecked(): boolean;
     set enumChecked(value: boolean);
+    get mergedExportsChecked(): boolean;
+    set mergedExportsChecked(value: boolean);
     get variances(): VarianceFlags[] | undefined;
     set variances(value: VarianceFlags[] | undefined);
     get lastAssignmentPos(): number;
@@ -1000,6 +1060,7 @@ export declare class RareSymbolLinks implements ProgramLifetime {
     indexSignaturesChecked: boolean;
     typeParametersChecked: boolean;
     enumChecked: boolean;
+    mergedExportsChecked: boolean;
     variances: VarianceFlags[] | undefined;
     lastAssignmentPos: number;
     hasDefiniteAssignment: boolean;
@@ -1091,3 +1152,19 @@ export declare class RareNodeLinks implements ProgramLifetime {
     mentionsArguments: number;
     constructor();
 }
+/** A conditional type made as a member of a distribution: the instantiation's key, and the constituent it is for. */
+export declare class DistributedConditional {
+    readonly typeArguments: Type[];
+    readonly alias: TypeAlias | undefined;
+    readonly tag: number;
+    readonly constituent: Type;
+    constructor(typeArguments: Type[], alias: TypeAlias | undefined, tag: number, constituent: Type);
+}
+/** The instantiation of a conditional type whose result is a conditional type: its root and key. */
+export declare class ConditionalResultKey {
+    readonly root: ConditionalRoot;
+    readonly typeArguments: Type[];
+    readonly alias: TypeAlias | undefined;
+    readonly tag: number;
+    constructor(root: ConditionalRoot, typeArguments: Type[], alias: TypeAlias | undefined, tag: number);
+}