fix #2306: split << when used in type arguments

Author: evanw

CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## Unreleased
 
+* Fix TypeScript parse error whe a generic function is the first type argument ([#2306](https://github.com/evanw/esbuild/issues/2306))
+
+    In TypeScript, the `<<` token may need to be split apart into two `<` tokens if it's present in a type argument context. This was already correctly handled for all type expressions and for identifier expressions such as in the following code:
+
+    ```ts
+    // These cases already worked in the previous release
+    let foo: Array<<T>() => T>;
+    bar<<T>() => T>;
+    ```
+
+    However, normal expressions of the following form were previously incorrectly treated as syntax errors:
+
+    ```ts
+    // These cases were broken but have now been fixed
+    foo.bar<<T>() => T>;
+    foo?.<<T>() => T>();
+    ```
+
+    With this release, these cases now parsed correctly.
+
 * Fix minification regression with pure IIFEs ([#2279](https://github.com/evanw/esbuild/issues/2279))
 
     An Immediately Invoked Function Expression (IIFE) is a function call to an anonymous function, and is a way of introducing a new function-level scope in JavaScript since JavaScript lacks a way to do this otherwise. And a pure function call is a function call with the special `/* @__PURE__ */` comment before it, which tells JavaScript build tools that the function call can be considered to have no side effects (and can be removed if it's unused).

internal/js_parser/js_parser.go

@@ -3014,11 +3014,6 @@ func (p *parser) parsePrefix(level js_ast.L, errors *deferredErrors, flags exprF
 			})}
 		}
 
-		// Allow "const a = b<c>"
-		if p.options.ts.Parse {
-			p.trySkipTypeScriptTypeArgumentsWithBacktracking()
-		}
-
 		ref := p.storeNameInRef(name)
 		return js_ast.Expr{Loc: loc, Data: &js_ast.EIdentifier{Ref: ref}}
 
@@ -3679,8 +3674,9 @@ func (p *parser) parseSuffix(left js_ast.Expr, level js_ast.L, errors *deferredE
 					OptionalChain: optionalStart,
 				}}
 
-			case js_lexer.TLessThan:
+			case js_lexer.TLessThan, js_lexer.TLessThanLessThan:
 				// "a?.<T>()"
+				// "a?.<<T>() => T>()"
 				if !p.options.ts.Parse {
 					p.lexer.Expected(js_lexer.TIdentifier)
 				}
@@ -4013,6 +4009,14 @@ func (p *parser) parseSuffix(left js_ast.Expr, level js_ast.L, errors *deferredE
 			left = js_ast.Expr{Loc: left.Loc, Data: &js_ast.EBinary{Op: js_ast.BinOpGe, Left: left, Right: p.parseExpr(js_ast.LCompare)}}
 
 		case js_lexer.TLessThanLessThan:
+			// TypeScript allows type arguments to be specified with angle brackets
+			// inside an expression. Unlike in other languages, this unfortunately
+			// appears to require backtracking to parse.
+			if p.options.ts.Parse && p.trySkipTypeScriptTypeArgumentsWithBacktracking() {
+				optionalChain = oldOptionalChain
+				continue
+			}
+
 			if level >= js_ast.LShift {
 				return left
 			}

internal/js_parser/ts_parser_test.go

@@ -1876,6 +1876,8 @@ func TestTSInstantiationExpression(t *testing.T) {
 
 	expectPrintedTS(t, "f<number>?.();", "f?.();\n")
 	expectPrintedTS(t, "f?.<number>();", "f?.();\n")
+	expectPrintedTS(t, "f<<T>() => T>?.();", "f?.();\n")
+	expectPrintedTS(t, "f?.<<T>() => T>();", "f?.();\n")
 
 	expectPrintedTS(t, "f<number>['g'];", "f < number > [\"g\"];\n")
 
@@ -1885,6 +1887,9 @@ func TestTSInstantiationExpression(t *testing.T) {
 	// This behavior matches TypeScript 4.7.0 nightly (specifically "typescript@4.7.0-dev.20220421")
 	// after various fixes from Microsoft that landed after the TypeScript 4.7.0 beta
 	expectPrintedTS(t, "f<x>, g<y>;", "f, g;\n")
+	expectPrintedTS(t, "f<<T>() => T>;", "f;\n")
+	expectPrintedTS(t, "f.x<<T>() => T>;", "f.x;\n")
+	expectPrintedTS(t, "f['x']<<T>() => T>;", "f[\"x\"];\n")
 	expectPrintedTS(t, "f<x>g<y>;", "f < x > g;\n")
 	expectPrintedTS(t, "f<x>=g<y>;", "f = g;\n")
 	expectPrintedTS(t, "f<x>>g<y>;", "f < x >> g;\n")
@@ -2193,9 +2198,13 @@ func TestTSTypeOnlyExport(t *testing.T) {
 
 func TestTSOptionalChain(t *testing.T) {
 	expectParseError(t, "a?.<T>()", "<stdin>: ERROR: Expected identifier but found \"<\"\n")
+	expectParseError(t, "a?.<<T>() => T>()", "<stdin>: ERROR: Expected identifier but found \"<<\"\n")
 	expectPrintedTS(t, "a?.<T>()", "a?.();\n")
+	expectPrintedTS(t, "a?.<<T>() => T>()", "a?.();\n")
 	expectParseErrorTS(t, "a?.<T>b", "<stdin>: ERROR: Expected \"(\" but found \"b\"\n")
 	expectParseErrorTS(t, "a?.<T>[b]", "<stdin>: ERROR: Expected \"(\" but found \"[\"\n")
+	expectParseErrorTS(t, "a?.<<T>() => T>b", "<stdin>: ERROR: Expected \"(\" but found \"b\"\n")
+	expectParseErrorTS(t, "a?.<<T>() => T>[b]", "<stdin>: ERROR: Expected \"(\" but found \"[\"\n")
 
 	expectPrintedTS(t, "a?.b.c", "a?.b.c;\n")
 	expectPrintedTS(t, "(a?.b).c", "(a?.b).c;\n")
@@ -2208,7 +2217,10 @@ func TestTSOptionalChain(t *testing.T) {
 	expectPrintedTS(t, "a?.b(c)", "a?.b(c);\n")
 	expectPrintedTS(t, "(a?.b)(c)", "(a?.b)(c);\n")
 	expectPrintedTS(t, "a?.b!(c)", "a?.b(c);\n")
+
 	expectPrintedTS(t, "a?.b<T>(c)", "a?.b(c);\n")
+	expectPrintedTS(t, "a?.b<+T>(c)", "a?.b < +T > c;\n")
+	expectPrintedTS(t, "a?.b<<T>() => T>(c)", "a?.b(c);\n")
 }
 
 func TestTSJSX(t *testing.T) {