Generalize type queries and tuple types

* Allow arbitrary types inside of tuples
* Allow typeof import('foo')

Author: maxbrunsfeld

common/corpus/types.txt

@@ -675,6 +675,7 @@ type T = keyof Person<P>;
 type T = typeof Person;
 type T = typeof Person.P;
 type T = typeof Person<P>;
+type T = typeof import('person');
 
 type T = keyof typeof Person;
 
@@ -693,6 +694,8 @@ type T = keyof typeof Person;
     (type_query (nested_identifier (identifier) (identifier))))
   (type_alias_declaration (type_identifier)
     (type_query (generic_type (type_identifier) (type_arguments (type_identifier)))))
+  (type_alias_declaration (type_identifier)
+    (type_query (call_expression (import) (arguments (string)))))
   (type_alias_declaration (type_identifier)
     (index_type_query (type_query (identifier)))))
 
@@ -851,12 +854,13 @@ Tuple types
 ==================================
 
 type t = []
-type t = [a, b]
-type t = readonly [a, b]
-type t = [...b]
-type t = [a, ...b]
-type t = [a, b, ...c]
-type t = [a, b?]
+type t = [A|B, C]
+type t = readonly [A[], B.C]
+
+// special optional and rest type syntax
+type t = [string?, ...B]
+
+// labeled elements
 type t = [a: A, b?: B, ...c: C[]]
 
 ---
@@ -868,29 +872,25 @@ type t = [a: A, b?: B, ...c: C[]]
   (type_alias_declaration
     (type_identifier)
     (tuple_type
-      (identifier)
-      (identifier)))
+      (union_type
+        (type_identifier)
+        (type_identifier))
+      (type_identifier)))
   (type_alias_declaration
     (type_identifier)
     (tuple_type
       (readonly)
-      (identifier)
-      (identifier)))
-  (type_alias_declaration
-    (type_identifier)
-    (tuple_type (rest_identifier (identifier))))
-  (type_alias_declaration
-    (type_identifier)
-    (tuple_type (identifier) (rest_identifier (identifier))))
+      (array_type (type_identifier))
+      (nested_type_identifier
+        (identifier)
+        (type_identifier))))
+  (comment)
   (type_alias_declaration
     (type_identifier)
     (tuple_type
-      (identifier)
-      (identifier)
-      (rest_identifier (identifier))))
-  (type_alias_declaration
-    (type_identifier)
-    (tuple_type (identifier) (optional_identifier (identifier))))
+      (optional_type (predefined_type))
+      (rest_type (type_identifier))))
+  (comment)
   (type_alias_declaration
     (type_identifier)
     (tuple_type
@@ -1002,7 +1002,7 @@ type T<X> = T extends { x: infer X } ? X : never;
         (type_arguments
           (infer_type (type_identifier))))
       (type_identifier)
-      (type_identifier))) 
+      (type_identifier)))
     (type_alias_declaration
       (type_identifier)
       (type_parameters

common/define-grammar.js

@@ -74,8 +74,8 @@ module.exports = function defineGrammar(dialect) {
       [$._expression, $.generic_type],
       [$._expression, $.predefined_type],
       [$._expression, $._rest_identifier],
-      [$._expression, $._tuple_type_identifier],
-      [$._expression, $.optional_identifier],
+      [$.optional_identifier, $._primary_type],
+      [$.optional_identifier, $._primary_type, $._expression],
 
       [$.object, $.object_type],
       [$.object, $._property_name],
@@ -530,15 +530,23 @@ module.exports = function defineGrammar(dialect) {
 
       _tuple_type_identifier: $ => choice(
         $.identifier,
-        $.optional_identifier,
-        $.rest_identifier
+        $.rest_identifier,
+        $.optional_identifier
       ),
 
-      labeled_tuple_type_member: $ => seq($._tuple_type_identifier, $.type_annotation),
+      labeled_tuple_type_member: $ => seq(
+        $._tuple_type_identifier,
+        $.type_annotation
+      ),
+
+      optional_type: $ => seq($._type, '?'),
+      rest_type: $ => seq('...', $._type),
 
       _tuple_type_member: $ => choice(
-        $._tuple_type_identifier,
         $.labeled_tuple_type_member,
+        $.optional_type,
+        $.rest_type,
+        $._type,
       ),
 
       constructor_type: $ => prec.left(PREC.CONSTRUCTOR_TYPE, seq(
@@ -600,7 +608,7 @@ module.exports = function defineGrammar(dialect) {
 
       type_query: $ => prec(PREC.TYPEOF, seq(
         'typeof',
-        choice($.identifier, $.nested_identifier, $.generic_type)
+        choice($.identifier, $.nested_identifier, $.generic_type, $.call_expression)
       )),
 
       index_type_query: $ => seq(

tsx/src/grammar.json

@@ -7859,11 +7859,11 @@
         },
         {
           "type": "SYMBOL",
-          "name": "optional_identifier"
+          "name": "rest_identifier"
         },
         {
           "type": "SYMBOL",
-          "name": "rest_identifier"
+          "name": "optional_identifier"
         }
       ]
     },
@@ -7880,16 +7880,50 @@
         }
       ]
     },
+    "optional_type": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_type"
+        },
+        {
+          "type": "STRING",
+          "value": "?"
+        }
+      ]
+    },
+    "rest_type": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "..."
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_type"
+        }
+      ]
+    },
     "_tuple_type_member": {
       "type": "CHOICE",
       "members": [
         {
           "type": "SYMBOL",
-          "name": "_tuple_type_identifier"
+          "name": "labeled_tuple_type_member"
         },
         {
           "type": "SYMBOL",
-          "name": "labeled_tuple_type_member"
+          "name": "optional_type"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "rest_type"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_type"
         }
       ]
     },
@@ -8155,6 +8189,10 @@
               {
                 "type": "SYMBOL",
                 "name": "generic_type"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "call_expression"
               }
             ]
           }
@@ -9322,12 +9360,13 @@
       "_rest_identifier"
     ],
     [
-      "_expression",
-      "_tuple_type_identifier"
+      "optional_identifier",
+      "_primary_type"
     ],
     [
-      "_expression",
-      "optional_identifier"
+      "optional_identifier",
+      "_primary_type",
+      "_expression"
     ],
     [
       "object",