From 6b25c170b5100f42efe39910ea2d47bc2a92ffaf Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 14 Sep 2020 14:53:21 -1000 Subject: [PATCH 01/20] Introduce Uppercase and Lowercase intrinsic types --- src/compiler/checker.ts | 119 ++++++++++++++++++++++++++++++++++++---- src/compiler/types.ts | 12 +++- 2 files changed, 116 insertions(+), 15 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d9afe5e47eceb..bbce602ce6054 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -705,6 +705,7 @@ namespace ts { const literalTypes = new Map(); const indexedAccessTypes = new Map(); const templateLiteralTypes = new Map(); + const stringMappingTypes = new Map(); const substitutionTypes = new Map(); const evolvingArrayTypes: EvolvingArrayType[] = []; const undefinedProperties: SymbolTable = new Map(); @@ -717,6 +718,7 @@ namespace ts { const wildcardType = createIntrinsicType(TypeFlags.Any, "any"); const errorType = createIntrinsicType(TypeFlags.Any, "error"); const nonInferrableAnyType = createIntrinsicType(TypeFlags.Any, "any", ObjectFlags.ContainsWideningType); + const intrinsicMarkerType = createIntrinsicType(TypeFlags.Any, "intrinsic"); const unknownType = createIntrinsicType(TypeFlags.Unknown, "unknown"); const undefinedType = createIntrinsicType(TypeFlags.Undefined, "undefined"); const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(TypeFlags.Undefined, "undefined", ObjectFlags.ContainsWideningType); @@ -871,6 +873,8 @@ namespace ts { let anyArrayType: Type; let autoArrayType: Type; let anyReadonlyArrayType: Type; + let globalUppercaseSymbol: Symbol | undefined; + let globalLowercaseSymbol: Symbol | undefined; let deferredGlobalNonNullableTypeAlias: Symbol; // The library files are only loaded when the feature is used. @@ -4143,6 +4147,9 @@ namespace ts { function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult { // get symbol of the first identifier of the entityName + if (isIntrinsicMarkerTypeReference(entityName.parent)) { + return { accessibility: SymbolAccessibility.Accessible }; + } let meaning: SymbolFlags; if (entityName.parent.kind === SyntaxKind.TypeQuery || isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) || @@ -4341,7 +4348,9 @@ namespace ts { if (type.flags & TypeFlags.Any) { context.approximateLength += 3; - return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword); + return type === intrinsicMarkerType ? + factory.createTypeReferenceNode(factory.createIdentifier(intrinsicMarkerType.intrinsicName), /*typeArguments*/ undefined) : + factory.createKeywordTypeNode(SyntaxKind.AnyKeyword); } if (type.flags & TypeFlags.Unknown) { return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword); @@ -4513,6 +4522,10 @@ namespace ts { context.approximateLength += 2; return factory.createTemplateLiteralType(templateHead, templateSpans); } + if (type.flags & TypeFlags.StringMapping) { + const typeNode = typeToTypeNodeHelper((type).type, context); + return symbolToTypeNode((type).symbol, context, SymbolFlags.Type, [typeNode]); + } if (type.flags & TypeFlags.IndexedAccess) { const objectTypeNode = typeToTypeNodeHelper((type).objectType, context); const indexTypeNode = typeToTypeNodeHelper((type).indexType, context); @@ -10818,7 +10831,7 @@ namespace ts { } function getBaseConstraintOfType(type: Type): Type | undefined { - if (type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral)) { + if (type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral | TypeFlags.StringMapping)) { const constraint = getResolvedBaseConstraint(type); return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined; } @@ -10918,6 +10931,10 @@ namespace ts { const constraints = mapDefined(types, getBaseConstraint); return constraints.length === types.length ? getTemplateLiteralType((t).texts, (t).casings, constraints) : stringType; } + if (t.flags & TypeFlags.StringMapping) { + const constraint = getBaseConstraint((t).type); + return constraint ? getStringMappingType((t).symbol, constraint) : stringType; + } if (t.flags & TypeFlags.IndexedAccess) { const baseObjectType = getBaseConstraint((t).objectType); const baseIndexType = getBaseConstraint((t).indexType); @@ -12121,6 +12138,9 @@ namespace ts { } function getTypeAliasInstantiation(symbol: Symbol, typeArguments: readonly Type[] | undefined): Type { + if ((symbol === globalUppercaseSymbol || symbol === globalLowercaseSymbol) && typeArguments && typeArguments.length === 1) { + return getStringMappingType(symbol, typeArguments[0]); + } const type = getDeclaredTypeOfSymbol(symbol); const links = getSymbolLinks(symbol); const typeParameters = links.typeParameters!; @@ -12532,6 +12552,23 @@ namespace ts { return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt" as __String, /*arity*/ 0, reportErrors)) || emptyObjectType; } + function getIntrinsicSymbolOrUndefined(name: __String): Symbol | undefined { + const symbol = getGlobalTypeSymbol(name, /*reportErrors*/ false); + if (symbol && symbol.flags & SymbolFlags.TypeAlias) { + const declaration = find(symbol.declarations, isTypeAliasDeclaration); + const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (declaration && declaration.type.kind === SyntaxKind.TypeReference && length(typeParameters) === 1) { + const typeReference = declaration.type; + if (isIdentifier(typeReference.typeName) && typeReference.typeName.escapedText === intrinsicMarkerType.intrinsicName && !typeReference.typeArguments) { + const links = getSymbolLinks(symbol); + links.declaredType = intrinsicMarkerType; + links.typeParameters = typeParameters; + return symbol; + } + } + } + } + /** * Instantiates a global type that is generic with some element type, and returns that instantiation. */ @@ -13531,6 +13568,29 @@ namespace ts { return type; } + function getStringMappingType(symbol: Symbol, type: Type): Type { + return type.flags & TypeFlags.Union ? mapType(type, t => getStringMappingType(symbol, t)) : + isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : + type.flags & TypeFlags.StringLiteral ? getLiteralType(symbol === globalUppercaseSymbol ? (type).value.toUpperCase() : (type).value.toLowerCase()) : + stringType; + } + + function getStringMappingTypeForGenericType(symbol: Symbol, type: Type): Type { + const id = `${getSymbolId(symbol)},${getTypeId(type)}`; + let result = stringMappingTypes.get(id); + if (!result) { + stringMappingTypes.set(id, result = createStringMappingType(symbol, type)); + } + return result; + } + + function createStringMappingType(symbol: Symbol, type: Type) { + const result = createType(TypeFlags.StringMapping); + result.symbol = symbol; + result.type = type; + return result; + } + function createIndexedAccessType(objectType: Type, indexType: Type, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) { const type = createType(TypeFlags.IndexedAccess); type.objectType = objectType; @@ -13766,7 +13826,7 @@ namespace ts { } return !!((type).objectFlags & ObjectFlags.IsGenericIndexType); } - return !!(type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral)); + return !!(type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping)); } function isThisTypeParameter(type: Type): boolean { @@ -14272,7 +14332,7 @@ namespace ts { } function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type: Type) { - return isEmptyObjectType(type) || !!(type.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral)); + return isEmptyObjectType(type) || !!(type.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index)); } function isSinglePropertyAnonymousObjectType(type: Type) { @@ -14358,7 +14418,7 @@ namespace ts { } return mapType(right, t => getSpreadType(left, t, symbol, objectFlags, readonly)); } - if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral)) { + if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index)) { return left; } @@ -15162,6 +15222,9 @@ namespace ts { if (flags & TypeFlags.TemplateLiteral) { return getTemplateLiteralType((type).texts, (type).casings, instantiateTypes((type).types, mapper)); } + if (flags & TypeFlags.StringMapping) { + return getStringMappingType((type).symbol, instantiateType((type).type, mapper)); + } if (flags & TypeFlags.IndexedAccess) { return getIndexedAccessType(instantiateType((type).objectType, mapper), instantiateType((type).indexType, mapper), /*accessNode*/ undefined, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)); } @@ -17317,6 +17380,21 @@ namespace ts { return result; } } + else if (source.flags & TypeFlags.StringMapping) { + if (target.flags & TypeFlags.StringMapping && (source).symbol === (target).symbol) { + if (result = isRelatedTo((source).type, (target).type, reportErrors)) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + else { + const constraint = getBaseConstraintOfType(source); + if (constraint && (result = isRelatedTo(constraint, target, reportErrors))) { + resetErrorInfo(saveErrorInfo); + return result; + } + } + } else if (source.flags & TypeFlags.Conditional) { if (target.flags & TypeFlags.Conditional) { // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if @@ -19761,6 +19839,11 @@ namespace ts { inferFromTypes((source).objectType, (target).objectType); inferFromTypes((source).indexType, (target).indexType); } + else if (source.flags & TypeFlags.StringMapping && target.flags & TypeFlags.StringMapping) { + if ((source).symbol === (target).symbol) { + inferFromTypes((source).type, (target).type); + } + } else if (target.flags & TypeFlags.Conditional) { invokeOnce(source, target, inferToConditionalType); } @@ -20251,7 +20334,7 @@ namespace ts { function hasPrimitiveConstraint(type: TypeParameter): boolean { const constraint = getConstraintOfTypeParameter(type); - return !!constraint && maybeTypeOfKind(constraint.flags & TypeFlags.Conditional ? getDefaultConstraintOfConditionalType(constraint as ConditionalType) : constraint, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.TemplateLiteral); + return !!constraint && maybeTypeOfKind(constraint.flags & TypeFlags.Conditional ? getDefaultConstraintOfConditionalType(constraint as ConditionalType) : constraint, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping); } function isObjectLiteralType(type: Type) { @@ -26304,7 +26387,7 @@ namespace ts { else { const contextualType = getIndexedAccessType(restType, getLiteralType(i - index)); const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode); - const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.TemplateLiteral); + const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping); types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType)); flags.push(ElementFlags.Required); } @@ -29343,7 +29426,7 @@ namespace ts { // and the right operand to be of type Any, an object type, or a type parameter type. // The result is always of the Boolean primitive type. if (!(allTypesAssignableToKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbolLike) || - isTypeAssignableToKind(leftType, TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.TypeParameter))) { + isTypeAssignableToKind(leftType, TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping | TypeFlags.TypeParameter))) { error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); } if (!allTypesAssignableToKind(rightType, TypeFlags.NonPrimitive | TypeFlags.InstantiableNonPrimitive)) { @@ -30297,7 +30380,7 @@ namespace ts { } // If the contextual type is a literal of a particular primitive type, we consider this a // literal context for all literals of that primitive type. - return !!(contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index | TypeFlags.TemplateLiteral) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) || + return !!(contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) || contextualType.flags & TypeFlags.NumberLiteral && maybeTypeOfKind(candidateType, TypeFlags.NumberLiteral) || contextualType.flags & TypeFlags.BigIntLiteral && maybeTypeOfKind(candidateType, TypeFlags.BigIntLiteral) || contextualType.flags & TypeFlags.BooleanLiteral && maybeTypeOfKind(candidateType, TypeFlags.BooleanLiteral) || @@ -35279,12 +35362,21 @@ namespace ts { function checkTypeAliasDeclaration(node: TypeAliasDeclaration) { // Grammar checking checkGrammarDecoratorsAndModifiers(node); - checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0); checkExportsOnMergedDeclarations(node); checkTypeParameters(node.typeParameters); - checkSourceElement(node.type); - registerForUnusedIdentifiersCheck(node); + if (!isIntrinsicMarkerTypeReference(node.type)) { + checkSourceElement(node.type); + registerForUnusedIdentifiersCheck(node); + } + } + + function isIntrinsicMarkerTypeReference(node: Node) { + if (isTypeReferenceNode(node) && isTypeAliasDeclaration(node.parent)) { + const symbol = getSymbolOfNode(node.parent); + return symbol === globalUppercaseSymbol || symbol === globalLowercaseSymbol; + } + return false; } function computeEnumMemberValues(node: EnumDeclaration) { @@ -38146,6 +38238,9 @@ namespace ts { anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType; globalThisType = getGlobalTypeOrUndefined("ThisType" as __String, /*arity*/ 1); + globalUppercaseSymbol = getIntrinsicSymbolOrUndefined("Uppercase" as __String); + globalLowercaseSymbol = getIntrinsicSymbolOrUndefined("Lowercase" as __String); + if (augmentations) { // merge _nonglobal_ module augmentations. // this needs to be done after global symbol table is initialized to make sure that all ambient modules are indexed diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 71d64d3c65bac..24a4ac5acc240 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4892,6 +4892,7 @@ namespace ts { Substitution = 1 << 25, // Type parameter substitution NonPrimitive = 1 << 26, // intrinsic object type TemplateLiteral = 1 << 27, // Template literal type + StringMapping = 1 << 28, // Uppercase/Lowercase type /* @internal */ AnyOrUnknown = Any | Unknown, @@ -4909,7 +4910,7 @@ namespace ts { Intrinsic = Any | Unknown | String | Number | BigInt | Boolean | BooleanLiteral | ESSymbol | Void | Undefined | Null | Never | NonPrimitive, /* @internal */ Primitive = String | Number | BigInt | Boolean | Enum | EnumLiteral | ESSymbol | Void | Undefined | Null | Literal | UniqueESSymbol, - StringLike = String | StringLiteral | TemplateLiteral, + StringLike = String | StringLiteral | TemplateLiteral | StringMapping, NumberLike = Number | NumberLiteral | Enum, BigIntLike = BigInt | BigIntLiteral, BooleanLike = Boolean | BooleanLiteral, @@ -4922,7 +4923,7 @@ namespace ts { StructuredType = Object | Union | Intersection, TypeVariable = TypeParameter | IndexedAccess, InstantiableNonPrimitive = TypeVariable | Conditional | Substitution, - InstantiablePrimitive = Index | TemplateLiteral, + InstantiablePrimitive = Index | TemplateLiteral | StringMapping, Instantiable = InstantiableNonPrimitive | InstantiablePrimitive, StructuredOrInstantiable = StructuredType | Instantiable, /* @internal */ @@ -4930,7 +4931,7 @@ namespace ts { /* @internal */ Simplifiable = IndexedAccess | Conditional, /* @internal */ - Substructure = Object | Union | Intersection | Index | IndexedAccess | Conditional | Substitution | TemplateLiteral, + Substructure = Object | Union | Intersection | Index | IndexedAccess | Conditional | Substitution | TemplateLiteral | StringMapping, // 'Narrowable' types are types where narrowing actually narrows. // This *should* be every type other than null, undefined, void, and never Narrowable = Any | Unknown | StructuredOrInstantiable | StringLike | NumberLike | BigIntLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive, @@ -5384,6 +5385,11 @@ namespace ts { types: readonly Type[]; // Always at least one element } + export interface StringMappingType extends InstantiableType { + symbol: Symbol; // globalUppercaseSymbol/globalLowercaseSymbol + type: Type; // Type argument + } + // Type parameter substitution (TypeFlags.Substitution) // Substitution types are created for type parameters or indexed access types that occur in the // true branch of a conditional type. For example, in 'T extends string ? Foo : Bar', the From 59a9049a36104963c38b7d0e4f03c26fce1c2b02 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 14 Sep 2020 14:53:42 -1000 Subject: [PATCH 02/20] Accept new API baselines --- .../baselines/reference/api/tsserverlibrary.d.ts | 15 ++++++++++----- tests/baselines/reference/api/typescript.d.ts | 15 ++++++++++----- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 2e5b82492bac6..c40829152eb1b 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -2489,11 +2489,12 @@ declare namespace ts { Substitution = 33554432, NonPrimitive = 67108864, TemplateLiteral = 134217728, + StringMapping = 268435456, Literal = 2944, Unit = 109440, StringOrNumberLiteral = 384, PossiblyFalsy = 117724, - StringLike = 134217860, + StringLike = 402653316, NumberLike = 296, BigIntLike = 2112, BooleanLike = 528, @@ -2504,10 +2505,10 @@ declare namespace ts { StructuredType = 3670016, TypeVariable = 8650752, InstantiableNonPrimitive = 58982400, - InstantiablePrimitive = 138412032, - Instantiable = 197394432, - StructuredOrInstantiable = 201064448, - Narrowable = 268188671, + InstantiablePrimitive = 406847488, + Instantiable = 465829888, + StructuredOrInstantiable = 469499904, + Narrowable = 536624127, } export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression; export interface Type { @@ -2663,6 +2664,10 @@ declare namespace ts { casings: readonly TemplateCasing[]; types: readonly Type[]; } + export interface StringMappingType extends InstantiableType { + symbol: Symbol; + type: Type; + } export interface SubstitutionType extends InstantiableType { baseType: Type; substitute: Type; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 5810c60b4672b..e2892d52a5d58 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -2489,11 +2489,12 @@ declare namespace ts { Substitution = 33554432, NonPrimitive = 67108864, TemplateLiteral = 134217728, + StringMapping = 268435456, Literal = 2944, Unit = 109440, StringOrNumberLiteral = 384, PossiblyFalsy = 117724, - StringLike = 134217860, + StringLike = 402653316, NumberLike = 296, BigIntLike = 2112, BooleanLike = 528, @@ -2504,10 +2505,10 @@ declare namespace ts { StructuredType = 3670016, TypeVariable = 8650752, InstantiableNonPrimitive = 58982400, - InstantiablePrimitive = 138412032, - Instantiable = 197394432, - StructuredOrInstantiable = 201064448, - Narrowable = 268188671, + InstantiablePrimitive = 406847488, + Instantiable = 465829888, + StructuredOrInstantiable = 469499904, + Narrowable = 536624127, } export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression; export interface Type { @@ -2663,6 +2664,10 @@ declare namespace ts { casings: readonly TemplateCasing[]; types: readonly Type[]; } + export interface StringMappingType extends InstantiableType { + symbol: Symbol; + type: Type; + } export interface SubstitutionType extends InstantiableType { baseType: Type; substitute: Type; From 93bf6c2764732ea5ef476ca8781680473a018375 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 05:35:28 -1000 Subject: [PATCH 03/20] Add Uppercase/Lowercase/Capitalize/Uncapitalize to lib.d.ts --- src/lib/es5.d.ts | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index d40318a5e8e53..dcb1d4ced41f8 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1508,6 +1508,26 @@ type ReturnType any> = T extends (...args: any) => i */ type InstanceType any> = T extends new (...args: any) => infer R ? R : any; +/** + * Convert string literal type to uppercase + */ +type Uppercase = intrinsic; + +/** + * Convert string literal type to lowercase + */ +type Lowercase = intrinsic; + +/** + * Convert first character of string literal type to uppercase + */ +type Capitalize = S extends `${infer H}${infer T}` ? `${Uppercase}${T}` : S; + +/** + * Convert first character of string literal type to lowercase + */ +type Uncapitalize = S extends `${infer H}${infer T}` ? `${Lowercase}${T}` : S; + /** * Marker for contextual 'this' type */ From e239db5dba0f19e4297c04c54b66144145f626c9 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 05:35:44 -1000 Subject: [PATCH 04/20] Update fourslash --- src/harness/fourslashInterfaceImpl.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index 096b1ea8e8dbc..a15998eaf3fe6 100644 --- a/src/harness/fourslashInterfaceImpl.ts +++ b/src/harness/fourslashInterfaceImpl.ts @@ -1065,6 +1065,10 @@ namespace FourSlashInterface { typeEntry("ConstructorParameters"), typeEntry("ReturnType"), typeEntry("InstanceType"), + typeEntry("Uppercase"), + typeEntry("Lowercase"), + typeEntry("Capitalize"), + typeEntry("Uncapitalize"), interfaceEntry("ThisType"), varEntry("ArrayBuffer"), interfaceEntry("ArrayBufferTypes"), From 68717bc506a3c2bfc74abde54dedf5f05cc66846 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 08:29:50 -1000 Subject: [PATCH 05/20] Add an 'intrinsic' keyword --- src/compiler/checker.ts | 52 ++++++++-------------------- src/compiler/diagnosticMessages.json | 4 +++ src/compiler/parser.ts | 2 +- src/compiler/scanner.ts | 1 + src/compiler/types.ts | 7 ++-- 5 files changed, 25 insertions(+), 41 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index bbce602ce6054..e69febccf38d7 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -873,8 +873,6 @@ namespace ts { let anyArrayType: Type; let autoArrayType: Type; let anyReadonlyArrayType: Type; - let globalUppercaseSymbol: Symbol | undefined; - let globalLowercaseSymbol: Symbol | undefined; let deferredGlobalNonNullableTypeAlias: Symbol; // The library files are only loaded when the feature is used. @@ -4147,9 +4145,6 @@ namespace ts { function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult { // get symbol of the first identifier of the entityName - if (isIntrinsicMarkerTypeReference(entityName.parent)) { - return { accessibility: SymbolAccessibility.Accessible }; - } let meaning: SymbolFlags; if (entityName.parent.kind === SyntaxKind.TypeQuery || isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) || @@ -4348,9 +4343,7 @@ namespace ts { if (type.flags & TypeFlags.Any) { context.approximateLength += 3; - return type === intrinsicMarkerType ? - factory.createTypeReferenceNode(factory.createIdentifier(intrinsicMarkerType.intrinsicName), /*typeArguments*/ undefined) : - factory.createKeywordTypeNode(SyntaxKind.AnyKeyword); + return factory.createKeywordTypeNode(type === intrinsicMarkerType ? SyntaxKind.IntrinsicKeyword : SyntaxKind.AnyKeyword); } if (type.flags & TypeFlags.Unknown) { return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword); @@ -12138,10 +12131,10 @@ namespace ts { } function getTypeAliasInstantiation(symbol: Symbol, typeArguments: readonly Type[] | undefined): Type { - if ((symbol === globalUppercaseSymbol || symbol === globalLowercaseSymbol) && typeArguments && typeArguments.length === 1) { + const type = getDeclaredTypeOfSymbol(symbol); + if (type === intrinsicMarkerType && isIntrinsicTypeName(symbol.escapedName as string) && typeArguments && typeArguments.length === 1) { return getStringMappingType(symbol, typeArguments[0]); } - const type = getDeclaredTypeOfSymbol(symbol); const links = getSymbolLinks(symbol); const typeParameters = links.typeParameters!; const id = getTypeListId(typeArguments); @@ -12552,23 +12545,6 @@ namespace ts { return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt" as __String, /*arity*/ 0, reportErrors)) || emptyObjectType; } - function getIntrinsicSymbolOrUndefined(name: __String): Symbol | undefined { - const symbol = getGlobalTypeSymbol(name, /*reportErrors*/ false); - if (symbol && symbol.flags & SymbolFlags.TypeAlias) { - const declaration = find(symbol.declarations, isTypeAliasDeclaration); - const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); - if (declaration && declaration.type.kind === SyntaxKind.TypeReference && length(typeParameters) === 1) { - const typeReference = declaration.type; - if (isIdentifier(typeReference.typeName) && typeReference.typeName.escapedText === intrinsicMarkerType.intrinsicName && !typeReference.typeArguments) { - const links = getSymbolLinks(symbol); - links.declaredType = intrinsicMarkerType; - links.typeParameters = typeParameters; - return symbol; - } - } - } - } - /** * Instantiates a global type that is generic with some element type, and returns that instantiation. */ @@ -13571,7 +13547,7 @@ namespace ts { function getStringMappingType(symbol: Symbol, type: Type): Type { return type.flags & TypeFlags.Union ? mapType(type, t => getStringMappingType(symbol, t)) : isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : - type.flags & TypeFlags.StringLiteral ? getLiteralType(symbol === globalUppercaseSymbol ? (type).value.toUpperCase() : (type).value.toLowerCase()) : + type.flags & TypeFlags.StringLiteral ? getLiteralType(symbol.escapedName === "Uppercase" ? (type).value.toUpperCase() : (type).value.toLowerCase()) : stringType; } @@ -14696,6 +14672,8 @@ namespace ts { return neverType; case SyntaxKind.ObjectKeyword: return node.flags & NodeFlags.JavaScriptFile && !noImplicitAny ? anyType : nonPrimitiveType; + case SyntaxKind.IntrinsicKeyword: + return intrinsicMarkerType; case SyntaxKind.ThisType: case SyntaxKind.ThisKeyword as TypeNodeSyntaxKind: // TODO(rbuckton): `ThisKeyword` is no longer a `TypeNode`, but we defensively allow it here because of incorrect casts in the Language Service and because of `isPartOfTypeNode`. @@ -35365,18 +35343,19 @@ namespace ts { checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0); checkExportsOnMergedDeclarations(node); checkTypeParameters(node.typeParameters); - if (!isIntrinsicMarkerTypeReference(node.type)) { + if (node.type.kind === SyntaxKind.IntrinsicKeyword) { + if (!isIntrinsicTypeName(node.name.escapedText as string) || length(node.typeParameters) !== 1) { + error(node.type, Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types); + } + } + else { checkSourceElement(node.type); registerForUnusedIdentifiersCheck(node); } } - function isIntrinsicMarkerTypeReference(node: Node) { - if (isTypeReferenceNode(node) && isTypeAliasDeclaration(node.parent)) { - const symbol = getSymbolOfNode(node.parent); - return symbol === globalUppercaseSymbol || symbol === globalLowercaseSymbol; - } - return false; + function isIntrinsicTypeName(name: string) { + return name === "Uppercase" || name === "Lowercase"; } function computeEnumMemberValues(node: EnumDeclaration) { @@ -38238,9 +38217,6 @@ namespace ts { anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType; globalThisType = getGlobalTypeOrUndefined("ThisType" as __String, /*arity*/ 1); - globalUppercaseSymbol = getIntrinsicSymbolOrUndefined("Uppercase" as __String); - globalLowercaseSymbol = getIntrinsicSymbolOrUndefined("Lowercase" as __String); - if (augmentations) { // merge _nonglobal_ module augmentations. // this needs to be done after global symbol table is initialized to make sure that all ambient modules are indexed diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fe9beaa1121e6..c20295302e1f3 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -3039,6 +3039,10 @@ "category": "Error", "code": 2793 }, + "The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types.": { + "category": "Error", + "code": 2794 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index af797435c9d4f..8c61c03095f40 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -6751,7 +6751,7 @@ namespace ts { const name = parseIdentifier(); const typeParameters = parseTypeParameters(); parseExpected(SyntaxKind.EqualsToken); - const type = parseType(); + const type = token() === SyntaxKind.IntrinsicKeyword && tryParse(parseKeywordAndNoDot) || parseType(); parseSemicolon(); const node = factory.createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type); return withJSDoc(finishNode(node, pos), hasJSDoc); diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 5f5248e1073f3..515f9de69c23e 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -111,6 +111,7 @@ namespace ts { infer: SyntaxKind.InferKeyword, instanceof: SyntaxKind.InstanceOfKeyword, interface: SyntaxKind.InterfaceKeyword, + intrinsic: SyntaxKind.IntrinsicKeyword, is: SyntaxKind.IsKeyword, keyof: SyntaxKind.KeyOfKeyword, let: SyntaxKind.LetKeyword, diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 24a4ac5acc240..c53f3e11b0433 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -167,6 +167,7 @@ namespace ts { DeclareKeyword, GetKeyword, InferKeyword, + IntrinsicKeyword, IsKeyword, KeyOfKeyword, ModuleKeyword, @@ -574,6 +575,7 @@ namespace ts { | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword + | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword @@ -635,6 +637,7 @@ namespace ts { | SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword + | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword @@ -5386,8 +5389,8 @@ namespace ts { } export interface StringMappingType extends InstantiableType { - symbol: Symbol; // globalUppercaseSymbol/globalLowercaseSymbol - type: Type; // Type argument + symbol: Symbol; + type: Type; } // Type parameter substitution (TypeFlags.Substitution) From d6108ac827e6113fb0e2501cb6cca8ffa224a394 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 08:32:31 -1000 Subject: [PATCH 06/20] Update template literal type tests --- .../templateLiteralTypes1.errors.txt | 14 +- .../reference/templateLiteralTypes1.js | 10 - .../reference/templateLiteralTypes1.symbols | 762 +++++++++--------- .../reference/templateLiteralTypes1.types | 12 - .../types/literal/templateLiteralTypes1.ts | 6 - 5 files changed, 371 insertions(+), 433 deletions(-) diff --git a/tests/baselines/reference/templateLiteralTypes1.errors.txt b/tests/baselines/reference/templateLiteralTypes1.errors.txt index 6a453496896a3..89090ee0adfc8 100644 --- a/tests/baselines/reference/templateLiteralTypes1.errors.txt +++ b/tests/baselines/reference/templateLiteralTypes1.errors.txt @@ -4,10 +4,10 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(39,5): error TS23 'A' is assignable to the constraint of type 'B', but 'B' could be instantiated with a different subtype of constraint 'string'. Type 'string' is not assignable to type 'B'. 'string' is assignable to the constraint of type 'B', but 'B' could be instantiated with a different subtype of constraint 'string'. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(165,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(197,16): error TS2590: Expression produces a union type that is too complex to represent. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(201,16): error TS2590: Expression produces a union type that is too complex to represent. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(205,16): error TS2590: Expression produces a union type that is too complex to represent. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(159,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(191,16): error TS2590: Expression produces a union type that is too complex to represent. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(195,16): error TS2590: Expression produces a union type that is too complex to represent. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(199,16): error TS2590: Expression produces a union type that is too complex to represent. ==== tests/cases/conformance/types/literal/templateLiteralTypes1.ts (6 errors) ==== @@ -106,12 +106,6 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(205,16): error TS type T26 = FirstTwoAndRest<'ab'>; // ['ab', ''] type T27 = FirstTwoAndRest<'a'>; // unknown - type Capitalize = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S; - type Uncapitalize = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S; - - type TC1 = Capitalize<'foo'>; // 'Foo' - type TC2 = Uncapitalize<'Foo'>; // 'foo' - type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; type HexColor = diff --git a/tests/baselines/reference/templateLiteralTypes1.js b/tests/baselines/reference/templateLiteralTypes1.js index bc880baef8cbd..a286c66881b6e 100644 --- a/tests/baselines/reference/templateLiteralTypes1.js +++ b/tests/baselines/reference/templateLiteralTypes1.js @@ -86,12 +86,6 @@ type T25 = FirstTwoAndRest<'abcde'>; // ['ab', 'cde'] type T26 = FirstTwoAndRest<'ab'>; // ['ab', ''] type T27 = FirstTwoAndRest<'a'>; // unknown -type Capitalize = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S; -type Uncapitalize = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S; - -type TC1 = Capitalize<'foo'>; // 'Foo' -type TC2 = Uncapitalize<'Foo'>; // 'foo' - type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; type HexColor = @@ -279,10 +273,6 @@ declare type FirstTwoAndRest = S extends `${infer A}${infer B} declare type T25 = FirstTwoAndRest<'abcde'>; declare type T26 = FirstTwoAndRest<'ab'>; declare type T27 = FirstTwoAndRest<'a'>; -declare type Capitalize = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S; -declare type Uncapitalize = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S; -declare type TC1 = Capitalize<'foo'>; -declare type TC2 = Uncapitalize<'Foo'>; declare type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; declare type HexColor = S extends `#${infer R1}${infer R2}${infer G1}${infer G2}${infer B1}${infer B2}` ? [ R1, diff --git a/tests/baselines/reference/templateLiteralTypes1.symbols b/tests/baselines/reference/templateLiteralTypes1.symbols index 679348bcbeae4..3dca8c592e649 100644 --- a/tests/baselines/reference/templateLiteralTypes1.symbols +++ b/tests/baselines/reference/templateLiteralTypes1.symbols @@ -288,557 +288,529 @@ type T27 = FirstTwoAndRest<'a'>; // unknown >T27 : Symbol(T27, Decl(templateLiteralTypes1.ts, 84, 33)) >FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 77, 43)) -type Capitalize = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S; ->Capitalize : Symbol(Capitalize, Decl(templateLiteralTypes1.ts, 85, 32)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 87, 16)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 87, 16)) ->H : Symbol(H, Decl(templateLiteralTypes1.ts, 87, 54)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 87, 64)) ->H : Symbol(H, Decl(templateLiteralTypes1.ts, 87, 54)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 87, 64)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 87, 16)) - -type Uncapitalize = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S; ->Uncapitalize : Symbol(Uncapitalize, Decl(templateLiteralTypes1.ts, 87, 96)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 88, 18)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 88, 18)) ->H : Symbol(H, Decl(templateLiteralTypes1.ts, 88, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 88, 66)) ->H : Symbol(H, Decl(templateLiteralTypes1.ts, 88, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 88, 66)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 88, 18)) - -type TC1 = Capitalize<'foo'>; // 'Foo' ->TC1 : Symbol(TC1, Decl(templateLiteralTypes1.ts, 88, 98)) ->Capitalize : Symbol(Capitalize, Decl(templateLiteralTypes1.ts, 85, 32)) - -type TC2 = Uncapitalize<'Foo'>; // 'foo' ->TC2 : Symbol(TC2, Decl(templateLiteralTypes1.ts, 90, 29)) ->Uncapitalize : Symbol(Uncapitalize, Decl(templateLiteralTypes1.ts, 87, 96)) - type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) type HexColor = ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 95, 14)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 89, 14)) S extends `#${infer R1}${infer R2}${infer G1}${infer G2}${infer B1}${infer B2}` ? ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 95, 14)) ->R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 96, 23)) ->R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 96, 34)) ->G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 96, 45)) ->G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 96, 56)) ->B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 96, 67)) ->B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 96, 78)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 89, 14)) +>R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 90, 23)) +>R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 90, 34)) +>G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 90, 45)) +>G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 90, 56)) +>B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 90, 67)) +>B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 90, 78)) [R1, R2, G1, G2, B1, B2] extends [HexDigit, HexDigit, HexDigit, HexDigit, HexDigit, HexDigit] ? ->R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 96, 23)) ->R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 96, 34)) ->G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 96, 45)) ->G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 96, 56)) ->B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 96, 67)) ->B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 96, 78)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 31)) +>R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 90, 23)) +>R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 90, 34)) +>G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 90, 45)) +>G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 90, 56)) +>B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 90, 67)) +>B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 90, 78)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) S : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 95, 14)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 89, 14)) never : never; type TH1 = HexColor<'#8080FF'>; // '#8080FF' ->TH1 : Symbol(TH1, Decl(templateLiteralTypes1.ts, 100, 14)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) +>TH1 : Symbol(TH1, Decl(templateLiteralTypes1.ts, 94, 14)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) type TH2 = HexColor<'#80c0ff'>; // '#80c0ff' ->TH2 : Symbol(TH2, Decl(templateLiteralTypes1.ts, 102, 31)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) +>TH2 : Symbol(TH2, Decl(templateLiteralTypes1.ts, 96, 31)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) type TH3 = HexColor<'#8080F'>; // never ->TH3 : Symbol(TH3, Decl(templateLiteralTypes1.ts, 103, 31)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) +>TH3 : Symbol(TH3, Decl(templateLiteralTypes1.ts, 97, 31)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) type TH4 = HexColor<'#8080FFF'>; // never ->TH4 : Symbol(TH4, Decl(templateLiteralTypes1.ts, 104, 30)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) +>TH4 : Symbol(TH4, Decl(templateLiteralTypes1.ts, 98, 30)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) // Recursive inference type Trim = ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) S extends ` ${infer T}` ? Trim : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 110, 23)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 110, 23)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 104, 23)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 104, 23)) S extends `${infer T} ` ? Trim : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 111, 22)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 111, 22)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 105, 22)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 105, 22)) S; ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) type TR1 = Trim<'xx '>; // 'xx' ->TR1 : Symbol(TR1, Decl(templateLiteralTypes1.ts, 112, 6)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) +>TR1 : Symbol(TR1, Decl(templateLiteralTypes1.ts, 106, 6)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) type TR2 = Trim<' xx'>; // 'xx' ->TR2 : Symbol(TR2, Decl(templateLiteralTypes1.ts, 114, 25)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) +>TR2 : Symbol(TR2, Decl(templateLiteralTypes1.ts, 108, 25)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) type TR3 = Trim<' xx '>; // 'xx' ->TR3 : Symbol(TR3, Decl(templateLiteralTypes1.ts, 115, 25)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) +>TR3 : Symbol(TR3, Decl(templateLiteralTypes1.ts, 109, 25)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) type Split = ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 118, 28)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 112, 28)) string extends S ? string[] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) S extends '' ? [] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) S extends `${infer T}${D}${infer U}` ? [T, ...Split] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 121, 22)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 118, 28)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 121, 36)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 121, 22)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 121, 36)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 118, 28)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 115, 22)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 112, 28)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 115, 36)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 115, 22)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 115, 36)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 112, 28)) [S]; ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) type T40 = Split<'foo', '.'>; // ['foo'] ->T40 : Symbol(T40, Decl(templateLiteralTypes1.ts, 122, 8)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) +>T40 : Symbol(T40, Decl(templateLiteralTypes1.ts, 116, 8)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) type T41 = Split<'foo.bar.baz', '.'>; // ['foo', 'bar', 'baz'] ->T41 : Symbol(T41, Decl(templateLiteralTypes1.ts, 124, 29)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) +>T41 : Symbol(T41, Decl(templateLiteralTypes1.ts, 118, 29)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) type T42 = Split<'foo.bar', ''>; // ['f', 'o', 'o', '.', 'b', 'a', 'r'] ->T42 : Symbol(T42, Decl(templateLiteralTypes1.ts, 125, 37)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) +>T42 : Symbol(T42, Decl(templateLiteralTypes1.ts, 119, 37)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) type T43 = Split; // string[] ->T43 : Symbol(T43, Decl(templateLiteralTypes1.ts, 126, 32)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) +>T43 : Symbol(T43, Decl(templateLiteralTypes1.ts, 120, 32)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) // Inference and property name paths declare function getProp(obj: T, path: `${P0}.${P1}.${P2}`): T[P0][P1][P2]; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) ->P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 131, 89)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 131, 127)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 131, 134)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) ->P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 131, 89)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) ->P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 131, 89)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) +>P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 125, 89)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 125, 127)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 125, 134)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) +>P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 125, 89)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) +>P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 125, 89)) declare function getProp(obj: T, path: `${P0}.${P1}`): T[P0][P1]; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 132, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 132, 90)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 132, 97)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 132, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 132, 56)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 126, 56)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 126, 90)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 126, 97)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 126, 56)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 126, 56)) declare function getProp(obj: T, path: P0): T[P0]; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 133, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 133, 57)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 133, 64)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 133, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 133, 27)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 127, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 127, 57)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 127, 64)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 127, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 127, 27)) declare function getProp(obj: object, path: string): unknown; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 134, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 134, 37)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 128, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 128, 37)) let p1 = getProp({ a: { b: {c: 42, d: 'hello' }}} as const, 'a'); ->p1 : Symbol(p1, Decl(templateLiteralTypes1.ts, 136, 3)) ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 136, 18)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 136, 23)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 136, 28)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 136, 34)) +>p1 : Symbol(p1, Decl(templateLiteralTypes1.ts, 130, 3)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 130, 18)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 130, 23)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 130, 28)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 130, 34)) let p2 = getProp({ a: { b: {c: 42, d: 'hello' }}} as const, 'a.b'); ->p2 : Symbol(p2, Decl(templateLiteralTypes1.ts, 137, 3)) ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 137, 18)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 137, 23)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 137, 28)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 137, 34)) +>p2 : Symbol(p2, Decl(templateLiteralTypes1.ts, 131, 3)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 131, 18)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 131, 23)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 131, 28)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 131, 34)) let p3 = getProp({ a: { b: {c: 42, d: 'hello' }}} as const, 'a.b.d'); ->p3 : Symbol(p3, Decl(templateLiteralTypes1.ts, 138, 3)) ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 138, 18)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 138, 23)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 138, 28)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 138, 34)) +>p3 : Symbol(p3, Decl(templateLiteralTypes1.ts, 132, 3)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 132, 18)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 132, 23)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 132, 28)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 132, 34)) type PropType = ->PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 138, 69)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) +>PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 132, 69)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) string extends Path ? unknown : ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) Path extends keyof T ? T[Path] : ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropType : unknown : ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) ->K : Symbol(K, Decl(templateLiteralTypes1.ts, 143, 25)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 143, 36)) ->K : Symbol(K, Decl(templateLiteralTypes1.ts, 143, 25)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) ->PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 138, 69)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) ->K : Symbol(K, Decl(templateLiteralTypes1.ts, 143, 25)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 143, 36)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) +>K : Symbol(K, Decl(templateLiteralTypes1.ts, 137, 25)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 137, 36)) +>K : Symbol(K, Decl(templateLiteralTypes1.ts, 137, 25)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) +>PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 132, 69)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) +>K : Symbol(K, Decl(templateLiteralTypes1.ts, 137, 25)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 137, 36)) unknown; declare function getPropValue(obj: T, path: P): PropType; ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 146, 30)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 146, 32)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 146, 51)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 146, 30)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 146, 58)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 146, 32)) ->PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 138, 69)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 146, 30)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 146, 32)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 30)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 140, 32)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 140, 51)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 30)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 140, 58)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 140, 32)) +>PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 132, 69)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 30)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 140, 32)) declare const s: string; ->s : Symbol(s, Decl(templateLiteralTypes1.ts, 147, 13)) +>s : Symbol(s, Decl(templateLiteralTypes1.ts, 141, 13)) const obj = { a: { b: {c: 42, d: 'hello' }}}; ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 149, 13)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 149, 18)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 149, 23)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 149, 29)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 143, 13)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 143, 18)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 143, 23)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 143, 29)) getPropValue(obj, 'a'); // { b: {c: number, d: string } } ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) getPropValue(obj, 'a.b'); // {c: number, d: string } ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) getPropValue(obj, 'a.b.d'); // string ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) getPropValue(obj, 'a.b.x'); // unknown ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) getPropValue(obj, s); // unknown ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) ->s : Symbol(s, Decl(templateLiteralTypes1.ts, 147, 13)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) +>s : Symbol(s, Decl(templateLiteralTypes1.ts, 141, 13)) // Infer type variables in template literals have string constraint type S1 = T extends `foo${infer U}bar` ? S2 : never; ->S1 : Symbol(S1, Decl(templateLiteralTypes1.ts, 155, 21)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 159, 8)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 159, 8)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 159, 34)) ->S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 159, 58)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 159, 34)) +>S1 : Symbol(S1, Decl(templateLiteralTypes1.ts, 149, 21)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 153, 8)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 153, 8)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 153, 34)) +>S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 153, 58)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 153, 34)) type S2 = S; ->S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 159, 58)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 160, 8)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 160, 8)) +>S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 153, 58)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 154, 8)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 154, 8)) // Check that infer T declarations are validated type TV1 = `${infer X}`; ->TV1 : Symbol(TV1, Decl(templateLiteralTypes1.ts, 160, 30)) ->X : Symbol(X, Decl(templateLiteralTypes1.ts, 164, 19)) +>TV1 : Symbol(TV1, Decl(templateLiteralTypes1.ts, 154, 30)) +>X : Symbol(X, Decl(templateLiteralTypes1.ts, 158, 19)) // Batched single character inferences for lower recursion depth type Chars = ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) string extends S ? string[] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) S extends `${infer C0}${infer C1}${infer C2}${infer C3}${infer C4}${infer C5}${infer C6}${infer C7}${infer C8}${infer C9}${infer R}` ? [C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, ...Chars] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) ->C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 170, 22)) ->C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 170, 33)) ->C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 170, 44)) ->C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 170, 55)) ->C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 170, 66)) ->C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 170, 77)) ->C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 170, 88)) ->C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 170, 99)) ->C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 170, 110)) ->C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 170, 121)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 170, 132)) ->C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 170, 22)) ->C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 170, 33)) ->C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 170, 44)) ->C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 170, 55)) ->C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 170, 66)) ->C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 170, 77)) ->C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 170, 88)) ->C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 170, 99)) ->C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 170, 110)) ->C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 170, 121)) ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 170, 132)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) +>C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 164, 22)) +>C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 164, 33)) +>C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 164, 44)) +>C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 164, 55)) +>C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 164, 66)) +>C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 164, 77)) +>C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 164, 88)) +>C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 164, 99)) +>C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 164, 110)) +>C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 164, 121)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 164, 132)) +>C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 164, 22)) +>C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 164, 33)) +>C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 164, 44)) +>C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 164, 55)) +>C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 164, 66)) +>C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 164, 77)) +>C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 164, 88)) +>C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 164, 99)) +>C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 164, 110)) +>C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 164, 121)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 164, 132)) S extends `${infer C}${infer R}` ? [C, ...Chars] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) ->C : Symbol(C, Decl(templateLiteralTypes1.ts, 171, 22)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 171, 32)) ->C : Symbol(C, Decl(templateLiteralTypes1.ts, 171, 22)) ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 171, 32)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) +>C : Symbol(C, Decl(templateLiteralTypes1.ts, 165, 22)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 165, 32)) +>C : Symbol(C, Decl(templateLiteralTypes1.ts, 165, 22)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 165, 32)) S extends '' ? [] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) never; type L1 = Chars<'FooBarBazThisIsALongerString'>; // ['F', 'o', 'o', 'B', 'a', 'r', ...] ->L1 : Symbol(L1, Decl(templateLiteralTypes1.ts, 173, 10)) ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) +>L1 : Symbol(L1, Decl(templateLiteralTypes1.ts, 167, 10)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) // Infer never when source isn't a literal type that matches the pattern type Foo = T extends `*${infer S}*` ? S : never; ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 179, 9)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 179, 9)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 179, 33)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 179, 33)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 173, 9)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 173, 9)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 173, 33)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 173, 33)) type TF1 = Foo; // never ->TF1 : Symbol(TF1, Decl(templateLiteralTypes1.ts, 179, 51)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) +>TF1 : Symbol(TF1, Decl(templateLiteralTypes1.ts, 173, 51)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) type TF2 = Foo; // never ->TF2 : Symbol(TF2, Decl(templateLiteralTypes1.ts, 181, 20)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) +>TF2 : Symbol(TF2, Decl(templateLiteralTypes1.ts, 175, 20)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) type TF3 = Foo<'abc'>; // never ->TF3 : Symbol(TF3, Decl(templateLiteralTypes1.ts, 182, 23)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) +>TF3 : Symbol(TF3, Decl(templateLiteralTypes1.ts, 176, 23)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) type TF4 = Foo<'*abc*'>; // 'abc' ->TF4 : Symbol(TF4, Decl(templateLiteralTypes1.ts, 183, 22)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) +>TF4 : Symbol(TF4, Decl(templateLiteralTypes1.ts, 177, 22)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) // Cross product unions limited to 100,000 constituents type A = any; ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) type U1 = {a1:A} | {b1:A} | {c1:A} | {d1:A} | {e1:A} | {f1:A} | {g1:A} | {h1:A} | {i1:A} | {j1:A}; ->U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 188, 13)) ->a1 : Symbol(a1, Decl(templateLiteralTypes1.ts, 190, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->b1 : Symbol(b1, Decl(templateLiteralTypes1.ts, 190, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->c1 : Symbol(c1, Decl(templateLiteralTypes1.ts, 190, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->d1 : Symbol(d1, Decl(templateLiteralTypes1.ts, 190, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->e1 : Symbol(e1, Decl(templateLiteralTypes1.ts, 190, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->f1 : Symbol(f1, Decl(templateLiteralTypes1.ts, 190, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->g1 : Symbol(g1, Decl(templateLiteralTypes1.ts, 190, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->h1 : Symbol(h1, Decl(templateLiteralTypes1.ts, 190, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->i1 : Symbol(i1, Decl(templateLiteralTypes1.ts, 190, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->j1 : Symbol(j1, Decl(templateLiteralTypes1.ts, 190, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 182, 13)) +>a1 : Symbol(a1, Decl(templateLiteralTypes1.ts, 184, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>b1 : Symbol(b1, Decl(templateLiteralTypes1.ts, 184, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>c1 : Symbol(c1, Decl(templateLiteralTypes1.ts, 184, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>d1 : Symbol(d1, Decl(templateLiteralTypes1.ts, 184, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>e1 : Symbol(e1, Decl(templateLiteralTypes1.ts, 184, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>f1 : Symbol(f1, Decl(templateLiteralTypes1.ts, 184, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>g1 : Symbol(g1, Decl(templateLiteralTypes1.ts, 184, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>h1 : Symbol(h1, Decl(templateLiteralTypes1.ts, 184, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>i1 : Symbol(i1, Decl(templateLiteralTypes1.ts, 184, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>j1 : Symbol(j1, Decl(templateLiteralTypes1.ts, 184, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) type U2 = {a2:A} | {b2:A} | {c2:A} | {d2:A} | {e2:A} | {f2:A} | {g2:A} | {h2:A} | {i2:A} | {j2:A}; ->U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 190, 98)) ->a2 : Symbol(a2, Decl(templateLiteralTypes1.ts, 191, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->b2 : Symbol(b2, Decl(templateLiteralTypes1.ts, 191, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->c2 : Symbol(c2, Decl(templateLiteralTypes1.ts, 191, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->d2 : Symbol(d2, Decl(templateLiteralTypes1.ts, 191, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->e2 : Symbol(e2, Decl(templateLiteralTypes1.ts, 191, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->f2 : Symbol(f2, Decl(templateLiteralTypes1.ts, 191, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->g2 : Symbol(g2, Decl(templateLiteralTypes1.ts, 191, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->h2 : Symbol(h2, Decl(templateLiteralTypes1.ts, 191, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->i2 : Symbol(i2, Decl(templateLiteralTypes1.ts, 191, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->j2 : Symbol(j2, Decl(templateLiteralTypes1.ts, 191, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 184, 98)) +>a2 : Symbol(a2, Decl(templateLiteralTypes1.ts, 185, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>b2 : Symbol(b2, Decl(templateLiteralTypes1.ts, 185, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>c2 : Symbol(c2, Decl(templateLiteralTypes1.ts, 185, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>d2 : Symbol(d2, Decl(templateLiteralTypes1.ts, 185, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>e2 : Symbol(e2, Decl(templateLiteralTypes1.ts, 185, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>f2 : Symbol(f2, Decl(templateLiteralTypes1.ts, 185, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>g2 : Symbol(g2, Decl(templateLiteralTypes1.ts, 185, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>h2 : Symbol(h2, Decl(templateLiteralTypes1.ts, 185, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>i2 : Symbol(i2, Decl(templateLiteralTypes1.ts, 185, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>j2 : Symbol(j2, Decl(templateLiteralTypes1.ts, 185, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) type U3 = {a3:A} | {b3:A} | {c3:A} | {d3:A} | {e3:A} | {f3:A} | {g3:A} | {h3:A} | {i3:A} | {j3:A}; ->U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 191, 98)) ->a3 : Symbol(a3, Decl(templateLiteralTypes1.ts, 192, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->b3 : Symbol(b3, Decl(templateLiteralTypes1.ts, 192, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->c3 : Symbol(c3, Decl(templateLiteralTypes1.ts, 192, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->d3 : Symbol(d3, Decl(templateLiteralTypes1.ts, 192, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->e3 : Symbol(e3, Decl(templateLiteralTypes1.ts, 192, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->f3 : Symbol(f3, Decl(templateLiteralTypes1.ts, 192, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->g3 : Symbol(g3, Decl(templateLiteralTypes1.ts, 192, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->h3 : Symbol(h3, Decl(templateLiteralTypes1.ts, 192, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->i3 : Symbol(i3, Decl(templateLiteralTypes1.ts, 192, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->j3 : Symbol(j3, Decl(templateLiteralTypes1.ts, 192, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 185, 98)) +>a3 : Symbol(a3, Decl(templateLiteralTypes1.ts, 186, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>b3 : Symbol(b3, Decl(templateLiteralTypes1.ts, 186, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>c3 : Symbol(c3, Decl(templateLiteralTypes1.ts, 186, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>d3 : Symbol(d3, Decl(templateLiteralTypes1.ts, 186, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>e3 : Symbol(e3, Decl(templateLiteralTypes1.ts, 186, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>f3 : Symbol(f3, Decl(templateLiteralTypes1.ts, 186, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>g3 : Symbol(g3, Decl(templateLiteralTypes1.ts, 186, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>h3 : Symbol(h3, Decl(templateLiteralTypes1.ts, 186, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>i3 : Symbol(i3, Decl(templateLiteralTypes1.ts, 186, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>j3 : Symbol(j3, Decl(templateLiteralTypes1.ts, 186, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) type U4 = {a4:A} | {b4:A} | {c4:A} | {d4:A} | {e4:A} | {f4:A} | {g4:A} | {h4:A} | {i4:A} | {j4:A}; ->U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 192, 98)) ->a4 : Symbol(a4, Decl(templateLiteralTypes1.ts, 193, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->b4 : Symbol(b4, Decl(templateLiteralTypes1.ts, 193, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->c4 : Symbol(c4, Decl(templateLiteralTypes1.ts, 193, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->d4 : Symbol(d4, Decl(templateLiteralTypes1.ts, 193, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->e4 : Symbol(e4, Decl(templateLiteralTypes1.ts, 193, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->f4 : Symbol(f4, Decl(templateLiteralTypes1.ts, 193, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->g4 : Symbol(g4, Decl(templateLiteralTypes1.ts, 193, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->h4 : Symbol(h4, Decl(templateLiteralTypes1.ts, 193, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->i4 : Symbol(i4, Decl(templateLiteralTypes1.ts, 193, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->j4 : Symbol(j4, Decl(templateLiteralTypes1.ts, 193, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 186, 98)) +>a4 : Symbol(a4, Decl(templateLiteralTypes1.ts, 187, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>b4 : Symbol(b4, Decl(templateLiteralTypes1.ts, 187, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>c4 : Symbol(c4, Decl(templateLiteralTypes1.ts, 187, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>d4 : Symbol(d4, Decl(templateLiteralTypes1.ts, 187, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>e4 : Symbol(e4, Decl(templateLiteralTypes1.ts, 187, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>f4 : Symbol(f4, Decl(templateLiteralTypes1.ts, 187, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>g4 : Symbol(g4, Decl(templateLiteralTypes1.ts, 187, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>h4 : Symbol(h4, Decl(templateLiteralTypes1.ts, 187, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>i4 : Symbol(i4, Decl(templateLiteralTypes1.ts, 187, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>j4 : Symbol(j4, Decl(templateLiteralTypes1.ts, 187, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) type U5 = {a5:A} | {b5:A} | {c5:A} | {d5:A} | {e5:A} | {f5:A} | {g5:A} | {h5:A} | {i5:A} | {j5:A}; ->U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 193, 98)) ->a5 : Symbol(a5, Decl(templateLiteralTypes1.ts, 194, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->b5 : Symbol(b5, Decl(templateLiteralTypes1.ts, 194, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->c5 : Symbol(c5, Decl(templateLiteralTypes1.ts, 194, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->d5 : Symbol(d5, Decl(templateLiteralTypes1.ts, 194, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->e5 : Symbol(e5, Decl(templateLiteralTypes1.ts, 194, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->f5 : Symbol(f5, Decl(templateLiteralTypes1.ts, 194, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->g5 : Symbol(g5, Decl(templateLiteralTypes1.ts, 194, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->h5 : Symbol(h5, Decl(templateLiteralTypes1.ts, 194, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->i5 : Symbol(i5, Decl(templateLiteralTypes1.ts, 194, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) ->j5 : Symbol(j5, Decl(templateLiteralTypes1.ts, 194, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 187, 98)) +>a5 : Symbol(a5, Decl(templateLiteralTypes1.ts, 188, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>b5 : Symbol(b5, Decl(templateLiteralTypes1.ts, 188, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>c5 : Symbol(c5, Decl(templateLiteralTypes1.ts, 188, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>d5 : Symbol(d5, Decl(templateLiteralTypes1.ts, 188, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>e5 : Symbol(e5, Decl(templateLiteralTypes1.ts, 188, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>f5 : Symbol(f5, Decl(templateLiteralTypes1.ts, 188, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>g5 : Symbol(g5, Decl(templateLiteralTypes1.ts, 188, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>h5 : Symbol(h5, Decl(templateLiteralTypes1.ts, 188, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>i5 : Symbol(i5, Decl(templateLiteralTypes1.ts, 188, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>j5 : Symbol(j5, Decl(templateLiteralTypes1.ts, 188, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) type U100000 = U1 & U2 & U3 & U4 & U5; // Error ->U100000 : Symbol(U100000, Decl(templateLiteralTypes1.ts, 194, 98)) ->U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 188, 13)) ->U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 190, 98)) ->U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 191, 98)) ->U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 192, 98)) ->U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 193, 98)) +>U100000 : Symbol(U100000, Decl(templateLiteralTypes1.ts, 188, 98)) +>U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 182, 13)) +>U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 184, 98)) +>U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 185, 98)) +>U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 186, 98)) +>U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 187, 98)) type Digits = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) type D100000 = `${Digits}${Digits}${Digits}${Digits}${Digits}`; // Error ->D100000 : Symbol(D100000, Decl(templateLiteralTypes1.ts, 198, 52)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) +>D100000 : Symbol(D100000, Decl(templateLiteralTypes1.ts, 192, 52)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) type TDigits = [0] | [1] | [2] | [3] | [4] | [5] | [6] | [7] | [8] | [9]; ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) type T100000 = [...TDigits, ...TDigits, ...TDigits, ...TDigits, ...TDigits]; // Error ->T100000 : Symbol(T100000, Decl(templateLiteralTypes1.ts, 202, 73)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) +>T100000 : Symbol(T100000, Decl(templateLiteralTypes1.ts, 196, 73)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) diff --git a/tests/baselines/reference/templateLiteralTypes1.types b/tests/baselines/reference/templateLiteralTypes1.types index b34eecce1fcb0..eca2ec69871c6 100644 --- a/tests/baselines/reference/templateLiteralTypes1.types +++ b/tests/baselines/reference/templateLiteralTypes1.types @@ -185,18 +185,6 @@ type T26 = FirstTwoAndRest<'ab'>; // ['ab', ''] type T27 = FirstTwoAndRest<'a'>; // unknown >T27 : unknown -type Capitalize = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S; ->Capitalize : Capitalize - -type Uncapitalize = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S; ->Uncapitalize : Uncapitalize - -type TC1 = Capitalize<'foo'>; // 'Foo' ->TC1 : "Foo" - -type TC2 = Uncapitalize<'Foo'>; // 'foo' ->TC2 : "foo" - type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; >HexDigit : HexDigit diff --git a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts index a71badcc6efb1..b8d0af20845b6 100644 --- a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts +++ b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts @@ -88,12 +88,6 @@ type T25 = FirstTwoAndRest<'abcde'>; // ['ab', 'cde'] type T26 = FirstTwoAndRest<'ab'>; // ['ab', ''] type T27 = FirstTwoAndRest<'a'>; // unknown -type Capitalize = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S; -type Uncapitalize = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S; - -type TC1 = Capitalize<'foo'>; // 'Foo' -type TC2 = Uncapitalize<'Foo'>; // 'foo' - type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; type HexColor = From 7167b2505b8003d49fb8cda8f2bd0692eb4a5eb7 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 08:37:12 -1000 Subject: [PATCH 07/20] Accept new API baselines --- .../reference/api/tsserverlibrary.d.ts | 445 +++++++++--------- tests/baselines/reference/api/typescript.d.ts | 445 +++++++++--------- 2 files changed, 446 insertions(+), 444 deletions(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index c40829152eb1b..bc533d099b851 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -240,215 +240,216 @@ declare namespace ts { DeclareKeyword = 133, GetKeyword = 134, InferKeyword = 135, - IsKeyword = 136, - KeyOfKeyword = 137, - ModuleKeyword = 138, - NamespaceKeyword = 139, - NeverKeyword = 140, - ReadonlyKeyword = 141, - RequireKeyword = 142, - NumberKeyword = 143, - ObjectKeyword = 144, - SetKeyword = 145, - StringKeyword = 146, - SymbolKeyword = 147, - TypeKeyword = 148, - UndefinedKeyword = 149, - UniqueKeyword = 150, - UnknownKeyword = 151, - FromKeyword = 152, - GlobalKeyword = 153, - BigIntKeyword = 154, - UppercaseKeyword = 155, - LowercaseKeyword = 156, - CapitalizeKeyword = 157, - UncapitalizeKeyword = 158, - OfKeyword = 159, - QualifiedName = 160, - ComputedPropertyName = 161, - TypeParameter = 162, - Parameter = 163, - Decorator = 164, - PropertySignature = 165, - PropertyDeclaration = 166, - MethodSignature = 167, - MethodDeclaration = 168, - Constructor = 169, - GetAccessor = 170, - SetAccessor = 171, - CallSignature = 172, - ConstructSignature = 173, - IndexSignature = 174, - TypePredicate = 175, - TypeReference = 176, - FunctionType = 177, - ConstructorType = 178, - TypeQuery = 179, - TypeLiteral = 180, - ArrayType = 181, - TupleType = 182, - OptionalType = 183, - RestType = 184, - UnionType = 185, - IntersectionType = 186, - ConditionalType = 187, - InferType = 188, - ParenthesizedType = 189, - ThisType = 190, - TypeOperator = 191, - IndexedAccessType = 192, - MappedType = 193, - LiteralType = 194, - NamedTupleMember = 195, - TemplateLiteralType = 196, - TemplateLiteralTypeSpan = 197, - ImportType = 198, - ObjectBindingPattern = 199, - ArrayBindingPattern = 200, - BindingElement = 201, - ArrayLiteralExpression = 202, - ObjectLiteralExpression = 203, - PropertyAccessExpression = 204, - ElementAccessExpression = 205, - CallExpression = 206, - NewExpression = 207, - TaggedTemplateExpression = 208, - TypeAssertionExpression = 209, - ParenthesizedExpression = 210, - FunctionExpression = 211, - ArrowFunction = 212, - DeleteExpression = 213, - TypeOfExpression = 214, - VoidExpression = 215, - AwaitExpression = 216, - PrefixUnaryExpression = 217, - PostfixUnaryExpression = 218, - BinaryExpression = 219, - ConditionalExpression = 220, - TemplateExpression = 221, - YieldExpression = 222, - SpreadElement = 223, - ClassExpression = 224, - OmittedExpression = 225, - ExpressionWithTypeArguments = 226, - AsExpression = 227, - NonNullExpression = 228, - MetaProperty = 229, - SyntheticExpression = 230, - TemplateSpan = 231, - SemicolonClassElement = 232, - Block = 233, - EmptyStatement = 234, - VariableStatement = 235, - ExpressionStatement = 236, - IfStatement = 237, - DoStatement = 238, - WhileStatement = 239, - ForStatement = 240, - ForInStatement = 241, - ForOfStatement = 242, - ContinueStatement = 243, - BreakStatement = 244, - ReturnStatement = 245, - WithStatement = 246, - SwitchStatement = 247, - LabeledStatement = 248, - ThrowStatement = 249, - TryStatement = 250, - DebuggerStatement = 251, - VariableDeclaration = 252, - VariableDeclarationList = 253, - FunctionDeclaration = 254, - ClassDeclaration = 255, - InterfaceDeclaration = 256, - TypeAliasDeclaration = 257, - EnumDeclaration = 258, - ModuleDeclaration = 259, - ModuleBlock = 260, - CaseBlock = 261, - NamespaceExportDeclaration = 262, - ImportEqualsDeclaration = 263, - ImportDeclaration = 264, - ImportClause = 265, - NamespaceImport = 266, - NamedImports = 267, - ImportSpecifier = 268, - ExportAssignment = 269, - ExportDeclaration = 270, - NamedExports = 271, - NamespaceExport = 272, - ExportSpecifier = 273, - MissingDeclaration = 274, - ExternalModuleReference = 275, - JsxElement = 276, - JsxSelfClosingElement = 277, - JsxOpeningElement = 278, - JsxClosingElement = 279, - JsxFragment = 280, - JsxOpeningFragment = 281, - JsxClosingFragment = 282, - JsxAttribute = 283, - JsxAttributes = 284, - JsxSpreadAttribute = 285, - JsxExpression = 286, - CaseClause = 287, - DefaultClause = 288, - HeritageClause = 289, - CatchClause = 290, - PropertyAssignment = 291, - ShorthandPropertyAssignment = 292, - SpreadAssignment = 293, - EnumMember = 294, - UnparsedPrologue = 295, - UnparsedPrepend = 296, - UnparsedText = 297, - UnparsedInternalText = 298, - UnparsedSyntheticReference = 299, - SourceFile = 300, - Bundle = 301, - UnparsedSource = 302, - InputFiles = 303, - JSDocTypeExpression = 304, - JSDocNameReference = 305, - JSDocAllType = 306, - JSDocUnknownType = 307, - JSDocNullableType = 308, - JSDocNonNullableType = 309, - JSDocOptionalType = 310, - JSDocFunctionType = 311, - JSDocVariadicType = 312, - JSDocNamepathType = 313, - JSDocComment = 314, - JSDocTypeLiteral = 315, - JSDocSignature = 316, - JSDocTag = 317, - JSDocAugmentsTag = 318, - JSDocImplementsTag = 319, - JSDocAuthorTag = 320, - JSDocDeprecatedTag = 321, - JSDocClassTag = 322, - JSDocPublicTag = 323, - JSDocPrivateTag = 324, - JSDocProtectedTag = 325, - JSDocReadonlyTag = 326, - JSDocCallbackTag = 327, - JSDocEnumTag = 328, - JSDocParameterTag = 329, - JSDocReturnTag = 330, - JSDocThisTag = 331, - JSDocTypeTag = 332, - JSDocTemplateTag = 333, - JSDocTypedefTag = 334, - JSDocSeeTag = 335, - JSDocPropertyTag = 336, - SyntaxList = 337, - NotEmittedStatement = 338, - PartiallyEmittedExpression = 339, - CommaListExpression = 340, - MergeDeclarationMarker = 341, - EndOfDeclarationMarker = 342, - SyntheticReferenceExpression = 343, - Count = 344, + IntrinsicKeyword = 136, + IsKeyword = 137, + KeyOfKeyword = 138, + ModuleKeyword = 139, + NamespaceKeyword = 140, + NeverKeyword = 141, + ReadonlyKeyword = 142, + RequireKeyword = 143, + NumberKeyword = 144, + ObjectKeyword = 145, + SetKeyword = 146, + StringKeyword = 147, + SymbolKeyword = 148, + TypeKeyword = 149, + UndefinedKeyword = 150, + UniqueKeyword = 151, + UnknownKeyword = 152, + FromKeyword = 153, + GlobalKeyword = 154, + BigIntKeyword = 155, + UppercaseKeyword = 156, + LowercaseKeyword = 157, + CapitalizeKeyword = 158, + UncapitalizeKeyword = 159, + OfKeyword = 160, + QualifiedName = 161, + ComputedPropertyName = 162, + TypeParameter = 163, + Parameter = 164, + Decorator = 165, + PropertySignature = 166, + PropertyDeclaration = 167, + MethodSignature = 168, + MethodDeclaration = 169, + Constructor = 170, + GetAccessor = 171, + SetAccessor = 172, + CallSignature = 173, + ConstructSignature = 174, + IndexSignature = 175, + TypePredicate = 176, + TypeReference = 177, + FunctionType = 178, + ConstructorType = 179, + TypeQuery = 180, + TypeLiteral = 181, + ArrayType = 182, + TupleType = 183, + OptionalType = 184, + RestType = 185, + UnionType = 186, + IntersectionType = 187, + ConditionalType = 188, + InferType = 189, + ParenthesizedType = 190, + ThisType = 191, + TypeOperator = 192, + IndexedAccessType = 193, + MappedType = 194, + LiteralType = 195, + NamedTupleMember = 196, + TemplateLiteralType = 197, + TemplateLiteralTypeSpan = 198, + ImportType = 199, + ObjectBindingPattern = 200, + ArrayBindingPattern = 201, + BindingElement = 202, + ArrayLiteralExpression = 203, + ObjectLiteralExpression = 204, + PropertyAccessExpression = 205, + ElementAccessExpression = 206, + CallExpression = 207, + NewExpression = 208, + TaggedTemplateExpression = 209, + TypeAssertionExpression = 210, + ParenthesizedExpression = 211, + FunctionExpression = 212, + ArrowFunction = 213, + DeleteExpression = 214, + TypeOfExpression = 215, + VoidExpression = 216, + AwaitExpression = 217, + PrefixUnaryExpression = 218, + PostfixUnaryExpression = 219, + BinaryExpression = 220, + ConditionalExpression = 221, + TemplateExpression = 222, + YieldExpression = 223, + SpreadElement = 224, + ClassExpression = 225, + OmittedExpression = 226, + ExpressionWithTypeArguments = 227, + AsExpression = 228, + NonNullExpression = 229, + MetaProperty = 230, + SyntheticExpression = 231, + TemplateSpan = 232, + SemicolonClassElement = 233, + Block = 234, + EmptyStatement = 235, + VariableStatement = 236, + ExpressionStatement = 237, + IfStatement = 238, + DoStatement = 239, + WhileStatement = 240, + ForStatement = 241, + ForInStatement = 242, + ForOfStatement = 243, + ContinueStatement = 244, + BreakStatement = 245, + ReturnStatement = 246, + WithStatement = 247, + SwitchStatement = 248, + LabeledStatement = 249, + ThrowStatement = 250, + TryStatement = 251, + DebuggerStatement = 252, + VariableDeclaration = 253, + VariableDeclarationList = 254, + FunctionDeclaration = 255, + ClassDeclaration = 256, + InterfaceDeclaration = 257, + TypeAliasDeclaration = 258, + EnumDeclaration = 259, + ModuleDeclaration = 260, + ModuleBlock = 261, + CaseBlock = 262, + NamespaceExportDeclaration = 263, + ImportEqualsDeclaration = 264, + ImportDeclaration = 265, + ImportClause = 266, + NamespaceImport = 267, + NamedImports = 268, + ImportSpecifier = 269, + ExportAssignment = 270, + ExportDeclaration = 271, + NamedExports = 272, + NamespaceExport = 273, + ExportSpecifier = 274, + MissingDeclaration = 275, + ExternalModuleReference = 276, + JsxElement = 277, + JsxSelfClosingElement = 278, + JsxOpeningElement = 279, + JsxClosingElement = 280, + JsxFragment = 281, + JsxOpeningFragment = 282, + JsxClosingFragment = 283, + JsxAttribute = 284, + JsxAttributes = 285, + JsxSpreadAttribute = 286, + JsxExpression = 287, + CaseClause = 288, + DefaultClause = 289, + HeritageClause = 290, + CatchClause = 291, + PropertyAssignment = 292, + ShorthandPropertyAssignment = 293, + SpreadAssignment = 294, + EnumMember = 295, + UnparsedPrologue = 296, + UnparsedPrepend = 297, + UnparsedText = 298, + UnparsedInternalText = 299, + UnparsedSyntheticReference = 300, + SourceFile = 301, + Bundle = 302, + UnparsedSource = 303, + InputFiles = 304, + JSDocTypeExpression = 305, + JSDocNameReference = 306, + JSDocAllType = 307, + JSDocUnknownType = 308, + JSDocNullableType = 309, + JSDocNonNullableType = 310, + JSDocOptionalType = 311, + JSDocFunctionType = 312, + JSDocVariadicType = 313, + JSDocNamepathType = 314, + JSDocComment = 315, + JSDocTypeLiteral = 316, + JSDocSignature = 317, + JSDocTag = 318, + JSDocAugmentsTag = 319, + JSDocImplementsTag = 320, + JSDocAuthorTag = 321, + JSDocDeprecatedTag = 322, + JSDocClassTag = 323, + JSDocPublicTag = 324, + JSDocPrivateTag = 325, + JSDocProtectedTag = 326, + JSDocReadonlyTag = 327, + JSDocCallbackTag = 328, + JSDocEnumTag = 329, + JSDocParameterTag = 330, + JSDocReturnTag = 331, + JSDocThisTag = 332, + JSDocTypeTag = 333, + JSDocTemplateTag = 334, + JSDocTypedefTag = 335, + JSDocSeeTag = 336, + JSDocPropertyTag = 337, + SyntaxList = 338, + NotEmittedStatement = 339, + PartiallyEmittedExpression = 340, + CommaListExpression = 341, + MergeDeclarationMarker = 342, + EndOfDeclarationMarker = 343, + SyntheticReferenceExpression = 344, + Count = 345, FirstAssignment = 62, LastAssignment = 77, FirstCompoundAssignment = 63, @@ -456,15 +457,15 @@ declare namespace ts { FirstReservedWord = 80, LastReservedWord = 115, FirstKeyword = 80, - LastKeyword = 159, + LastKeyword = 160, FirstFutureReservedWord = 116, LastFutureReservedWord = 124, - FirstTypeNode = 175, - LastTypeNode = 198, + FirstTypeNode = 176, + LastTypeNode = 199, FirstPunctuation = 18, LastPunctuation = 77, FirstToken = 0, - LastToken = 159, + LastToken = 160, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -473,21 +474,21 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 77, - FirstStatement = 235, - LastStatement = 251, - FirstNode = 160, - FirstJSDocNode = 304, - LastJSDocNode = 336, - FirstJSDocTagNode = 317, - LastJSDocTagNode = 336, + FirstStatement = 236, + LastStatement = 252, + FirstNode = 161, + FirstJSDocNode = 305, + LastJSDocNode = 337, + FirstJSDocTagNode = 318, + LastJSDocTagNode = 337, } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail; export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken; - export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; + export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.StaticKeyword; - export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; + export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken; export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index e2892d52a5d58..4bbe281b15712 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -240,215 +240,216 @@ declare namespace ts { DeclareKeyword = 133, GetKeyword = 134, InferKeyword = 135, - IsKeyword = 136, - KeyOfKeyword = 137, - ModuleKeyword = 138, - NamespaceKeyword = 139, - NeverKeyword = 140, - ReadonlyKeyword = 141, - RequireKeyword = 142, - NumberKeyword = 143, - ObjectKeyword = 144, - SetKeyword = 145, - StringKeyword = 146, - SymbolKeyword = 147, - TypeKeyword = 148, - UndefinedKeyword = 149, - UniqueKeyword = 150, - UnknownKeyword = 151, - FromKeyword = 152, - GlobalKeyword = 153, - BigIntKeyword = 154, - UppercaseKeyword = 155, - LowercaseKeyword = 156, - CapitalizeKeyword = 157, - UncapitalizeKeyword = 158, - OfKeyword = 159, - QualifiedName = 160, - ComputedPropertyName = 161, - TypeParameter = 162, - Parameter = 163, - Decorator = 164, - PropertySignature = 165, - PropertyDeclaration = 166, - MethodSignature = 167, - MethodDeclaration = 168, - Constructor = 169, - GetAccessor = 170, - SetAccessor = 171, - CallSignature = 172, - ConstructSignature = 173, - IndexSignature = 174, - TypePredicate = 175, - TypeReference = 176, - FunctionType = 177, - ConstructorType = 178, - TypeQuery = 179, - TypeLiteral = 180, - ArrayType = 181, - TupleType = 182, - OptionalType = 183, - RestType = 184, - UnionType = 185, - IntersectionType = 186, - ConditionalType = 187, - InferType = 188, - ParenthesizedType = 189, - ThisType = 190, - TypeOperator = 191, - IndexedAccessType = 192, - MappedType = 193, - LiteralType = 194, - NamedTupleMember = 195, - TemplateLiteralType = 196, - TemplateLiteralTypeSpan = 197, - ImportType = 198, - ObjectBindingPattern = 199, - ArrayBindingPattern = 200, - BindingElement = 201, - ArrayLiteralExpression = 202, - ObjectLiteralExpression = 203, - PropertyAccessExpression = 204, - ElementAccessExpression = 205, - CallExpression = 206, - NewExpression = 207, - TaggedTemplateExpression = 208, - TypeAssertionExpression = 209, - ParenthesizedExpression = 210, - FunctionExpression = 211, - ArrowFunction = 212, - DeleteExpression = 213, - TypeOfExpression = 214, - VoidExpression = 215, - AwaitExpression = 216, - PrefixUnaryExpression = 217, - PostfixUnaryExpression = 218, - BinaryExpression = 219, - ConditionalExpression = 220, - TemplateExpression = 221, - YieldExpression = 222, - SpreadElement = 223, - ClassExpression = 224, - OmittedExpression = 225, - ExpressionWithTypeArguments = 226, - AsExpression = 227, - NonNullExpression = 228, - MetaProperty = 229, - SyntheticExpression = 230, - TemplateSpan = 231, - SemicolonClassElement = 232, - Block = 233, - EmptyStatement = 234, - VariableStatement = 235, - ExpressionStatement = 236, - IfStatement = 237, - DoStatement = 238, - WhileStatement = 239, - ForStatement = 240, - ForInStatement = 241, - ForOfStatement = 242, - ContinueStatement = 243, - BreakStatement = 244, - ReturnStatement = 245, - WithStatement = 246, - SwitchStatement = 247, - LabeledStatement = 248, - ThrowStatement = 249, - TryStatement = 250, - DebuggerStatement = 251, - VariableDeclaration = 252, - VariableDeclarationList = 253, - FunctionDeclaration = 254, - ClassDeclaration = 255, - InterfaceDeclaration = 256, - TypeAliasDeclaration = 257, - EnumDeclaration = 258, - ModuleDeclaration = 259, - ModuleBlock = 260, - CaseBlock = 261, - NamespaceExportDeclaration = 262, - ImportEqualsDeclaration = 263, - ImportDeclaration = 264, - ImportClause = 265, - NamespaceImport = 266, - NamedImports = 267, - ImportSpecifier = 268, - ExportAssignment = 269, - ExportDeclaration = 270, - NamedExports = 271, - NamespaceExport = 272, - ExportSpecifier = 273, - MissingDeclaration = 274, - ExternalModuleReference = 275, - JsxElement = 276, - JsxSelfClosingElement = 277, - JsxOpeningElement = 278, - JsxClosingElement = 279, - JsxFragment = 280, - JsxOpeningFragment = 281, - JsxClosingFragment = 282, - JsxAttribute = 283, - JsxAttributes = 284, - JsxSpreadAttribute = 285, - JsxExpression = 286, - CaseClause = 287, - DefaultClause = 288, - HeritageClause = 289, - CatchClause = 290, - PropertyAssignment = 291, - ShorthandPropertyAssignment = 292, - SpreadAssignment = 293, - EnumMember = 294, - UnparsedPrologue = 295, - UnparsedPrepend = 296, - UnparsedText = 297, - UnparsedInternalText = 298, - UnparsedSyntheticReference = 299, - SourceFile = 300, - Bundle = 301, - UnparsedSource = 302, - InputFiles = 303, - JSDocTypeExpression = 304, - JSDocNameReference = 305, - JSDocAllType = 306, - JSDocUnknownType = 307, - JSDocNullableType = 308, - JSDocNonNullableType = 309, - JSDocOptionalType = 310, - JSDocFunctionType = 311, - JSDocVariadicType = 312, - JSDocNamepathType = 313, - JSDocComment = 314, - JSDocTypeLiteral = 315, - JSDocSignature = 316, - JSDocTag = 317, - JSDocAugmentsTag = 318, - JSDocImplementsTag = 319, - JSDocAuthorTag = 320, - JSDocDeprecatedTag = 321, - JSDocClassTag = 322, - JSDocPublicTag = 323, - JSDocPrivateTag = 324, - JSDocProtectedTag = 325, - JSDocReadonlyTag = 326, - JSDocCallbackTag = 327, - JSDocEnumTag = 328, - JSDocParameterTag = 329, - JSDocReturnTag = 330, - JSDocThisTag = 331, - JSDocTypeTag = 332, - JSDocTemplateTag = 333, - JSDocTypedefTag = 334, - JSDocSeeTag = 335, - JSDocPropertyTag = 336, - SyntaxList = 337, - NotEmittedStatement = 338, - PartiallyEmittedExpression = 339, - CommaListExpression = 340, - MergeDeclarationMarker = 341, - EndOfDeclarationMarker = 342, - SyntheticReferenceExpression = 343, - Count = 344, + IntrinsicKeyword = 136, + IsKeyword = 137, + KeyOfKeyword = 138, + ModuleKeyword = 139, + NamespaceKeyword = 140, + NeverKeyword = 141, + ReadonlyKeyword = 142, + RequireKeyword = 143, + NumberKeyword = 144, + ObjectKeyword = 145, + SetKeyword = 146, + StringKeyword = 147, + SymbolKeyword = 148, + TypeKeyword = 149, + UndefinedKeyword = 150, + UniqueKeyword = 151, + UnknownKeyword = 152, + FromKeyword = 153, + GlobalKeyword = 154, + BigIntKeyword = 155, + UppercaseKeyword = 156, + LowercaseKeyword = 157, + CapitalizeKeyword = 158, + UncapitalizeKeyword = 159, + OfKeyword = 160, + QualifiedName = 161, + ComputedPropertyName = 162, + TypeParameter = 163, + Parameter = 164, + Decorator = 165, + PropertySignature = 166, + PropertyDeclaration = 167, + MethodSignature = 168, + MethodDeclaration = 169, + Constructor = 170, + GetAccessor = 171, + SetAccessor = 172, + CallSignature = 173, + ConstructSignature = 174, + IndexSignature = 175, + TypePredicate = 176, + TypeReference = 177, + FunctionType = 178, + ConstructorType = 179, + TypeQuery = 180, + TypeLiteral = 181, + ArrayType = 182, + TupleType = 183, + OptionalType = 184, + RestType = 185, + UnionType = 186, + IntersectionType = 187, + ConditionalType = 188, + InferType = 189, + ParenthesizedType = 190, + ThisType = 191, + TypeOperator = 192, + IndexedAccessType = 193, + MappedType = 194, + LiteralType = 195, + NamedTupleMember = 196, + TemplateLiteralType = 197, + TemplateLiteralTypeSpan = 198, + ImportType = 199, + ObjectBindingPattern = 200, + ArrayBindingPattern = 201, + BindingElement = 202, + ArrayLiteralExpression = 203, + ObjectLiteralExpression = 204, + PropertyAccessExpression = 205, + ElementAccessExpression = 206, + CallExpression = 207, + NewExpression = 208, + TaggedTemplateExpression = 209, + TypeAssertionExpression = 210, + ParenthesizedExpression = 211, + FunctionExpression = 212, + ArrowFunction = 213, + DeleteExpression = 214, + TypeOfExpression = 215, + VoidExpression = 216, + AwaitExpression = 217, + PrefixUnaryExpression = 218, + PostfixUnaryExpression = 219, + BinaryExpression = 220, + ConditionalExpression = 221, + TemplateExpression = 222, + YieldExpression = 223, + SpreadElement = 224, + ClassExpression = 225, + OmittedExpression = 226, + ExpressionWithTypeArguments = 227, + AsExpression = 228, + NonNullExpression = 229, + MetaProperty = 230, + SyntheticExpression = 231, + TemplateSpan = 232, + SemicolonClassElement = 233, + Block = 234, + EmptyStatement = 235, + VariableStatement = 236, + ExpressionStatement = 237, + IfStatement = 238, + DoStatement = 239, + WhileStatement = 240, + ForStatement = 241, + ForInStatement = 242, + ForOfStatement = 243, + ContinueStatement = 244, + BreakStatement = 245, + ReturnStatement = 246, + WithStatement = 247, + SwitchStatement = 248, + LabeledStatement = 249, + ThrowStatement = 250, + TryStatement = 251, + DebuggerStatement = 252, + VariableDeclaration = 253, + VariableDeclarationList = 254, + FunctionDeclaration = 255, + ClassDeclaration = 256, + InterfaceDeclaration = 257, + TypeAliasDeclaration = 258, + EnumDeclaration = 259, + ModuleDeclaration = 260, + ModuleBlock = 261, + CaseBlock = 262, + NamespaceExportDeclaration = 263, + ImportEqualsDeclaration = 264, + ImportDeclaration = 265, + ImportClause = 266, + NamespaceImport = 267, + NamedImports = 268, + ImportSpecifier = 269, + ExportAssignment = 270, + ExportDeclaration = 271, + NamedExports = 272, + NamespaceExport = 273, + ExportSpecifier = 274, + MissingDeclaration = 275, + ExternalModuleReference = 276, + JsxElement = 277, + JsxSelfClosingElement = 278, + JsxOpeningElement = 279, + JsxClosingElement = 280, + JsxFragment = 281, + JsxOpeningFragment = 282, + JsxClosingFragment = 283, + JsxAttribute = 284, + JsxAttributes = 285, + JsxSpreadAttribute = 286, + JsxExpression = 287, + CaseClause = 288, + DefaultClause = 289, + HeritageClause = 290, + CatchClause = 291, + PropertyAssignment = 292, + ShorthandPropertyAssignment = 293, + SpreadAssignment = 294, + EnumMember = 295, + UnparsedPrologue = 296, + UnparsedPrepend = 297, + UnparsedText = 298, + UnparsedInternalText = 299, + UnparsedSyntheticReference = 300, + SourceFile = 301, + Bundle = 302, + UnparsedSource = 303, + InputFiles = 304, + JSDocTypeExpression = 305, + JSDocNameReference = 306, + JSDocAllType = 307, + JSDocUnknownType = 308, + JSDocNullableType = 309, + JSDocNonNullableType = 310, + JSDocOptionalType = 311, + JSDocFunctionType = 312, + JSDocVariadicType = 313, + JSDocNamepathType = 314, + JSDocComment = 315, + JSDocTypeLiteral = 316, + JSDocSignature = 317, + JSDocTag = 318, + JSDocAugmentsTag = 319, + JSDocImplementsTag = 320, + JSDocAuthorTag = 321, + JSDocDeprecatedTag = 322, + JSDocClassTag = 323, + JSDocPublicTag = 324, + JSDocPrivateTag = 325, + JSDocProtectedTag = 326, + JSDocReadonlyTag = 327, + JSDocCallbackTag = 328, + JSDocEnumTag = 329, + JSDocParameterTag = 330, + JSDocReturnTag = 331, + JSDocThisTag = 332, + JSDocTypeTag = 333, + JSDocTemplateTag = 334, + JSDocTypedefTag = 335, + JSDocSeeTag = 336, + JSDocPropertyTag = 337, + SyntaxList = 338, + NotEmittedStatement = 339, + PartiallyEmittedExpression = 340, + CommaListExpression = 341, + MergeDeclarationMarker = 342, + EndOfDeclarationMarker = 343, + SyntheticReferenceExpression = 344, + Count = 345, FirstAssignment = 62, LastAssignment = 77, FirstCompoundAssignment = 63, @@ -456,15 +457,15 @@ declare namespace ts { FirstReservedWord = 80, LastReservedWord = 115, FirstKeyword = 80, - LastKeyword = 159, + LastKeyword = 160, FirstFutureReservedWord = 116, LastFutureReservedWord = 124, - FirstTypeNode = 175, - LastTypeNode = 198, + FirstTypeNode = 176, + LastTypeNode = 199, FirstPunctuation = 18, LastPunctuation = 77, FirstToken = 0, - LastToken = 159, + LastToken = 160, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -473,21 +474,21 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 77, - FirstStatement = 235, - LastStatement = 251, - FirstNode = 160, - FirstJSDocNode = 304, - LastJSDocNode = 336, - FirstJSDocTagNode = 317, - LastJSDocTagNode = 336, + FirstStatement = 236, + LastStatement = 252, + FirstNode = 161, + FirstJSDocNode = 305, + LastJSDocNode = 337, + FirstJSDocTagNode = 318, + LastJSDocTagNode = 337, } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail; export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken; - export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; + export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.StaticKeyword; - export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; + export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken; export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind; From 5230d842785a507fa45c684378e9c19d57d4627a Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 09:27:29 -1000 Subject: [PATCH 08/20] Minor fixes --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e69febccf38d7..c98af5f4b247a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -13545,10 +13545,10 @@ namespace ts { } function getStringMappingType(symbol: Symbol, type: Type): Type { - return type.flags & TypeFlags.Union ? mapType(type, t => getStringMappingType(symbol, t)) : + return type.flags & (TypeFlags.Union | TypeFlags.Never) ? mapType(type, t => getStringMappingType(symbol, t)) : isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : type.flags & TypeFlags.StringLiteral ? getLiteralType(symbol.escapedName === "Uppercase" ? (type).value.toUpperCase() : (type).value.toLowerCase()) : - stringType; + type; } function getStringMappingTypeForGenericType(symbol: Symbol, type: Type): Type { From aa17b5e117d73ca5efe7bebd7c1ff70013bea183 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 11:28:06 -1000 Subject: [PATCH 09/20] Switch Capitalize and Uncapitalize to intrinsic types --- src/compiler/checker.ts | 34 +++++++++++++++++++++++++++------- src/lib/es5.d.ts | 4 ++-- 2 files changed, 29 insertions(+), 9 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c98af5f4b247a..1b058f0515ba0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -256,6 +256,20 @@ namespace ts { VoidIsNonOptional = 1 << 1, } + const enum IntrinsicTypeKind { + Uppercase, + Lowercase, + Capitalize, + Uncapitalize + } + + const intrinsicTypeKinds: ReadonlyESMap = new Map(getEntries({ + Uppercase: IntrinsicTypeKind.Uppercase, + Lowercase: IntrinsicTypeKind.Lowercase, + Capitalize: IntrinsicTypeKind.Capitalize, + Uncapitalize: IntrinsicTypeKind.Uncapitalize + })); + function SymbolLinks(this: SymbolLinks) { } @@ -12132,7 +12146,7 @@ namespace ts { function getTypeAliasInstantiation(symbol: Symbol, typeArguments: readonly Type[] | undefined): Type { const type = getDeclaredTypeOfSymbol(symbol); - if (type === intrinsicMarkerType && isIntrinsicTypeName(symbol.escapedName as string) && typeArguments && typeArguments.length === 1) { + if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName as string) && typeArguments && typeArguments.length === 1) { return getStringMappingType(symbol, typeArguments[0]); } const links = getSymbolLinks(symbol); @@ -13547,10 +13561,20 @@ namespace ts { function getStringMappingType(symbol: Symbol, type: Type): Type { return type.flags & (TypeFlags.Union | TypeFlags.Never) ? mapType(type, t => getStringMappingType(symbol, t)) : isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : - type.flags & TypeFlags.StringLiteral ? getLiteralType(symbol.escapedName === "Uppercase" ? (type).value.toUpperCase() : (type).value.toLowerCase()) : + type.flags & TypeFlags.StringLiteral ? getLiteralType(applyStringMapping(symbol, (type).value)) : type; } + function applyStringMapping(symbol: Symbol, str: string) { + switch (intrinsicTypeKinds.get(symbol.escapedName as string)) { + case IntrinsicTypeKind.Uppercase: return str.toUpperCase(); + case IntrinsicTypeKind.Lowercase: return str.toLowerCase(); + case IntrinsicTypeKind.Capitalize: return str.charAt(0).toUpperCase() + str.slice(1); + case IntrinsicTypeKind.Uncapitalize: return str.charAt(0).toLowerCase() + str.slice(1); + } + return str; + } + function getStringMappingTypeForGenericType(symbol: Symbol, type: Type): Type { const id = `${getSymbolId(symbol)},${getTypeId(type)}`; let result = stringMappingTypes.get(id); @@ -35344,7 +35368,7 @@ namespace ts { checkExportsOnMergedDeclarations(node); checkTypeParameters(node.typeParameters); if (node.type.kind === SyntaxKind.IntrinsicKeyword) { - if (!isIntrinsicTypeName(node.name.escapedText as string) || length(node.typeParameters) !== 1) { + if (!intrinsicTypeKinds.has(node.name.escapedText as string) || length(node.typeParameters) !== 1) { error(node.type, Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types); } } @@ -35354,10 +35378,6 @@ namespace ts { } } - function isIntrinsicTypeName(name: string) { - return name === "Uppercase" || name === "Lowercase"; - } - function computeEnumMemberValues(node: EnumDeclaration) { const nodeLinks = getNodeLinks(node); if (!(nodeLinks.flags & NodeCheckFlags.EnumValuesComputed)) { diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index dcb1d4ced41f8..cf95c473240fe 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1521,12 +1521,12 @@ type Lowercase = intrinsic; /** * Convert first character of string literal type to uppercase */ -type Capitalize = S extends `${infer H}${infer T}` ? `${Uppercase}${T}` : S; +type Capitalize = intrinsic; /** * Convert first character of string literal type to lowercase */ -type Uncapitalize = S extends `${infer H}${infer T}` ? `${Lowercase}${T}` : S; +type Uncapitalize = intrinsic; /** * Marker for contextual 'this' type From b55d3f3161cb3a793b262687d149f8153fc73270 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 13:53:58 -1000 Subject: [PATCH 10/20] Add tests --- .../types/typeAliases/intrinsicTypes.ts | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 tests/cases/conformance/types/typeAliases/intrinsicTypes.ts diff --git a/tests/cases/conformance/types/typeAliases/intrinsicTypes.ts b/tests/cases/conformance/types/typeAliases/intrinsicTypes.ts new file mode 100644 index 0000000000000..cfdf08d0609f0 --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/intrinsicTypes.ts @@ -0,0 +1,57 @@ +// @strict: true +// @declaration: true + +type TU1 = Uppercase<'hello'>; // "HELLO" +type TU2 = Uppercase<'foo' | 'bar'>; // "FOO" | "BAR" +type TU3 = Uppercase; // string +type TU4 = Uppercase; // any +type TU5 = Uppercase; // never +type TU6 = Uppercase<42>; // Error + +type TL1 = Lowercase<'HELLO'>; // "hello" +type TL2 = Lowercase<'FOO' | 'BAR'>; // "foo" | "bar" +type TL3 = Lowercase; // string +type TL4 = Lowercase; // any +type TL5 = Lowercase; // never +type TL6 = Lowercase<42>; // Error + +type TC1 = Capitalize<'hello'>; // "Hello" +type TC2 = Capitalize<'foo' | 'bar'>; // "Foo" | "Bar" +type TC3 = Capitalize; // string +type TC4 = Capitalize; // any +type TC5 = Capitalize; // never +type TC6 = Capitalize<42>; // Error + +type TN1 = Uncapitalize<'Hello'>; // "hello" +type TN2 = Uncapitalize<'Foo' | 'Bar'>; // "foo" | "bar" +type TN3 = Uncapitalize; // string +type TN4 = Uncapitalize; // any +type TN5 = Uncapitalize; // never +type TN6 = Uncapitalize<42>; // Error + +type TX1 = Uppercase<`aB${S}`>; +type TX2 = TX1<'xYz'>; // "ABXYZ" +type TX3 = Lowercase<`aB${S}`>; +type TX4 = TX3<'xYz'>; // "abxyz" +type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`; // "ABCxyz" + +type MyUppercase = intrinsic; // Error + +function foo1(s: string, x: Uppercase, y: Uppercase) { + s = x; + s = y; + x = s; // Error + x = y; + y = s; // Error + y = x; // Error +} + +function foo2(x: Uppercase) { + let s: 'FOO' | 'BAR' = x; +} + +declare function foo3(x: Uppercase): T; + +function foo4(x: Uppercase) { + return foo3(x); +} From b9c395d5de1f1ebf823c0e876b625834b56695b4 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 13:54:06 -1000 Subject: [PATCH 11/20] Accept new baselines --- .../reference/intrinsicTypes.errors.txt | 90 ++++++++ tests/baselines/reference/intrinsicTypes.js | 110 ++++++++++ .../reference/intrinsicTypes.symbols | 196 ++++++++++++++++++ .../baselines/reference/intrinsicTypes.types | 151 ++++++++++++++ 4 files changed, 547 insertions(+) create mode 100644 tests/baselines/reference/intrinsicTypes.errors.txt create mode 100644 tests/baselines/reference/intrinsicTypes.js create mode 100644 tests/baselines/reference/intrinsicTypes.symbols create mode 100644 tests/baselines/reference/intrinsicTypes.types diff --git a/tests/baselines/reference/intrinsicTypes.errors.txt b/tests/baselines/reference/intrinsicTypes.errors.txt new file mode 100644 index 0000000000000..6d9b05c9564f6 --- /dev/null +++ b/tests/baselines/reference/intrinsicTypes.errors.txt @@ -0,0 +1,90 @@ +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(6,22): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(13,22): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(20,23): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(27,25): error TS2344: Type 'number' does not satisfy the constraint 'string'. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(35,38): error TS2794: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(40,5): error TS2322: Type 'string' is not assignable to type 'Uppercase'. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(42,5): error TS2322: Type 'string' is not assignable to type 'Uppercase'. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(43,5): error TS2322: Type 'Uppercase' is not assignable to type 'Uppercase'. + Type 'T' is not assignable to type 'U'. + 'T' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint 'string'. + Type 'string' is not assignable to type 'U'. + 'string' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint 'string'. + + +==== tests/cases/conformance/types/typeAliases/intrinsicTypes.ts (8 errors) ==== + type TU1 = Uppercase<'hello'>; // "HELLO" + type TU2 = Uppercase<'foo' | 'bar'>; // "FOO" | "BAR" + type TU3 = Uppercase; // string + type TU4 = Uppercase; // any + type TU5 = Uppercase; // never + type TU6 = Uppercase<42>; // Error + ~~ +!!! error TS2344: Type 'number' does not satisfy the constraint 'string'. + + type TL1 = Lowercase<'HELLO'>; // "hello" + type TL2 = Lowercase<'FOO' | 'BAR'>; // "foo" | "bar" + type TL3 = Lowercase; // string + type TL4 = Lowercase; // any + type TL5 = Lowercase; // never + type TL6 = Lowercase<42>; // Error + ~~ +!!! error TS2344: Type 'number' does not satisfy the constraint 'string'. + + type TC1 = Capitalize<'hello'>; // "Hello" + type TC2 = Capitalize<'foo' | 'bar'>; // "Foo" | "Bar" + type TC3 = Capitalize; // string + type TC4 = Capitalize; // any + type TC5 = Capitalize; // never + type TC6 = Capitalize<42>; // Error + ~~ +!!! error TS2344: Type 'number' does not satisfy the constraint 'string'. + + type TN1 = Uncapitalize<'Hello'>; // "hello" + type TN2 = Uncapitalize<'Foo' | 'Bar'>; // "foo" | "bar" + type TN3 = Uncapitalize; // string + type TN4 = Uncapitalize; // any + type TN5 = Uncapitalize; // never + type TN6 = Uncapitalize<42>; // Error + ~~ +!!! error TS2344: Type 'number' does not satisfy the constraint 'string'. + + type TX1 = Uppercase<`aB${S}`>; + type TX2 = TX1<'xYz'>; // "ABXYZ" + type TX3 = Lowercase<`aB${S}`>; + type TX4 = TX3<'xYz'>; // "abxyz" + type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`; // "ABCxyz" + + type MyUppercase = intrinsic; // Error + ~~~~~~~~~ +!!! error TS2794: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. + + function foo1(s: string, x: Uppercase, y: Uppercase) { + s = x; + s = y; + x = s; // Error + ~ +!!! error TS2322: Type 'string' is not assignable to type 'Uppercase'. + x = y; + y = s; // Error + ~ +!!! error TS2322: Type 'string' is not assignable to type 'Uppercase'. + y = x; // Error + ~ +!!! error TS2322: Type 'Uppercase' is not assignable to type 'Uppercase'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. +!!! error TS2322: 'T' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint 'string'. +!!! error TS2322: Type 'string' is not assignable to type 'U'. +!!! error TS2322: 'string' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint 'string'. + } + + function foo2(x: Uppercase) { + let s: 'FOO' | 'BAR' = x; + } + + declare function foo3(x: Uppercase): T; + + function foo4(x: Uppercase) { + return foo3(x); + } + \ No newline at end of file diff --git a/tests/baselines/reference/intrinsicTypes.js b/tests/baselines/reference/intrinsicTypes.js new file mode 100644 index 0000000000000..697371da226ff --- /dev/null +++ b/tests/baselines/reference/intrinsicTypes.js @@ -0,0 +1,110 @@ +//// [intrinsicTypes.ts] +type TU1 = Uppercase<'hello'>; // "HELLO" +type TU2 = Uppercase<'foo' | 'bar'>; // "FOO" | "BAR" +type TU3 = Uppercase; // string +type TU4 = Uppercase; // any +type TU5 = Uppercase; // never +type TU6 = Uppercase<42>; // Error + +type TL1 = Lowercase<'HELLO'>; // "hello" +type TL2 = Lowercase<'FOO' | 'BAR'>; // "foo" | "bar" +type TL3 = Lowercase; // string +type TL4 = Lowercase; // any +type TL5 = Lowercase; // never +type TL6 = Lowercase<42>; // Error + +type TC1 = Capitalize<'hello'>; // "Hello" +type TC2 = Capitalize<'foo' | 'bar'>; // "Foo" | "Bar" +type TC3 = Capitalize; // string +type TC4 = Capitalize; // any +type TC5 = Capitalize; // never +type TC6 = Capitalize<42>; // Error + +type TN1 = Uncapitalize<'Hello'>; // "hello" +type TN2 = Uncapitalize<'Foo' | 'Bar'>; // "foo" | "bar" +type TN3 = Uncapitalize; // string +type TN4 = Uncapitalize; // any +type TN5 = Uncapitalize; // never +type TN6 = Uncapitalize<42>; // Error + +type TX1 = Uppercase<`aB${S}`>; +type TX2 = TX1<'xYz'>; // "ABXYZ" +type TX3 = Lowercase<`aB${S}`>; +type TX4 = TX3<'xYz'>; // "abxyz" +type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`; // "ABCxyz" + +type MyUppercase = intrinsic; // Error + +function foo1(s: string, x: Uppercase, y: Uppercase) { + s = x; + s = y; + x = s; // Error + x = y; + y = s; // Error + y = x; // Error +} + +function foo2(x: Uppercase) { + let s: 'FOO' | 'BAR' = x; +} + +declare function foo3(x: Uppercase): T; + +function foo4(x: Uppercase) { + return foo3(x); +} + + +//// [intrinsicTypes.js] +"use strict"; +function foo1(s, x, y) { + s = x; + s = y; + x = s; // Error + x = y; + y = s; // Error + y = x; // Error +} +function foo2(x) { + var s = x; +} +function foo4(x) { + return foo3(x); +} + + +//// [intrinsicTypes.d.ts] +declare type TU1 = Uppercase<'hello'>; +declare type TU2 = Uppercase<'foo' | 'bar'>; +declare type TU3 = Uppercase; +declare type TU4 = Uppercase; +declare type TU5 = Uppercase; +declare type TU6 = Uppercase<42>; +declare type TL1 = Lowercase<'HELLO'>; +declare type TL2 = Lowercase<'FOO' | 'BAR'>; +declare type TL3 = Lowercase; +declare type TL4 = Lowercase; +declare type TL5 = Lowercase; +declare type TL6 = Lowercase<42>; +declare type TC1 = Capitalize<'hello'>; +declare type TC2 = Capitalize<'foo' | 'bar'>; +declare type TC3 = Capitalize; +declare type TC4 = Capitalize; +declare type TC5 = Capitalize; +declare type TC6 = Capitalize<42>; +declare type TN1 = Uncapitalize<'Hello'>; +declare type TN2 = Uncapitalize<'Foo' | 'Bar'>; +declare type TN3 = Uncapitalize; +declare type TN4 = Uncapitalize; +declare type TN5 = Uncapitalize; +declare type TN6 = Uncapitalize<42>; +declare type TX1 = Uppercase<`aB${S}`>; +declare type TX2 = TX1<'xYz'>; +declare type TX3 = Lowercase<`aB${S}`>; +declare type TX4 = TX3<'xYz'>; +declare type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`; +declare type MyUppercase = intrinsic; +declare function foo1(s: string, x: Uppercase, y: Uppercase): void; +declare function foo2(x: Uppercase): void; +declare function foo3(x: Uppercase): T; +declare function foo4(x: Uppercase): U; diff --git a/tests/baselines/reference/intrinsicTypes.symbols b/tests/baselines/reference/intrinsicTypes.symbols new file mode 100644 index 0000000000000..13efe08aaa237 --- /dev/null +++ b/tests/baselines/reference/intrinsicTypes.symbols @@ -0,0 +1,196 @@ +=== tests/cases/conformance/types/typeAliases/intrinsicTypes.ts === +type TU1 = Uppercase<'hello'>; // "HELLO" +>TU1 : Symbol(TU1, Decl(intrinsicTypes.ts, 0, 0)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) + +type TU2 = Uppercase<'foo' | 'bar'>; // "FOO" | "BAR" +>TU2 : Symbol(TU2, Decl(intrinsicTypes.ts, 0, 30)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) + +type TU3 = Uppercase; // string +>TU3 : Symbol(TU3, Decl(intrinsicTypes.ts, 1, 36)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) + +type TU4 = Uppercase; // any +>TU4 : Symbol(TU4, Decl(intrinsicTypes.ts, 2, 29)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) + +type TU5 = Uppercase; // never +>TU5 : Symbol(TU5, Decl(intrinsicTypes.ts, 3, 26)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) + +type TU6 = Uppercase<42>; // Error +>TU6 : Symbol(TU6, Decl(intrinsicTypes.ts, 4, 28)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) + +type TL1 = Lowercase<'HELLO'>; // "hello" +>TL1 : Symbol(TL1, Decl(intrinsicTypes.ts, 5, 25)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type TL2 = Lowercase<'FOO' | 'BAR'>; // "foo" | "bar" +>TL2 : Symbol(TL2, Decl(intrinsicTypes.ts, 7, 30)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type TL3 = Lowercase; // string +>TL3 : Symbol(TL3, Decl(intrinsicTypes.ts, 8, 36)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type TL4 = Lowercase; // any +>TL4 : Symbol(TL4, Decl(intrinsicTypes.ts, 9, 29)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type TL5 = Lowercase; // never +>TL5 : Symbol(TL5, Decl(intrinsicTypes.ts, 10, 26)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type TL6 = Lowercase<42>; // Error +>TL6 : Symbol(TL6, Decl(intrinsicTypes.ts, 11, 28)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type TC1 = Capitalize<'hello'>; // "Hello" +>TC1 : Symbol(TC1, Decl(intrinsicTypes.ts, 12, 25)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) + +type TC2 = Capitalize<'foo' | 'bar'>; // "Foo" | "Bar" +>TC2 : Symbol(TC2, Decl(intrinsicTypes.ts, 14, 31)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) + +type TC3 = Capitalize; // string +>TC3 : Symbol(TC3, Decl(intrinsicTypes.ts, 15, 37)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) + +type TC4 = Capitalize; // any +>TC4 : Symbol(TC4, Decl(intrinsicTypes.ts, 16, 30)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) + +type TC5 = Capitalize; // never +>TC5 : Symbol(TC5, Decl(intrinsicTypes.ts, 17, 27)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) + +type TC6 = Capitalize<42>; // Error +>TC6 : Symbol(TC6, Decl(intrinsicTypes.ts, 18, 29)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) + +type TN1 = Uncapitalize<'Hello'>; // "hello" +>TN1 : Symbol(TN1, Decl(intrinsicTypes.ts, 19, 26)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) + +type TN2 = Uncapitalize<'Foo' | 'Bar'>; // "foo" | "bar" +>TN2 : Symbol(TN2, Decl(intrinsicTypes.ts, 21, 33)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) + +type TN3 = Uncapitalize; // string +>TN3 : Symbol(TN3, Decl(intrinsicTypes.ts, 22, 39)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) + +type TN4 = Uncapitalize; // any +>TN4 : Symbol(TN4, Decl(intrinsicTypes.ts, 23, 32)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) + +type TN5 = Uncapitalize; // never +>TN5 : Symbol(TN5, Decl(intrinsicTypes.ts, 24, 29)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) + +type TN6 = Uncapitalize<42>; // Error +>TN6 : Symbol(TN6, Decl(intrinsicTypes.ts, 25, 31)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) + +type TX1 = Uppercase<`aB${S}`>; +>TX1 : Symbol(TX1, Decl(intrinsicTypes.ts, 26, 28)) +>S : Symbol(S, Decl(intrinsicTypes.ts, 28, 9)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>S : Symbol(S, Decl(intrinsicTypes.ts, 28, 9)) + +type TX2 = TX1<'xYz'>; // "ABXYZ" +>TX2 : Symbol(TX2, Decl(intrinsicTypes.ts, 28, 49)) +>TX1 : Symbol(TX1, Decl(intrinsicTypes.ts, 26, 28)) + +type TX3 = Lowercase<`aB${S}`>; +>TX3 : Symbol(TX3, Decl(intrinsicTypes.ts, 29, 22)) +>S : Symbol(S, Decl(intrinsicTypes.ts, 30, 9)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) +>S : Symbol(S, Decl(intrinsicTypes.ts, 30, 9)) + +type TX4 = TX3<'xYz'>; // "abxyz" +>TX4 : Symbol(TX4, Decl(intrinsicTypes.ts, 30, 49)) +>TX3 : Symbol(TX3, Decl(intrinsicTypes.ts, 29, 22)) + +type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`; // "ABCxyz" +>TX5 : Symbol(TX5, Decl(intrinsicTypes.ts, 31, 22)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) + +type MyUppercase = intrinsic; // Error +>MyUppercase : Symbol(MyUppercase, Decl(intrinsicTypes.ts, 32, 52)) +>S : Symbol(S, Decl(intrinsicTypes.ts, 34, 17)) + +function foo1(s: string, x: Uppercase, y: Uppercase) { +>foo1 : Symbol(foo1, Decl(intrinsicTypes.ts, 34, 47)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 36, 14)) +>U : Symbol(U, Decl(intrinsicTypes.ts, 36, 31)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 36, 14)) +>s : Symbol(s, Decl(intrinsicTypes.ts, 36, 45)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 36, 55)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 36, 14)) +>y : Symbol(y, Decl(intrinsicTypes.ts, 36, 72)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>U : Symbol(U, Decl(intrinsicTypes.ts, 36, 31)) + + s = x; +>s : Symbol(s, Decl(intrinsicTypes.ts, 36, 45)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 36, 55)) + + s = y; +>s : Symbol(s, Decl(intrinsicTypes.ts, 36, 45)) +>y : Symbol(y, Decl(intrinsicTypes.ts, 36, 72)) + + x = s; // Error +>x : Symbol(x, Decl(intrinsicTypes.ts, 36, 55)) +>s : Symbol(s, Decl(intrinsicTypes.ts, 36, 45)) + + x = y; +>x : Symbol(x, Decl(intrinsicTypes.ts, 36, 55)) +>y : Symbol(y, Decl(intrinsicTypes.ts, 36, 72)) + + y = s; // Error +>y : Symbol(y, Decl(intrinsicTypes.ts, 36, 72)) +>s : Symbol(s, Decl(intrinsicTypes.ts, 36, 45)) + + y = x; // Error +>y : Symbol(y, Decl(intrinsicTypes.ts, 36, 72)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 36, 55)) +} + +function foo2(x: Uppercase) { +>foo2 : Symbol(foo2, Decl(intrinsicTypes.ts, 43, 1)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 45, 14)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 45, 39)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 45, 14)) + + let s: 'FOO' | 'BAR' = x; +>s : Symbol(s, Decl(intrinsicTypes.ts, 46, 7)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 45, 39)) +} + +declare function foo3(x: Uppercase): T; +>foo3 : Symbol(foo3, Decl(intrinsicTypes.ts, 47, 1)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 49, 22)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 49, 40)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 49, 22)) +>T : Symbol(T, Decl(intrinsicTypes.ts, 49, 22)) + +function foo4(x: Uppercase) { +>foo4 : Symbol(foo4, Decl(intrinsicTypes.ts, 49, 60)) +>U : Symbol(U, Decl(intrinsicTypes.ts, 51, 14)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 51, 32)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>U : Symbol(U, Decl(intrinsicTypes.ts, 51, 14)) + + return foo3(x); +>foo3 : Symbol(foo3, Decl(intrinsicTypes.ts, 47, 1)) +>x : Symbol(x, Decl(intrinsicTypes.ts, 51, 32)) +} + diff --git a/tests/baselines/reference/intrinsicTypes.types b/tests/baselines/reference/intrinsicTypes.types new file mode 100644 index 0000000000000..e57a5f22ed35e --- /dev/null +++ b/tests/baselines/reference/intrinsicTypes.types @@ -0,0 +1,151 @@ +=== tests/cases/conformance/types/typeAliases/intrinsicTypes.ts === +type TU1 = Uppercase<'hello'>; // "HELLO" +>TU1 : "HELLO" + +type TU2 = Uppercase<'foo' | 'bar'>; // "FOO" | "BAR" +>TU2 : "FOO" | "BAR" + +type TU3 = Uppercase; // string +>TU3 : string + +type TU4 = Uppercase; // any +>TU4 : any + +type TU5 = Uppercase; // never +>TU5 : never + +type TU6 = Uppercase<42>; // Error +>TU6 : 42 + +type TL1 = Lowercase<'HELLO'>; // "hello" +>TL1 : "hello" + +type TL2 = Lowercase<'FOO' | 'BAR'>; // "foo" | "bar" +>TL2 : "foo" | "bar" + +type TL3 = Lowercase; // string +>TL3 : string + +type TL4 = Lowercase; // any +>TL4 : any + +type TL5 = Lowercase; // never +>TL5 : never + +type TL6 = Lowercase<42>; // Error +>TL6 : 42 + +type TC1 = Capitalize<'hello'>; // "Hello" +>TC1 : "Hello" + +type TC2 = Capitalize<'foo' | 'bar'>; // "Foo" | "Bar" +>TC2 : "Foo" | "Bar" + +type TC3 = Capitalize; // string +>TC3 : string + +type TC4 = Capitalize; // any +>TC4 : any + +type TC5 = Capitalize; // never +>TC5 : never + +type TC6 = Capitalize<42>; // Error +>TC6 : 42 + +type TN1 = Uncapitalize<'Hello'>; // "hello" +>TN1 : "hello" + +type TN2 = Uncapitalize<'Foo' | 'Bar'>; // "foo" | "bar" +>TN2 : "foo" | "bar" + +type TN3 = Uncapitalize; // string +>TN3 : string + +type TN4 = Uncapitalize; // any +>TN4 : any + +type TN5 = Uncapitalize; // never +>TN5 : never + +type TN6 = Uncapitalize<42>; // Error +>TN6 : 42 + +type TX1 = Uppercase<`aB${S}`>; +>TX1 : Uppercase<`aB${S}`> + +type TX2 = TX1<'xYz'>; // "ABXYZ" +>TX2 : "ABXYZ" + +type TX3 = Lowercase<`aB${S}`>; +>TX3 : Lowercase<`aB${S}`> + +type TX4 = TX3<'xYz'>; // "abxyz" +>TX4 : "abxyz" + +type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`; // "ABCxyz" +>TX5 : "ABCxyz" + +type MyUppercase = intrinsic; // Error +>MyUppercase : intrinsic + +function foo1(s: string, x: Uppercase, y: Uppercase) { +>foo1 : (s: string, x: Uppercase, y: Uppercase) => void +>s : string +>x : Uppercase +>y : Uppercase + + s = x; +>s = x : Uppercase +>s : string +>x : Uppercase + + s = y; +>s = y : Uppercase +>s : string +>y : Uppercase + + x = s; // Error +>x = s : string +>x : Uppercase +>s : string + + x = y; +>x = y : Uppercase +>x : Uppercase +>y : Uppercase + + y = s; // Error +>y = s : string +>y : Uppercase +>s : string + + y = x; // Error +>y = x : Uppercase +>y : Uppercase +>x : Uppercase +} + +function foo2(x: Uppercase) { +>foo2 : (x: Uppercase) => void +>x : Uppercase + + let s: 'FOO' | 'BAR' = x; +>s : "FOO" | "BAR" +>x : Uppercase +} + +declare function foo3(x: Uppercase): T; +>foo3 : (x: Uppercase) => T +>x : Uppercase + +function foo4(x: Uppercase) { +>foo4 : (x: Uppercase) => U +>x : Uppercase + + return foo3(x); +>foo3(x) : U +>foo3 : (x: Uppercase) => T +>x : Uppercase +} + From de5e589be8efa278a1d4e4d2589f927f35bb6933 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 15 Sep 2020 16:28:46 -1000 Subject: [PATCH 12/20] Accept new baselines --- tests/baselines/reference/intrinsicTypes.errors.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/baselines/reference/intrinsicTypes.errors.txt b/tests/baselines/reference/intrinsicTypes.errors.txt index 6d9b05c9564f6..46a3ab82ec14a 100644 --- a/tests/baselines/reference/intrinsicTypes.errors.txt +++ b/tests/baselines/reference/intrinsicTypes.errors.txt @@ -2,7 +2,7 @@ tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(6,22): error TS2344: tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(13,22): error TS2344: Type 'number' does not satisfy the constraint 'string'. tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(20,23): error TS2344: Type 'number' does not satisfy the constraint 'string'. tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(27,25): error TS2344: Type 'number' does not satisfy the constraint 'string'. -tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(35,38): error TS2794: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. +tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(35,38): error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(40,5): error TS2322: Type 'string' is not assignable to type 'Uppercase'. tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(42,5): error TS2322: Type 'string' is not assignable to type 'Uppercase'. tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(43,5): error TS2322: Type 'Uppercase' is not assignable to type 'Uppercase'. @@ -57,7 +57,7 @@ tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(43,5): error TS2322: type MyUppercase = intrinsic; // Error ~~~~~~~~~ -!!! error TS2794: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. +!!! error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. function foo1(s: string, x: Uppercase, y: Uppercase) { s = x; From a5b3c611e4c606473931de4bdb10bc86d1464f7a Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 16 Sep 2020 07:36:50 -1000 Subject: [PATCH 13/20] Remove template literal type casing modifiers --- src/compiler/checker.ts | 35 ++++++++--------------------- src/compiler/emitter.ts | 9 -------- src/compiler/factory/nodeFactory.ts | 10 ++++----- src/compiler/parser.ts | 9 -------- src/compiler/scanner.ts | 4 ---- src/compiler/types.ts | 24 +++----------------- 6 files changed, 16 insertions(+), 75 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index cf7f516abe48b..c26185860e9b4 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4521,12 +4521,10 @@ namespace ts { } if (type.flags & TypeFlags.TemplateLiteral) { const texts = (type).texts; - const casings = (type).casings; const types = (type).types; const templateHead = factory.createTemplateHead(texts[0]); const templateSpans = factory.createNodeArray( map(types, (t, i) => factory.createTemplateLiteralTypeSpan( - casings[i], typeToTypeNodeHelper(t, context), (i < types.length - 1 ? factory.createTemplateMiddle : factory.createTemplateTail)(texts[i + 1])))); context.approximateLength += 2; @@ -10942,7 +10940,7 @@ namespace ts { if (t.flags & TypeFlags.TemplateLiteral) { const types = (t).types; const constraints = mapDefined(types, getBaseConstraint); - return constraints.length === types.length ? getTemplateLiteralType((t).texts, (t).casings, constraints) : stringType; + return constraints.length === types.length ? getTemplateLiteralType((t).texts, constraints) : stringType; } if (t.flags & TypeFlags.StringMapping) { const constraint = getBaseConstraint((t).type); @@ -13492,33 +13490,29 @@ namespace ts { if (!links.resolvedType) { links.resolvedType = getTemplateLiteralType( [node.head.text, ...map(node.templateSpans, span => span.literal.text)], - map(node.templateSpans, span => span.casing), map(node.templateSpans, span => getTypeFromTypeNode(span.type))); } return links.resolvedType; } - function getTemplateLiteralType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]): Type { + function getTemplateLiteralType(texts: readonly string[], types: readonly Type[]): Type { const unionIndex = findIndex(types, t => !!(t.flags & (TypeFlags.Never | TypeFlags.Union))); if (unionIndex >= 0) { return checkCrossProductUnion(types) ? - mapType(types[unionIndex], t => getTemplateLiteralType(texts, casings, replaceElement(types, unionIndex, t))) : + mapType(types[unionIndex], t => getTemplateLiteralType(texts, replaceElement(types, unionIndex, t))) : errorType; } const newTypes = []; - const newCasings = []; const newTexts = []; let text = texts[0]; for (let i = 0; i < types.length; i++) { const t = types[i]; if (t.flags & TypeFlags.Literal) { - const s = applyTemplateCasing(getTemplateStringForType(t) || "", casings[i]); - text += s; + text += getTemplateStringForType(t) || ""; text += texts[i + 1]; } else if (isGenericIndexType(t)) { newTypes.push(t); - newCasings.push(casings[i]); newTexts.push(text); text = texts[i + 1]; } @@ -13530,10 +13524,10 @@ namespace ts { return getLiteralType(text); } newTexts.push(text); - const id = `${getTypeListId(newTypes)}|${newCasings.join(",")}|${map(newTexts, t => t.length).join(",")}|${newTexts.join("")}`; + const id = `${getTypeListId(newTypes)}|${map(newTexts, t => t.length).join(",")}|${newTexts.join("")}`; let type = templateLiteralTypes.get(id); if (!type) { - templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newCasings, newTypes)); + templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes)); } return type; } @@ -13546,20 +13540,9 @@ namespace ts { undefined; } - function applyTemplateCasing(str: string, casing: TemplateCasing) { - switch (casing) { - case TemplateCasing.Uppercase: return str.toUpperCase(); - case TemplateCasing.Lowercase: return str.toLowerCase(); - case TemplateCasing.Capitalize: return str.charAt(0).toUpperCase() + str.slice(1); - case TemplateCasing.Uncapitalize: return str.charAt(0).toLowerCase() + str.slice(1); - } - return str; - } - - function createTemplateLiteralType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]) { + function createTemplateLiteralType(texts: readonly string[], types: readonly Type[]) { const type = createType(TypeFlags.TemplateLiteral); type.texts = texts; - type.casings = casings; type.types = types; return type; } @@ -15228,7 +15211,7 @@ namespace ts { return getIndexType(instantiateType((type).type, mapper)); } if (flags & TypeFlags.TemplateLiteral) { - return getTemplateLiteralType((type).texts, (type).casings, instantiateTypes((type).types, mapper)); + return getTemplateLiteralType((type).texts, instantiateTypes((type).types, mapper)); } if (flags & TypeFlags.StringMapping) { return getStringMappingType((type).symbol, instantiateType((type).type, mapper)); @@ -20148,7 +20131,7 @@ namespace ts { function inferToTemplateLiteralType(source: Type, target: TemplateLiteralType) { const matches = source.flags & TypeFlags.StringLiteral ? inferLiteralsFromTemplateLiteralType(source, target) : - source.flags & TypeFlags.TemplateLiteral && arraysEqual((source).texts, target.texts) && arraysEqual((source).casings, target.casings)? (source).types : + source.flags & TypeFlags.TemplateLiteral && arraysEqual((source).texts, target.texts) ? (source).types : undefined; const types = target.types; for (let i = 0; i < types.length; i++) { diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 5d4811f08effb..237d3fee9cdc5 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2023,15 +2023,6 @@ namespace ts { } function emitTemplateTypeSpan(node: TemplateLiteralTypeSpan) { - const keyword = node.casing === TemplateCasing.Uppercase ? "uppercase" : - node.casing === TemplateCasing.Lowercase ? "lowercase" : - node.casing === TemplateCasing.Capitalize ? "capitalize" : - node.casing === TemplateCasing.Uncapitalize ? "uncapitalize" : - undefined; - if (keyword) { - writeKeyword(keyword); - writeSpace(); - } emit(node.type); emit(node.literal); } diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 0e2cf25d28186..3d1b6fdb9a7d3 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -1605,9 +1605,8 @@ namespace ts { } // @api - function createTemplateLiteralTypeSpan(casing: TemplateCasing, type: TypeNode, literal: TemplateMiddle | TemplateTail) { + function createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail) { const node = createBaseNode(SyntaxKind.TemplateLiteralTypeSpan); - node.casing = casing; node.type = type; node.literal = literal; node.transformFlags = TransformFlags.ContainsTypeScript; @@ -1615,11 +1614,10 @@ namespace ts { } // @api - function updateTemplateLiteralTypeSpan(casing: TemplateCasing, node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail) { - return node.casing !== casing - || node.type !== type + function updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail) { + return node.type !== type || node.literal !== literal - ? update(createTemplateLiteralTypeSpan(casing, type, literal), node) + ? update(createTemplateLiteralTypeSpan(type, literal), node) : node; } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 8c61c03095f40..a815a12db9a53 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2618,7 +2618,6 @@ namespace ts { const pos = getNodePos(); return finishNode( factory.createTemplateLiteralTypeSpan( - parseTemplateCasing(), parseType(), parseLiteralOfTemplateSpan(/*isTaggedTemplate*/ false) ), @@ -2626,14 +2625,6 @@ namespace ts { ); } - function parseTemplateCasing(): TemplateCasing { - return parseOptional(SyntaxKind.UppercaseKeyword) ? TemplateCasing.Uppercase : - parseOptional(SyntaxKind.LowercaseKeyword) ? TemplateCasing.Lowercase : - parseOptional(SyntaxKind.CapitalizeKeyword) ? TemplateCasing.Capitalize : - parseOptional(SyntaxKind.UncapitalizeKeyword) ? TemplateCasing.Uncapitalize : - TemplateCasing.None; - } - function parseLiteralOfTemplateSpan(isTaggedTemplate: boolean) { if (token() === SyntaxKind.CloseBraceToken) { reScanTemplateToken(isTaggedTemplate); diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 515f9de69c23e..35388e38b049f 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -152,10 +152,6 @@ namespace ts { yield: SyntaxKind.YieldKeyword, async: SyntaxKind.AsyncKeyword, await: SyntaxKind.AwaitKeyword, - uppercase: SyntaxKind.UppercaseKeyword, - lowercase: SyntaxKind.LowercaseKeyword, - capitalize: SyntaxKind.CapitalizeKeyword, - uncapitalize: SyntaxKind.UncapitalizeKeyword, of: SyntaxKind.OfKeyword, }; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 2149cfa276a77..fbf308707a10d 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -187,10 +187,6 @@ namespace ts { FromKeyword, GlobalKeyword, BigIntKeyword, - UppercaseKeyword, - LowercaseKeyword, - CapitalizeKeyword, - UncapitalizeKeyword, OfKeyword, // LastKeyword and LastToken and LastContextualKeyword // Parse tree nodes @@ -545,7 +541,6 @@ namespace ts { | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword - | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword @@ -579,7 +574,6 @@ namespace ts { | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword - | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword @@ -607,11 +601,9 @@ namespace ts { | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword - | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword - | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword @@ -1668,19 +1660,10 @@ namespace ts { export interface TemplateLiteralTypeSpan extends TypeNode { readonly kind: SyntaxKind.TemplateLiteralTypeSpan, readonly parent: TemplateLiteralTypeNode; - readonly casing: TemplateCasing; readonly type: TypeNode; readonly literal: TemplateMiddle | TemplateTail; } - export const enum TemplateCasing { - None, - Uppercase, - Lowercase, - Capitalize, - Uncapitalize, - } - // Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing. // Consider 'Expression'. Without the brand, 'Expression' is actually no different // (structurally) than 'Node'. Because of this you can pass any Node to a function that @@ -5383,8 +5366,7 @@ namespace ts { } export interface TemplateLiteralType extends InstantiableType { - texts: readonly string[]; // Always one element longer than casings/types - casings: readonly TemplateCasing[]; // Always at least one element + texts: readonly string[]; // Always one element longer than types types: readonly Type[]; // Always at least one element } @@ -6783,8 +6765,8 @@ namespace ts { createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; /* @internal */ createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): IndexSignatureDeclaration; // eslint-disable-line @typescript-eslint/unified-signatures updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; - createTemplateLiteralTypeSpan(casing: TemplateCasing, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; - updateTemplateLiteralTypeSpan(casing: TemplateCasing, node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; + createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; + updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; // // Types From a405006a2e9b1a2e0b8146852140dabd2cf21fd8 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 16 Sep 2020 07:37:00 -1000 Subject: [PATCH 14/20] Update tests --- .../types/literal/templateLiteralTypes1.ts | 14 +++++++------- .../types/mapped/mappedTypeAsClauses.ts | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts index b8d0af20845b6..f4d072f7227ab 100644 --- a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts +++ b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts @@ -18,16 +18,16 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; -// Casing modifiers +// Casing intrinsics -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; +type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' // Assignability -function test(name: `get${capitalize T}`) { +function test(name: `get${Capitalize}`) { let s1: string = name; let s2: 'getFoo' | 'getBar' = name; } @@ -65,14 +65,14 @@ type T23 = MatchPair<'[123]'>; // unknown type T24 = MatchPair<'[1,2,3,4]'>; // ['1', '2,3,4'] type SnakeToCamelCase = - S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${lowercase T}` : + S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Lowercase}` : SnakeToPascalCase; type SnakeToPascalCase = string extends S ? string : - S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : + S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Capitalize>}` : never; type RR0 = SnakeToPascalCase<'hello_world_foo'>; // 'HelloWorldFoo' diff --git a/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts b/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts index 51f6bd720bf4b..386cfbf320a8f 100644 --- a/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts +++ b/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts @@ -3,7 +3,7 @@ // Mapped type 'as N' clauses -type Getters = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] }; +type Getters = { [P in keyof T & string as `get${Capitalize

}`]: () => T[P] }; type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>; // Mapped type with 'as N' clause has no constraint on 'in T' clause From b46b3ec414ac889c34b6ba35e24f3180ca044ee1 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 16 Sep 2020 07:37:23 -1000 Subject: [PATCH 15/20] Accept new baselines --- .../reference/api/tsserverlibrary.d.ts | 413 +++++++++--------- tests/baselines/reference/api/typescript.d.ts | 413 +++++++++--------- .../reference/mappedTypeAsClauses.js | 4 +- .../reference/mappedTypeAsClauses.symbols | 5 +- .../reference/mappedTypeAsClauses.types | 2 +- .../templateLiteralTypes1.errors.txt | 14 +- .../reference/templateLiteralTypes1.js | 22 +- .../reference/templateLiteralTypes1.symbols | 27 +- .../reference/templateLiteralTypes1.types | 24 +- 9 files changed, 455 insertions(+), 469 deletions(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 4dcb8a8f69083..621b4141291f3 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -260,196 +260,192 @@ declare namespace ts { FromKeyword = 153, GlobalKeyword = 154, BigIntKeyword = 155, - UppercaseKeyword = 156, - LowercaseKeyword = 157, - CapitalizeKeyword = 158, - UncapitalizeKeyword = 159, - OfKeyword = 160, - QualifiedName = 161, - ComputedPropertyName = 162, - TypeParameter = 163, - Parameter = 164, - Decorator = 165, - PropertySignature = 166, - PropertyDeclaration = 167, - MethodSignature = 168, - MethodDeclaration = 169, - Constructor = 170, - GetAccessor = 171, - SetAccessor = 172, - CallSignature = 173, - ConstructSignature = 174, - IndexSignature = 175, - TypePredicate = 176, - TypeReference = 177, - FunctionType = 178, - ConstructorType = 179, - TypeQuery = 180, - TypeLiteral = 181, - ArrayType = 182, - TupleType = 183, - OptionalType = 184, - RestType = 185, - UnionType = 186, - IntersectionType = 187, - ConditionalType = 188, - InferType = 189, - ParenthesizedType = 190, - ThisType = 191, - TypeOperator = 192, - IndexedAccessType = 193, - MappedType = 194, - LiteralType = 195, - NamedTupleMember = 196, - TemplateLiteralType = 197, - TemplateLiteralTypeSpan = 198, - ImportType = 199, - ObjectBindingPattern = 200, - ArrayBindingPattern = 201, - BindingElement = 202, - ArrayLiteralExpression = 203, - ObjectLiteralExpression = 204, - PropertyAccessExpression = 205, - ElementAccessExpression = 206, - CallExpression = 207, - NewExpression = 208, - TaggedTemplateExpression = 209, - TypeAssertionExpression = 210, - ParenthesizedExpression = 211, - FunctionExpression = 212, - ArrowFunction = 213, - DeleteExpression = 214, - TypeOfExpression = 215, - VoidExpression = 216, - AwaitExpression = 217, - PrefixUnaryExpression = 218, - PostfixUnaryExpression = 219, - BinaryExpression = 220, - ConditionalExpression = 221, - TemplateExpression = 222, - YieldExpression = 223, - SpreadElement = 224, - ClassExpression = 225, - OmittedExpression = 226, - ExpressionWithTypeArguments = 227, - AsExpression = 228, - NonNullExpression = 229, - MetaProperty = 230, - SyntheticExpression = 231, - TemplateSpan = 232, - SemicolonClassElement = 233, - Block = 234, - EmptyStatement = 235, - VariableStatement = 236, - ExpressionStatement = 237, - IfStatement = 238, - DoStatement = 239, - WhileStatement = 240, - ForStatement = 241, - ForInStatement = 242, - ForOfStatement = 243, - ContinueStatement = 244, - BreakStatement = 245, - ReturnStatement = 246, - WithStatement = 247, - SwitchStatement = 248, - LabeledStatement = 249, - ThrowStatement = 250, - TryStatement = 251, - DebuggerStatement = 252, - VariableDeclaration = 253, - VariableDeclarationList = 254, - FunctionDeclaration = 255, - ClassDeclaration = 256, - InterfaceDeclaration = 257, - TypeAliasDeclaration = 258, - EnumDeclaration = 259, - ModuleDeclaration = 260, - ModuleBlock = 261, - CaseBlock = 262, - NamespaceExportDeclaration = 263, - ImportEqualsDeclaration = 264, - ImportDeclaration = 265, - ImportClause = 266, - NamespaceImport = 267, - NamedImports = 268, - ImportSpecifier = 269, - ExportAssignment = 270, - ExportDeclaration = 271, - NamedExports = 272, - NamespaceExport = 273, - ExportSpecifier = 274, - MissingDeclaration = 275, - ExternalModuleReference = 276, - JsxElement = 277, - JsxSelfClosingElement = 278, - JsxOpeningElement = 279, - JsxClosingElement = 280, - JsxFragment = 281, - JsxOpeningFragment = 282, - JsxClosingFragment = 283, - JsxAttribute = 284, - JsxAttributes = 285, - JsxSpreadAttribute = 286, - JsxExpression = 287, - CaseClause = 288, - DefaultClause = 289, - HeritageClause = 290, - CatchClause = 291, - PropertyAssignment = 292, - ShorthandPropertyAssignment = 293, - SpreadAssignment = 294, - EnumMember = 295, - UnparsedPrologue = 296, - UnparsedPrepend = 297, - UnparsedText = 298, - UnparsedInternalText = 299, - UnparsedSyntheticReference = 300, - SourceFile = 301, - Bundle = 302, - UnparsedSource = 303, - InputFiles = 304, - JSDocTypeExpression = 305, - JSDocNameReference = 306, - JSDocAllType = 307, - JSDocUnknownType = 308, - JSDocNullableType = 309, - JSDocNonNullableType = 310, - JSDocOptionalType = 311, - JSDocFunctionType = 312, - JSDocVariadicType = 313, - JSDocNamepathType = 314, - JSDocComment = 315, - JSDocTypeLiteral = 316, - JSDocSignature = 317, - JSDocTag = 318, - JSDocAugmentsTag = 319, - JSDocImplementsTag = 320, - JSDocAuthorTag = 321, - JSDocDeprecatedTag = 322, - JSDocClassTag = 323, - JSDocPublicTag = 324, - JSDocPrivateTag = 325, - JSDocProtectedTag = 326, - JSDocReadonlyTag = 327, - JSDocCallbackTag = 328, - JSDocEnumTag = 329, - JSDocParameterTag = 330, - JSDocReturnTag = 331, - JSDocThisTag = 332, - JSDocTypeTag = 333, - JSDocTemplateTag = 334, - JSDocTypedefTag = 335, - JSDocSeeTag = 336, - JSDocPropertyTag = 337, - SyntaxList = 338, - NotEmittedStatement = 339, - PartiallyEmittedExpression = 340, - CommaListExpression = 341, - MergeDeclarationMarker = 342, - EndOfDeclarationMarker = 343, - SyntheticReferenceExpression = 344, - Count = 345, + OfKeyword = 156, + QualifiedName = 157, + ComputedPropertyName = 158, + TypeParameter = 159, + Parameter = 160, + Decorator = 161, + PropertySignature = 162, + PropertyDeclaration = 163, + MethodSignature = 164, + MethodDeclaration = 165, + Constructor = 166, + GetAccessor = 167, + SetAccessor = 168, + CallSignature = 169, + ConstructSignature = 170, + IndexSignature = 171, + TypePredicate = 172, + TypeReference = 173, + FunctionType = 174, + ConstructorType = 175, + TypeQuery = 176, + TypeLiteral = 177, + ArrayType = 178, + TupleType = 179, + OptionalType = 180, + RestType = 181, + UnionType = 182, + IntersectionType = 183, + ConditionalType = 184, + InferType = 185, + ParenthesizedType = 186, + ThisType = 187, + TypeOperator = 188, + IndexedAccessType = 189, + MappedType = 190, + LiteralType = 191, + NamedTupleMember = 192, + TemplateLiteralType = 193, + TemplateLiteralTypeSpan = 194, + ImportType = 195, + ObjectBindingPattern = 196, + ArrayBindingPattern = 197, + BindingElement = 198, + ArrayLiteralExpression = 199, + ObjectLiteralExpression = 200, + PropertyAccessExpression = 201, + ElementAccessExpression = 202, + CallExpression = 203, + NewExpression = 204, + TaggedTemplateExpression = 205, + TypeAssertionExpression = 206, + ParenthesizedExpression = 207, + FunctionExpression = 208, + ArrowFunction = 209, + DeleteExpression = 210, + TypeOfExpression = 211, + VoidExpression = 212, + AwaitExpression = 213, + PrefixUnaryExpression = 214, + PostfixUnaryExpression = 215, + BinaryExpression = 216, + ConditionalExpression = 217, + TemplateExpression = 218, + YieldExpression = 219, + SpreadElement = 220, + ClassExpression = 221, + OmittedExpression = 222, + ExpressionWithTypeArguments = 223, + AsExpression = 224, + NonNullExpression = 225, + MetaProperty = 226, + SyntheticExpression = 227, + TemplateSpan = 228, + SemicolonClassElement = 229, + Block = 230, + EmptyStatement = 231, + VariableStatement = 232, + ExpressionStatement = 233, + IfStatement = 234, + DoStatement = 235, + WhileStatement = 236, + ForStatement = 237, + ForInStatement = 238, + ForOfStatement = 239, + ContinueStatement = 240, + BreakStatement = 241, + ReturnStatement = 242, + WithStatement = 243, + SwitchStatement = 244, + LabeledStatement = 245, + ThrowStatement = 246, + TryStatement = 247, + DebuggerStatement = 248, + VariableDeclaration = 249, + VariableDeclarationList = 250, + FunctionDeclaration = 251, + ClassDeclaration = 252, + InterfaceDeclaration = 253, + TypeAliasDeclaration = 254, + EnumDeclaration = 255, + ModuleDeclaration = 256, + ModuleBlock = 257, + CaseBlock = 258, + NamespaceExportDeclaration = 259, + ImportEqualsDeclaration = 260, + ImportDeclaration = 261, + ImportClause = 262, + NamespaceImport = 263, + NamedImports = 264, + ImportSpecifier = 265, + ExportAssignment = 266, + ExportDeclaration = 267, + NamedExports = 268, + NamespaceExport = 269, + ExportSpecifier = 270, + MissingDeclaration = 271, + ExternalModuleReference = 272, + JsxElement = 273, + JsxSelfClosingElement = 274, + JsxOpeningElement = 275, + JsxClosingElement = 276, + JsxFragment = 277, + JsxOpeningFragment = 278, + JsxClosingFragment = 279, + JsxAttribute = 280, + JsxAttributes = 281, + JsxSpreadAttribute = 282, + JsxExpression = 283, + CaseClause = 284, + DefaultClause = 285, + HeritageClause = 286, + CatchClause = 287, + PropertyAssignment = 288, + ShorthandPropertyAssignment = 289, + SpreadAssignment = 290, + EnumMember = 291, + UnparsedPrologue = 292, + UnparsedPrepend = 293, + UnparsedText = 294, + UnparsedInternalText = 295, + UnparsedSyntheticReference = 296, + SourceFile = 297, + Bundle = 298, + UnparsedSource = 299, + InputFiles = 300, + JSDocTypeExpression = 301, + JSDocNameReference = 302, + JSDocAllType = 303, + JSDocUnknownType = 304, + JSDocNullableType = 305, + JSDocNonNullableType = 306, + JSDocOptionalType = 307, + JSDocFunctionType = 308, + JSDocVariadicType = 309, + JSDocNamepathType = 310, + JSDocComment = 311, + JSDocTypeLiteral = 312, + JSDocSignature = 313, + JSDocTag = 314, + JSDocAugmentsTag = 315, + JSDocImplementsTag = 316, + JSDocAuthorTag = 317, + JSDocDeprecatedTag = 318, + JSDocClassTag = 319, + JSDocPublicTag = 320, + JSDocPrivateTag = 321, + JSDocProtectedTag = 322, + JSDocReadonlyTag = 323, + JSDocCallbackTag = 324, + JSDocEnumTag = 325, + JSDocParameterTag = 326, + JSDocReturnTag = 327, + JSDocThisTag = 328, + JSDocTypeTag = 329, + JSDocTemplateTag = 330, + JSDocTypedefTag = 331, + JSDocSeeTag = 332, + JSDocPropertyTag = 333, + SyntaxList = 334, + NotEmittedStatement = 335, + PartiallyEmittedExpression = 336, + CommaListExpression = 337, + MergeDeclarationMarker = 338, + EndOfDeclarationMarker = 339, + SyntheticReferenceExpression = 340, + Count = 341, FirstAssignment = 62, LastAssignment = 77, FirstCompoundAssignment = 63, @@ -457,15 +453,15 @@ declare namespace ts { FirstReservedWord = 80, LastReservedWord = 115, FirstKeyword = 80, - LastKeyword = 160, + LastKeyword = 156, FirstFutureReservedWord = 116, LastFutureReservedWord = 124, - FirstTypeNode = 176, - LastTypeNode = 199, + FirstTypeNode = 172, + LastTypeNode = 195, FirstPunctuation = 18, LastPunctuation = 77, FirstToken = 0, - LastToken = 160, + LastToken = 156, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -474,19 +470,19 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 77, - FirstStatement = 236, - LastStatement = 252, - FirstNode = 161, - FirstJSDocNode = 305, - LastJSDocNode = 337, - FirstJSDocTagNode = 318, - LastJSDocTagNode = 337, + FirstStatement = 232, + LastStatement = 248, + FirstNode = 157, + FirstJSDocNode = 301, + LastJSDocNode = 333, + FirstJSDocTagNode = 314, + LastJSDocTagNode = 333, } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail; export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken; - export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; + export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.StaticKeyword; export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; @@ -973,17 +969,9 @@ declare namespace ts { export interface TemplateLiteralTypeSpan extends TypeNode { readonly kind: SyntaxKind.TemplateLiteralTypeSpan; readonly parent: TemplateLiteralTypeNode; - readonly casing: TemplateCasing; readonly type: TypeNode; readonly literal: TemplateMiddle | TemplateTail; } - export enum TemplateCasing { - None = 0, - Uppercase = 1, - Lowercase = 2, - Capitalize = 3, - Uncapitalize = 4 - } export interface Expression extends Node { _expressionBrand: any; } @@ -2662,7 +2650,6 @@ declare namespace ts { } export interface TemplateLiteralType extends InstantiableType { texts: readonly string[]; - casings: readonly TemplateCasing[]; types: readonly Type[]; } export interface StringMappingType extends InstantiableType { @@ -3231,8 +3218,8 @@ declare namespace ts { updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): ConstructSignatureDeclaration; createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; - createTemplateLiteralTypeSpan(casing: TemplateCasing, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; - updateTemplateLiteralTypeSpan(casing: TemplateCasing, node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; + createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; + updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; createKeywordTypeNode(kind: TKind): KeywordTypeNode; createTypePredicateNode(assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode; updateTypePredicateNode(node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index bc8ec6da64acf..0df67772e6e09 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -260,196 +260,192 @@ declare namespace ts { FromKeyword = 153, GlobalKeyword = 154, BigIntKeyword = 155, - UppercaseKeyword = 156, - LowercaseKeyword = 157, - CapitalizeKeyword = 158, - UncapitalizeKeyword = 159, - OfKeyword = 160, - QualifiedName = 161, - ComputedPropertyName = 162, - TypeParameter = 163, - Parameter = 164, - Decorator = 165, - PropertySignature = 166, - PropertyDeclaration = 167, - MethodSignature = 168, - MethodDeclaration = 169, - Constructor = 170, - GetAccessor = 171, - SetAccessor = 172, - CallSignature = 173, - ConstructSignature = 174, - IndexSignature = 175, - TypePredicate = 176, - TypeReference = 177, - FunctionType = 178, - ConstructorType = 179, - TypeQuery = 180, - TypeLiteral = 181, - ArrayType = 182, - TupleType = 183, - OptionalType = 184, - RestType = 185, - UnionType = 186, - IntersectionType = 187, - ConditionalType = 188, - InferType = 189, - ParenthesizedType = 190, - ThisType = 191, - TypeOperator = 192, - IndexedAccessType = 193, - MappedType = 194, - LiteralType = 195, - NamedTupleMember = 196, - TemplateLiteralType = 197, - TemplateLiteralTypeSpan = 198, - ImportType = 199, - ObjectBindingPattern = 200, - ArrayBindingPattern = 201, - BindingElement = 202, - ArrayLiteralExpression = 203, - ObjectLiteralExpression = 204, - PropertyAccessExpression = 205, - ElementAccessExpression = 206, - CallExpression = 207, - NewExpression = 208, - TaggedTemplateExpression = 209, - TypeAssertionExpression = 210, - ParenthesizedExpression = 211, - FunctionExpression = 212, - ArrowFunction = 213, - DeleteExpression = 214, - TypeOfExpression = 215, - VoidExpression = 216, - AwaitExpression = 217, - PrefixUnaryExpression = 218, - PostfixUnaryExpression = 219, - BinaryExpression = 220, - ConditionalExpression = 221, - TemplateExpression = 222, - YieldExpression = 223, - SpreadElement = 224, - ClassExpression = 225, - OmittedExpression = 226, - ExpressionWithTypeArguments = 227, - AsExpression = 228, - NonNullExpression = 229, - MetaProperty = 230, - SyntheticExpression = 231, - TemplateSpan = 232, - SemicolonClassElement = 233, - Block = 234, - EmptyStatement = 235, - VariableStatement = 236, - ExpressionStatement = 237, - IfStatement = 238, - DoStatement = 239, - WhileStatement = 240, - ForStatement = 241, - ForInStatement = 242, - ForOfStatement = 243, - ContinueStatement = 244, - BreakStatement = 245, - ReturnStatement = 246, - WithStatement = 247, - SwitchStatement = 248, - LabeledStatement = 249, - ThrowStatement = 250, - TryStatement = 251, - DebuggerStatement = 252, - VariableDeclaration = 253, - VariableDeclarationList = 254, - FunctionDeclaration = 255, - ClassDeclaration = 256, - InterfaceDeclaration = 257, - TypeAliasDeclaration = 258, - EnumDeclaration = 259, - ModuleDeclaration = 260, - ModuleBlock = 261, - CaseBlock = 262, - NamespaceExportDeclaration = 263, - ImportEqualsDeclaration = 264, - ImportDeclaration = 265, - ImportClause = 266, - NamespaceImport = 267, - NamedImports = 268, - ImportSpecifier = 269, - ExportAssignment = 270, - ExportDeclaration = 271, - NamedExports = 272, - NamespaceExport = 273, - ExportSpecifier = 274, - MissingDeclaration = 275, - ExternalModuleReference = 276, - JsxElement = 277, - JsxSelfClosingElement = 278, - JsxOpeningElement = 279, - JsxClosingElement = 280, - JsxFragment = 281, - JsxOpeningFragment = 282, - JsxClosingFragment = 283, - JsxAttribute = 284, - JsxAttributes = 285, - JsxSpreadAttribute = 286, - JsxExpression = 287, - CaseClause = 288, - DefaultClause = 289, - HeritageClause = 290, - CatchClause = 291, - PropertyAssignment = 292, - ShorthandPropertyAssignment = 293, - SpreadAssignment = 294, - EnumMember = 295, - UnparsedPrologue = 296, - UnparsedPrepend = 297, - UnparsedText = 298, - UnparsedInternalText = 299, - UnparsedSyntheticReference = 300, - SourceFile = 301, - Bundle = 302, - UnparsedSource = 303, - InputFiles = 304, - JSDocTypeExpression = 305, - JSDocNameReference = 306, - JSDocAllType = 307, - JSDocUnknownType = 308, - JSDocNullableType = 309, - JSDocNonNullableType = 310, - JSDocOptionalType = 311, - JSDocFunctionType = 312, - JSDocVariadicType = 313, - JSDocNamepathType = 314, - JSDocComment = 315, - JSDocTypeLiteral = 316, - JSDocSignature = 317, - JSDocTag = 318, - JSDocAugmentsTag = 319, - JSDocImplementsTag = 320, - JSDocAuthorTag = 321, - JSDocDeprecatedTag = 322, - JSDocClassTag = 323, - JSDocPublicTag = 324, - JSDocPrivateTag = 325, - JSDocProtectedTag = 326, - JSDocReadonlyTag = 327, - JSDocCallbackTag = 328, - JSDocEnumTag = 329, - JSDocParameterTag = 330, - JSDocReturnTag = 331, - JSDocThisTag = 332, - JSDocTypeTag = 333, - JSDocTemplateTag = 334, - JSDocTypedefTag = 335, - JSDocSeeTag = 336, - JSDocPropertyTag = 337, - SyntaxList = 338, - NotEmittedStatement = 339, - PartiallyEmittedExpression = 340, - CommaListExpression = 341, - MergeDeclarationMarker = 342, - EndOfDeclarationMarker = 343, - SyntheticReferenceExpression = 344, - Count = 345, + OfKeyword = 156, + QualifiedName = 157, + ComputedPropertyName = 158, + TypeParameter = 159, + Parameter = 160, + Decorator = 161, + PropertySignature = 162, + PropertyDeclaration = 163, + MethodSignature = 164, + MethodDeclaration = 165, + Constructor = 166, + GetAccessor = 167, + SetAccessor = 168, + CallSignature = 169, + ConstructSignature = 170, + IndexSignature = 171, + TypePredicate = 172, + TypeReference = 173, + FunctionType = 174, + ConstructorType = 175, + TypeQuery = 176, + TypeLiteral = 177, + ArrayType = 178, + TupleType = 179, + OptionalType = 180, + RestType = 181, + UnionType = 182, + IntersectionType = 183, + ConditionalType = 184, + InferType = 185, + ParenthesizedType = 186, + ThisType = 187, + TypeOperator = 188, + IndexedAccessType = 189, + MappedType = 190, + LiteralType = 191, + NamedTupleMember = 192, + TemplateLiteralType = 193, + TemplateLiteralTypeSpan = 194, + ImportType = 195, + ObjectBindingPattern = 196, + ArrayBindingPattern = 197, + BindingElement = 198, + ArrayLiteralExpression = 199, + ObjectLiteralExpression = 200, + PropertyAccessExpression = 201, + ElementAccessExpression = 202, + CallExpression = 203, + NewExpression = 204, + TaggedTemplateExpression = 205, + TypeAssertionExpression = 206, + ParenthesizedExpression = 207, + FunctionExpression = 208, + ArrowFunction = 209, + DeleteExpression = 210, + TypeOfExpression = 211, + VoidExpression = 212, + AwaitExpression = 213, + PrefixUnaryExpression = 214, + PostfixUnaryExpression = 215, + BinaryExpression = 216, + ConditionalExpression = 217, + TemplateExpression = 218, + YieldExpression = 219, + SpreadElement = 220, + ClassExpression = 221, + OmittedExpression = 222, + ExpressionWithTypeArguments = 223, + AsExpression = 224, + NonNullExpression = 225, + MetaProperty = 226, + SyntheticExpression = 227, + TemplateSpan = 228, + SemicolonClassElement = 229, + Block = 230, + EmptyStatement = 231, + VariableStatement = 232, + ExpressionStatement = 233, + IfStatement = 234, + DoStatement = 235, + WhileStatement = 236, + ForStatement = 237, + ForInStatement = 238, + ForOfStatement = 239, + ContinueStatement = 240, + BreakStatement = 241, + ReturnStatement = 242, + WithStatement = 243, + SwitchStatement = 244, + LabeledStatement = 245, + ThrowStatement = 246, + TryStatement = 247, + DebuggerStatement = 248, + VariableDeclaration = 249, + VariableDeclarationList = 250, + FunctionDeclaration = 251, + ClassDeclaration = 252, + InterfaceDeclaration = 253, + TypeAliasDeclaration = 254, + EnumDeclaration = 255, + ModuleDeclaration = 256, + ModuleBlock = 257, + CaseBlock = 258, + NamespaceExportDeclaration = 259, + ImportEqualsDeclaration = 260, + ImportDeclaration = 261, + ImportClause = 262, + NamespaceImport = 263, + NamedImports = 264, + ImportSpecifier = 265, + ExportAssignment = 266, + ExportDeclaration = 267, + NamedExports = 268, + NamespaceExport = 269, + ExportSpecifier = 270, + MissingDeclaration = 271, + ExternalModuleReference = 272, + JsxElement = 273, + JsxSelfClosingElement = 274, + JsxOpeningElement = 275, + JsxClosingElement = 276, + JsxFragment = 277, + JsxOpeningFragment = 278, + JsxClosingFragment = 279, + JsxAttribute = 280, + JsxAttributes = 281, + JsxSpreadAttribute = 282, + JsxExpression = 283, + CaseClause = 284, + DefaultClause = 285, + HeritageClause = 286, + CatchClause = 287, + PropertyAssignment = 288, + ShorthandPropertyAssignment = 289, + SpreadAssignment = 290, + EnumMember = 291, + UnparsedPrologue = 292, + UnparsedPrepend = 293, + UnparsedText = 294, + UnparsedInternalText = 295, + UnparsedSyntheticReference = 296, + SourceFile = 297, + Bundle = 298, + UnparsedSource = 299, + InputFiles = 300, + JSDocTypeExpression = 301, + JSDocNameReference = 302, + JSDocAllType = 303, + JSDocUnknownType = 304, + JSDocNullableType = 305, + JSDocNonNullableType = 306, + JSDocOptionalType = 307, + JSDocFunctionType = 308, + JSDocVariadicType = 309, + JSDocNamepathType = 310, + JSDocComment = 311, + JSDocTypeLiteral = 312, + JSDocSignature = 313, + JSDocTag = 314, + JSDocAugmentsTag = 315, + JSDocImplementsTag = 316, + JSDocAuthorTag = 317, + JSDocDeprecatedTag = 318, + JSDocClassTag = 319, + JSDocPublicTag = 320, + JSDocPrivateTag = 321, + JSDocProtectedTag = 322, + JSDocReadonlyTag = 323, + JSDocCallbackTag = 324, + JSDocEnumTag = 325, + JSDocParameterTag = 326, + JSDocReturnTag = 327, + JSDocThisTag = 328, + JSDocTypeTag = 329, + JSDocTemplateTag = 330, + JSDocTypedefTag = 331, + JSDocSeeTag = 332, + JSDocPropertyTag = 333, + SyntaxList = 334, + NotEmittedStatement = 335, + PartiallyEmittedExpression = 336, + CommaListExpression = 337, + MergeDeclarationMarker = 338, + EndOfDeclarationMarker = 339, + SyntheticReferenceExpression = 340, + Count = 341, FirstAssignment = 62, LastAssignment = 77, FirstCompoundAssignment = 63, @@ -457,15 +453,15 @@ declare namespace ts { FirstReservedWord = 80, LastReservedWord = 115, FirstKeyword = 80, - LastKeyword = 160, + LastKeyword = 156, FirstFutureReservedWord = 116, LastFutureReservedWord = 124, - FirstTypeNode = 176, - LastTypeNode = 199, + FirstTypeNode = 172, + LastTypeNode = 195, FirstPunctuation = 18, LastPunctuation = 77, FirstToken = 0, - LastToken = 160, + LastToken = 156, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -474,19 +470,19 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 77, - FirstStatement = 236, - LastStatement = 252, - FirstNode = 161, - FirstJSDocNode = 305, - LastJSDocNode = 337, - FirstJSDocTagNode = 318, - LastJSDocTagNode = 337, + FirstStatement = 232, + LastStatement = 248, + FirstNode = 157, + FirstJSDocNode = 301, + LastJSDocNode = 333, + FirstJSDocTagNode = 314, + LastJSDocTagNode = 333, } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail; export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken; - export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UncapitalizeKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.UppercaseKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; + export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.StaticKeyword; export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; @@ -973,17 +969,9 @@ declare namespace ts { export interface TemplateLiteralTypeSpan extends TypeNode { readonly kind: SyntaxKind.TemplateLiteralTypeSpan; readonly parent: TemplateLiteralTypeNode; - readonly casing: TemplateCasing; readonly type: TypeNode; readonly literal: TemplateMiddle | TemplateTail; } - export enum TemplateCasing { - None = 0, - Uppercase = 1, - Lowercase = 2, - Capitalize = 3, - Uncapitalize = 4 - } export interface Expression extends Node { _expressionBrand: any; } @@ -2662,7 +2650,6 @@ declare namespace ts { } export interface TemplateLiteralType extends InstantiableType { texts: readonly string[]; - casings: readonly TemplateCasing[]; types: readonly Type[]; } export interface StringMappingType extends InstantiableType { @@ -3231,8 +3218,8 @@ declare namespace ts { updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): ConstructSignatureDeclaration; createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; - createTemplateLiteralTypeSpan(casing: TemplateCasing, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; - updateTemplateLiteralTypeSpan(casing: TemplateCasing, node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; + createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; + updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan; createKeywordTypeNode(kind: TKind): KeywordTypeNode; createTypePredicateNode(assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode; updateTypePredicateNode(node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode; diff --git a/tests/baselines/reference/mappedTypeAsClauses.js b/tests/baselines/reference/mappedTypeAsClauses.js index 75c1d32cd60ae..0aa23d73e5bcb 100644 --- a/tests/baselines/reference/mappedTypeAsClauses.js +++ b/tests/baselines/reference/mappedTypeAsClauses.js @@ -1,7 +1,7 @@ //// [mappedTypeAsClauses.ts] // Mapped type 'as N' clauses -type Getters = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] }; +type Getters = { [P in keyof T & string as `get${Capitalize

}`]: () => T[P] }; type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>; // Mapped type with 'as N' clause has no constraint on 'in T' clause @@ -37,7 +37,7 @@ type TD3 = keyof DoubleProp; // `${keyof U & string}1` | `${keyof U & str //// [mappedTypeAsClauses.d.ts] declare type Getters = { - [P in keyof T & string as `get${capitalize P}`]: () => T[P]; + [P in keyof T & string as `get${Capitalize

}`]: () => T[P]; }; declare type TG1 = Getters<{ foo: string; diff --git a/tests/baselines/reference/mappedTypeAsClauses.symbols b/tests/baselines/reference/mappedTypeAsClauses.symbols index 75768ce31af90..018dbc5b4bf99 100644 --- a/tests/baselines/reference/mappedTypeAsClauses.symbols +++ b/tests/baselines/reference/mappedTypeAsClauses.symbols @@ -1,17 +1,18 @@ === tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts === // Mapped type 'as N' clauses -type Getters = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] }; +type Getters = { [P in keyof T & string as `get${Capitalize

}`]: () => T[P] }; >Getters : Symbol(Getters, Decl(mappedTypeAsClauses.ts, 0, 0)) >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 2, 13)) >P : Symbol(P, Decl(mappedTypeAsClauses.ts, 2, 21)) >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 2, 13)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) >P : Symbol(P, Decl(mappedTypeAsClauses.ts, 2, 21)) >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 2, 13)) >P : Symbol(P, Decl(mappedTypeAsClauses.ts, 2, 21)) type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>; ->TG1 : Symbol(TG1, Decl(mappedTypeAsClauses.ts, 2, 82)) +>TG1 : Symbol(TG1, Decl(mappedTypeAsClauses.ts, 2, 83)) >Getters : Symbol(Getters, Decl(mappedTypeAsClauses.ts, 0, 0)) >foo : Symbol(foo, Decl(mappedTypeAsClauses.ts, 3, 20)) >bar : Symbol(bar, Decl(mappedTypeAsClauses.ts, 3, 33)) diff --git a/tests/baselines/reference/mappedTypeAsClauses.types b/tests/baselines/reference/mappedTypeAsClauses.types index 438d9c1fcbf6f..2bf93234ce14a 100644 --- a/tests/baselines/reference/mappedTypeAsClauses.types +++ b/tests/baselines/reference/mappedTypeAsClauses.types @@ -1,7 +1,7 @@ === tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts === // Mapped type 'as N' clauses -type Getters = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] }; +type Getters = { [P in keyof T & string as `get${Capitalize

}`]: () => T[P] }; >Getters : Getters type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>; diff --git a/tests/baselines/reference/templateLiteralTypes1.errors.txt b/tests/baselines/reference/templateLiteralTypes1.errors.txt index 89090ee0adfc8..382ca4e4ba319 100644 --- a/tests/baselines/reference/templateLiteralTypes1.errors.txt +++ b/tests/baselines/reference/templateLiteralTypes1.errors.txt @@ -28,16 +28,16 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(199,16): error TS type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; - // Casing modifiers + // Casing intrinsics - type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; + type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' // Assignability - function test(name: `get${capitalize T}`) { + function test(name: `get${Capitalize}`) { let s1: string = name; let s2: 'getFoo' | 'getBar' = name; } @@ -83,14 +83,14 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(199,16): error TS type T24 = MatchPair<'[1,2,3,4]'>; // ['1', '2,3,4'] type SnakeToCamelCase = - S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${lowercase T}` : + S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Lowercase}` : SnakeToPascalCase; type SnakeToPascalCase = string extends S ? string : - S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : + S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Capitalize>}` : never; type RR0 = SnakeToPascalCase<'hello_world_foo'>; // 'HelloWorldFoo' diff --git a/tests/baselines/reference/templateLiteralTypes1.js b/tests/baselines/reference/templateLiteralTypes1.js index a286c66881b6e..e4dc39647f8ea 100644 --- a/tests/baselines/reference/templateLiteralTypes1.js +++ b/tests/baselines/reference/templateLiteralTypes1.js @@ -16,16 +16,16 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; -// Casing modifiers +// Casing intrinsics -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; +type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' // Assignability -function test(name: `get${capitalize T}`) { +function test(name: `get${Capitalize}`) { let s1: string = name; let s2: 'getFoo' | 'getBar' = name; } @@ -63,14 +63,14 @@ type T23 = MatchPair<'[123]'>; // unknown type T24 = MatchPair<'[1,2,3,4]'>; // ['1', '2,3,4'] type SnakeToCamelCase = - S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${lowercase T}` : + S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Lowercase}` : SnakeToPascalCase; type SnakeToPascalCase = string extends S ? string : - S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : + S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Capitalize>}` : never; type RR0 = SnakeToPascalCase<'hello_world_foo'>; // 'HelloWorldFoo' @@ -239,10 +239,10 @@ declare type EN1 = EventName<'Foo' | 'Bar' | 'Baz'>; declare type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; declare type ToString = `${T}`; declare type TS1 = ToString<'abc' | 42 | true | -1234n>; -declare type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; +declare type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; declare type TCA1 = Cases<'bar'>; declare type TCA2 = Cases<'BAR'>; -declare function test(name: `get${capitalize T}`): void; +declare function test(name: `get${Capitalize}`): void; declare function fa1(x: T, y: { [P in keyof T]: T[P]; }, z: { @@ -263,8 +263,8 @@ declare type T21 = MatchPair<'[foo,bar]'>; declare type T22 = MatchPair<' [1,2]'>; declare type T23 = MatchPair<'[123]'>; declare type T24 = MatchPair<'[1,2,3,4]'>; -declare type SnakeToCamelCase = S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase}` : S extends `${infer T}` ? `${lowercase T}` : SnakeToPascalCase; -declare type SnakeToPascalCase = string extends S ? string : S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : never; +declare type SnakeToCamelCase = S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : S extends `${infer T}` ? `${Lowercase}` : SnakeToPascalCase; +declare type SnakeToPascalCase = string extends S ? string : S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : S extends `${infer T}` ? `${Capitalize>}` : never; declare type RR0 = SnakeToPascalCase<'hello_world_foo'>; declare type RR1 = SnakeToPascalCase<'FOO_BAR_BAZ'>; declare type RR2 = SnakeToCamelCase<'hello_world_foo'>; diff --git a/tests/baselines/reference/templateLiteralTypes1.symbols b/tests/baselines/reference/templateLiteralTypes1.symbols index 3dca8c592e649..6a3934ec911f6 100644 --- a/tests/baselines/reference/templateLiteralTypes1.symbols +++ b/tests/baselines/reference/templateLiteralTypes1.symbols @@ -47,18 +47,22 @@ type TS1 = ToString<'abc' | 42 | true | -1234n>; >TS1 : Symbol(TS1, Decl(templateLiteralTypes1.ts, 14, 69)) >ToString : Symbol(ToString, Decl(templateLiteralTypes1.ts, 10, 75)) -// Casing modifiers +// Casing intrinsics -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; +type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; >Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 15, 48)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' ->TCA1 : Symbol(TCA1, Decl(templateLiteralTypes1.ts, 19, 97)) +>TCA1 : Symbol(TCA1, Decl(templateLiteralTypes1.ts, 19, 101)) >Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 15, 48)) type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' @@ -67,10 +71,11 @@ type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' // Assignability -function test(name: `get${capitalize T}`) { +function test(name: `get${Capitalize}`) { >test : Symbol(test, Decl(templateLiteralTypes1.ts, 22, 25)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 26, 14)) >name : Symbol(name, Decl(templateLiteralTypes1.ts, 26, 39)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 26, 14)) let s1: string = name; @@ -208,17 +213,19 @@ type SnakeToCamelCase = >SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 61, 34)) >S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) - S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase}` : + S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : >S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 64, 22)) >U : Symbol(U, Decl(templateLiteralTypes1.ts, 64, 33)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 64, 22)) >SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) >U : Symbol(U, Decl(templateLiteralTypes1.ts, 64, 33)) - S extends `${infer T}` ? `${lowercase T}` : + S extends `${infer T}` ? `${Lowercase}` : >S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 65, 22)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 65, 22)) SnakeToPascalCase; @@ -232,17 +239,21 @@ type SnakeToPascalCase = string extends S ? string : >S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) - S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : + S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : >S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22)) >U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22)) >SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) >U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) - S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : + S extends `${infer T}` ? `${Capitalize>}` : >S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22)) never; diff --git a/tests/baselines/reference/templateLiteralTypes1.types b/tests/baselines/reference/templateLiteralTypes1.types index eca2ec69871c6..308a21dcbd4d9 100644 --- a/tests/baselines/reference/templateLiteralTypes1.types +++ b/tests/baselines/reference/templateLiteralTypes1.types @@ -46,10 +46,10 @@ type TS1 = ToString<'abc' | 42 | true | -1234n>; >-1234n : -1234n >1234n : 1234n -// Casing modifiers +// Casing intrinsics -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; ->Cases : `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}` +type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; +>Cases : `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}` type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' >TCA1 : "BAR bar Bar bar" @@ -59,17 +59,17 @@ type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' // Assignability -function test(name: `get${capitalize T}`) { ->test : (name: `get${capitalize T}`) => void ->name : `get${capitalize T}` +function test(name: `get${Capitalize}`) { +>test : (name: `get${Capitalize}`) => void +>name : `get${Capitalize}` let s1: string = name; >s1 : string ->name : `get${capitalize T}` +>name : `get${Capitalize}` let s2: 'getFoo' | 'getBar' = name; >s2 : "getFoo" | "getBar" ->name : `get${capitalize T}` +>name : `get${Capitalize}` } function fa1(x: T, y: { [P in keyof T]: T[P] }, z: { [P in keyof T & string as `p_${P}`]: T[P] }) { @@ -147,16 +147,16 @@ type T24 = MatchPair<'[1,2,3,4]'>; // ['1', '2,3,4'] type SnakeToCamelCase = >SnakeToCamelCase : SnakeToCamelCase - S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${lowercase T}` : + S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Lowercase}` : SnakeToPascalCase; type SnakeToPascalCase = >SnakeToPascalCase : SnakeToPascalCase string extends S ? string : - S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : - S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : + S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : + S extends `${infer T}` ? `${Capitalize>}` : never; type RR0 = SnakeToPascalCase<'hello_world_foo'>; // 'HelloWorldFoo' From d5980d10d33433e9abd67d7cec750d080718227d Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 17 Sep 2020 07:48:19 -1000 Subject: [PATCH 16/20] Add more tests --- .../reference/intrinsicKeyword.errors.txt | 51 +++++++++++++++++ tests/baselines/reference/intrinsicKeyword.js | 36 ++++++++++++ .../reference/intrinsicKeyword.symbols | 57 +++++++++++++++++++ .../reference/intrinsicKeyword.types | 50 ++++++++++++++++ .../types/typeAliases/intrinsicKeyword.ts | 22 +++++++ 5 files changed, 216 insertions(+) create mode 100644 tests/baselines/reference/intrinsicKeyword.errors.txt create mode 100644 tests/baselines/reference/intrinsicKeyword.js create mode 100644 tests/baselines/reference/intrinsicKeyword.symbols create mode 100644 tests/baselines/reference/intrinsicKeyword.types create mode 100644 tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts diff --git a/tests/baselines/reference/intrinsicKeyword.errors.txt b/tests/baselines/reference/intrinsicKeyword.errors.txt new file mode 100644 index 0000000000000..5164a75ae0b10 --- /dev/null +++ b/tests/baselines/reference/intrinsicKeyword.errors.txt @@ -0,0 +1,51 @@ +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(1,9): error TS2304: Cannot find name 'intrinsic'. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(2,22): error TS2304: Cannot find name 'intrinsic'. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(3,13): error TS2304: Cannot find name 'intrinsic'. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(4,23): error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(5,20): error TS2304: Cannot find name 'intrinsic'. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(6,28): error TS2313: Type parameter 'intrinsic' has a circular constraint. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(6,41): error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(7,28): error TS2313: Type parameter 'intrinsic' has a circular constraint. +tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts(10,20): error TS2503: Cannot find namespace 'intrinsic'. + + +==== tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts (9 errors) ==== + let e1: intrinsic; + ~~~~~~~~~ +!!! error TS2304: Cannot find name 'intrinsic'. + let e2: { intrinsic: intrinsic }; + ~~~~~~~~~ +!!! error TS2304: Cannot find name 'intrinsic'. + type TE1 = (intrinsic); + ~~~~~~~~~ +!!! error TS2304: Cannot find name 'intrinsic'. + type TE2 = intrinsic; + ~~~~~~~~~ +!!! error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. + type TE3 = T; + ~~~~~~~~~ +!!! error TS2304: Cannot find name 'intrinsic'. + type TE4 = intrinsic; + ~~~~~~~~~ +!!! error TS2313: Type parameter 'intrinsic' has a circular constraint. + ~~~~~~~~~ +!!! error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types. + type TE5 = (intrinsic); + ~~~~~~~~~ +!!! error TS2313: Type parameter 'intrinsic' has a circular constraint. + + function f1() { + let intrinsic: intrinsic.intrinsic; + ~~~~~~~~~ +!!! error TS2503: Cannot find namespace 'intrinsic'. + } + + function f2(intrinsic: string) { + return intrinsic; + } + + function f3() { + type intrinsic = string; + let s1: intrinsic = 'ok'; + } + \ No newline at end of file diff --git a/tests/baselines/reference/intrinsicKeyword.js b/tests/baselines/reference/intrinsicKeyword.js new file mode 100644 index 0000000000000..f6e7596604fd3 --- /dev/null +++ b/tests/baselines/reference/intrinsicKeyword.js @@ -0,0 +1,36 @@ +//// [intrinsicKeyword.ts] +let e1: intrinsic; +let e2: { intrinsic: intrinsic }; +type TE1 = (intrinsic); +type TE2 = intrinsic; +type TE3 = T; +type TE4 = intrinsic; +type TE5 = (intrinsic); + +function f1() { + let intrinsic: intrinsic.intrinsic; +} + +function f2(intrinsic: string) { + return intrinsic; +} + +function f3() { + type intrinsic = string; + let s1: intrinsic = 'ok'; +} + + +//// [intrinsicKeyword.js] +"use strict"; +var e1; +var e2; +function f1() { + var intrinsic; +} +function f2(intrinsic) { + return intrinsic; +} +function f3() { + var s1 = 'ok'; +} diff --git a/tests/baselines/reference/intrinsicKeyword.symbols b/tests/baselines/reference/intrinsicKeyword.symbols new file mode 100644 index 0000000000000..ef61b04409b84 --- /dev/null +++ b/tests/baselines/reference/intrinsicKeyword.symbols @@ -0,0 +1,57 @@ +=== tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts === +let e1: intrinsic; +>e1 : Symbol(e1, Decl(intrinsicKeyword.ts, 0, 3)) + +let e2: { intrinsic: intrinsic }; +>e2 : Symbol(e2, Decl(intrinsicKeyword.ts, 1, 3)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 1, 9)) + +type TE1 = (intrinsic); +>TE1 : Symbol(TE1, Decl(intrinsicKeyword.ts, 1, 33)) + +type TE2 = intrinsic; +>TE2 : Symbol(TE2, Decl(intrinsicKeyword.ts, 2, 23)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 3, 9)) + +type TE3 = T; +>TE3 : Symbol(TE3, Decl(intrinsicKeyword.ts, 3, 32)) +>T : Symbol(T, Decl(intrinsicKeyword.ts, 4, 9)) +>T : Symbol(T, Decl(intrinsicKeyword.ts, 4, 9)) + +type TE4 = intrinsic; +>TE4 : Symbol(TE4, Decl(intrinsicKeyword.ts, 4, 34)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 5, 9)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 5, 9)) + +type TE5 = (intrinsic); +>TE5 : Symbol(TE5, Decl(intrinsicKeyword.ts, 5, 50)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 6, 9)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 6, 9)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 6, 9)) + +function f1() { +>f1 : Symbol(f1, Decl(intrinsicKeyword.ts, 6, 52)) + + let intrinsic: intrinsic.intrinsic; +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 9, 7)) +} + +function f2(intrinsic: string) { +>f2 : Symbol(f2, Decl(intrinsicKeyword.ts, 10, 1)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 12, 12)) + + return intrinsic; +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 12, 12)) +} + +function f3() { +>f3 : Symbol(f3, Decl(intrinsicKeyword.ts, 14, 1)) + + type intrinsic = string; +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 16, 15)) + + let s1: intrinsic = 'ok'; +>s1 : Symbol(s1, Decl(intrinsicKeyword.ts, 18, 7)) +>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 16, 15)) +} + diff --git a/tests/baselines/reference/intrinsicKeyword.types b/tests/baselines/reference/intrinsicKeyword.types new file mode 100644 index 0000000000000..b1fb4a480ce10 --- /dev/null +++ b/tests/baselines/reference/intrinsicKeyword.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts === +let e1: intrinsic; +>e1 : any + +let e2: { intrinsic: intrinsic }; +>e2 : { intrinsic: any; } +>intrinsic : any + +type TE1 = (intrinsic); +>TE1 : any + +type TE2 = intrinsic; +>TE2 : intrinsic + +type TE3 = T; +>TE3 : T + +type TE4 = intrinsic; +>TE4 : intrinsic + +type TE5 = (intrinsic); +>TE5 : intrinsic + +function f1() { +>f1 : () => void + + let intrinsic: intrinsic.intrinsic; +>intrinsic : any +>intrinsic : any +} + +function f2(intrinsic: string) { +>f2 : (intrinsic: string) => string +>intrinsic : string + + return intrinsic; +>intrinsic : string +} + +function f3() { +>f3 : () => void + + type intrinsic = string; +>intrinsic : string + + let s1: intrinsic = 'ok'; +>s1 : string +>'ok' : "ok" +} + diff --git a/tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts b/tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts new file mode 100644 index 0000000000000..21528e04caa74 --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/intrinsicKeyword.ts @@ -0,0 +1,22 @@ +// @strict: true + +let e1: intrinsic; +let e2: { intrinsic: intrinsic }; +type TE1 = (intrinsic); +type TE2 = intrinsic; +type TE3 = T; +type TE4 = intrinsic; +type TE5 = (intrinsic); + +function f1() { + let intrinsic: intrinsic.intrinsic; +} + +function f2(intrinsic: string) { + return intrinsic; +} + +function f3() { + type intrinsic = string; + let s1: intrinsic = 'ok'; +} From d0fcddd79325dc33d451b5d26b947eb9714d7f95 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 20 Sep 2020 07:10:46 -1000 Subject: [PATCH 17/20] Normalize nested template literal types --- src/compiler/checker.ts | 44 ++++++++++++++++++++++++++--------------- 1 file changed, 28 insertions(+), 16 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c26185860e9b4..06e36a11d2f8b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -13502,23 +13502,11 @@ namespace ts { mapType(types[unionIndex], t => getTemplateLiteralType(texts, replaceElement(types, unionIndex, t))) : errorType; } - const newTypes = []; - const newTexts = []; + const newTypes: Type[] = []; + const newTexts: string[] = []; let text = texts[0]; - for (let i = 0; i < types.length; i++) { - const t = types[i]; - if (t.flags & TypeFlags.Literal) { - text += getTemplateStringForType(t) || ""; - text += texts[i + 1]; - } - else if (isGenericIndexType(t)) { - newTypes.push(t); - newTexts.push(text); - text = texts[i + 1]; - } - else { - return stringType; - } + if (!addSpans(texts, types)) { + return stringType; } if (newTypes.length === 0) { return getLiteralType(text); @@ -13530,6 +13518,30 @@ namespace ts { templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes)); } return type; + + function addSpans(texts: readonly string[], types: readonly Type[]): boolean { + for (let i = 0; i < types.length; i++) { + const t = types[i]; + if (t.flags & TypeFlags.Literal) { + text += getTemplateStringForType(t) || ""; + text += texts[i + 1]; + } + else if (t.flags & TypeFlags.TemplateLiteral) { + text += (t).texts[0]; + if (!addSpans((t).texts, (t).types)) return false; + text += texts[i + 1]; + } + else if (isGenericIndexType(t)) { + newTypes.push(t); + newTexts.push(text); + text = texts[i + 1]; + } + else { + return false; + } + } + return true; + } } function getTemplateStringForType(type: Type) { From 3933ae94abf036fe3e0d934212b5b1a5259740b7 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 20 Sep 2020 07:27:03 -1000 Subject: [PATCH 18/20] Add normalization tests --- .../conformance/types/literal/templateLiteralTypes1.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts index f4d072f7227ab..08e467d980cc5 100644 --- a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts +++ b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts @@ -18,6 +18,12 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; +// Nested template literal type normalization + +type TL1 = `a${T}b${T}c`; +type TL2 = TL1<`x${U}y`>; // `ax${U}ybx{$U}yc` +type TL3 = TL2<'o'>; // 'axoybxoyc' + // Casing intrinsics type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; From 43a249424442ebb0c2964b961d8f2cada2ae6f60 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 20 Sep 2020 07:27:11 -1000 Subject: [PATCH 19/20] Accept new baselines --- .../templateLiteralTypes1.errors.txt | 18 +- .../reference/templateLiteralTypes1.js | 9 + .../reference/templateLiteralTypes1.symbols | 1036 +++++++++-------- .../reference/templateLiteralTypes1.types | 11 + 4 files changed, 559 insertions(+), 515 deletions(-) diff --git a/tests/baselines/reference/templateLiteralTypes1.errors.txt b/tests/baselines/reference/templateLiteralTypes1.errors.txt index 382ca4e4ba319..66c5859bc7e7b 100644 --- a/tests/baselines/reference/templateLiteralTypes1.errors.txt +++ b/tests/baselines/reference/templateLiteralTypes1.errors.txt @@ -1,13 +1,13 @@ -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(34,5): error TS2322: Type 'T' is not assignable to type '{ [P in keyof T & string as `p_${P}`]: T[P]; }'. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(39,5): error TS2322: Type '{ [P in B as `p_${P}`]: T; }' is not assignable to type '{ [Q in A as `p_${Q}`]: U; }'. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(40,5): error TS2322: Type 'T' is not assignable to type '{ [P in keyof T & string as `p_${P}`]: T[P]; }'. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(45,5): error TS2322: Type '{ [P in B as `p_${P}`]: T; }' is not assignable to type '{ [Q in A as `p_${Q}`]: U; }'. Type 'A' is not assignable to type 'B'. 'A' is assignable to the constraint of type 'B', but 'B' could be instantiated with a different subtype of constraint 'string'. Type 'string' is not assignable to type 'B'. 'string' is assignable to the constraint of type 'B', but 'B' could be instantiated with a different subtype of constraint 'string'. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(159,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(191,16): error TS2590: Expression produces a union type that is too complex to represent. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(195,16): error TS2590: Expression produces a union type that is too complex to represent. -tests/cases/conformance/types/literal/templateLiteralTypes1.ts(199,16): error TS2590: Expression produces a union type that is too complex to represent. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(165,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(197,16): error TS2590: Expression produces a union type that is too complex to represent. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(201,16): error TS2590: Expression produces a union type that is too complex to represent. +tests/cases/conformance/types/literal/templateLiteralTypes1.ts(205,16): error TS2590: Expression produces a union type that is too complex to represent. ==== tests/cases/conformance/types/literal/templateLiteralTypes1.ts (6 errors) ==== @@ -28,6 +28,12 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(199,16): error TS type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; + // Nested template literal type normalization + + type TL1 = `a${T}b${T}c`; + type TL2 = TL1<`x${U}y`>; // `ax${U}ybx{$U}yc` + type TL3 = TL2<'o'>; // 'axoybxoyc' + // Casing intrinsics type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; diff --git a/tests/baselines/reference/templateLiteralTypes1.js b/tests/baselines/reference/templateLiteralTypes1.js index e4dc39647f8ea..1b28a658d446f 100644 --- a/tests/baselines/reference/templateLiteralTypes1.js +++ b/tests/baselines/reference/templateLiteralTypes1.js @@ -16,6 +16,12 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; +// Nested template literal type normalization + +type TL1 = `a${T}b${T}c`; +type TL2 = TL1<`x${U}y`>; // `ax${U}ybx{$U}yc` +type TL3 = TL2<'o'>; // 'axoybxoyc' + // Casing intrinsics type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; @@ -239,6 +245,9 @@ declare type EN1 = EventName<'Foo' | 'Bar' | 'Baz'>; declare type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; declare type ToString = `${T}`; declare type TS1 = ToString<'abc' | 42 | true | -1234n>; +declare type TL1 = `a${T}b${T}c`; +declare type TL2 = TL1<`x${U}y`>; +declare type TL3 = TL2<'o'>; declare type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; declare type TCA1 = Cases<'bar'>; declare type TCA2 = Cases<'BAR'>; diff --git a/tests/baselines/reference/templateLiteralTypes1.symbols b/tests/baselines/reference/templateLiteralTypes1.symbols index 6a3934ec911f6..727638c918b75 100644 --- a/tests/baselines/reference/templateLiteralTypes1.symbols +++ b/tests/baselines/reference/templateLiteralTypes1.symbols @@ -47,781 +47,799 @@ type TS1 = ToString<'abc' | 42 | true | -1234n>; >TS1 : Symbol(TS1, Decl(templateLiteralTypes1.ts, 14, 69)) >ToString : Symbol(ToString, Decl(templateLiteralTypes1.ts, 10, 75)) +// Nested template literal type normalization + +type TL1 = `a${T}b${T}c`; +>TL1 : Symbol(TL1, Decl(templateLiteralTypes1.ts, 15, 48)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 9)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 9)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 9)) + +type TL2 = TL1<`x${U}y`>; // `ax${U}ybx{$U}yc` +>TL2 : Symbol(TL2, Decl(templateLiteralTypes1.ts, 19, 43)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 20, 9)) +>TL1 : Symbol(TL1, Decl(templateLiteralTypes1.ts, 15, 48)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 20, 9)) + +type TL3 = TL2<'o'>; // 'axoybxoyc' +>TL3 : Symbol(TL3, Decl(templateLiteralTypes1.ts, 20, 43)) +>TL2 : Symbol(TL2, Decl(templateLiteralTypes1.ts, 19, 43)) + // Casing intrinsics type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; ->Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 15, 48)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 21, 20)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) >Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) >Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) >Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) >Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' ->TCA1 : Symbol(TCA1, Decl(templateLiteralTypes1.ts, 19, 101)) ->Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 15, 48)) +>TCA1 : Symbol(TCA1, Decl(templateLiteralTypes1.ts, 25, 101)) +>Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 21, 20)) type TCA2 = Cases<'BAR'>; // 'BAR bar BAR bAR' ->TCA2 : Symbol(TCA2, Decl(templateLiteralTypes1.ts, 21, 25)) ->Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 15, 48)) +>TCA2 : Symbol(TCA2, Decl(templateLiteralTypes1.ts, 27, 25)) +>Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 21, 20)) // Assignability function test(name: `get${Capitalize}`) { ->test : Symbol(test, Decl(templateLiteralTypes1.ts, 22, 25)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 26, 14)) ->name : Symbol(name, Decl(templateLiteralTypes1.ts, 26, 39)) +>test : Symbol(test, Decl(templateLiteralTypes1.ts, 28, 25)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 32, 14)) +>name : Symbol(name, Decl(templateLiteralTypes1.ts, 32, 39)) >Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 26, 14)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 32, 14)) let s1: string = name; ->s1 : Symbol(s1, Decl(templateLiteralTypes1.ts, 27, 7)) ->name : Symbol(name, Decl(templateLiteralTypes1.ts, 26, 39)) +>s1 : Symbol(s1, Decl(templateLiteralTypes1.ts, 33, 7)) +>name : Symbol(name, Decl(templateLiteralTypes1.ts, 32, 39)) let s2: 'getFoo' | 'getBar' = name; ->s2 : Symbol(s2, Decl(templateLiteralTypes1.ts, 28, 7)) ->name : Symbol(name, Decl(templateLiteralTypes1.ts, 26, 39)) +>s2 : Symbol(s2, Decl(templateLiteralTypes1.ts, 34, 7)) +>name : Symbol(name, Decl(templateLiteralTypes1.ts, 32, 39)) } function fa1(x: T, y: { [P in keyof T]: T[P] }, z: { [P in keyof T & string as `p_${P}`]: T[P] }) { ->fa1 : Symbol(fa1, Decl(templateLiteralTypes1.ts, 29, 1)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 31, 13)) ->x : Symbol(x, Decl(templateLiteralTypes1.ts, 31, 16)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 31, 13)) ->y : Symbol(y, Decl(templateLiteralTypes1.ts, 31, 21)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 31, 28)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 31, 13)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 31, 13)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 31, 28)) ->z : Symbol(z, Decl(templateLiteralTypes1.ts, 31, 50)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 31, 57)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 31, 13)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 31, 57)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 31, 13)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 31, 57)) +>fa1 : Symbol(fa1, Decl(templateLiteralTypes1.ts, 35, 1)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 37, 13)) +>x : Symbol(x, Decl(templateLiteralTypes1.ts, 37, 16)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 37, 13)) +>y : Symbol(y, Decl(templateLiteralTypes1.ts, 37, 21)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 37, 28)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 37, 13)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 37, 13)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 37, 28)) +>z : Symbol(z, Decl(templateLiteralTypes1.ts, 37, 50)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 37, 57)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 37, 13)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 37, 57)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 37, 13)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 37, 57)) y = x; ->y : Symbol(y, Decl(templateLiteralTypes1.ts, 31, 21)) ->x : Symbol(x, Decl(templateLiteralTypes1.ts, 31, 16)) +>y : Symbol(y, Decl(templateLiteralTypes1.ts, 37, 21)) +>x : Symbol(x, Decl(templateLiteralTypes1.ts, 37, 16)) z = x; // Error ->z : Symbol(z, Decl(templateLiteralTypes1.ts, 31, 50)) ->x : Symbol(x, Decl(templateLiteralTypes1.ts, 31, 16)) +>z : Symbol(z, Decl(templateLiteralTypes1.ts, 37, 50)) +>x : Symbol(x, Decl(templateLiteralTypes1.ts, 37, 16)) } function fa2(x: { [P in B as `p_${P}`]: T }, y: { [Q in A as `p_${Q}`]: U }) { ->fa2 : Symbol(fa2, Decl(templateLiteralTypes1.ts, 34, 1)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 36, 13)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 36, 15)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 36, 13)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 36, 28)) ->B : Symbol(B, Decl(templateLiteralTypes1.ts, 36, 46)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 36, 28)) ->x : Symbol(x, Decl(templateLiteralTypes1.ts, 36, 60)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 36, 66)) ->B : Symbol(B, Decl(templateLiteralTypes1.ts, 36, 46)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 36, 66)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 36, 13)) ->y : Symbol(y, Decl(templateLiteralTypes1.ts, 36, 91)) ->Q : Symbol(Q, Decl(templateLiteralTypes1.ts, 36, 98)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 36, 28)) ->Q : Symbol(Q, Decl(templateLiteralTypes1.ts, 36, 98)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 36, 15)) +>fa2 : Symbol(fa2, Decl(templateLiteralTypes1.ts, 40, 1)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 42, 13)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 42, 15)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 42, 13)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 42, 28)) +>B : Symbol(B, Decl(templateLiteralTypes1.ts, 42, 46)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 42, 28)) +>x : Symbol(x, Decl(templateLiteralTypes1.ts, 42, 60)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 42, 66)) +>B : Symbol(B, Decl(templateLiteralTypes1.ts, 42, 46)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 42, 66)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 42, 13)) +>y : Symbol(y, Decl(templateLiteralTypes1.ts, 42, 91)) +>Q : Symbol(Q, Decl(templateLiteralTypes1.ts, 42, 98)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 42, 28)) +>Q : Symbol(Q, Decl(templateLiteralTypes1.ts, 42, 98)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 42, 15)) x = y; ->x : Symbol(x, Decl(templateLiteralTypes1.ts, 36, 60)) ->y : Symbol(y, Decl(templateLiteralTypes1.ts, 36, 91)) +>x : Symbol(x, Decl(templateLiteralTypes1.ts, 42, 60)) +>y : Symbol(y, Decl(templateLiteralTypes1.ts, 42, 91)) y = x; // Error ->y : Symbol(y, Decl(templateLiteralTypes1.ts, 36, 91)) ->x : Symbol(x, Decl(templateLiteralTypes1.ts, 36, 60)) +>y : Symbol(y, Decl(templateLiteralTypes1.ts, 42, 91)) +>x : Symbol(x, Decl(templateLiteralTypes1.ts, 42, 60)) } // String transformations using recursive conditional types type Join = ->Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 39, 1)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 43, 10)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 43, 30)) +>Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 45, 1)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 49, 10)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 49, 30)) T extends [] ? '' : ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 43, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 49, 10)) T extends [string | number | boolean | bigint] ? `${T[0]}` : ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 43, 10)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 43, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 49, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 49, 10)) T extends [string | number | boolean | bigint, ...infer U] ? `${T[0]}${D}${Join}` : ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 43, 10)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 46, 59)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 43, 10)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 43, 30)) ->Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 39, 1)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 46, 59)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 43, 30)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 49, 10)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 52, 59)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 49, 10)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 49, 30)) +>Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 45, 1)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 52, 59)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 49, 30)) string; type TJ1 = Join<[1, 2, 3, 4], '.'> ->TJ1 : Symbol(TJ1, Decl(templateLiteralTypes1.ts, 47, 11)) ->Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 39, 1)) +>TJ1 : Symbol(TJ1, Decl(templateLiteralTypes1.ts, 53, 11)) +>Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 45, 1)) type TJ2 = Join<['foo', 'bar', 'baz'], '-'>; ->TJ2 : Symbol(TJ2, Decl(templateLiteralTypes1.ts, 49, 34)) ->Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 39, 1)) +>TJ2 : Symbol(TJ2, Decl(templateLiteralTypes1.ts, 55, 34)) +>Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 45, 1)) type TJ3 = Join<[], '.'> ->TJ3 : Symbol(TJ3, Decl(templateLiteralTypes1.ts, 50, 44)) ->Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 39, 1)) +>TJ3 : Symbol(TJ3, Decl(templateLiteralTypes1.ts, 56, 44)) +>Join : Symbol(Join, Decl(templateLiteralTypes1.ts, 45, 1)) // Inference based on delimiters type MatchPair = S extends `[${infer A},${infer B}]` ? [A, B] : unknown; ->MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 51, 24)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 55, 15)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 55, 15)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 55, 54)) ->B : Symbol(B, Decl(templateLiteralTypes1.ts, 55, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 55, 54)) ->B : Symbol(B, Decl(templateLiteralTypes1.ts, 55, 65)) +>MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 57, 24)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 61, 15)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 61, 15)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 61, 54)) +>B : Symbol(B, Decl(templateLiteralTypes1.ts, 61, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 61, 54)) +>B : Symbol(B, Decl(templateLiteralTypes1.ts, 61, 65)) type T20 = MatchPair<'[1,2]'>; // ['1', '2'] ->T20 : Symbol(T20, Decl(templateLiteralTypes1.ts, 55, 90)) ->MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 51, 24)) +>T20 : Symbol(T20, Decl(templateLiteralTypes1.ts, 61, 90)) +>MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 57, 24)) type T21 = MatchPair<'[foo,bar]'>; // ['foo', 'bar'] ->T21 : Symbol(T21, Decl(templateLiteralTypes1.ts, 57, 30)) ->MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 51, 24)) +>T21 : Symbol(T21, Decl(templateLiteralTypes1.ts, 63, 30)) +>MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 57, 24)) type T22 = MatchPair<' [1,2]'>; // unknown ->T22 : Symbol(T22, Decl(templateLiteralTypes1.ts, 58, 34)) ->MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 51, 24)) +>T22 : Symbol(T22, Decl(templateLiteralTypes1.ts, 64, 34)) +>MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 57, 24)) type T23 = MatchPair<'[123]'>; // unknown ->T23 : Symbol(T23, Decl(templateLiteralTypes1.ts, 59, 31)) ->MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 51, 24)) +>T23 : Symbol(T23, Decl(templateLiteralTypes1.ts, 65, 31)) +>MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 57, 24)) type T24 = MatchPair<'[1,2,3,4]'>; // ['1', '2,3,4'] ->T24 : Symbol(T24, Decl(templateLiteralTypes1.ts, 60, 30)) ->MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 51, 24)) +>T24 : Symbol(T24, Decl(templateLiteralTypes1.ts, 66, 30)) +>MatchPair : Symbol(MatchPair, Decl(templateLiteralTypes1.ts, 57, 24)) type SnakeToCamelCase = ->SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 61, 34)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) +>SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 67, 34)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22)) S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 64, 22)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 64, 33)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) >Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 64, 22)) ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 64, 33)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) S extends `${infer T}` ? `${Lowercase}` : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 65, 22)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22)) >Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 65, 22)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22)) SnakeToPascalCase; ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22)) type SnakeToPascalCase = ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 74, 23)) string extends S ? string : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 74, 23)) S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 74, 23)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 76, 22)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 76, 33)) >Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) >Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22)) ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 76, 22)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 76, 33)) S extends `${infer T}` ? `${Capitalize>}` : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 74, 23)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 77, 22)) >Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) >Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 77, 22)) never; type RR0 = SnakeToPascalCase<'hello_world_foo'>; // 'HelloWorldFoo' ->RR0 : Symbol(RR0, Decl(templateLiteralTypes1.ts, 72, 10)) ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) +>RR0 : Symbol(RR0, Decl(templateLiteralTypes1.ts, 78, 10)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) type RR1 = SnakeToPascalCase<'FOO_BAR_BAZ'>; // 'FooBarBaz' ->RR1 : Symbol(RR1, Decl(templateLiteralTypes1.ts, 74, 48)) ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) +>RR1 : Symbol(RR1, Decl(templateLiteralTypes1.ts, 80, 48)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) type RR2 = SnakeToCamelCase<'hello_world_foo'>; // 'helloWorldFoo' ->RR2 : Symbol(RR2, Decl(templateLiteralTypes1.ts, 75, 44)) ->SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 61, 34)) +>RR2 : Symbol(RR2, Decl(templateLiteralTypes1.ts, 81, 44)) +>SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 67, 34)) type RR3 = SnakeToCamelCase<'FOO_BAR_BAZ'>; // 'fooBarBaz' ->RR3 : Symbol(RR3, Decl(templateLiteralTypes1.ts, 76, 47)) ->SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 61, 34)) +>RR3 : Symbol(RR3, Decl(templateLiteralTypes1.ts, 82, 47)) +>SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 67, 34)) // Single character inference type FirstTwoAndRest = S extends `${infer A}${infer B}${infer R}` ? [`${A}${B}`, R] : unknown; ->FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 77, 43)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 81, 21)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 81, 21)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 81, 59)) ->B : Symbol(B, Decl(templateLiteralTypes1.ts, 81, 69)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 81, 79)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 81, 59)) ->B : Symbol(B, Decl(templateLiteralTypes1.ts, 81, 69)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 81, 79)) +>FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 83, 43)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 87, 21)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 87, 21)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 87, 59)) +>B : Symbol(B, Decl(templateLiteralTypes1.ts, 87, 69)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 87, 79)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 87, 59)) +>B : Symbol(B, Decl(templateLiteralTypes1.ts, 87, 69)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 87, 79)) type T25 = FirstTwoAndRest<'abcde'>; // ['ab', 'cde'] ->T25 : Symbol(T25, Decl(templateLiteralTypes1.ts, 81, 112)) ->FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 77, 43)) +>T25 : Symbol(T25, Decl(templateLiteralTypes1.ts, 87, 112)) +>FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 83, 43)) type T26 = FirstTwoAndRest<'ab'>; // ['ab', ''] ->T26 : Symbol(T26, Decl(templateLiteralTypes1.ts, 83, 36)) ->FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 77, 43)) +>T26 : Symbol(T26, Decl(templateLiteralTypes1.ts, 89, 36)) +>FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 83, 43)) type T27 = FirstTwoAndRest<'a'>; // unknown ->T27 : Symbol(T27, Decl(templateLiteralTypes1.ts, 84, 33)) ->FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 77, 43)) +>T27 : Symbol(T27, Decl(templateLiteralTypes1.ts, 90, 33)) +>FirstTwoAndRest : Symbol(FirstTwoAndRest, Decl(templateLiteralTypes1.ts, 83, 43)) type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'; ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) type HexColor = ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 89, 14)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 95, 14)) S extends `#${infer R1}${infer R2}${infer G1}${infer G2}${infer B1}${infer B2}` ? ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 89, 14)) ->R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 90, 23)) ->R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 90, 34)) ->G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 90, 45)) ->G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 90, 56)) ->B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 90, 67)) ->B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 90, 78)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 95, 14)) +>R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 96, 23)) +>R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 96, 34)) +>G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 96, 45)) +>G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 96, 56)) +>B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 96, 67)) +>B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 96, 78)) [R1, R2, G1, G2, B1, B2] extends [HexDigit, HexDigit, HexDigit, HexDigit, HexDigit, HexDigit] ? ->R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 90, 23)) ->R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 90, 34)) ->G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 90, 45)) ->G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 90, 56)) ->B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 90, 67)) ->B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 90, 78)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) ->HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 85, 32)) +>R1 : Symbol(R1, Decl(templateLiteralTypes1.ts, 96, 23)) +>R2 : Symbol(R2, Decl(templateLiteralTypes1.ts, 96, 34)) +>G1 : Symbol(G1, Decl(templateLiteralTypes1.ts, 96, 45)) +>G2 : Symbol(G2, Decl(templateLiteralTypes1.ts, 96, 56)) +>B1 : Symbol(B1, Decl(templateLiteralTypes1.ts, 96, 67)) +>B2 : Symbol(B2, Decl(templateLiteralTypes1.ts, 96, 78)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) S : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 89, 14)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 95, 14)) never : never; type TH1 = HexColor<'#8080FF'>; // '#8080FF' ->TH1 : Symbol(TH1, Decl(templateLiteralTypes1.ts, 94, 14)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) +>TH1 : Symbol(TH1, Decl(templateLiteralTypes1.ts, 100, 14)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) type TH2 = HexColor<'#80c0ff'>; // '#80c0ff' ->TH2 : Symbol(TH2, Decl(templateLiteralTypes1.ts, 96, 31)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) +>TH2 : Symbol(TH2, Decl(templateLiteralTypes1.ts, 102, 31)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) type TH3 = HexColor<'#8080F'>; // never ->TH3 : Symbol(TH3, Decl(templateLiteralTypes1.ts, 97, 31)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) +>TH3 : Symbol(TH3, Decl(templateLiteralTypes1.ts, 103, 31)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) type TH4 = HexColor<'#8080FFF'>; // never ->TH4 : Symbol(TH4, Decl(templateLiteralTypes1.ts, 98, 30)) ->HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 87, 145)) +>TH4 : Symbol(TH4, Decl(templateLiteralTypes1.ts, 104, 30)) +>HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) // Recursive inference type Trim = ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) S extends ` ${infer T}` ? Trim : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 104, 23)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 104, 23)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 110, 23)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 110, 23)) S extends `${infer T} ` ? Trim : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 105, 22)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 105, 22)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 111, 22)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 111, 22)) S; ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 103, 10)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 109, 10)) type TR1 = Trim<'xx '>; // 'xx' ->TR1 : Symbol(TR1, Decl(templateLiteralTypes1.ts, 106, 6)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) +>TR1 : Symbol(TR1, Decl(templateLiteralTypes1.ts, 112, 6)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) type TR2 = Trim<' xx'>; // 'xx' ->TR2 : Symbol(TR2, Decl(templateLiteralTypes1.ts, 108, 25)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) +>TR2 : Symbol(TR2, Decl(templateLiteralTypes1.ts, 114, 25)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) type TR3 = Trim<' xx '>; // 'xx' ->TR3 : Symbol(TR3, Decl(templateLiteralTypes1.ts, 109, 25)) ->Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 99, 32)) +>TR3 : Symbol(TR3, Decl(templateLiteralTypes1.ts, 115, 25)) +>Trim : Symbol(Trim, Decl(templateLiteralTypes1.ts, 105, 32)) type Split = ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 112, 28)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 118, 28)) string extends S ? string[] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) S extends '' ? [] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) S extends `${infer T}${D}${infer U}` ? [T, ...Split] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 115, 22)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 112, 28)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 115, 36)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 115, 22)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 115, 36)) ->D : Symbol(D, Decl(templateLiteralTypes1.ts, 112, 28)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 121, 22)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 118, 28)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 121, 36)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 121, 22)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 121, 36)) +>D : Symbol(D, Decl(templateLiteralTypes1.ts, 118, 28)) [S]; ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 112, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 118, 11)) type T40 = Split<'foo', '.'>; // ['foo'] ->T40 : Symbol(T40, Decl(templateLiteralTypes1.ts, 116, 8)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) +>T40 : Symbol(T40, Decl(templateLiteralTypes1.ts, 122, 8)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) type T41 = Split<'foo.bar.baz', '.'>; // ['foo', 'bar', 'baz'] ->T41 : Symbol(T41, Decl(templateLiteralTypes1.ts, 118, 29)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) +>T41 : Symbol(T41, Decl(templateLiteralTypes1.ts, 124, 29)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) type T42 = Split<'foo.bar', ''>; // ['f', 'o', 'o', '.', 'b', 'a', 'r'] ->T42 : Symbol(T42, Decl(templateLiteralTypes1.ts, 119, 37)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) +>T42 : Symbol(T42, Decl(templateLiteralTypes1.ts, 125, 37)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) type T43 = Split; // string[] ->T43 : Symbol(T43, Decl(templateLiteralTypes1.ts, 120, 32)) ->Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 110, 28)) +>T43 : Symbol(T43, Decl(templateLiteralTypes1.ts, 126, 32)) +>Split : Symbol(Split, Decl(templateLiteralTypes1.ts, 116, 28)) // Inference and property name paths declare function getProp(obj: T, path: `${P0}.${P1}.${P2}`): T[P0][P1][P2]; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) ->P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 125, 89)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 125, 127)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 125, 134)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) ->P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 125, 89)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 125, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 125, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 125, 56)) ->P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 125, 89)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) +>P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 131, 89)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 131, 127)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 131, 134)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) +>P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 131, 89)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 131, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 131, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 131, 56)) +>P2 : Symbol(P2, Decl(templateLiteralTypes1.ts, 131, 89)) declare function getProp(obj: T, path: `${P0}.${P1}`): T[P0][P1]; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 126, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 126, 90)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 126, 97)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 126, 56)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 126, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 126, 27)) ->P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 126, 56)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 132, 56)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 132, 90)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 132, 97)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 132, 56)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 132, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 132, 27)) +>P1 : Symbol(P1, Decl(templateLiteralTypes1.ts, 132, 56)) declare function getProp(obj: T, path: P0): T[P0]; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 127, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 127, 57)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 127, 64)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 127, 27)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 127, 25)) ->P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 127, 27)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 133, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 133, 57)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 133, 64)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 133, 27)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 133, 25)) +>P0 : Symbol(P0, Decl(templateLiteralTypes1.ts, 133, 27)) declare function getProp(obj: object, path: string): unknown; ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 128, 25)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 128, 37)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 134, 25)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 134, 37)) let p1 = getProp({ a: { b: {c: 42, d: 'hello' }}} as const, 'a'); ->p1 : Symbol(p1, Decl(templateLiteralTypes1.ts, 130, 3)) ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 130, 18)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 130, 23)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 130, 28)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 130, 34)) +>p1 : Symbol(p1, Decl(templateLiteralTypes1.ts, 136, 3)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 136, 18)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 136, 23)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 136, 28)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 136, 34)) let p2 = getProp({ a: { b: {c: 42, d: 'hello' }}} as const, 'a.b'); ->p2 : Symbol(p2, Decl(templateLiteralTypes1.ts, 131, 3)) ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 131, 18)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 131, 23)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 131, 28)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 131, 34)) +>p2 : Symbol(p2, Decl(templateLiteralTypes1.ts, 137, 3)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 137, 18)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 137, 23)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 137, 28)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 137, 34)) let p3 = getProp({ a: { b: {c: 42, d: 'hello' }}} as const, 'a.b.d'); ->p3 : Symbol(p3, Decl(templateLiteralTypes1.ts, 132, 3)) ->getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 121, 27), Decl(templateLiteralTypes1.ts, 125, 177), Decl(templateLiteralTypes1.ts, 126, 130), Decl(templateLiteralTypes1.ts, 127, 82)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 132, 18)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 132, 23)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 132, 28)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 132, 34)) +>p3 : Symbol(p3, Decl(templateLiteralTypes1.ts, 138, 3)) +>getProp : Symbol(getProp, Decl(templateLiteralTypes1.ts, 127, 27), Decl(templateLiteralTypes1.ts, 131, 177), Decl(templateLiteralTypes1.ts, 132, 130), Decl(templateLiteralTypes1.ts, 133, 82)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 138, 18)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 138, 23)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 138, 28)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 138, 34)) type PropType = ->PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 132, 69)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) +>PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 138, 69)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) string extends Path ? unknown : ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) Path extends keyof T ? T[Path] : ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropType : unknown : ->Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 134, 16)) ->K : Symbol(K, Decl(templateLiteralTypes1.ts, 137, 25)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 137, 36)) ->K : Symbol(K, Decl(templateLiteralTypes1.ts, 137, 25)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) ->PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 132, 69)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 134, 14)) ->K : Symbol(K, Decl(templateLiteralTypes1.ts, 137, 25)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 137, 36)) +>Path : Symbol(Path, Decl(templateLiteralTypes1.ts, 140, 16)) +>K : Symbol(K, Decl(templateLiteralTypes1.ts, 143, 25)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 143, 36)) +>K : Symbol(K, Decl(templateLiteralTypes1.ts, 143, 25)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) +>PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 138, 69)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 14)) +>K : Symbol(K, Decl(templateLiteralTypes1.ts, 143, 25)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 143, 36)) unknown; declare function getPropValue(obj: T, path: P): PropType; ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 30)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 140, 32)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 140, 51)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 30)) ->path : Symbol(path, Decl(templateLiteralTypes1.ts, 140, 58)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 140, 32)) ->PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 132, 69)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 140, 30)) ->P : Symbol(P, Decl(templateLiteralTypes1.ts, 140, 32)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 146, 30)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 146, 32)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 146, 51)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 146, 30)) +>path : Symbol(path, Decl(templateLiteralTypes1.ts, 146, 58)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 146, 32)) +>PropType : Symbol(PropType, Decl(templateLiteralTypes1.ts, 138, 69)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 146, 30)) +>P : Symbol(P, Decl(templateLiteralTypes1.ts, 146, 32)) declare const s: string; ->s : Symbol(s, Decl(templateLiteralTypes1.ts, 141, 13)) +>s : Symbol(s, Decl(templateLiteralTypes1.ts, 147, 13)) const obj = { a: { b: {c: 42, d: 'hello' }}}; ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) ->a : Symbol(a, Decl(templateLiteralTypes1.ts, 143, 13)) ->b : Symbol(b, Decl(templateLiteralTypes1.ts, 143, 18)) ->c : Symbol(c, Decl(templateLiteralTypes1.ts, 143, 23)) ->d : Symbol(d, Decl(templateLiteralTypes1.ts, 143, 29)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) +>a : Symbol(a, Decl(templateLiteralTypes1.ts, 149, 13)) +>b : Symbol(b, Decl(templateLiteralTypes1.ts, 149, 18)) +>c : Symbol(c, Decl(templateLiteralTypes1.ts, 149, 23)) +>d : Symbol(d, Decl(templateLiteralTypes1.ts, 149, 29)) getPropValue(obj, 'a'); // { b: {c: number, d: string } } ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) getPropValue(obj, 'a.b'); // {c: number, d: string } ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) getPropValue(obj, 'a.b.d'); // string ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) getPropValue(obj, 'a.b.x'); // unknown ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) getPropValue(obj, s); // unknown ->getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 138, 12)) ->obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 143, 5)) ->s : Symbol(s, Decl(templateLiteralTypes1.ts, 141, 13)) +>getPropValue : Symbol(getPropValue, Decl(templateLiteralTypes1.ts, 144, 12)) +>obj : Symbol(obj, Decl(templateLiteralTypes1.ts, 149, 5)) +>s : Symbol(s, Decl(templateLiteralTypes1.ts, 147, 13)) // Infer type variables in template literals have string constraint type S1 = T extends `foo${infer U}bar` ? S2 : never; ->S1 : Symbol(S1, Decl(templateLiteralTypes1.ts, 149, 21)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 153, 8)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 153, 8)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 153, 34)) ->S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 153, 58)) ->U : Symbol(U, Decl(templateLiteralTypes1.ts, 153, 34)) +>S1 : Symbol(S1, Decl(templateLiteralTypes1.ts, 155, 21)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 159, 8)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 159, 8)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 159, 34)) +>S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 159, 58)) +>U : Symbol(U, Decl(templateLiteralTypes1.ts, 159, 34)) type S2 = S; ->S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 153, 58)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 154, 8)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 154, 8)) +>S2 : Symbol(S2, Decl(templateLiteralTypes1.ts, 159, 58)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 160, 8)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 160, 8)) // Check that infer T declarations are validated type TV1 = `${infer X}`; ->TV1 : Symbol(TV1, Decl(templateLiteralTypes1.ts, 154, 30)) ->X : Symbol(X, Decl(templateLiteralTypes1.ts, 158, 19)) +>TV1 : Symbol(TV1, Decl(templateLiteralTypes1.ts, 160, 30)) +>X : Symbol(X, Decl(templateLiteralTypes1.ts, 164, 19)) // Batched single character inferences for lower recursion depth type Chars = ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) string extends S ? string[] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) S extends `${infer C0}${infer C1}${infer C2}${infer C3}${infer C4}${infer C5}${infer C6}${infer C7}${infer C8}${infer C9}${infer R}` ? [C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, ...Chars] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) ->C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 164, 22)) ->C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 164, 33)) ->C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 164, 44)) ->C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 164, 55)) ->C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 164, 66)) ->C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 164, 77)) ->C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 164, 88)) ->C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 164, 99)) ->C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 164, 110)) ->C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 164, 121)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 164, 132)) ->C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 164, 22)) ->C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 164, 33)) ->C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 164, 44)) ->C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 164, 55)) ->C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 164, 66)) ->C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 164, 77)) ->C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 164, 88)) ->C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 164, 99)) ->C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 164, 110)) ->C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 164, 121)) ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 164, 132)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) +>C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 170, 22)) +>C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 170, 33)) +>C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 170, 44)) +>C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 170, 55)) +>C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 170, 66)) +>C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 170, 77)) +>C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 170, 88)) +>C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 170, 99)) +>C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 170, 110)) +>C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 170, 121)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 170, 132)) +>C0 : Symbol(C0, Decl(templateLiteralTypes1.ts, 170, 22)) +>C1 : Symbol(C1, Decl(templateLiteralTypes1.ts, 170, 33)) +>C2 : Symbol(C2, Decl(templateLiteralTypes1.ts, 170, 44)) +>C3 : Symbol(C3, Decl(templateLiteralTypes1.ts, 170, 55)) +>C4 : Symbol(C4, Decl(templateLiteralTypes1.ts, 170, 66)) +>C5 : Symbol(C5, Decl(templateLiteralTypes1.ts, 170, 77)) +>C6 : Symbol(C6, Decl(templateLiteralTypes1.ts, 170, 88)) +>C7 : Symbol(C7, Decl(templateLiteralTypes1.ts, 170, 99)) +>C8 : Symbol(C8, Decl(templateLiteralTypes1.ts, 170, 110)) +>C9 : Symbol(C9, Decl(templateLiteralTypes1.ts, 170, 121)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 170, 132)) S extends `${infer C}${infer R}` ? [C, ...Chars] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) ->C : Symbol(C, Decl(templateLiteralTypes1.ts, 165, 22)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 165, 32)) ->C : Symbol(C, Decl(templateLiteralTypes1.ts, 165, 22)) ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) ->R : Symbol(R, Decl(templateLiteralTypes1.ts, 165, 32)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) +>C : Symbol(C, Decl(templateLiteralTypes1.ts, 171, 22)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 171, 32)) +>C : Symbol(C, Decl(templateLiteralTypes1.ts, 171, 22)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) +>R : Symbol(R, Decl(templateLiteralTypes1.ts, 171, 32)) S extends '' ? [] : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 162, 11)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 168, 11)) never; type L1 = Chars<'FooBarBazThisIsALongerString'>; // ['F', 'o', 'o', 'B', 'a', 'r', ...] ->L1 : Symbol(L1, Decl(templateLiteralTypes1.ts, 167, 10)) ->Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 158, 24)) +>L1 : Symbol(L1, Decl(templateLiteralTypes1.ts, 173, 10)) +>Chars : Symbol(Chars, Decl(templateLiteralTypes1.ts, 164, 24)) // Infer never when source isn't a literal type that matches the pattern type Foo = T extends `*${infer S}*` ? S : never; ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 173, 9)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 173, 9)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 173, 33)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 173, 33)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 179, 9)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 179, 9)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 179, 33)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 179, 33)) type TF1 = Foo; // never ->TF1 : Symbol(TF1, Decl(templateLiteralTypes1.ts, 173, 51)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) +>TF1 : Symbol(TF1, Decl(templateLiteralTypes1.ts, 179, 51)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) type TF2 = Foo; // never ->TF2 : Symbol(TF2, Decl(templateLiteralTypes1.ts, 175, 20)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) +>TF2 : Symbol(TF2, Decl(templateLiteralTypes1.ts, 181, 20)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) type TF3 = Foo<'abc'>; // never ->TF3 : Symbol(TF3, Decl(templateLiteralTypes1.ts, 176, 23)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) +>TF3 : Symbol(TF3, Decl(templateLiteralTypes1.ts, 182, 23)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) type TF4 = Foo<'*abc*'>; // 'abc' ->TF4 : Symbol(TF4, Decl(templateLiteralTypes1.ts, 177, 22)) ->Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 169, 48)) +>TF4 : Symbol(TF4, Decl(templateLiteralTypes1.ts, 183, 22)) +>Foo : Symbol(Foo, Decl(templateLiteralTypes1.ts, 175, 48)) // Cross product unions limited to 100,000 constituents type A = any; ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) type U1 = {a1:A} | {b1:A} | {c1:A} | {d1:A} | {e1:A} | {f1:A} | {g1:A} | {h1:A} | {i1:A} | {j1:A}; ->U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 182, 13)) ->a1 : Symbol(a1, Decl(templateLiteralTypes1.ts, 184, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->b1 : Symbol(b1, Decl(templateLiteralTypes1.ts, 184, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->c1 : Symbol(c1, Decl(templateLiteralTypes1.ts, 184, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->d1 : Symbol(d1, Decl(templateLiteralTypes1.ts, 184, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->e1 : Symbol(e1, Decl(templateLiteralTypes1.ts, 184, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->f1 : Symbol(f1, Decl(templateLiteralTypes1.ts, 184, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->g1 : Symbol(g1, Decl(templateLiteralTypes1.ts, 184, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->h1 : Symbol(h1, Decl(templateLiteralTypes1.ts, 184, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->i1 : Symbol(i1, Decl(templateLiteralTypes1.ts, 184, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->j1 : Symbol(j1, Decl(templateLiteralTypes1.ts, 184, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 188, 13)) +>a1 : Symbol(a1, Decl(templateLiteralTypes1.ts, 190, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>b1 : Symbol(b1, Decl(templateLiteralTypes1.ts, 190, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>c1 : Symbol(c1, Decl(templateLiteralTypes1.ts, 190, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>d1 : Symbol(d1, Decl(templateLiteralTypes1.ts, 190, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>e1 : Symbol(e1, Decl(templateLiteralTypes1.ts, 190, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>f1 : Symbol(f1, Decl(templateLiteralTypes1.ts, 190, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>g1 : Symbol(g1, Decl(templateLiteralTypes1.ts, 190, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>h1 : Symbol(h1, Decl(templateLiteralTypes1.ts, 190, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>i1 : Symbol(i1, Decl(templateLiteralTypes1.ts, 190, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>j1 : Symbol(j1, Decl(templateLiteralTypes1.ts, 190, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) type U2 = {a2:A} | {b2:A} | {c2:A} | {d2:A} | {e2:A} | {f2:A} | {g2:A} | {h2:A} | {i2:A} | {j2:A}; ->U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 184, 98)) ->a2 : Symbol(a2, Decl(templateLiteralTypes1.ts, 185, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->b2 : Symbol(b2, Decl(templateLiteralTypes1.ts, 185, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->c2 : Symbol(c2, Decl(templateLiteralTypes1.ts, 185, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->d2 : Symbol(d2, Decl(templateLiteralTypes1.ts, 185, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->e2 : Symbol(e2, Decl(templateLiteralTypes1.ts, 185, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->f2 : Symbol(f2, Decl(templateLiteralTypes1.ts, 185, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->g2 : Symbol(g2, Decl(templateLiteralTypes1.ts, 185, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->h2 : Symbol(h2, Decl(templateLiteralTypes1.ts, 185, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->i2 : Symbol(i2, Decl(templateLiteralTypes1.ts, 185, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->j2 : Symbol(j2, Decl(templateLiteralTypes1.ts, 185, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 190, 98)) +>a2 : Symbol(a2, Decl(templateLiteralTypes1.ts, 191, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>b2 : Symbol(b2, Decl(templateLiteralTypes1.ts, 191, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>c2 : Symbol(c2, Decl(templateLiteralTypes1.ts, 191, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>d2 : Symbol(d2, Decl(templateLiteralTypes1.ts, 191, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>e2 : Symbol(e2, Decl(templateLiteralTypes1.ts, 191, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>f2 : Symbol(f2, Decl(templateLiteralTypes1.ts, 191, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>g2 : Symbol(g2, Decl(templateLiteralTypes1.ts, 191, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>h2 : Symbol(h2, Decl(templateLiteralTypes1.ts, 191, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>i2 : Symbol(i2, Decl(templateLiteralTypes1.ts, 191, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>j2 : Symbol(j2, Decl(templateLiteralTypes1.ts, 191, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) type U3 = {a3:A} | {b3:A} | {c3:A} | {d3:A} | {e3:A} | {f3:A} | {g3:A} | {h3:A} | {i3:A} | {j3:A}; ->U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 185, 98)) ->a3 : Symbol(a3, Decl(templateLiteralTypes1.ts, 186, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->b3 : Symbol(b3, Decl(templateLiteralTypes1.ts, 186, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->c3 : Symbol(c3, Decl(templateLiteralTypes1.ts, 186, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->d3 : Symbol(d3, Decl(templateLiteralTypes1.ts, 186, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->e3 : Symbol(e3, Decl(templateLiteralTypes1.ts, 186, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->f3 : Symbol(f3, Decl(templateLiteralTypes1.ts, 186, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->g3 : Symbol(g3, Decl(templateLiteralTypes1.ts, 186, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->h3 : Symbol(h3, Decl(templateLiteralTypes1.ts, 186, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->i3 : Symbol(i3, Decl(templateLiteralTypes1.ts, 186, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->j3 : Symbol(j3, Decl(templateLiteralTypes1.ts, 186, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 191, 98)) +>a3 : Symbol(a3, Decl(templateLiteralTypes1.ts, 192, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>b3 : Symbol(b3, Decl(templateLiteralTypes1.ts, 192, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>c3 : Symbol(c3, Decl(templateLiteralTypes1.ts, 192, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>d3 : Symbol(d3, Decl(templateLiteralTypes1.ts, 192, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>e3 : Symbol(e3, Decl(templateLiteralTypes1.ts, 192, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>f3 : Symbol(f3, Decl(templateLiteralTypes1.ts, 192, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>g3 : Symbol(g3, Decl(templateLiteralTypes1.ts, 192, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>h3 : Symbol(h3, Decl(templateLiteralTypes1.ts, 192, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>i3 : Symbol(i3, Decl(templateLiteralTypes1.ts, 192, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>j3 : Symbol(j3, Decl(templateLiteralTypes1.ts, 192, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) type U4 = {a4:A} | {b4:A} | {c4:A} | {d4:A} | {e4:A} | {f4:A} | {g4:A} | {h4:A} | {i4:A} | {j4:A}; ->U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 186, 98)) ->a4 : Symbol(a4, Decl(templateLiteralTypes1.ts, 187, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->b4 : Symbol(b4, Decl(templateLiteralTypes1.ts, 187, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->c4 : Symbol(c4, Decl(templateLiteralTypes1.ts, 187, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->d4 : Symbol(d4, Decl(templateLiteralTypes1.ts, 187, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->e4 : Symbol(e4, Decl(templateLiteralTypes1.ts, 187, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->f4 : Symbol(f4, Decl(templateLiteralTypes1.ts, 187, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->g4 : Symbol(g4, Decl(templateLiteralTypes1.ts, 187, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->h4 : Symbol(h4, Decl(templateLiteralTypes1.ts, 187, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->i4 : Symbol(i4, Decl(templateLiteralTypes1.ts, 187, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->j4 : Symbol(j4, Decl(templateLiteralTypes1.ts, 187, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 192, 98)) +>a4 : Symbol(a4, Decl(templateLiteralTypes1.ts, 193, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>b4 : Symbol(b4, Decl(templateLiteralTypes1.ts, 193, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>c4 : Symbol(c4, Decl(templateLiteralTypes1.ts, 193, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>d4 : Symbol(d4, Decl(templateLiteralTypes1.ts, 193, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>e4 : Symbol(e4, Decl(templateLiteralTypes1.ts, 193, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>f4 : Symbol(f4, Decl(templateLiteralTypes1.ts, 193, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>g4 : Symbol(g4, Decl(templateLiteralTypes1.ts, 193, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>h4 : Symbol(h4, Decl(templateLiteralTypes1.ts, 193, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>i4 : Symbol(i4, Decl(templateLiteralTypes1.ts, 193, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>j4 : Symbol(j4, Decl(templateLiteralTypes1.ts, 193, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) type U5 = {a5:A} | {b5:A} | {c5:A} | {d5:A} | {e5:A} | {f5:A} | {g5:A} | {h5:A} | {i5:A} | {j5:A}; ->U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 187, 98)) ->a5 : Symbol(a5, Decl(templateLiteralTypes1.ts, 188, 11)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->b5 : Symbol(b5, Decl(templateLiteralTypes1.ts, 188, 20)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->c5 : Symbol(c5, Decl(templateLiteralTypes1.ts, 188, 29)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->d5 : Symbol(d5, Decl(templateLiteralTypes1.ts, 188, 38)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->e5 : Symbol(e5, Decl(templateLiteralTypes1.ts, 188, 47)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->f5 : Symbol(f5, Decl(templateLiteralTypes1.ts, 188, 56)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->g5 : Symbol(g5, Decl(templateLiteralTypes1.ts, 188, 65)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->h5 : Symbol(h5, Decl(templateLiteralTypes1.ts, 188, 74)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->i5 : Symbol(i5, Decl(templateLiteralTypes1.ts, 188, 83)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) ->j5 : Symbol(j5, Decl(templateLiteralTypes1.ts, 188, 92)) ->A : Symbol(A, Decl(templateLiteralTypes1.ts, 178, 24)) +>U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 193, 98)) +>a5 : Symbol(a5, Decl(templateLiteralTypes1.ts, 194, 11)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>b5 : Symbol(b5, Decl(templateLiteralTypes1.ts, 194, 20)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>c5 : Symbol(c5, Decl(templateLiteralTypes1.ts, 194, 29)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>d5 : Symbol(d5, Decl(templateLiteralTypes1.ts, 194, 38)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>e5 : Symbol(e5, Decl(templateLiteralTypes1.ts, 194, 47)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>f5 : Symbol(f5, Decl(templateLiteralTypes1.ts, 194, 56)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>g5 : Symbol(g5, Decl(templateLiteralTypes1.ts, 194, 65)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>h5 : Symbol(h5, Decl(templateLiteralTypes1.ts, 194, 74)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>i5 : Symbol(i5, Decl(templateLiteralTypes1.ts, 194, 83)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) +>j5 : Symbol(j5, Decl(templateLiteralTypes1.ts, 194, 92)) +>A : Symbol(A, Decl(templateLiteralTypes1.ts, 184, 24)) type U100000 = U1 & U2 & U3 & U4 & U5; // Error ->U100000 : Symbol(U100000, Decl(templateLiteralTypes1.ts, 188, 98)) ->U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 182, 13)) ->U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 184, 98)) ->U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 185, 98)) ->U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 186, 98)) ->U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 187, 98)) +>U100000 : Symbol(U100000, Decl(templateLiteralTypes1.ts, 194, 98)) +>U1 : Symbol(U1, Decl(templateLiteralTypes1.ts, 188, 13)) +>U2 : Symbol(U2, Decl(templateLiteralTypes1.ts, 190, 98)) +>U3 : Symbol(U3, Decl(templateLiteralTypes1.ts, 191, 98)) +>U4 : Symbol(U4, Decl(templateLiteralTypes1.ts, 192, 98)) +>U5 : Symbol(U5, Decl(templateLiteralTypes1.ts, 193, 98)) type Digits = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) type D100000 = `${Digits}${Digits}${Digits}${Digits}${Digits}`; // Error ->D100000 : Symbol(D100000, Decl(templateLiteralTypes1.ts, 192, 52)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) ->Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 190, 38)) +>D100000 : Symbol(D100000, Decl(templateLiteralTypes1.ts, 198, 52)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) +>Digits : Symbol(Digits, Decl(templateLiteralTypes1.ts, 196, 38)) type TDigits = [0] | [1] | [2] | [3] | [4] | [5] | [6] | [7] | [8] | [9]; ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) type T100000 = [...TDigits, ...TDigits, ...TDigits, ...TDigits, ...TDigits]; // Error ->T100000 : Symbol(T100000, Decl(templateLiteralTypes1.ts, 196, 73)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) ->TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 194, 63)) +>T100000 : Symbol(T100000, Decl(templateLiteralTypes1.ts, 202, 73)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) +>TDigits : Symbol(TDigits, Decl(templateLiteralTypes1.ts, 200, 63)) diff --git a/tests/baselines/reference/templateLiteralTypes1.types b/tests/baselines/reference/templateLiteralTypes1.types index 308a21dcbd4d9..fe1d45d0c7543 100644 --- a/tests/baselines/reference/templateLiteralTypes1.types +++ b/tests/baselines/reference/templateLiteralTypes1.types @@ -46,6 +46,17 @@ type TS1 = ToString<'abc' | 42 | true | -1234n>; >-1234n : -1234n >1234n : 1234n +// Nested template literal type normalization + +type TL1 = `a${T}b${T}c`; +>TL1 : `a${T}b${T}c` + +type TL2 = TL1<`x${U}y`>; // `ax${U}ybx{$U}yc` +>TL2 : `ax${U}ybx${U}yc` + +type TL3 = TL2<'o'>; // 'axoybxoyc' +>TL3 : "axoybxoyc" + // Casing intrinsics type Cases = `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}`; From 4031f478a9176acf7e50b872dfaf06f9e91166e4 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 20 Sep 2020 14:40:47 -1000 Subject: [PATCH 20/20] Update tests --- tests/baselines/reference/mappedTypeAsClauses.js | 4 ++-- tests/baselines/reference/mappedTypeAsClauses.symbols | 3 ++- tests/baselines/reference/mappedTypeAsClauses.types | 2 +- tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/tests/baselines/reference/mappedTypeAsClauses.js b/tests/baselines/reference/mappedTypeAsClauses.js index 75dc75880f0cf..cefa284f1f41d 100644 --- a/tests/baselines/reference/mappedTypeAsClauses.js +++ b/tests/baselines/reference/mappedTypeAsClauses.js @@ -32,7 +32,7 @@ type TD3 = keyof DoubleProp; // `${keyof U & string}1` | `${keyof U & str // Repro from #40619 type Lazyify = { - [K in keyof T as `get${capitalize string & K}`]: () => T[K] + [K in keyof T as `get${Capitalize}`]: () => T[K] }; interface Person { @@ -97,7 +97,7 @@ declare type TD1 = DoubleProp<{ declare type TD2 = keyof TD1; declare type TD3 = keyof DoubleProp; declare type Lazyify = { - [K in keyof T as `get${capitalize string & K}`]: () => T[K]; + [K in keyof T as `get${Capitalize}`]: () => T[K]; }; interface Person { readonly name: string; diff --git a/tests/baselines/reference/mappedTypeAsClauses.symbols b/tests/baselines/reference/mappedTypeAsClauses.symbols index 1235f6e5e3c75..ec340db38c2df 100644 --- a/tests/baselines/reference/mappedTypeAsClauses.symbols +++ b/tests/baselines/reference/mappedTypeAsClauses.symbols @@ -115,9 +115,10 @@ type Lazyify = { >Lazyify : Symbol(Lazyify, Decl(mappedTypeAsClauses.ts, 28, 34)) >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 32, 13)) - [K in keyof T as `get${capitalize string & K}`]: () => T[K] + [K in keyof T as `get${Capitalize}`]: () => T[K] >K : Symbol(K, Decl(mappedTypeAsClauses.ts, 33, 5)) >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 32, 13)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) >K : Symbol(K, Decl(mappedTypeAsClauses.ts, 33, 5)) >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 32, 13)) >K : Symbol(K, Decl(mappedTypeAsClauses.ts, 33, 5)) diff --git a/tests/baselines/reference/mappedTypeAsClauses.types b/tests/baselines/reference/mappedTypeAsClauses.types index 5a533a7691c97..1ac3ff557b19b 100644 --- a/tests/baselines/reference/mappedTypeAsClauses.types +++ b/tests/baselines/reference/mappedTypeAsClauses.types @@ -71,7 +71,7 @@ type TD3 = keyof DoubleProp; // `${keyof U & string}1` | `${keyof U & str type Lazyify = { >Lazyify : Lazyify - [K in keyof T as `get${capitalize string & K}`]: () => T[K] + [K in keyof T as `get${Capitalize}`]: () => T[K] }; interface Person { diff --git a/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts b/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts index 714660e684735..f9677a517ab88 100644 --- a/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts +++ b/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts @@ -34,7 +34,7 @@ type TD3 = keyof DoubleProp; // `${keyof U & string}1` | `${keyof U & str // Repro from #40619 type Lazyify = { - [K in keyof T as `get${capitalize string & K}`]: () => T[K] + [K in keyof T as `get${Capitalize}`]: () => T[K] }; interface Person {