fix #4248: #private ids in arrow fn body in ?:

Author: evanw

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+* Fix another TypeScript parsing edge case ([#4248](https://github.com/evanw/esbuild/issues/4248))
+
+    This fixes a regression with a change in the previous release that tries to more accurately parse TypeScript arrow functions inside the `?:` operator. The regression specifically involves parsing an arrow function containing a `#private` identifier inside the middle of a `?:` ternary operator inside a class body. This was fixed by propagating private identifier state into the parser clone used to speculatively parse the arrow function body. Here is an example of some affected code:
+
+    ```ts
+    class CachedDict {
+      #has = (a: string) => dict.has(a);
+      has = window
+        ? (word: string): boolean => this.#has(word)
+        : this.#has;
+    }
+    ```
+
 ## 0.25.7
 
 * Parse and print JavaScript imports with an explicit phase ([#4238](https://github.com/evanw/esbuild/issues/4238))

internal/js_parser/ts_parser.go

@@ -976,18 +976,14 @@ func (originalParser *parser) isTypeScriptArrowReturnTypeAfterQuestionAndBeforeC
 	// future) from accidentally depending on some parser state that isn't cloned
 	// here. That could result in a parser panic when parsing a more complex
 	// version of this edge case.
-	p := parser{
-		// Clone all state that the parser needs to parse this arrow function body
-		options: originalParser.options,
-		source:  originalParser.source,
-		lexer:   originalParser.lexer,
-		log:     logger.NewDeferLog(logger.DeferLogNoVerboseOrDebug, nil),
-		currentScope: &js_ast.Scope{
-			Kind:    js_ast.ScopeFunctionArgs,
-			Members: make(map[string]js_ast.ScopeMember),
-		},
-	}
+	p := newParser(logger.NewDeferLog(logger.DeferLogNoVerboseOrDebug, nil), originalParser.source, originalParser.lexer, &originalParser.options)
+
+	// Clone all state that the parser needs to parse this arrow function body
+	p.allowPrivateIdentifiers = originalParser.allowPrivateIdentifiers
+	p.allowIn = originalParser.allowIn
 	p.lexer.IsLogDisabled = true
+	p.pushScopeForParsePass(js_ast.ScopeEntry, logger.Loc{Start: 0})
+	p.pushScopeForParsePass(js_ast.ScopeFunctionArgs, logger.Loc{Start: 1})
 
 	// Parse the return type
 	p.lexer.Expect(js_lexer.TColon)

internal/js_parser/ts_parser_test.go

@@ -2388,11 +2388,19 @@ func TestTSArrow(t *testing.T) {
 	expectPrintedTS(t, "x = a ? (b) : T => c : d", "x = a ? (b) => c : d;\n")
 	expectPrintedTS(t, "x = a ? b - (c) : d => e", "x = a ? b - c : (d) => e;\n")
 	expectPrintedTS(t, "x = a ? b = (c) : T => d : e", "x = a ? b = (c) => d : e;\n")
-	expectPrintedTS(t, "x = (\n  a ? (b = c) : { d: e }\n)", "x = a ? b = c : { d: e };\n") // Note: Newlines are important (they trigger backtracking)
 	expectParseErrorTS(t, "x = a ? (b = c) : T => d : (e = f) : g", "<stdin>: ERROR: Expected \";\" but found \":\"\n")
 	expectParseErrorTS(t, "x = a ? b ? (c = d) : T => e : (f = g)", "<stdin>: ERROR: Expected \":\" but found end of file\n")
 	expectParseErrorTS(t, "x = a ? - (b) : c => d : e", "<stdin>: ERROR: Expected \";\" but found \":\"\n")
 	expectParseErrorTS(t, "x = a ? b - (c) : d => e : f", "<stdin>: ERROR: Expected \";\" but found \":\"\n")
+
+	// Note: Newlines are important (they trigger backtracking)
+	expectPrintedTS(t, "x = (\n  a ? (b = c) : { d: e }\n)", "x = a ? b = c : { d: e };\n")
+
+	// Need to clone "#private" identifier state in the parser
+	expectPrintedTS(t, "x = class { #y; y = a ? (b : T) : T => this.#y : c }", "x = class {\n  #y;\n  y = a ? (b) => this.#y : c;\n};\n")
+
+	// Need to clone "in" operator state in the parser
+	expectPrintedTS(t, "for (x = a ? () : T => b in c : d; ; ) ;", "for (x = a ? () => b in c : d; ; ) ;\n")
 }
 
 func TestTSSuperCall(t *testing.T) {