Add support for instantiation expressions

Author: guillaumebrunerie

common/corpus/expressions.txt

@@ -214,3 +214,54 @@ foo! += bar;
       (non_null_expression
         (parenthesized_expression (identifier)))
       (identifier))))
+
+==================================
+Generic calls
+==================================
+
+f<T>(x)
+
+---
+
+(program
+  (expression_statement
+    (call_expression
+      (identifier)
+      (type_arguments
+        (type_identifier))
+      (arguments
+        (identifier)))))
+
+==================================
+Instantiation expressions
+==================================
+
+const makeHammerBox = makeBox<Hammer>;
+const makeStringBox = makeBox<string>;
+const ErrorMap = Map<string, Error>;
+
+---
+
+(program
+  (lexical_declaration
+    (variable_declarator
+      (identifier)
+      (instantiation_expression
+        (identifier)
+        (type_arguments
+          (type_identifier)))))
+  (lexical_declaration
+    (variable_declarator
+      (identifier)
+      (instantiation_expression
+        (identifier)
+        (type_arguments
+          (predefined_type)))))
+  (lexical_declaration
+    (variable_declarator
+      (identifier)
+      (instantiation_expression
+        (identifier)
+        (type_arguments
+          (predefined_type)
+          (type_identifier))))))

common/corpus/types.txt

@@ -602,6 +602,8 @@ class E extends funThatEvalsToClass()<
   Y,
 > {}
 
+class F extends G, H<T> {}
+
 ---
 
 (program
@@ -621,6 +623,15 @@ class E extends funThatEvalsToClass()<
       (extends_clause
         (call_expression (identifier) (arguments))
         (type_arguments (type_identifier) (type_identifier))))
+    (class_body))
+  (class_declaration
+    (type_identifier)
+    (class_heritage
+      (extends_clause
+        (identifier)
+        (identifier)
+        (type_arguments
+          (type_identifier))))
     (class_body)))
 
 =======================================
@@ -1599,3 +1610,24 @@ type X2 = (typeof Y)[keyof typeof Z];
       (index_type_query
         (type_query
           (identifier))))))
+
+=========================
+Type of instantiation expressions
+=========================
+
+// This is a special construct, different from both "typeof (f<T>)" and
+// "(typeof f)<T>" (which are both invalid)
+type T = typeof f<T>;
+
+---
+
+(program
+  (comment)
+  (comment)
+  (type_alias_declaration
+    (type_identifier)
+    (type_query
+      (instantiation_expression
+        (identifier)
+        (type_arguments
+          (type_identifier))))))

common/define-grammar.js

@@ -19,11 +19,16 @@ module.exports = function defineGrammar(dialect) {
     precedences: ($, previous) => previous.concat([
       [
         'call',
+        'instantiation',
         'unary',
         'binary',
         $.await_expression,
         $.arrow_function,
       ],
+      [
+        'extends',
+        'instantiation',
+      ],
       [
         $.intersection_type,
         $.union_type,
@@ -53,6 +58,7 @@ module.exports = function defineGrammar(dialect) {
       [$._type_query_subscript_expression, $.subscript_expression],
       [$._type_query_subscript_expression, $.primary_expression],
       [$._type_query_call_expression, $.primary_expression],
+      [$._type_query_instantiation_expression, $.primary_expression],
       [$.type_query, $.primary_expression],
       [$.override_modifier, $.primary_expression],
       [$.decorator_call_expression, $.decorator],
@@ -61,11 +67,11 @@ module.exports = function defineGrammar(dialect) {
     ]),
 
     conflicts: ($, previous) => previous.concat([
-      [$.call_expression, $.binary_expression],
-      [$.call_expression, $.binary_expression, $.unary_expression],
-      [$.call_expression, $.binary_expression, $.update_expression],
+      [$.call_expression, $.instantiation_expression, $.binary_expression],
+      [$.call_expression, $.instantiation_expression, $.binary_expression, $.unary_expression],
+      [$.call_expression, $.instantiation_expression, $.binary_expression, $.update_expression],
       [$.call_expression, $.binary_expression, $.type_assertion],
-      [$.call_expression, $.binary_expression, $.await_expression],
+      [$.call_expression, $.instantiation_expression, $.binary_expression, $.await_expression],
 
       // This appears to be necessary to parse a parenthesized class expression
       [$.class],
@@ -208,6 +214,7 @@ module.exports = function defineGrammar(dialect) {
         const choices = [
           $.as_expression,
           $.satisfies_expression,
+          $.instantiation_expression,
           $.internal_module,
         ];
 
@@ -447,6 +454,11 @@ module.exports = function defineGrammar(dialect) {
         $._type
       )),
 
+      instantiation_expression: $ => prec('instantiation', seq(
+        $.expression,
+        field('type_arguments', $.type_arguments),
+      )),
+
       class_heritage: $ => choice(
         seq($.extends_clause, optional($.implements_clause)),
         $.implements_clause
@@ -463,11 +475,13 @@ module.exports = function defineGrammar(dialect) {
 
       extends_clause: $ => seq(
         'extends',
-        commaSep1(seq(
+        commaSep1($._extends_clause_single),
+      ),
+
+      _extends_clause_single: $ => prec('extends', seq(
           field('value', $.expression),
           field('type_arguments', optional($.type_arguments))
-        )),
-      ),
+      )),
 
       implements_clause: $ => seq(
         'implements',
@@ -786,12 +800,22 @@ module.exports = function defineGrammar(dialect) {
         )),
         field('arguments', $.arguments)
       ),
+      _type_query_instantiation_expression: $ => seq(
+        field('function', choice(
+          $.import,
+          $.identifier,
+          alias($._type_query_member_expression, $.member_expression),
+          alias($._type_query_subscript_expression, $.subscript_expression)
+        )),
+        field('type_arguments', $.type_arguments)
+      ),
       type_query: $ => prec.right(seq(
         'typeof',
         choice(
           alias($._type_query_subscript_expression, $.subscript_expression),
           alias($._type_query_member_expression, $.member_expression),
           alias($._type_query_call_expression, $.call_expression),
+          alias($._type_query_instantiation_expression, $.instantiation_expression),
           $.identifier
         ),
       )),