Port ?? binary operator emit (#1375)

Author: weswigham

internal/ast/ast.go

@@ -2074,7 +2074,9 @@ func (node *Token) computeSubtreeFacts() SubtreeFacts {
 		return SubtreeContainsClassFields
 	case KindAsteriskAsteriskToken, KindAsteriskAsteriskEqualsToken:
 		return SubtreeContainsExponentiationOperator
-	case KindQuestionQuestionToken, KindQuestionDotToken:
+	case KindQuestionQuestionToken:
+		return SubtreeContainsNullishCoalescing
+	case KindQuestionDotToken:
 		return SubtreeContainsOptionalChaining
 	case KindQuestionQuestionEqualsToken, KindBarBarEqualsToken, KindAmpersandAmpersandEqualsToken:
 		return SubtreeContainsLogicalAssignments

internal/printer/emitcontext.go

@@ -27,9 +27,19 @@ type EmitContext struct {
 	emitHelpers   collections.OrderedSet[*EmitHelper]
 }
 
+type environmentFlags int
+
+const (
+	environmentFlagsNone                         environmentFlags = 0
+	environmentFlagsInParameters                 environmentFlags = 1 << 0 // currently visiting a parameter list
+	environmentFlagsVariablesHoistedInParameters environmentFlags = 1 << 1 // a temp variable was hoisted while visiting a parameter list
+)
+
 type varScope struct {
-	variables []*ast.VariableDeclarationNode
-	functions []*ast.FunctionDeclarationNode
+	variables                []*ast.VariableDeclarationNode
+	functions                []*ast.FunctionDeclarationNode
+	flags                    environmentFlags
+	initializationStatements []*ast.Node
 }
 
 func NewEmitContext() *EmitContext {
@@ -105,12 +115,18 @@ func (c *EmitContext) StartVariableEnvironment() {
 func (c *EmitContext) EndVariableEnvironment() []*ast.Statement {
 	scope := c.varScopeStack.Pop()
 	var statements []*ast.Statement
+	if len(scope.functions) > 0 {
+		statements = slices.Clone(scope.functions)
+	}
 	if len(scope.variables) > 0 {
 		varDeclList := c.Factory.NewVariableDeclarationList(ast.NodeFlagsNone, c.Factory.NewNodeList(scope.variables))
 		varStatement := c.Factory.NewVariableStatement(nil /*modifiers*/, varDeclList)
 		c.SetEmitFlags(varStatement, EFCustomPrologue)
 		statements = append(statements, varStatement)
 	}
+	if len(scope.initializationStatements) > 0 {
+		statements = append(statements, scope.initializationStatements...)
+	}
 	return append(statements, c.EndLexicalEnvironment()...)
 }
 
@@ -148,6 +164,9 @@ func (c *EmitContext) AddVariableDeclaration(name *ast.IdentifierNode) {
 	c.SetEmitFlags(varDecl, EFNoNestedSourceMaps)
 	scope := c.varScopeStack.Peek()
 	scope.variables = append(scope.variables, varDecl)
+	if scope.flags&environmentFlagsInParameters != 0 {
+		scope.flags |= environmentFlagsVariablesHoistedInParameters
+	}
 }
 
 // Adds a hoisted function declaration to the current VariableEnvironment
@@ -721,11 +740,135 @@ func (c *EmitContext) VisitVariableEnvironment(nodes *ast.StatementList, visitor
 
 func (c *EmitContext) VisitParameters(nodes *ast.ParameterList, visitor *ast.NodeVisitor) *ast.ParameterList {
 	c.StartVariableEnvironment()
+	scope := c.varScopeStack.Peek()
+	oldFlags := scope.flags
+	scope.flags |= environmentFlagsInParameters
 	nodes = visitor.VisitNodes(nodes)
+
+	// As of ES2015, any runtime execution of that occurs in for a parameter (such as evaluating an
+	// initializer or a binding pattern), occurs in its own lexical scope. As a result, any expression
+	// that we might transform that introduces a temporary variable would fail as the temporary variable
+	// exists in a different lexical scope. To address this, we move any binding patterns and initializers
+	// in a parameter list to the body if we detect a variable being hoisted while visiting a parameter list
+	// when the emit target is greater than ES2015. (Which is now all targets.)
+	if scope.flags&environmentFlagsVariablesHoistedInParameters != 0 {
+		nodes = c.addDefaultValueAssignmentsIfNeeded(nodes)
+	}
+	scope.flags = oldFlags
 	// !!! c.suspendVariableEnvironment()
 	return nodes
 }
 
+func (c *EmitContext) addDefaultValueAssignmentsIfNeeded(nodeList *ast.ParameterList) *ast.ParameterList {
+	if nodeList == nil {
+		return nodeList
+	}
+	var result []*ast.Node
+	nodes := nodeList.Nodes
+	for i, parameter := range nodes {
+		updated := c.addDefaultValueAssignmentIfNeeded(parameter.AsParameterDeclaration())
+		if updated != parameter {
+			if result == nil {
+				result = slices.Clone(nodes)
+			}
+			result[i] = updated
+		}
+	}
+	if result != nil {
+		res := c.Factory.NewNodeList(result)
+		res.Loc = nodeList.Loc
+		return res
+	}
+	return nodeList
+}
+
+func (c *EmitContext) addDefaultValueAssignmentIfNeeded(parameter *ast.ParameterDeclaration) *ast.Node {
+	// A rest parameter cannot have a binding pattern or an initializer,
+	// so let's just ignore it.
+	if parameter.DotDotDotToken != nil {
+		return parameter.AsNode()
+	} else if ast.IsBindingPattern(parameter.Name()) {
+		return c.addDefaultValueAssignmentForBindingPattern(parameter)
+	} else if parameter.Initializer != nil {
+		return c.addDefaultValueAssignmentForInitializer(parameter, parameter.Name(), parameter.Initializer)
+	}
+	return parameter.AsNode()
+}
+
+func (c *EmitContext) addDefaultValueAssignmentForBindingPattern(parameter *ast.ParameterDeclaration) *ast.Node {
+	var initNode *ast.Node
+	if parameter.Initializer != nil {
+		initNode = c.Factory.NewConditionalExpression(
+			c.Factory.NewStrictEqualityExpression(
+				c.Factory.NewGeneratedNameForNode(parameter.AsNode()),
+				c.Factory.NewVoidZeroExpression(),
+			),
+			c.Factory.NewToken(ast.KindQuestionToken),
+			parameter.Initializer,
+			c.Factory.NewToken(ast.KindColonToken),
+			c.Factory.NewGeneratedNameForNode(parameter.AsNode()),
+		)
+	} else {
+		initNode = c.Factory.NewGeneratedNameForNode(parameter.AsNode())
+	}
+	c.AddInitializationStatement(c.Factory.NewVariableStatement(
+		nil,
+		c.Factory.NewVariableDeclarationList(ast.NodeFlagsNone, c.Factory.NewNodeList([]*ast.Node{c.Factory.NewVariableDeclaration(
+			parameter.Name(),
+			nil,
+			parameter.Type,
+			initNode,
+		)})),
+	))
+	return c.Factory.UpdateParameterDeclaration(
+		parameter,
+		parameter.Modifiers(),
+		parameter.DotDotDotToken,
+		c.Factory.NewGeneratedNameForNode(parameter.AsNode()),
+		parameter.QuestionToken,
+		parameter.Type,
+		nil,
+	)
+}
+
+func (c *EmitContext) addDefaultValueAssignmentForInitializer(parameter *ast.ParameterDeclaration, name *ast.Node, initializer *ast.Node) *ast.Node {
+	c.AddEmitFlags(initializer, EFNoSourceMap|EFNoComments)
+	nameClone := name.Clone(c.Factory)
+	c.AddEmitFlags(nameClone, EFNoSourceMap)
+	initAssignment := c.Factory.NewAssignmentExpression(
+		nameClone,
+		initializer,
+	)
+	initAssignment.Loc = parameter.Loc
+	c.AddEmitFlags(initAssignment, EFNoComments)
+	initBlock := c.Factory.NewBlock(c.Factory.NewNodeList([]*ast.Node{c.Factory.NewExpressionStatement(initAssignment)}), false)
+	initBlock.Loc = parameter.Loc
+	c.AddEmitFlags(initBlock, EFSingleLine|EFNoTrailingSourceMap|EFNoTokenSourceMaps|EFNoComments)
+	c.AddInitializationStatement(c.Factory.NewIfStatement(
+		c.Factory.NewTypeCheck(name.Clone(c.Factory), "undefined"),
+		initBlock,
+		nil,
+	))
+	return c.Factory.UpdateParameterDeclaration(
+		parameter,
+		parameter.Modifiers(),
+		parameter.DotDotDotToken,
+		parameter.Name(),
+		parameter.QuestionToken,
+		parameter.Type,
+		nil,
+	)
+}
+
+func (c *EmitContext) AddInitializationStatement(node *ast.Node) {
+	scope := c.varScopeStack.Peek()
+	if scope == nil {
+		panic("Tried to add an initialization statement without a surrounding variable scope")
+	}
+	c.AddEmitFlags(node, EFCustomPrologue)
+	scope.initializationStatements = append(scope.initializationStatements, node)
+}
+
 func (c *EmitContext) VisitFunctionBody(node *ast.BlockOrExpression, visitor *ast.NodeVisitor) *ast.BlockOrExpression {
 	// !!! c.resumeVariableEnvironment()
 	updated := visitor.VisitNode(node)

internal/printer/factory.go

@@ -219,7 +219,9 @@ func (f *NodeFactory) NewLogicalORExpression(left *ast.Expression, right *ast.Ex
 // func (f *NodeFactory) NewBitwiseORExpression(left *ast.Expression, right *ast.Expression) *ast.Expression
 // func (f *NodeFactory) NewBitwiseXORExpression(left *ast.Expression, right *ast.Expression) *ast.Expression
 // func (f *NodeFactory) NewBitwiseANDExpression(left *ast.Expression, right *ast.Expression) *ast.Expression
-// func (f *NodeFactory) NewStrictEqualityExpression(left *ast.Expression, right *ast.Expression) *ast.Expression
+func (f *NodeFactory) NewStrictEqualityExpression(left *ast.Expression, right *ast.Expression) *ast.Expression {
+	return f.NewBinaryExpression(nil /*modifiers*/, left, nil /*typeNode*/, f.NewToken(ast.KindEqualsEqualsEqualsToken), right)
+}
 
 func (f *NodeFactory) NewStrictInequalityExpression(left *ast.Expression, right *ast.Expression) *ast.Expression {
 	return f.NewBinaryExpression(nil /*modifiers*/, left, nil /*typeNode*/, f.NewToken(ast.KindExclamationEqualsEqualsToken), right)
@@ -272,6 +274,16 @@ func (f *NodeFactory) InlineExpressions(expressions []*ast.Expression) *ast.Expr
 // Utilities
 //
 
+func (f *NodeFactory) NewTypeCheck(value *ast.Node, tag string) *ast.Node {
+	if tag == "null" {
+		return f.NewStrictEqualityExpression(value, f.NewKeywordExpression(ast.KindNullKeyword))
+	} else if tag == "undefined" {
+		return f.NewStrictEqualityExpression(value, f.NewVoidZeroExpression())
+	} else {
+		return f.NewStrictEqualityExpression(f.NewTypeOfExpression(value), f.NewStringLiteral(tag))
+	}
+}
+
 func (f *NodeFactory) NewMethodCall(object *ast.Node, methodName *ast.Node, argumentsList []*ast.Node) *ast.Node {
 	// Preserve the optionality of `object`.
 	if ast.IsCallExpression(object) && (object.Flags&ast.NodeFlagsOptionalChain != 0) {

internal/transformers/estransforms/nullishcoalescing.go

@@ -11,7 +11,37 @@ type nullishCoalescingTransformer struct {
 }
 
 func (ch *nullishCoalescingTransformer) visit(node *ast.Node) *ast.Node {
-	return node // !!!
+	if node.SubtreeFacts()&ast.SubtreeContainsNullishCoalescing == 0 {
+		return node
+	}
+	switch node.Kind {
+	case ast.KindBinaryExpression:
+		return ch.visitBinaryExpression(node.AsBinaryExpression())
+	default:
+		return ch.Visitor().VisitEachChild(node)
+	}
+}
+
+func (ch *nullishCoalescingTransformer) visitBinaryExpression(node *ast.BinaryExpression) *ast.Node {
+	switch node.OperatorToken.Kind {
+	case ast.KindQuestionQuestionToken:
+		left := ch.Visitor().VisitNode(node.Left)
+		right := left
+		if !transformers.IsSimpleCopiableExpression(left) {
+			right = ch.Factory().NewTempVariable()
+			ch.EmitContext().AddVariableDeclaration(right)
+			left = ch.Factory().NewAssignmentExpression(right, left)
+		}
+		return ch.Factory().NewConditionalExpression(
+			createNotNullCondition(ch.EmitContext(), left, right, false),
+			ch.Factory().NewToken(ast.KindQuestionToken),
+			right,
+			ch.Factory().NewToken(ast.KindColonToken),
+			ch.Visitor().VisitNode(node.Right),
+		)
+	default:
+		return ch.Visitor().VisitEachChild(node.AsNode())
+	}
 }
 
 func newNullishCoalescingTransformer(emitContext *printer.EmitContext) *transformers.Transformer {

internal/transformers/estransforms/utilities.go

@@ -18,3 +18,32 @@ func convertClassDeclarationToClassExpression(emitContext *printer.EmitContext,
 	updated.Loc = node.Loc
 	return updated
 }
+
+func createNotNullCondition(emitContext *printer.EmitContext, left *ast.Node, right *ast.Node, invert bool) *ast.Node {
+	token := ast.KindExclamationEqualsEqualsToken
+	op := ast.KindAmpersandAmpersandToken
+	if invert {
+		token = ast.KindEqualsEqualsEqualsToken
+		op = ast.KindBarBarToken
+	}
+
+	return emitContext.Factory.NewBinaryExpression(
+		nil,
+		emitContext.Factory.NewBinaryExpression(
+			nil,
+			left,
+			nil,
+			emitContext.Factory.NewToken(token),
+			emitContext.Factory.NewKeywordExpression(ast.KindNullKeyword),
+		),
+		nil,
+		emitContext.Factory.NewToken(op),
+		emitContext.Factory.NewBinaryExpression(
+			nil,
+			right,
+			nil,
+			emitContext.Factory.NewToken(token),
+			emitContext.Factory.NewVoidZeroExpression(),
+		),
+	)
+}

testdata/baselines/reference/submodule/compiler/discriminatedUnionJsxElement.js

@@ -26,7 +26,8 @@ function ListItem(_data: IListItemData) {
 
 //// [discriminatedUnionJsxElement.jsx]
 function Menu(data) {
-    const listItemVariant = data.menuItemsVariant ?? ListItemVariant.OneLine;
+    var _a;
+    const listItemVariant = (_a = data.menuItemsVariant) !== null && _a !== void 0 ? _a : ListItemVariant.OneLine;
     return <ListItem variant={listItemVariant}/>;
 }
 var ListItemVariant;

testdata/baselines/reference/submodule/compiler/discriminatedUnionJsxElement.js.diff

@@ -7,13 +7,9 @@
 -"use strict";
 -// Repro from #46021
  function Menu(data) {
--    var _a;
--    const listItemVariant = (_a = data.menuItemsVariant) !== null && _a !== void 0 ? _a : ListItemVariant.OneLine;
-+    const listItemVariant = data.menuItemsVariant ?? ListItemVariant.OneLine;
-     return <ListItem variant={listItemVariant}/>;
- }
- var ListItemVariant;
-@@= skipped -18, +15 lines =@@
+     var _a;
+     const listItemVariant = (_a = data.menuItemsVariant) !== null && _a !== void 0 ? _a : ListItemVariant.OneLine;
+@@= skipped -18, +16 lines =@@
 
 
  //// [discriminatedUnionJsxElement.d.ts]

testdata/baselines/reference/submodule/compiler/enumMemberReduction.js

@@ -72,13 +72,13 @@ var MyStringEnumWithEmpty;
     MyStringEnumWithEmpty["C"] = "c";
 })(MyStringEnumWithEmpty || (MyStringEnumWithEmpty = {}));
 function fn(optionalEnum) {
-    return optionalEnum ?? MyEnum.A;
+    return optionalEnum !== null && optionalEnum !== void 0 ? optionalEnum : MyEnum.A;
 }
 function fn2(optionalEnum) {
     return optionalEnum || MyEnum.B;
 }
 function fn3(optionalEnum) {
-    return optionalEnum ?? MyEnum.A;
+    return optionalEnum !== null && optionalEnum !== void 0 ? optionalEnum : MyEnum.A;
 }
 function fn4(optionalEnum) {
     return optionalEnum || MyEnum.B;

testdata/baselines/reference/submodule/compiler/enumMemberReduction.js.diff

@@ -90,7 +90,7 @@ numberOrObject.x /= 1;
 //// [getterSetterSubtypeAssignment.js]
 class NumberOrUndefined {
     _x;
-    get x() { return this._x ?? 0; }
+    get x() { var _a; return (_a = this._x) !== null && _a !== void 0 ? _a : 0; }
     set x(value) { this._x = value; }
     additionAssignment() {
         this.x += 1;