Disable JSX recovery hack when in unary expression context

Author: jakebailey

src/compiler/parser.ts

@@ -5694,7 +5694,7 @@ namespace Parser {
                 // Just like in parseUpdateExpression, we need to avoid parsing type assertions when
                 // in JSX and we see an expression like "+ <foo> bar".
                 if (languageVariant === LanguageVariant.JSX) {
-                    return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true);
+                    return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true, /*topInvalidNodePosition*/ undefined, /*openingTag*/ undefined, /*mustBeUnary*/ true);
                 }
                 // This is modified UnaryExpression grammar in TypeScript
                 //  UnaryExpression (modified):
@@ -5921,7 +5921,7 @@ namespace Parser {
         return finishNode(factoryCreatePropertyAccessExpression(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true)), pos);
     }
 
-    function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext: boolean, topInvalidNodePosition?: number, openingTag?: JsxOpeningElement | JsxOpeningFragment): JsxElement | JsxSelfClosingElement | JsxFragment {
+    function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext: boolean, topInvalidNodePosition?: number, openingTag?: JsxOpeningElement | JsxOpeningFragment, mustBeUnary = false): JsxElement | JsxSelfClosingElement | JsxFragment {
         const pos = getNodePos();
         const opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
         let result: JsxElement | JsxSelfClosingElement | JsxFragment;
@@ -5978,7 +5978,9 @@ namespace Parser {
         // does less damage and we can report a better error.
         // Since JSX elements are invalid < operands anyway, this lookahead parse will only occur in error scenarios
         // of one sort or another.
-        if (inExpressionContext && token() === SyntaxKind.LessThanToken) {
+        // If we are in a unary context, we can't do this recovery; the binary expression we return here is not
+        // a valid UnaryExpression and will cause problems later.
+        if (!mustBeUnary && inExpressionContext && token() === SyntaxKind.LessThanToken) {
             const topBadPos = typeof topInvalidNodePosition === "undefined" ? result.pos : topInvalidNodePosition;
             const invalidElement = tryParse(() => parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true, topBadPos));
             if (invalidElement) {

tests/baselines/reference/parseJsxElementInUnaryExpressionCrash.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/compiler/a.js(1,4): error TS1003: Identifier expected.
+tests/cases/compiler/a.js(1,5): error TS1109: Expression expected.
+
+
+==== tests/cases/compiler/a.js (2 errors) ====
+    ~< <
+       ~
+!!! error TS1003: Identifier expected.
+        
+!!! error TS1109: Expression expected.
+    

tests/baselines/reference/parseJsxElementInUnaryExpressionCrash.js

@@ -0,0 +1,7 @@
+//// [a.js]
+~< <
+
+
+//// [a.js]
+~< /> <
+;

tests/baselines/reference/parseJsxElementInUnaryExpressionCrash.symbols

@@ -0,0 +1,4 @@
+=== tests/cases/compiler/a.js ===
+
+~< <
+

tests/baselines/reference/parseJsxElementInUnaryExpressionCrash.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/a.js ===
+~< <
+>~< < : boolean
+>~< : number
+>< : any
+> : any
+
+> : any
+

tests/cases/compiler/parseJsxElementInUnaryExpressionCrash.ts

@@ -0,0 +1,4 @@
+// @allowJs: true
+// @outDir: ./out
+// @filename: a.js
+~< <