implement template literal types

Author: resolritter

common/corpus/expressions.txt

@@ -9,7 +9,7 @@ T as {} & { [t: T]: T } & { [g: G]: G }
 ---
 
 (program
-  (expression_statement (as_expression (identifier) (template_string)))
+  (expression_statement (as_expression (identifier) (template_literal_type)))
   (expression_statement
     (as_expression
       (identifier)

common/corpus/types.txt

@@ -1079,3 +1079,87 @@ type T<X> = T extends { x: infer X } ? X : never;
             (type_annotation (infer_type (type_identifier)))))
       (type_identifier)
       (type_identifier))))
+
+==================================
+Template literal types
+==================================
+
+type A<B, C> = `${B}${C}`;
+type A = `${B[0]}-foo-${C}-bar-${D<U, D>}`
+type A = `[${'a'}${0}]`
+
+type A<B, C> = B extends C
+  ? C extends string
+    ? `${C}${"" extends C ? "" : "."}${B}`
+    : never
+  : never
+
+---
+
+(program
+  (type_alias_declaration
+    (type_identifier)
+    (type_parameters
+      (type_parameter
+        (type_identifier))
+      (type_parameter
+        (type_identifier)))
+    (template_literal_type
+      (template_type
+        (type_identifier))
+      (template_type
+        (type_identifier))))
+  (type_alias_declaration
+    (type_identifier)
+    (template_literal_type
+      (template_type
+        (lookup_type
+          (type_identifier)
+          (literal_type
+            (number))))
+      (template_type
+        (type_identifier))
+      (template_type
+        (generic_type
+          (type_identifier)
+          (type_arguments
+            (type_identifier)
+            (type_identifier))))))
+  (type_alias_declaration
+    (type_identifier)
+    (template_literal_type
+      (template_type
+        (literal_type
+          (string)))
+      (template_type
+        (literal_type
+          (number)))))
+          (type_alias_declaration
+            (type_identifier)
+            (type_parameters
+              (type_parameter
+                (type_identifier))
+              (type_parameter
+                (type_identifier)))
+            (conditional_type
+              (type_identifier)
+              (type_identifier)
+              (conditional_type
+                (type_identifier)
+                (predefined_type)
+                (template_literal_type
+                  (template_type
+                    (type_identifier))
+                  (template_type
+                    (conditional_type
+                      (literal_type
+                        (string))
+                      (type_identifier)
+                      (literal_type
+                        (string))
+                      (literal_type
+                        (string))))
+                  (template_type
+                    (type_identifier)))
+                (type_identifier))
+              (type_identifier))))

common/define-grammar.js

@@ -46,6 +46,7 @@ module.exports = function defineGrammar(dialect) {
       [$.readonly_type, $.primary_expression],
       [$.type_query, $.subscript_expression, $.expression],
       [$.nested_type_identifier, $.generic_type, $._primary_type, $.lookup_type, $.index_type_query, $._type],
+      [$.as_expression, $._primary_type],
     ]),
 
     conflicts: ($, previous) => previous.concat([
@@ -103,6 +104,8 @@ module.exports = function defineGrammar(dialect) {
       [$.array, $.tuple_type],
       [$.array, $.array_pattern, $.tuple_type],
       [$.array_pattern, $.tuple_type],
+
+      [$.template_literal_type, $.template_string]
     ]),
 
     inline: ($, previous) => previous
@@ -368,7 +371,7 @@ module.exports = function defineGrammar(dialect) {
       as_expression: $ => prec.left('binary_as', seq(
         $.expression,
         'as',
-        choice($._type, $.template_string)
+        choice($._type, $.template_literal_type)
       )),
 
       class_heritage: $ => choice(
@@ -599,6 +602,18 @@ module.exports = function defineGrammar(dialect) {
         $.literal_type,
         $.lookup_type,
         $.conditional_type,
+        $.template_literal_type
+      ),
+
+      template_type: $ => seq('${',$._primary_type,'}'),
+
+      template_literal_type: $ =>     seq(
+        '`',
+        repeat(choice(
+          $._template_chars,
+          $.template_type
+        )),
+        '`'
       ),
 
       infer_type: $ => seq("infer", $._type_identifier),