Intrinsic string types (#40580)

* Introduce Uppercase<T> and Lowercase<T> intrinsic types

* Accept new API baselines

* Add Uppercase/Lowercase/Capitalize/Uncapitalize to lib.d.ts

* Update fourslash

* Add an 'intrinsic' keyword

* Update template literal type tests

* Accept new API baselines

* Minor fixes

* Switch Capitalize<T> and Uncapitalize<T> to intrinsic types

* Add tests

* Accept new baselines

* Accept new baselines

* Remove template literal type casing modifiers

* Update tests

* Accept new baselines

* Add more tests

* Normalize nested template literal types

* Add normalization tests

* Accept new baselines

* Update tests

src/compiler/checker.ts

@@ -256,6 +256,20 @@ namespace ts {
         VoidIsNonOptional = 1 << 1,
     }
 
+    const enum IntrinsicTypeKind {
+        Uppercase,
+        Lowercase,
+        Capitalize,
+        Uncapitalize
+    }
+
+    const intrinsicTypeKinds: ReadonlyESMap<string, IntrinsicTypeKind> = 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<string, LiteralType>();
         const indexedAccessTypes = new Map<string, IndexedAccessType>();
         const templateLiteralTypes = new Map<string, TemplateLiteralType>();
+        const stringMappingTypes = new Map<string, StringMappingType>();
         const substitutionTypes = new Map<string, SubstitutionType>();
         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 = (<TemplateLiteralType>type).texts;
-                    const casings = (<TemplateLiteralType>type).casings;
                     const types = (<TemplateLiteralType>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((<StringMappingType>type).type, context);
+                    return symbolToTypeNode((<StringMappingType>type).symbol, context, SymbolFlags.Type, [typeNode]);
+                }
                 if (type.flags & TypeFlags.IndexedAccess) {
                     const objectTypeNode = typeToTypeNodeHelper((<IndexedAccessType>type).objectType, context);
                     const indexTypeNode = typeToTypeNodeHelper((<IndexedAccessType>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(<InstantiableType | UnionOrIntersectionType>type);
                 return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined;
             }
@@ -10922,7 +10940,11 @@ namespace ts {
                 if (t.flags & TypeFlags.TemplateLiteral) {
                     const types = (<TemplateLiteralType>t).types;
                     const constraints = mapDefined(types, getBaseConstraint);
-                    return constraints.length === types.length ? getTemplateLiteralType((<TemplateLiteralType>t).texts, (<TemplateLiteralType>t).casings, constraints) : stringType;
+                    return constraints.length === types.length ? getTemplateLiteralType((<TemplateLiteralType>t).texts, constraints) : stringType;
+                }
+                if (t.flags & TypeFlags.StringMapping) {
+                    const constraint = getBaseConstraint((<StringMappingType>t).type);
+                    return constraint ? getStringMappingType((<StringMappingType>t).symbol, constraint) : stringType;
                 }
                 if (t.flags & TypeFlags.IndexedAccess) {
                     const baseObjectType = getBaseConstraint((<IndexedAccessType>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 += (<TemplateLiteralType>t).texts[0];
+                        if (!addSpans((<TemplateLiteralType>t).texts, (<TemplateLiteralType>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,22 +13552,44 @@ 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);
+        function createTemplateLiteralType(texts: readonly string[], types: readonly Type[]) {
+            const type = <TemplateLiteralType>createType(TypeFlags.TemplateLiteral);
+            type.texts = texts;
+            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, (<StringLiteralType>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 createTemplateLiteralType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]) {
-            const type = <TemplateLiteralType>createType(TypeFlags.TemplateLiteral);
-            type.texts = texts;
-            type.casings = casings;
-            type.types = types;
-            return type;
+        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 = <StringMappingType>createType(TypeFlags.StringMapping);
+            result.symbol = symbol;
+            result.type = type;
+            return result;
         }
 
         function createIndexedAccessType(objectType: Type, indexType: Type, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) {
@@ -13772,7 +13827,7 @@ namespace ts {
                 }
                 return !!((<UnionOrIntersectionType>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((<IndexType>type).type, mapper));
             }
             if (flags & TypeFlags.TemplateLiteral) {
-                return getTemplateLiteralType((<TemplateLiteralType>type).texts, (<TemplateLiteralType>type).casings, instantiateTypes((<TemplateLiteralType>type).types, mapper));
+                return getTemplateLiteralType((<TemplateLiteralType>type).texts, instantiateTypes((<TemplateLiteralType>type).types, mapper));
+            }
+            if (flags & TypeFlags.StringMapping) {
+                return getStringMappingType((<StringMappingType>type).symbol, instantiateType((<StringMappingType>type).type, mapper));
             }
             if (flags & TypeFlags.IndexedAccess) {
                 return getIndexedAccessType(instantiateType((<IndexedAccessType>type).objectType, mapper), instantiateType((<IndexedAccessType>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 && (<StringMappingType>source).symbol === (<StringMappingType>target).symbol) {
+                        if (result = isRelatedTo((<StringMappingType>source).type, (<StringMappingType>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((<IndexedAccessType>source).objectType, (<IndexedAccessType>target).objectType);
                     inferFromTypes((<IndexedAccessType>source).indexType, (<IndexedAccessType>target).indexType);
                 }
+                else if (source.flags & TypeFlags.StringMapping && target.flags & TypeFlags.StringMapping) {
+                    if ((<StringMappingType>source).symbol === (<StringMappingType>target).symbol) {
+                        inferFromTypes((<StringMappingType>source).type, (<StringMappingType>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(<StringLiteralType>source, target) :
-                    source.flags & TypeFlags.TemplateLiteral && arraysEqual((<TemplateLiteralType>source).texts, target.texts) && arraysEqual((<TemplateLiteralType>source).casings, target.casings)? (<TemplateLiteralType>source).types :
+                    source.flags & TypeFlags.TemplateLiteral && arraysEqual((<TemplateLiteralType>source).texts, target.texts) ? (<TemplateLiteralType>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) {
@@ -26319,7 +26399,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);
                 }
@@ -29380,7 +29460,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)) {
@@ -30334,7 +30414,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) ||
@@ -35316,12 +35396,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) {

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",

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);
         }

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<TemplateLiteralTypeSpan>(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;
         }
 

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);

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,
     };
 

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<T> : Bar<T>', 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

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"),

src/lib/es5.d.ts

@@ -1508,6 +1508,26 @@ type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => i
  */
 type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;
 
+/**
+ * Convert string literal type to uppercase
+ */
+type Uppercase<S extends string> = intrinsic;
+
+/**
+ * Convert string literal type to lowercase
+ */
+type Lowercase<S extends string> = intrinsic;
+
+/**
+ * Convert first character of string literal type to uppercase
+ */
+type Capitalize<S extends string> = intrinsic;
+
+/**
+ * Convert first character of string literal type to lowercase
+ */
+type Uncapitalize<S extends string> = intrinsic;
+
 /**
  * Marker for contextual 'this' type
  */

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<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, 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<TKind extends KeywordTypeSyntaxKind>(kind: TKind): KeywordTypeNode<TKind>;
         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;

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<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, 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<TKind extends KeywordTypeSyntaxKind>(kind: TKind): KeywordTypeNode<TKind>;
         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;

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> = intrinsic;
+                          ~~~~~~~~~
+!!! error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types.
+    type TE3<T extends intrinsic> = T;
+                       ~~~~~~~~~
+!!! error TS2304: Cannot find name 'intrinsic'.
+    type TE4<intrinsic extends intrinsic> = 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 extends intrinsic> = (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';
+    }
+    

tests/baselines/reference/intrinsicKeyword.js

@@ -0,0 +1,36 @@
+//// [intrinsicKeyword.ts]
+let e1: intrinsic;
+let e2: { intrinsic: intrinsic };
+type TE1 = (intrinsic);
+type TE2<intrinsic> = intrinsic;
+type TE3<T extends intrinsic> = T;
+type TE4<intrinsic extends intrinsic> = intrinsic;
+type TE5<intrinsic extends intrinsic> = (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';
+}

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> = intrinsic;
+>TE2 : Symbol(TE2, Decl(intrinsicKeyword.ts, 2, 23))
+>intrinsic : Symbol(intrinsic, Decl(intrinsicKeyword.ts, 3, 9))
+
+type TE3<T extends intrinsic> = 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 extends intrinsic> = 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 extends intrinsic> = (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))
+}
+

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> = intrinsic;
+>TE2 : intrinsic
+
+type TE3<T extends intrinsic> = T;
+>TE3 : T
+
+type TE4<intrinsic extends intrinsic> = intrinsic;
+>TE4 : intrinsic
+
+type TE5<intrinsic extends intrinsic> = (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"
+}
+

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<T>'.
+tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(42,5): error TS2322: Type 'string' is not assignable to type 'Uppercase<U>'.
+tests/cases/conformance/types/typeAliases/intrinsicTypes.ts(43,5): error TS2322: Type 'Uppercase<T>' is not assignable to type 'Uppercase<U>'.
+  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>;  // string
+    type TU4 = Uppercase<any>;  // any
+    type TU5 = Uppercase<never>;  // 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>;  // string
+    type TL4 = Lowercase<any>;  // any
+    type TL5 = Lowercase<never>;  // 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>;  // string
+    type TC4 = Capitalize<any>;  // any
+    type TC5 = Capitalize<never>;  // 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>;  // string
+    type TN4 = Uncapitalize<any>;  // any
+    type TN5 = Uncapitalize<never>;  // never
+    type TN6 = Uncapitalize<42>;  // Error
+                            ~~
+!!! error TS2344: Type 'number' does not satisfy the constraint 'string'.
+    
+    type TX1<S extends string> = Uppercase<`aB${S}`>;
+    type TX2 = TX1<'xYz'>;  // "ABXYZ"
+    type TX3<S extends string> = Lowercase<`aB${S}`>;
+    type TX4 = TX3<'xYz'>;  // "abxyz"
+    type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`;  // "ABCxyz"
+    
+    type MyUppercase<S extends string> = intrinsic;  // Error
+                                         ~~~~~~~~~
+!!! error TS2795: The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types.
+    
+    function foo1<T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>) {
+        s = x;
+        s = y;
+        x = s;  // Error
+        ~
+!!! error TS2322: Type 'string' is not assignable to type 'Uppercase<T>'.
+        x = y;
+        y = s;  // Error
+        ~
+!!! error TS2322: Type 'string' is not assignable to type 'Uppercase<U>'.
+        y = x;  // Error
+        ~
+!!! error TS2322: Type 'Uppercase<T>' is not assignable to type 'Uppercase<U>'.
+!!! 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<T extends 'foo' | 'bar'>(x: Uppercase<T>) {
+        let s: 'FOO' | 'BAR' = x;
+    }
+    
+    declare function foo3<T extends string>(x: Uppercase<T>): T;
+    
+    function foo4<U extends string>(x: Uppercase<U>) {
+        return foo3(x);
+    }
+    

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>;  // string
+type TU4 = Uppercase<any>;  // any
+type TU5 = Uppercase<never>;  // never
+type TU6 = Uppercase<42>;  // Error
+
+type TL1 = Lowercase<'HELLO'>;  // "hello"
+type TL2 = Lowercase<'FOO' | 'BAR'>;  // "foo" | "bar"
+type TL3 = Lowercase<string>;  // string
+type TL4 = Lowercase<any>;  // any
+type TL5 = Lowercase<never>;  // never
+type TL6 = Lowercase<42>;  // Error
+
+type TC1 = Capitalize<'hello'>;  // "Hello"
+type TC2 = Capitalize<'foo' | 'bar'>;  // "Foo" | "Bar"
+type TC3 = Capitalize<string>;  // string
+type TC4 = Capitalize<any>;  // any
+type TC5 = Capitalize<never>;  // never
+type TC6 = Capitalize<42>;  // Error
+
+type TN1 = Uncapitalize<'Hello'>;  // "hello"
+type TN2 = Uncapitalize<'Foo' | 'Bar'>;  // "foo" | "bar"
+type TN3 = Uncapitalize<string>;  // string
+type TN4 = Uncapitalize<any>;  // any
+type TN5 = Uncapitalize<never>;  // never
+type TN6 = Uncapitalize<42>;  // Error
+
+type TX1<S extends string> = Uppercase<`aB${S}`>;
+type TX2 = TX1<'xYz'>;  // "ABXYZ"
+type TX3<S extends string> = Lowercase<`aB${S}`>;
+type TX4 = TX3<'xYz'>;  // "abxyz"
+type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`;  // "ABCxyz"
+
+type MyUppercase<S extends string> = intrinsic;  // Error
+
+function foo1<T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>) {
+    s = x;
+    s = y;
+    x = s;  // Error
+    x = y;
+    y = s;  // Error
+    y = x;  // Error
+}
+
+function foo2<T extends 'foo' | 'bar'>(x: Uppercase<T>) {
+    let s: 'FOO' | 'BAR' = x;
+}
+
+declare function foo3<T extends string>(x: Uppercase<T>): T;
+
+function foo4<U extends string>(x: Uppercase<U>) {
+    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<string>;
+declare type TU4 = Uppercase<any>;
+declare type TU5 = Uppercase<never>;
+declare type TU6 = Uppercase<42>;
+declare type TL1 = Lowercase<'HELLO'>;
+declare type TL2 = Lowercase<'FOO' | 'BAR'>;
+declare type TL3 = Lowercase<string>;
+declare type TL4 = Lowercase<any>;
+declare type TL5 = Lowercase<never>;
+declare type TL6 = Lowercase<42>;
+declare type TC1 = Capitalize<'hello'>;
+declare type TC2 = Capitalize<'foo' | 'bar'>;
+declare type TC3 = Capitalize<string>;
+declare type TC4 = Capitalize<any>;
+declare type TC5 = Capitalize<never>;
+declare type TC6 = Capitalize<42>;
+declare type TN1 = Uncapitalize<'Hello'>;
+declare type TN2 = Uncapitalize<'Foo' | 'Bar'>;
+declare type TN3 = Uncapitalize<string>;
+declare type TN4 = Uncapitalize<any>;
+declare type TN5 = Uncapitalize<never>;
+declare type TN6 = Uncapitalize<42>;
+declare type TX1<S extends string> = Uppercase<`aB${S}`>;
+declare type TX2 = TX1<'xYz'>;
+declare type TX3<S extends string> = Lowercase<`aB${S}`>;
+declare type TX4 = TX3<'xYz'>;
+declare type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`;
+declare type MyUppercase<S extends string> = intrinsic;
+declare function foo1<T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>): void;
+declare function foo2<T extends 'foo' | 'bar'>(x: Uppercase<T>): void;
+declare function foo3<T extends string>(x: Uppercase<T>): T;
+declare function foo4<U extends string>(x: Uppercase<U>): U;

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>;  // string
+>TU3 : Symbol(TU3, Decl(intrinsicTypes.ts, 1, 36))
+>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --))
+
+type TU4 = Uppercase<any>;  // any
+>TU4 : Symbol(TU4, Decl(intrinsicTypes.ts, 2, 29))
+>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --))
+
+type TU5 = Uppercase<never>;  // 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>;  // string
+>TL3 : Symbol(TL3, Decl(intrinsicTypes.ts, 8, 36))
+>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --))
+
+type TL4 = Lowercase<any>;  // any
+>TL4 : Symbol(TL4, Decl(intrinsicTypes.ts, 9, 29))
+>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --))
+
+type TL5 = Lowercase<never>;  // 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>;  // string
+>TC3 : Symbol(TC3, Decl(intrinsicTypes.ts, 15, 37))
+>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --))
+
+type TC4 = Capitalize<any>;  // any
+>TC4 : Symbol(TC4, Decl(intrinsicTypes.ts, 16, 30))
+>Capitalize : Symbol(Capitalize, Decl(lib.es5.d.ts, --, --))
+
+type TC5 = Capitalize<never>;  // 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>;  // string
+>TN3 : Symbol(TN3, Decl(intrinsicTypes.ts, 22, 39))
+>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --))
+
+type TN4 = Uncapitalize<any>;  // any
+>TN4 : Symbol(TN4, Decl(intrinsicTypes.ts, 23, 32))
+>Uncapitalize : Symbol(Uncapitalize, Decl(lib.es5.d.ts, --, --))
+
+type TN5 = Uncapitalize<never>;  // 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<S extends string> = 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<S extends string> = 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<S extends string> = intrinsic;  // Error
+>MyUppercase : Symbol(MyUppercase, Decl(intrinsicTypes.ts, 32, 52))
+>S : Symbol(S, Decl(intrinsicTypes.ts, 34, 17))
+
+function foo1<T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>) {
+>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<T extends 'foo' | 'bar'>(x: Uppercase<T>) {
+>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<T extends string>(x: Uppercase<T>): 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<U extends string>(x: Uppercase<U>) {
+>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))
+}
+

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>;  // string
+>TU3 : string
+
+type TU4 = Uppercase<any>;  // any
+>TU4 : any
+
+type TU5 = Uppercase<never>;  // 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>;  // string
+>TL3 : string
+
+type TL4 = Lowercase<any>;  // any
+>TL4 : any
+
+type TL5 = Lowercase<never>;  // 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>;  // string
+>TC3 : string
+
+type TC4 = Capitalize<any>;  // any
+>TC4 : any
+
+type TC5 = Capitalize<never>;  // 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>;  // string
+>TN3 : string
+
+type TN4 = Uncapitalize<any>;  // any
+>TN4 : any
+
+type TN5 = Uncapitalize<never>;  // never
+>TN5 : never
+
+type TN6 = Uncapitalize<42>;  // Error
+>TN6 : 42
+
+type TX1<S extends string> = Uppercase<`aB${S}`>;
+>TX1 : Uppercase<`aB${S}`>
+
+type TX2 = TX1<'xYz'>;  // "ABXYZ"
+>TX2 : "ABXYZ"
+
+type TX3<S extends string> = 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<S extends string> = intrinsic;  // Error
+>MyUppercase : intrinsic
+
+function foo1<T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>) {
+>foo1 : <T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>) => void
+>s : string
+>x : Uppercase<T>
+>y : Uppercase<U>
+
+    s = x;
+>s = x : Uppercase<T>
+>s : string
+>x : Uppercase<T>
+
+    s = y;
+>s = y : Uppercase<U>
+>s : string
+>y : Uppercase<U>
+
+    x = s;  // Error
+>x = s : string
+>x : Uppercase<T>
+>s : string
+
+    x = y;
+>x = y : Uppercase<U>
+>x : Uppercase<T>
+>y : Uppercase<U>
+
+    y = s;  // Error
+>y = s : string
+>y : Uppercase<U>
+>s : string
+
+    y = x;  // Error
+>y = x : Uppercase<T>
+>y : Uppercase<U>
+>x : Uppercase<T>
+}
+
+function foo2<T extends 'foo' | 'bar'>(x: Uppercase<T>) {
+>foo2 : <T extends "foo" | "bar">(x: Uppercase<T>) => void
+>x : Uppercase<T>
+
+    let s: 'FOO' | 'BAR' = x;
+>s : "FOO" | "BAR"
+>x : Uppercase<T>
+}
+
+declare function foo3<T extends string>(x: Uppercase<T>): T;
+>foo3 : <T extends string>(x: Uppercase<T>) => T
+>x : Uppercase<T>
+
+function foo4<U extends string>(x: Uppercase<U>) {
+>foo4 : <U extends string>(x: Uppercase<U>) => U
+>x : Uppercase<U>
+
+    return foo3(x);
+>foo3(x) : U
+>foo3 : <T extends string>(x: Uppercase<T>) => T
+>x : Uppercase<U>
+}
+

tests/baselines/reference/mappedTypeAsClauses.js

@@ -1,7 +1,7 @@
 //// [mappedTypeAsClauses.ts]
 // Mapped type 'as N' clauses
 
-type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
+type Getters<T> = { [P in keyof T & string as `get${Capitalize<P>}`]: () => 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<U> = keyof DoubleProp<U>;  // `${keyof U & string}1` | `${keyof U & str
 // Repro from #40619
 
 type Lazyify<T> = {
-    [K in keyof T as `get${capitalize string & K}`]: () => T[K]
+    [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K]
 };
 
 interface Person {
@@ -51,7 +51,7 @@ type LazyPerson = Lazyify<Person>;
 
 //// [mappedTypeAsClauses.d.ts]
 declare type Getters<T> = {
-    [P in keyof T & string as `get${capitalize P}`]: () => T[P];
+    [P in keyof T & string as `get${Capitalize<P>}`]: () => T[P];
 };
 declare type TG1 = Getters<{
     foo: string;
@@ -97,7 +97,7 @@ declare type TD1 = DoubleProp<{
 declare type TD2 = keyof TD1;
 declare type TD3<U> = keyof DoubleProp<U>;
 declare type Lazyify<T> = {
-    [K in keyof T as `get${capitalize string & K}`]: () => T[K];
+    [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K];
 };
 interface Person {
     readonly name: string;

tests/baselines/reference/mappedTypeAsClauses.symbols

@@ -1,17 +1,18 @@
 === tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts ===
 // Mapped type 'as N' clauses
 
-type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
+type Getters<T> = { [P in keyof T & string as `get${Capitalize<P>}`]: () => 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<T> = {
 >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<K & string>}`]: () => 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))

tests/baselines/reference/mappedTypeAsClauses.types

@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts ===
 // Mapped type 'as N' clauses
 
-type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
+type Getters<T> = { [P in keyof T & string as `get${Capitalize<P>}`]: () => T[P] };
 >Getters : Getters<T>
 
 type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>;
@@ -71,7 +71,7 @@ type TD3<U> = keyof DoubleProp<U>;  // `${keyof U & string}1` | `${keyof U & str
 type Lazyify<T> = {
 >Lazyify : Lazyify<T>
 
-    [K in keyof T as `get${capitalize string & K}`]: () => T[K]
+    [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K]
 };
 
 interface Person {

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 extends string | number | boolean | bigint> = `${T}`;
     type TS1 = ToString<'abc' | 42 | true | -1234n>;
     
-    // Casing modifiers
+    // Nested template literal type normalization
     
-    type Cases<T extends string> = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`;
+    type TL1<T extends string> = `a${T}b${T}c`;
+    type TL2<U extends string> = TL1<`x${U}y`>;  // `ax${U}ybx{$U}yc`
+    type TL3 = TL2<'o'>;  // 'axoybxoyc'
+    
+    // Casing intrinsics
+    
+    type Cases<T extends string> = `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`;
     
     type TCA1 = Cases<'bar'>;  // 'BAR bar Bar bar'
     type TCA2 = Cases<'BAR'>;  // 'BAR bar BAR bAR'
     
     // Assignability
     
-    function test<T extends 'foo' | 'bar'>(name: `get${capitalize T}`) {
+    function test<T extends 'foo' | 'bar'>(name: `get${Capitalize<T>}`) {
         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 string> =
-        S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` :
-        S extends `${infer T}` ? `${lowercase T}` :
+        S extends `${infer T}_${infer U}` ? `${Lowercase<T>}${SnakeToPascalCase<U>}` :
+        S extends `${infer T}` ? `${Lowercase<T>}` :
         SnakeToPascalCase<S>;
     
     type SnakeToPascalCase<S extends string> =
         string extends S ? string :
-        S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` :
-        S extends `${infer T}` ? `${capitalize `${lowercase T}`}` :
+        S extends `${infer T}_${infer U}` ? `${Capitalize<Lowercase<T>>}${SnakeToPascalCase<U>}` :
+        S extends `${infer T}` ? `${Capitalize<Lowercase<T>>}` :
         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 string> = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S;
-    type Uncapitalize<S extends string> = 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<S extends string> =

tests/baselines/reference/templateLiteralTypes1.js

@@ -16,16 +16,22 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`;
 type ToString<T extends string | number | boolean | bigint> = `${T}`;
 type TS1 = ToString<'abc' | 42 | true | -1234n>;
 
-// Casing modifiers
+// Nested template literal type normalization
 
-type Cases<T extends string> = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`;
+type TL1<T extends string> = `a${T}b${T}c`;
+type TL2<U extends string> = TL1<`x${U}y`>;  // `ax${U}ybx{$U}yc`
+type TL3 = TL2<'o'>;  // 'axoybxoyc'
+
+// Casing intrinsics
+
+type Cases<T extends string> = `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`;
 
 type TCA1 = Cases<'bar'>;  // 'BAR bar Bar bar'
 type TCA2 = Cases<'BAR'>;  // 'BAR bar BAR bAR'
 
 // Assignability
 
-function test<T extends 'foo' | 'bar'>(name: `get${capitalize T}`) {
+function test<T extends 'foo' | 'bar'>(name: `get${Capitalize<T>}`) {
     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 string> =
-    S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` :
-    S extends `${infer T}` ? `${lowercase T}` :
+    S extends `${infer T}_${infer U}` ? `${Lowercase<T>}${SnakeToPascalCase<U>}` :
+    S extends `${infer T}` ? `${Lowercase<T>}` :
     SnakeToPascalCase<S>;
 
 type SnakeToPascalCase<S extends string> =
     string extends S ? string :
-    S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` :
-    S extends `${infer T}` ? `${capitalize `${lowercase T}`}` :
+    S extends `${infer T}_${infer U}` ? `${Capitalize<Lowercase<T>>}${SnakeToPascalCase<U>}` :
+    S extends `${infer T}` ? `${Capitalize<Lowercase<T>>}` :
     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 string> = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S;
-type Uncapitalize<S extends string> = 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<S extends string> =
@@ -245,10 +245,13 @@ declare type EN1 = EventName<'Foo' | 'Bar' | 'Baz'>;
 declare type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`;
 declare type ToString<T extends string | number | boolean | bigint> = `${T}`;
 declare type TS1 = ToString<'abc' | 42 | true | -1234n>;
-declare type Cases<T extends string> = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`;
+declare type TL1<T extends string> = `a${T}b${T}c`;
+declare type TL2<U extends string> = TL1<`x${U}y`>;
+declare type TL3 = TL2<'o'>;
+declare type Cases<T extends string> = `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`;
 declare type TCA1 = Cases<'bar'>;
 declare type TCA2 = Cases<'BAR'>;
-declare function test<T extends 'foo' | 'bar'>(name: `get${capitalize T}`): void;
+declare function test<T extends 'foo' | 'bar'>(name: `get${Capitalize<T>}`): void;
 declare function fa1<T>(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 string> = S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` : S extends `${infer T}` ? `${lowercase T}` : SnakeToPascalCase<S>;
-declare type SnakeToPascalCase<S extends string> = string extends S ? string : S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` : S extends `${infer T}` ? `${capitalize `${lowercase T}`}` : never;
+declare type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${Lowercase<T>}${SnakeToPascalCase<U>}` : S extends `${infer T}` ? `${Lowercase<T>}` : SnakeToPascalCase<S>;
+declare type SnakeToPascalCase<S extends string> = string extends S ? string : S extends `${infer T}_${infer U}` ? `${Capitalize<Lowercase<T>>}${SnakeToPascalCase<U>}` : S extends `${infer T}` ? `${Capitalize<Lowercase<T>>}` : 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 string> = 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 string> = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S;
-declare type Uncapitalize<S extends string> = 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 string> = S extends `#${infer R1}${infer R2}${infer G1}${infer G2}${infer B1}${infer B2}` ? [
     R1,

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
+// Nested template literal type normalization
 
-type Cases<T extends string> = `${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))
+type TL1<T extends string> = `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<U extends string> = 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<T extends string> = `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`;
+>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<T extends 'foo' | 'bar'>(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<T extends 'foo' | 'bar'>(name: `get${Capitalize<T>}`) {
+>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<T>(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<T, U extends T, A extends string, B extends A>(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<T extends unknown[], D extends string> =
->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<U, D>}` :
->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 string> = 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<S extends string> =
->SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 61, 34))
->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22))
+>SnakeToCamelCase : Symbol(SnakeToCamelCase, Decl(templateLiteralTypes1.ts, 67, 34))
+>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22))
 
-    S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` :
->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}_${infer U}` ? `${Lowercase<T>}${SnakeToPascalCase<U>}` :
+>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, 72, 25))
+>U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 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))
+    S extends `${infer T}` ? `${Lowercase<T>}` :
+>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<S>;
->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25))
->S : Symbol(S, Decl(templateLiteralTypes1.ts, 63, 22))
+>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25))
+>S : Symbol(S, Decl(templateLiteralTypes1.ts, 69, 22))
 
 type SnakeToPascalCase<S extends string> =
->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25))
->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23))
+>SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 72, 25))
+>S : Symbol(S, Decl(templateLiteralTypes1.ts, 74, 23))
 
     string extends S ? string :
->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23))
+>S : Symbol(S, Decl(templateLiteralTypes1.ts, 74, 23))
 
-    S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` :
->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23))
->T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22))
->U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33))
->T : Symbol(T, Decl(templateLiteralTypes1.ts, 70, 22))
->SnakeToPascalCase : Symbol(SnakeToPascalCase, Decl(templateLiteralTypes1.ts, 66, 25))
->U : Symbol(U, Decl(templateLiteralTypes1.ts, 70, 33))
+    S extends `${infer T}_${infer U}` ? `${Capitalize<Lowercase<T>>}${SnakeToPascalCase<U>}` :
+>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 `${lowercase T}`}` :
->S : Symbol(S, Decl(templateLiteralTypes1.ts, 68, 23))
->T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22))
->T : Symbol(T, Decl(templateLiteralTypes1.ts, 71, 22))
+    S extends `${infer T}` ? `${Capitalize<Lowercase<T>>}` :
+>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 string> = 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 string> = 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 string> = 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<S extends string> =
 >HexColor : Symbol(HexColor, Decl(templateLiteralTypes1.ts, 93, 145))
@@ -339,12 +340,12 @@ type HexColor<S extends string> =
 >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))

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<T extends string> = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`;
->Cases : `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`
+type TL1<T extends string> = `a${T}b${T}c`;
+>TL1 : `a${T}b${T}c`
+
+type TL2<U extends string> = 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<T extends string> = `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`;
+>Cases : `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`
 
 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<T extends 'foo' | 'bar'>(name: `get${capitalize T}`) {
->test : <T extends "bar" | "foo">(name: `get${capitalize T}`) => void
->name : `get${capitalize T}`
+function test<T extends 'foo' | 'bar'>(name: `get${Capitalize<T>}`) {
+>test : <T extends "bar" | "foo">(name: `get${Capitalize<T>}`) => void
+>name : `get${Capitalize<T>}`
 
     let s1: string = name;
 >s1 : string
->name : `get${capitalize T}`
+>name : `get${Capitalize<T>}`
 
     let s2: 'getFoo' | 'getBar' = name;
 >s2 : "getFoo" | "getBar"
->name : `get${capitalize T}`
+>name : `get${Capitalize<T>}`
 }
 
 function fa1<T>(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<S extends string> =
 >SnakeToCamelCase : SnakeToCamelCase<S>
 
-    S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` :
-    S extends `${infer T}` ? `${lowercase T}` :
+    S extends `${infer T}_${infer U}` ? `${Lowercase<T>}${SnakeToPascalCase<U>}` :
+    S extends `${infer T}` ? `${Lowercase<T>}` :
     SnakeToPascalCase<S>;
 
 type SnakeToPascalCase<S extends string> =
 >SnakeToPascalCase : SnakeToPascalCase<S>
 
     string extends S ? string :
-    S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` :
-    S extends `${infer T}` ? `${capitalize `${lowercase T}`}` :
+    S extends `${infer T}_${infer U}` ? `${Capitalize<Lowercase<T>>}${SnakeToPascalCase<U>}` :
+    S extends `${infer T}` ? `${Capitalize<Lowercase<T>>}` :
     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 string> = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S;
->Capitalize : Capitalize<S>
-
-type Uncapitalize<S extends string> = S extends `${infer H}${infer T}` ? `${lowercase H}${T}` : S;
->Uncapitalize : Uncapitalize<S>
-
-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
 

tests/cases/conformance/types/literal/templateLiteralTypes1.ts

@@ -18,16 +18,22 @@ type Loc = `${'top' | 'middle' | 'bottom'}-${'left' | 'center' | 'right'}`;
 type ToString<T extends string | number | boolean | bigint> = `${T}`;
 type TS1 = ToString<'abc' | 42 | true | -1234n>;
 
-// Casing modifiers
+// Nested template literal type normalization
 
-type Cases<T extends string> = `${uppercase T} ${lowercase T} ${capitalize T} ${uncapitalize T}`;
+type TL1<T extends string> = `a${T}b${T}c`;
+type TL2<U extends string> = TL1<`x${U}y`>;  // `ax${U}ybx{$U}yc`
+type TL3 = TL2<'o'>;  // 'axoybxoyc'
+
+// Casing intrinsics
+
+type Cases<T extends string> = `${Uppercase<T>} ${Lowercase<T>} ${Capitalize<T>} ${Uncapitalize<T>}`;
 
 type TCA1 = Cases<'bar'>;  // 'BAR bar Bar bar'
 type TCA2 = Cases<'BAR'>;  // 'BAR bar BAR bAR'
 
 // Assignability
 
-function test<T extends 'foo' | 'bar'>(name: `get${capitalize T}`) {
+function test<T extends 'foo' | 'bar'>(name: `get${Capitalize<T>}`) {
     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 string> =
-    S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` :
-    S extends `${infer T}` ? `${lowercase T}` :
+    S extends `${infer T}_${infer U}` ? `${Lowercase<T>}${SnakeToPascalCase<U>}` :
+    S extends `${infer T}` ? `${Lowercase<T>}` :
     SnakeToPascalCase<S>;
 
 type SnakeToPascalCase<S extends string> =
     string extends S ? string :
-    S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` :
-    S extends `${infer T}` ? `${capitalize `${lowercase T}`}` :
+    S extends `${infer T}_${infer U}` ? `${Capitalize<Lowercase<T>>}${SnakeToPascalCase<U>}` :
+    S extends `${infer T}` ? `${Capitalize<Lowercase<T>>}` :
     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 string> = S extends `${infer H}${infer T}` ? `${uppercase H}${T}` : S;
-type Uncapitalize<S extends string> = 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<S extends string> =

tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts

@@ -3,7 +3,7 @@
 
 // Mapped type 'as N' clauses
 
-type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
+type Getters<T> = { [P in keyof T & string as `get${Capitalize<P>}`]: () => 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<U> = keyof DoubleProp<U>;  // `${keyof U & string}1` | `${keyof U & str
 // Repro from #40619
 
 type Lazyify<T> = {
-    [K in keyof T as `get${capitalize string & K}`]: () => T[K]
+    [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K]
 };
 
 interface Person {

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> = intrinsic;
+type TE3<T extends intrinsic> = T;
+type TE4<intrinsic extends intrinsic> = intrinsic;
+type TE5<intrinsic extends intrinsic> = (intrinsic);
+
+function f1() {
+    let intrinsic: intrinsic.intrinsic;
+}
+
+function f2(intrinsic: string) {
+    return intrinsic;
+}
+
+function f3() {
+    type intrinsic = string;
+    let s1: intrinsic = 'ok';
+}

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>;  // string
+type TU4 = Uppercase<any>;  // any
+type TU5 = Uppercase<never>;  // never
+type TU6 = Uppercase<42>;  // Error
+
+type TL1 = Lowercase<'HELLO'>;  // "hello"
+type TL2 = Lowercase<'FOO' | 'BAR'>;  // "foo" | "bar"
+type TL3 = Lowercase<string>;  // string
+type TL4 = Lowercase<any>;  // any
+type TL5 = Lowercase<never>;  // never
+type TL6 = Lowercase<42>;  // Error
+
+type TC1 = Capitalize<'hello'>;  // "Hello"
+type TC2 = Capitalize<'foo' | 'bar'>;  // "Foo" | "Bar"
+type TC3 = Capitalize<string>;  // string
+type TC4 = Capitalize<any>;  // any
+type TC5 = Capitalize<never>;  // never
+type TC6 = Capitalize<42>;  // Error
+
+type TN1 = Uncapitalize<'Hello'>;  // "hello"
+type TN2 = Uncapitalize<'Foo' | 'Bar'>;  // "foo" | "bar"
+type TN3 = Uncapitalize<string>;  // string
+type TN4 = Uncapitalize<any>;  // any
+type TN5 = Uncapitalize<never>;  // never
+type TN6 = Uncapitalize<42>;  // Error
+
+type TX1<S extends string> = Uppercase<`aB${S}`>;
+type TX2 = TX1<'xYz'>;  // "ABXYZ"
+type TX3<S extends string> = Lowercase<`aB${S}`>;
+type TX4 = TX3<'xYz'>;  // "abxyz"
+type TX5 = `${Uppercase<'abc'>}${Lowercase<'XYZ'>}`;  // "ABCxyz"
+
+type MyUppercase<S extends string> = intrinsic;  // Error
+
+function foo1<T extends string, U extends T>(s: string, x: Uppercase<T>, y: Uppercase<U>) {
+    s = x;
+    s = y;
+    x = s;  // Error
+    x = y;
+    y = s;  // Error
+    y = x;  // Error
+}
+
+function foo2<T extends 'foo' | 'bar'>(x: Uppercase<T>) {
+    let s: 'FOO' | 'BAR' = x;
+}
+
+declare function foo3<T extends string>(x: Uppercase<T>): T;
+
+function foo4<U extends string>(x: Uppercase<U>) {
+    return foo3(x);
+}