diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 54339bbdf3fcf..38fa90003a832 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) { } @@ -705,6 +719,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 +732,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); @@ -4344,7 +4360,7 @@ namespace ts { if (type.flags & TypeFlags.Any) { context.approximateLength += 3; - return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword); + return factory.createKeywordTypeNode(type === intrinsicMarkerType ? SyntaxKind.IntrinsicKeyword : SyntaxKind.AnyKeyword); } if (type.flags & TypeFlags.Unknown) { return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword); @@ -4505,17 +4521,19 @@ 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; 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); @@ -10824,7 +10842,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; } @@ -10922,7 +10940,11 @@ 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); + return constraint ? getStringMappingType((t).symbol, constraint) : stringType; } if (t.flags & TypeFlags.IndexedAccess) { const baseObjectType = getBaseConstraint((t).objectType); @@ -12128,6 +12150,9 @@ namespace ts { function getTypeAliasInstantiation(symbol: Symbol, typeArguments: readonly Type[] | undefined): Type { const type = getDeclaredTypeOfSymbol(symbol); + if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName as string) && typeArguments && typeArguments.length === 1) { + return getStringMappingType(symbol, typeArguments[0]); + } const links = getSymbolLinks(symbol); const typeParameters = links.typeParameters!; const id = getTypeListId(typeArguments); @@ -13465,50 +13490,58 @@ 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 = []; + 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) { - const s = applyTemplateCasing(getTemplateStringForType(t) || "", casings[i]); - text += s; - text += texts[i + 1]; - } - else if (isGenericIndexType(t)) { - newTypes.push(t); - newCasings.push(casings[i]); - newTexts.push(text); - text = texts[i + 1]; - } - else { - return stringType; - } + if (!addSpans(texts, types)) { + return stringType; } if (newTypes.length === 0) { 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; + + 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) { @@ -13519,24 +13552,46 @@ 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; } + 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(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); + 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; @@ -13772,7 +13827,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 { @@ -14278,7 +14333,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) { @@ -14364,7 +14419,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; } @@ -14642,6 +14697,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`. @@ -15166,7 +15223,10 @@ 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)); } if (flags & TypeFlags.IndexedAccess) { return getIndexedAccessType(instantiateType((type).objectType, mapper), instantiateType((type).indexType, mapper), /*accessNode*/ undefined, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)); @@ -17323,6 +17383,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 @@ -19767,6 +19842,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); } @@ -20063,7 +20143,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++) { @@ -20257,7 +20337,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) { @@ -26313,7 +26393,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); } @@ -29374,7 +29454,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)) { @@ -30328,7 +30408,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) || @@ -35310,12 +35390,18 @@ 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 (node.type.kind === SyntaxKind.IntrinsicKeyword) { + 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); + } + } + else { + checkSourceElement(node.type); + registerForUnusedIdentifiersCheck(node); + } } function computeEnumMemberValues(node: EnumDeclaration) { diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index a46ddd430f9a6..29a31559aa4d8 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -3043,6 +3043,10 @@ "category": "Error", "code": 2794 }, + "The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types.": { + "category": "Error", + "code": 2795 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", 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 af797435c9d4f..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); @@ -6751,7 +6742,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..35388e38b049f 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, @@ -151,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 eec63bd905413..fbf308707a10d 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -167,6 +167,7 @@ namespace ts { DeclareKeyword, GetKeyword, InferKeyword, + IntrinsicKeyword, IsKeyword, KeyOfKeyword, ModuleKeyword, @@ -186,10 +187,6 @@ namespace ts { FromKeyword, GlobalKeyword, BigIntKeyword, - UppercaseKeyword, - LowercaseKeyword, - CapitalizeKeyword, - UncapitalizeKeyword, OfKeyword, // LastKeyword and LastToken and LastContextualKeyword // Parse tree nodes @@ -544,7 +541,6 @@ namespace ts { | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword - | SyntaxKind.CapitalizeKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword @@ -574,10 +570,10 @@ namespace ts { | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword + | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword - | SyntaxKind.LowercaseKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword @@ -605,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 @@ -635,6 +629,7 @@ namespace ts { | SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword + | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword @@ -1665,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 @@ -4892,6 +4878,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 +4896,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 +4909,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 +4917,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, @@ -5379,11 +5366,15 @@ 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 } + export interface StringMappingType extends InstantiableType { + symbol: Symbol; + type: Type; + } + // 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 @@ -6774,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 diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index fc3dce9e1ff00..f946e2d8bc336 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"), diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index d40318a5e8e53..cf95c473240fe 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 = intrinsic; + +/** + * Convert first character of string literal type to lowercase + */ +type Uncapitalize = intrinsic; + /** * Marker for contextual 'this' type */ diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 58167e3f7b92b..621b4141291f3 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -240,215 +240,212 @@ 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, + 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, @@ -456,15 +453,15 @@ declare namespace ts { FirstReservedWord = 80, LastReservedWord = 115, FirstKeyword = 80, - LastKeyword = 159, + LastKeyword = 156, FirstFutureReservedWord = 116, LastFutureReservedWord = 124, - FirstTypeNode = 175, - LastTypeNode = 198, + FirstTypeNode = 172, + LastTypeNode = 195, FirstPunctuation = 18, LastPunctuation = 77, FirstToken = 0, - LastToken = 159, + LastToken = 156, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -473,21 +470,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 = 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.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.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; @@ -972,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; } @@ -2489,11 +2478,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 +2494,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 { @@ -2660,9 +2650,12 @@ declare namespace ts { } export interface TemplateLiteralType extends InstantiableType { texts: readonly string[]; - casings: readonly TemplateCasing[]; types: readonly Type[]; } + export interface StringMappingType extends InstantiableType { + symbol: Symbol; + type: Type; + } export interface SubstitutionType extends InstantiableType { baseType: Type; substitute: Type; @@ -3225,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 3a4fc7ae36e20..0df67772e6e09 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -240,215 +240,212 @@ 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, + 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, @@ -456,15 +453,15 @@ declare namespace ts { FirstReservedWord = 80, LastReservedWord = 115, FirstKeyword = 80, - LastKeyword = 159, + LastKeyword = 156, FirstFutureReservedWord = 116, LastFutureReservedWord = 124, - FirstTypeNode = 175, - LastTypeNode = 198, + FirstTypeNode = 172, + LastTypeNode = 195, FirstPunctuation = 18, LastPunctuation = 77, FirstToken = 0, - LastToken = 159, + LastToken = 156, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -473,21 +470,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 = 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.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.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; @@ -972,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; } @@ -2489,11 +2478,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 +2494,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 { @@ -2660,9 +2650,12 @@ declare namespace ts { } export interface TemplateLiteralType extends InstantiableType { texts: readonly string[]; - casings: readonly TemplateCasing[]; types: readonly Type[]; } + export interface StringMappingType extends InstantiableType { + symbol: Symbol; + type: Type; + } export interface SubstitutionType extends InstantiableType { baseType: Type; substitute: Type; @@ -3225,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/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/baselines/reference/intrinsicTypes.errors.txt b/tests/baselines/reference/intrinsicTypes.errors.txt new file mode 100644 index 0000000000000..46a3ab82ec14a --- /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 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'. + 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 TS2795: 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 +} + diff --git a/tests/baselines/reference/mappedTypeAsClauses.js b/tests/baselines/reference/mappedTypeAsClauses.js index 9bb361db932f2..cefa284f1f41d 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 @@ -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 { @@ -51,7 +51,7 @@ type LazyPerson = Lazyify; //// [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; @@ -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 31a9ca0bef884..ec340db38c2df 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)) @@ -114,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 f2426a9c74c01..1ac3ff557b19b 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 } }>; @@ -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/baselines/reference/templateLiteralTypes1.errors.txt b/tests/baselines/reference/templateLiteralTypes1.errors.txt index 6a453496896a3..66c5859bc7e7b 100644 --- a/tests/baselines/reference/templateLiteralTypes1.errors.txt +++ b/tests/baselines/reference/templateLiteralTypes1.errors.txt @@ -1,5 +1,5 @@ -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'. @@ -28,16 +28,22 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(205,16): error TS type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; - // Casing modifiers + // Nested template literal type normalization - type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; + 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}`; 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 +89,14 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(205,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' @@ -106,12 +112,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..1b28a658d446f 100644 --- a/tests/baselines/reference/templateLiteralTypes1.js +++ b/tests/baselines/reference/templateLiteralTypes1.js @@ -16,16 +16,22 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; -// Casing modifiers +// Nested template literal type normalization -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; +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}`; 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 +69,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' @@ -86,12 +92,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 = @@ -245,10 +245,13 @@ 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 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'>; -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: { @@ -269,8 +272,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'>; @@ -279,10 +282,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..727638c918b75 100644 --- a/tests/baselines/reference/templateLiteralTypes1.symbols +++ b/tests/baselines/reference/templateLiteralTypes1.symbols @@ -47,277 +47,278 @@ 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 - -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; ->Cases : Symbol(Cases, Decl(templateLiteralTypes1.ts, 15, 48)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 19, 11)) +// 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, 21, 20)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) +>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) +>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(templateLiteralTypes1.ts, 25, 11)) type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' ->TCA1 : Symbol(TCA1, Decl(templateLiteralTypes1.ts, 19, 97)) ->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 T}`) { ->test : Symbol(test, Decl(templateLiteralTypes1.ts, 22, 25)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 26, 14)) ->name : Symbol(name, Decl(templateLiteralTypes1.ts, 26, 39)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 26, 14)) +function test(name: `get${Capitalize}`) { +>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, 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)) - - S extends `${infer T}_${infer U}` ? `${lowercase T}${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)) ->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 : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 65, 22)) ->T : Symbol(T, Decl(templateLiteralTypes1.ts, 65, 22)) - - SnakeToPascalCase; ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22)) - -type SnakeToPascalCase = ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) - - string extends S ? string : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) +>SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 67, 34)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22)) - S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase}` : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) + S extends `${infer T}_${infer U}` ? `${Lowercase}${SnakeToPascalCase}` : +>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, 70, 22)) ->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25)) +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) >U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33)) - S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : ->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23)) + S extends `${infer T}` ? `${Lowercase}` : +>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, 71, 22)) + SnakeToPascalCase; +>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25)) +>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22)) + +type SnakeToPascalCase = +>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, 74, 23)) + + S extends `${infer T}_${infer U}` ? `${Capitalize>}${SnakeToPascalCase}` : +>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, 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, 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, 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)) - -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)) +>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, 91, 31)) +>HexDigit : Symbol(HexDigit, Decl(templateLiteralTypes1.ts, 91, 32)) type HexColor = >HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145)) @@ -339,12 +340,12 @@ type HexColor = >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)) +>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, 95, 14)) diff --git a/tests/baselines/reference/templateLiteralTypes1.types b/tests/baselines/reference/templateLiteralTypes1.types index b34eecce1fcb0..fe1d45d0c7543 100644 --- a/tests/baselines/reference/templateLiteralTypes1.types +++ b/tests/baselines/reference/templateLiteralTypes1.types @@ -46,10 +46,21 @@ type TS1 = ToString<'abc' | 42 | true | -1234n>; >-1234n : -1234n >1234n : 1234n -// Casing modifiers +// Nested template literal type normalization -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; ->Cases : `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}` +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}`; +>Cases : `${Uppercase} ${Lowercase} ${Capitalize} ${Uncapitalize}` type TCA1 = Cases<'bar'>; // 'BAR bar Bar bar' >TCA1 : "BAR bar Bar bar" @@ -59,17 +70,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 +158,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' @@ -185,18 +196,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..08e467d980cc5 100644 --- a/tests/cases/conformance/types/literal/templateLiteralTypes1.ts +++ b/tests/cases/conformance/types/literal/templateLiteralTypes1.ts @@ -18,16 +18,22 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`; type ToString = `${T}`; type TS1 = ToString<'abc' | 42 | true | -1234n>; -// Casing modifiers +// Nested template literal type normalization -type Cases = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`; +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}`; 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 +71,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' @@ -88,12 +94,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 = diff --git a/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts b/tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts index 542503e82dc5e..f9677a517ab88 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 @@ -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 { 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'; +} 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); +}