disambiguate between call expressions with subscript type parameters and binary expressions between subscript expressions

Author: resolritter

common/corpus/functions.txt

@@ -79,6 +79,7 @@ Function calls with optional chaining and type arguments
 ==================================
 
 A?.<B>();
+A<B[]>();
 
 ---
 
@@ -87,6 +88,11 @@ A?.<B>();
     (call_expression
       (identifier)
       (type_arguments (type_identifier))
+      (arguments)))
+  (expression_statement
+    (call_expression
+      (identifier)
+      (type_arguments (array_type (type_identifier)))
       (arguments))))
 
 ==================================

common/define-grammar.js

@@ -36,6 +36,21 @@ module.exports = function defineGrammar(dialect) {
     ]),
 
     conflicts: ($, previous) => previous.concat([
+      [$._expression, $.call_expression],
+      [$._expression, $.arrow_function, $.call_expression],
+      [$._property_name, $.arrow_function, $.call_expression],
+      [$._property_name, $._expression, $.arrow_function, $.call_expression],
+      [$._property_name, $.call_expression],
+      [$._expression, $._property_name, $.call_expression],
+      [$._expression, $.call_expression, $.new_expression, $.member_expression, $.subscript_expression],
+      [$._expression, $.call_expression, $.generic_type],
+
+      [$._expression, $.call_expression, $.new_expression],
+      [$._expression, $.new_expression],
+      [$._expression, $.arrow_function, $.call_expression, $.new_expression],
+      [$.call_expression, $.new_expression],
+      [$.arrow_function, $.new_expression, $.call_expression],
+
       [$.call_expression, $.binary_expression],
       [$.call_expression, $.binary_expression, $.unary_expression],
 
@@ -93,25 +108,14 @@ module.exports = function defineGrammar(dialect) {
         optional($._initializer)
       ),
 
-      call_expression: ($, previous) => choice(
-        prec(PREC.CALL, seq(
-          field('function', $._expression),
-          field('type_arguments', optional($.type_arguments)),
-          field('arguments', choice($.arguments, $.template_string))
-        )),
-        prec(PREC.MEMBER, seq(
-          field('function', $._primary_expression),
-          '?.',
-          field('type_arguments', optional($.type_arguments)),
-          field('arguments', $.arguments)
-        ))
+      call_expression: $ => choice(
+        callExpression($)(PREC.CALL),
+        callExpression($)(PREC.MEMBER, '?.'),
       ),
 
-      new_expression: $ => prec.right(PREC.NEW, seq(
+      new_expression: $ => prec.dynamic(PREC.NEW, seq(
         'new',
-        field('constructor', $._primary_expression),
-        field('type_arguments', optional($.type_arguments)),
-        field('arguments', optional($.arguments))
+        callExpression($)(PREC.NEW)
       )),
 
       // If the dialect is regular typescript, we exclude JSX expressions and
@@ -726,6 +730,19 @@ module.exports = function defineGrammar(dialect) {
   });
 }
 
+function callExpression ($) {
+  return function (precedence, punctuation) {
+    return seq(
+      ...[
+        field('function', $._primary_expression),
+        ...(punctuation ? [punctuation] : []),
+        field('type_arguments', prec.dynamic(precedence, optional($.type_arguments))),
+        field('arguments', choice($.arguments, $.template_string))
+      ]
+    )
+  }
+}
+
 function commaSep1 (rule) {
   return sepBy1(',', rule);
 }