microsoft · a-tarasyuk · Sep 29, 2023
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -422,6 +422,7 @@ import {
     TemplateLiteralTypeSpan,
     TemplateSpan,
     TextRange,
+    ThrowExpression,
     ThrowStatement,
     TokenFlags,
     tokenToString,
@@ -2278,6 +2279,8 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
                     return emitSpreadElement(node as SpreadElement);
                 case SyntaxKind.ClassExpression:
                     return emitClassExpression(node as ClassExpression);
+                case SyntaxKind.ThrowExpression:
+                    return emitThrowExpression(node as ThrowExpression);
                 case SyntaxKind.OmittedExpression:
                     return;
                 case SyntaxKind.AsExpression:
@@ -3367,6 +3370,12 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
         emitClassDeclarationOrExpression(node);
     }
 
+    function emitThrowExpression(node: ThrowExpression) {
+        emitTokenWithComment(SyntaxKind.ThrowKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
+    }
+
     function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
         emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
         emitTypeArguments(node, node.typeArguments);

diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -438,6 +438,7 @@ import {
     TextRange,
     ThisExpression,
     ThisTypeNode,
+    ThrowExpression,
     ThrowStatement,
     Token,
     TokenFlags,
@@ -679,6 +680,8 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         updateFunctionExpression,
         createArrowFunction,
         updateArrowFunction,
+        createThrowExpression,
+        updateThrowExpression,
         createDeleteExpression,
         updateDeleteExpression,
         createTypeOfExpression,
@@ -3317,6 +3320,22 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
             : node;
     }
 
+    // @api
+    function createThrowExpression(expression: Expression) {
+        const node = createBaseNode<ThrowExpression>(SyntaxKind.ThrowExpression);
+        node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
+        node.transformFlags |= propagateChildFlags(node.expression);
+        node.transformFlags |= TransformFlags.ContainsESNext;
+        return node;
+    }
+
+    // @api
+    function updateThrowExpression(node: ThrowExpression, expression: Expression) {
+        return node.expression !== expression
+            ? update(createThrowExpression(expression), node)
+            : node;
+    }
+
     // @api
     function createDeleteExpression(expression: Expression) {
         const node = createBaseNode<DeleteExpression>(SyntaxKind.DeleteExpression);

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -360,6 +360,7 @@ import {
     textToKeywordObj,
     ThisExpression,
     ThisTypeNode,
+    ThrowExpression,
     ThrowStatement,
     toArray,
     Token,
@@ -991,6 +992,9 @@ const forEachChildTable: ForEachChildTable = {
         return visitNode(cbNode, node.expression) ||
             visitNodes(cbNode, cbNodes, node.typeArguments);
     },
+    [SyntaxKind.ThrowExpression]: function forEachChildInThrowExpression<T>(node: ThrowExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    },
     [SyntaxKind.ExternalModuleReference]: function forEachChildInExternalModuleReference<T>(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
         return visitNode(cbNode, node.expression);
     },
@@ -5505,6 +5509,7 @@ namespace Parser {
             token() !== SyntaxKind.SemicolonToken &&
             token() !== SyntaxKind.FunctionKeyword &&
             token() !== SyntaxKind.ClassKeyword &&
+            token() !== SyntaxKind.ThrowKeyword &&
             isStartOfStatement() &&
             !isStartOfExpressionStatement()
         ) {
@@ -5658,6 +5663,64 @@ namespace Parser {
         return finishNode(factory.createPrefixUnaryExpression(token() as PrefixUnaryOperator, nextTokenAnd(parseSimpleUnaryExpression)), pos);
     }
 
+    function parseThrowExpression() {
+        const pos = getNodePos();
+        const expression = nextTokenAnd(parseSimpleUnaryExpression);
+        if (isInfixPunctuationToken()) {
+            parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(SyntaxKind.SemicolonToken));
+        }
+        return finishNode(factory.createThrowExpression(expression), pos);
+    }
+
+    function isInfixPunctuationToken() {
+        switch (token()) {
+            case SyntaxKind.CommaToken:
+            case SyntaxKind.LessThanToken:
+            case SyntaxKind.GreaterThanToken:
+            case SyntaxKind.EqualsToken:
+            case SyntaxKind.LessThanEqualsToken:
+            case SyntaxKind.GreaterThanEqualsToken:
+            case SyntaxKind.EqualsEqualsToken:
+            case SyntaxKind.ExclamationEqualsToken:
+            case SyntaxKind.EqualsEqualsEqualsToken:
+            case SyntaxKind.ExclamationEqualsEqualsToken:
+            case SyntaxKind.PlusToken:
+            case SyntaxKind.MinusToken:
+            case SyntaxKind.AsteriskToken:
+            case SyntaxKind.SlashToken:
+            case SyntaxKind.PercentToken:
+            case SyntaxKind.AmpersandToken:
+            case SyntaxKind.BarToken:
+            case SyntaxKind.CaretToken:
+            case SyntaxKind.AsteriskAsteriskToken:
+            case SyntaxKind.LessThanLessThanToken:
+            case SyntaxKind.GreaterThanGreaterThanToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+            case SyntaxKind.AmpersandAmpersandToken:
+            case SyntaxKind.BarBarToken:
+            case SyntaxKind.QuestionQuestionToken:
+            case SyntaxKind.PlusEqualsToken:
+            case SyntaxKind.MinusEqualsToken:
+            case SyntaxKind.AsteriskEqualsToken:
+            case SyntaxKind.SlashEqualsToken:
+            case SyntaxKind.PercentEqualsToken:
+            case SyntaxKind.AmpersandEqualsToken:
+            case SyntaxKind.BarEqualsToken:
+            case SyntaxKind.CaretEqualsToken:
+            case SyntaxKind.AsteriskAsteriskEqualsToken:
+            case SyntaxKind.LessThanLessThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+            case SyntaxKind.AmpersandAmpersandEqualsToken:
+            case SyntaxKind.BarBarEqualsToken:
+            case SyntaxKind.QuestionQuestionEqualsToken:
+            case SyntaxKind.QuestionToken:
+                return true;
+            default:
+                return false;
+        }
+    }
+
     function parseDeleteExpression() {
         const pos = getNodePos();
         return finishNode(factory.createDeleteExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
@@ -5769,6 +5832,8 @@ namespace Parser {
                 return parseTypeOfExpression();
             case SyntaxKind.VoidKeyword:
                 return parseVoidExpression();
+            case SyntaxKind.ThrowKeyword:
+                return parseThrowExpression();
             case SyntaxKind.LessThanToken:
                 // Just like in parseUpdateExpression, we need to avoid parsing type assertions when
                 // in JSX and we see an expression like "+ <foo> bar".
@@ -5811,6 +5876,7 @@ namespace Parser {
             case SyntaxKind.TypeOfKeyword:
             case SyntaxKind.VoidKeyword:
             case SyntaxKind.AwaitKeyword:
+            case SyntaxKind.ThrowKeyword:
                 return false;
             case SyntaxKind.LessThanToken:
                 // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression

diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
@@ -50,6 +50,7 @@ import {
     Statement,
     SwitchStatement,
     SyntaxKind,
+    ThrowExpression,
     TransformationContext,
     TransformFlags,
     transformNamedEvaluation,
@@ -120,6 +121,9 @@ export function transformESNext(context: TransformationContext): (x: SourceFile
             case SyntaxKind.SwitchStatement:
                 return visitSwitchStatement(node as SwitchStatement);
 
+            case SyntaxKind.ThrowExpression:
+                return visitThrowExpression(node as ThrowExpression);
+
             default:
                 return visitEachChild(node, visitor, context);
         }
@@ -403,6 +407,12 @@ export function transformESNext(context: TransformationContext): (x: SourceFile
         return visitEachChild(node, visitor, context);
     }
 
+    function visitThrowExpression(node: ThrowExpression): Expression {
+        return factory.createImmediatelyInvokedArrowFunction([
+            factory.createThrowStatement(node.expression),
+        ]);
+    }
+
     /**
      * Transform `using` declarations in a statement list.
      */

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -286,6 +286,7 @@ export const enum SyntaxKind {
     ParenthesizedExpression,
     FunctionExpression,
     ArrowFunction,
+    ThrowExpression,
     DeleteExpression,
     TypeOfExpression,
     VoidExpression,
@@ -1084,6 +1085,7 @@ export type HasChildren =
     | DeleteExpression
     | TypeOfExpression
     | VoidExpression
+    | ThrowExpression
     | AwaitExpression
     | PrefixUnaryExpression
     | PostfixUnaryExpression
@@ -2453,6 +2455,11 @@ export interface AwaitExpression extends UnaryExpression {
     readonly expression: UnaryExpression;
 }
 
+export interface ThrowExpression extends UnaryExpression {
+    readonly kind: SyntaxKind.ThrowExpression;
+    readonly expression: UnaryExpression;
+}
+
 export interface YieldExpression extends Expression {
     readonly kind: SyntaxKind.YieldExpression;
     readonly asteriskToken?: AsteriskToken;
@@ -8501,6 +8508,8 @@ export interface NodeFactory {
     updateFunctionExpression(node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression;
     createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
     updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
+    createThrowExpression(expression: Expression): ThrowExpression;
+    updateThrowExpression(node: ThrowExpression, expression: Expression): ThrowExpression;
     createDeleteExpression(expression: Expression): DeleteExpression;
     updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression;
     createTypeOfExpression(expression: Expression): TypeOfExpression;

diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts
@@ -2006,6 +2006,7 @@ function isUnaryExpressionKind(kind: SyntaxKind): boolean {
         case SyntaxKind.VoidExpression:
         case SyntaxKind.AwaitExpression:
         case SyntaxKind.TypeAssertionExpression:
+        case SyntaxKind.ThrowExpression:
             return true;
         default:
             return isLeftHandSideExpressionKind(kind);

diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts
@@ -1163,6 +1163,13 @@ const visitEachChildTable: VisitEachChildTable = {
         );
     },
 
+    [SyntaxKind.ThrowExpression]: function visitEachChildThrowExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+        return context.factory.updateThrowExpression(
+            node,
+            Debug.checkDefined(nodeVisitor(node.expression, visitor, isExpression)),
+        );
+    },
+
     [SyntaxKind.BinaryExpression]: function visitEachChildOfBinaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
         return context.factory.updateBinaryExpression(
             node,

diff --git a/src/typingsInstallerCore/throwExpression1.errors.txt b/src/typingsInstallerCore/throwExpression1.errors.txt
@@ -0,0 +1,11 @@
+throwExpression1.ts(2,14): error TS1005: ';' expected.
+
+
+==== throwExpression1.ts (1 errors) ====
+    function t1(a: any, b: any, c: any) {
+        (throw a ? b : c);
+                 ~
+!!! error TS1005: ';' expected.
+    }
+
+