feat: add typeof modifier in template string

Author: Jack-Works

src/compiler/checker.ts

@@ -13438,13 +13438,16 @@ namespace ts {
             let i = 0;
             while (i < types.length) {
                 const t = types[i];
-                if (t.flags & TypeFlags.Literal) {
-                    const s = applyTemplateCasing(getTemplateStringForType(t) || "", casings[i]);
+                const casingType = casings[i];
+                const isGeneric = isGenericIndexType(t);
+                const resolvable = (t.flags & TypeFlags.Literal) || (!isGeneric && casingType === TemplateCasing.TypeOf);
+                if (resolvable) {
+                    const s = applyTemplateCasing(getTemplateStringForType(t, casingType) || "", casingType);
                     texts = [...texts.slice(0, i), texts[i] + s + texts[i + 1], ...texts.slice(i + 2)];
                     casings = [...casings.slice(0, i), ...casings.slice(i + 1)];
                     types = [...types.slice(0, i), ...types.slice(i + 1)];
                 }
-                else if (isGenericIndexType(t)) {
+                else if (isGeneric) {
                     i++;
                 }
                 else {
@@ -13462,7 +13465,10 @@ namespace ts {
             return type;
         }
 
-        function getTemplateStringForType(type: Type) {
+        function getTemplateStringForType(type: Type, casing: TemplateCasing) {
+            if (casing === TemplateCasing.TypeOf) {
+                return getTypeNameForErrorDisplay(type);
+            }
             return type.flags & TypeFlags.StringLiteral ? (<StringLiteralType>type).value :
                 type.flags & TypeFlags.NumberLiteral ? "" + (<NumberLiteralType>type).value :
                 type.flags & TypeFlags.BigIntLiteral ? pseudoBigIntToString((<BigIntLiteralType>type).value) :
@@ -31418,7 +31424,9 @@ namespace ts {
             getTypeFromTypeNode(node);
             for (const span of node.templateSpans) {
                 const type = getTypeFromTypeNode(span.type);
-                checkTypeAssignableTo(type, templateConstraintType, span.type);
+                if (span.casing !== TemplateCasing.TypeOf) {
+                    checkTypeAssignableTo(type, templateConstraintType, span.type);
+                }
                 if (!everyType(type, t => !!(t.flags & TypeFlags.Literal) || isGenericIndexType(t))) {
                     error(span.type, Diagnostics.Template_type_argument_0_is_not_literal_type_or_a_generic_type, typeToString(type));
                 }

src/compiler/emitter.ts

@@ -2013,6 +2013,7 @@ namespace ts {
                 node.casing === TemplateCasing.Lowercase ? "lowercase" :
                 node.casing === TemplateCasing.Capitalize ? "capitalize" :
                 node.casing === TemplateCasing.Uncapitalize ? "uncapitalize" :
+                node.casing === TemplateCasing.TypeOf ? "typeof" :
                 undefined;
             if (keyword) {
                 writeKeyword(keyword);

src/compiler/parser.ts

@@ -2621,6 +2621,7 @@ namespace ts {
                 parseOptional(SyntaxKind.LowercaseKeyword) ? TemplateCasing.Lowercase :
                 parseOptional(SyntaxKind.CapitalizeKeyword) ? TemplateCasing.Capitalize :
                 parseOptional(SyntaxKind.UncapitalizeKeyword) ? TemplateCasing.Uncapitalize :
+                parseOptional(SyntaxKind.TypeOfKeyword) ? TemplateCasing.TypeOf :
                 TemplateCasing.None;
         }
 

src/compiler/types.ts

@@ -1672,6 +1672,7 @@ namespace ts {
         Lowercase,
         Capitalize,
         Uncapitalize,
+        TypeOf,
     }
 
     // Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.