Port ?. emit

internal/ast/ast.go

@@ -879,6 +879,20 @@ func (n *Node) Elements() []*Node {
 	return nil
 }
 
+func (n *Node) QuestionDotToken() *Node {
+	switch n.Kind {
+	case KindElementAccessExpression:
+		return n.AsElementAccessExpression().QuestionDotToken
+	case KindPropertyAccessExpression:
+		return n.AsPropertyAccessExpression().QuestionDotToken
+	case KindCallExpression:
+		return n.AsCallExpression().QuestionDotToken
+	case KindTaggedTemplateExpression:
+		return n.AsTaggedTemplateExpression().QuestionDotToken
+	}
+	panic("Unhandled case in Node.QuestionDotToken: " + n.Kind.String())
+}
+
 // Determines if `n` contains `descendant` by walking up the `Parent` pointers from `descendant`. This method panics if
 // `descendant` or one of its ancestors is not parented except when that node is a `SourceFile`.
 func (n *Node) Contains(descendant *Node) bool {
@@ -1673,6 +1687,10 @@ func (n *Node) AsSyntaxList() *SyntaxList {
 	return n.data.(*SyntaxList)
 }
 
+func (n *Node) AsSyntheticReferenceExpression() *SyntheticReferenceExpression {
+	return n.data.(*SyntheticReferenceExpression)
+}
+
 // NodeData
 
 type nodeData interface {
@@ -4127,6 +4145,53 @@ func IsNotEmittedTypeElement(node *Node) bool {
 	return node.Kind == KindNotEmittedTypeElement
 }
 
+// SyntheticReferenceExpression
+// Used by optional chaining transform to shuffle a `this` arg expression between steps of a chain.
+// While this does implement the full expected interface of a node, and is used in place of a node in transforms,
+// it generally shouldn't be treated or visited like a normal node.
+
+type SyntheticReferenceExpression struct {
+	ExpressionBase
+	Expression *Expression
+	ThisArg    *Expression
+}
+
+func (f *NodeFactory) NewSyntheticReferenceExpression(expr *Expression, thisArg *Expression) *Node {
+	data := &SyntheticReferenceExpression{Expression: expr, ThisArg: thisArg}
+	return newNode(KindSyntheticReferenceExpression, data, f.hooks)
+}
+
+func (f *NodeFactory) UpdateSyntheticReferenceExpression(node *SyntheticReferenceExpression, expr *Expression, thisArg *Expression) *Node {
+	if expr != node.Expression || thisArg != node.ThisArg {
+		return updateNode(f.NewSyntheticReferenceExpression(expr, thisArg), node.AsNode(), f.hooks)
+	}
+	return node.AsNode()
+}
+
+func (node *SyntheticReferenceExpression) ForEachChild(v Visitor) bool {
+	return visit(v, node.Expression)
+}
+
+func (node *SyntheticReferenceExpression) VisitEachChild(v *NodeVisitor) *Node {
+	return v.Factory.UpdateSyntheticReferenceExpression(node, v.visitNode(node.Expression), node.ThisArg)
+}
+
+func (node *SyntheticReferenceExpression) Clone(f NodeFactoryCoercible) *Node {
+	return cloneNode(f.AsNodeFactory().NewSyntheticReferenceExpression(node.Expression, node.ThisArg), node.AsNode(), f.AsNodeFactory().hooks)
+}
+
+func (node *SyntheticReferenceExpression) computeSubtreeFacts() SubtreeFacts {
+	return propagateSubtreeFacts(node.Expression)
+}
+
+func (node *SyntheticReferenceExpression) propagateSubtreeFacts() SubtreeFacts {
+	return node.SubtreeFacts()
+}
+
+func IsSyntheticReferenceExpression(node *Node) bool {
+	return node.Kind == KindSyntheticReferenceExpression
+}
+
 // ImportEqualsDeclaration
 
 type ImportEqualsDeclaration struct {

internal/printer/factory.go

@@ -308,6 +308,14 @@ func (f *NodeFactory) NewGlobalMethodCall(globalObjectName string, methodName st
 	return f.NewMethodCall(f.NewIdentifier(globalObjectName), f.NewIdentifier(methodName), argumentsList)
 }
 
+func (f *NodeFactory) NewFunctionCallCall(target *ast.Expression, thisArg *ast.Expression, argumentsList []*ast.Node) *ast.Node {
+	if thisArg == nil {
+		panic("Attempted to construct function call call without this argument expression")
+	}
+	args := append([]*ast.Expression{thisArg}, argumentsList...)
+	return f.NewMethodCall(target, f.NewIdentifier("call"), args)
+}
+
 // Determines whether a node is a parenthesized expression that can be ignored when recreating outer expressions.
 //
 // A parenthesized expression can be ignored when all of the following are true:

internal/printer/printer.go

@@ -3093,12 +3093,12 @@ func (p *Printer) emitExpression(node *ast.Expression, precedence ast.OperatorPr
 		return
 	case ast.KindPartiallyEmittedExpression:
 		p.emitPartiallyEmittedExpression(node.AsPartiallyEmittedExpression(), precedence)
+	case ast.KindSyntheticReferenceExpression:
+		panic("SyntheticReferenceExpression should not be printed")
 
 	// !!!
 	////case ast.KindCommaListExpression:
 	////	p.emitCommaList(node.AsCommaListExpression())
-	////case ast.KindSyntheticReferenceExpression:
-	////	return Debug.fail("SyntheticReferenceExpression should not be printed")
 
 	default:
 		panic(fmt.Sprintf("unexpected Expression: %v", node.Kind))

internal/transformers/estransforms/optionalchain.go

@@ -11,7 +11,222 @@ type optionalChainTransformer struct {
 }
 
 func (ch *optionalChainTransformer) visit(node *ast.Node) *ast.Node {
-	return node // !!!
+	if node.SubtreeFacts()&ast.SubtreeContainsOptionalChaining == 0 {
+		return node
+	}
+	switch node.Kind {
+	case ast.KindCallExpression:
+		return ch.visitCallExpression(node.AsCallExpression(), false)
+	case ast.KindPropertyAccessExpression,
+		ast.KindElementAccessExpression:
+		if node.Flags&ast.NodeFlagsOptionalChain != 0 {
+			return ch.visitOptionalExpression(node, false, false)
+		}
+		return ch.Visitor().VisitEachChild(node)
+	case ast.KindDeleteExpression:
+		return ch.visitDeleteExpression(node.AsDeleteExpression())
+	default:
+		return ch.Visitor().VisitEachChild(node)
+	}
+}
+
+func (ch *optionalChainTransformer) visitCallExpression(node *ast.CallExpression, captureThisArg bool) *ast.Node {
+	if node.Flags&ast.NodeFlagsOptionalChain != 0 {
+		// If `node` is an optional chain, then it is the outermost chain of an optional expression.
+		return ch.visitOptionalExpression(node.AsNode(), captureThisArg, false)
+	}
+	if ast.IsParenthesizedExpression(node.Expression) {
+		unwrapped := ast.SkipParentheses(node.Expression)
+		if unwrapped.Flags&ast.NodeFlagsOptionalChain != 0 {
+			// capture thisArg for calls of parenthesized optional chains like `(foo?.bar)()`
+			expression := ch.visitParenthesizedExpression(node.Expression.AsParenthesizedExpression(), true, false)
+			args := ch.Visitor().VisitNodes(node.Arguments)
+			if ast.IsSyntheticReferenceExpression(expression) {
+				res := ch.Factory().NewFunctionCallCall(expression.AsSyntheticReferenceExpression().Expression, expression.AsSyntheticReferenceExpression().ThisArg, args.Nodes)
+				res.Loc = node.Loc
+				ch.EmitContext().SetOriginal(res, node.AsNode())
+				return res
+			}
+			return ch.Factory().UpdateCallExpression(node, expression, nil, nil, args)
+		}
+	}
+	return ch.Visitor().VisitEachChild(node.AsNode())
+}
+
+func (ch *optionalChainTransformer) visitParenthesizedExpression(node *ast.ParenthesizedExpression, captureThisArg bool, isDelete bool) *ast.Node {
+	expr := ch.visitNonOptionalExpression(node.Expression, captureThisArg, isDelete)
+	if ast.IsSyntheticReferenceExpression(expr) {
+		// `(a.b)` -> { expression `((_a = a).b)`, thisArg: `_a` }
+		// `(a[b])` -> { expression `((_a = a)[b])`, thisArg: `_a` }
+		synth := expr.AsSyntheticReferenceExpression()
+		res := ch.Factory().NewSyntheticReferenceExpression(ch.Factory().UpdateParenthesizedExpression(node, synth.Expression), synth.ThisArg)
+		ch.EmitContext().SetOriginal(res, node.AsNode())
+		return res
+	}
+	return ch.Factory().UpdateParenthesizedExpression(node, expr)
+}
+
+func (ch *optionalChainTransformer) visitPropertyOrElementAccessExpression(node *ast.Expression, captureThisArg bool, isDelete bool) *ast.Expression {
+	if node.Flags&ast.NodeFlagsOptionalChain != 0 {
+		// If `node` is an optional chain, then it is the outermost chain of an optional expression.
+		return ch.visitOptionalExpression(node.AsNode(), captureThisArg, isDelete)
+	}
+	expression := ch.Visitor().VisitNode(node.Expression())
+	// Debug.assertNotNode(expression, isSyntheticReference); // !!!
+
+	var thisArg *ast.Expression
+	if captureThisArg {
+		if !transformers.IsSimpleCopiableExpression(expression) {
+			thisArg = ch.Factory().NewTempVariable()
+			ch.EmitContext().AddVariableDeclaration(thisArg)
+			expression = ch.Factory().NewAssignmentExpression(thisArg, expression)
+		} else {
+			thisArg = expression
+		}
+	}
+
+	if node.Kind == ast.KindPropertyAccessExpression {
+		p := node.AsPropertyAccessExpression()
+		expression = ch.Factory().UpdatePropertyAccessExpression(p, expression, nil, ch.Visitor().VisitNode(p.Name()))
+	} else {
+		p := node.AsElementAccessExpression()
+		expression = ch.Factory().UpdateElementAccessExpression(p, expression, nil, ch.Visitor().VisitNode(p.AsElementAccessExpression().ArgumentExpression))
+	}
+
+	if thisArg != nil {
+		res := ch.Factory().NewSyntheticReferenceExpression(expression, thisArg)
+		ch.EmitContext().SetOriginal(res, node.AsNode())
+		return res
+	}
+	return expression
+}
+
+func (ch *optionalChainTransformer) visitDeleteExpression(node *ast.DeleteExpression) *ast.Node {
+	unwrapped := ast.SkipParentheses(node.Expression)
+	if unwrapped.Flags&ast.NodeFlagsOptionalChain != 0 {
+		return ch.visitNonOptionalExpression(node.Expression, false, true)
+	}
+	return ch.Visitor().VisitEachChild(node.AsNode())
+}
+
+func (ch *optionalChainTransformer) visitNonOptionalExpression(node *ast.Expression, captureThisArg bool, isDelete bool) *ast.Expression {
+	switch node.Kind {
+	case ast.KindParenthesizedExpression:
+		return ch.visitParenthesizedExpression(node.AsParenthesizedExpression(), captureThisArg, isDelete)
+	case ast.KindElementAccessExpression, ast.KindPropertyAccessExpression:
+		return ch.visitPropertyOrElementAccessExpression(node, captureThisArg, isDelete)
+	case ast.KindCallExpression:
+		return ch.visitCallExpression(node.AsCallExpression(), captureThisArg)
+	default:
+		return ch.Visitor().VisitNode(node.AsNode())
+	}
+}
+
+type flattenResult struct {
+	expression *ast.Expression
+	chain      []*ast.Node
+}
+
+func flattenChain(chain *ast.Node) flattenResult {
+	// Debug.assertNotNode(chain, isNonNullChain); // !!!
+	links := []*ast.Node{chain}
+	for !ast.IsTaggedTemplateExpression(chain) && chain.QuestionDotToken() == nil {
+		chain = ast.SkipPartiallyEmittedExpressions(chain.Expression())
+		// Debug.assertNotNode(chain, isNonNullChain); // !!!
+		links = append([]*ast.Node{chain}, links...)
+	}
+	return flattenResult{chain.Expression(), links}
+}
+
+func isCallChain(node *ast.Node) bool {
+	return ast.IsCallExpression(node) && node.Flags&ast.NodeFlagsOptionalChain != 0
+}
+
+func (ch *optionalChainTransformer) visitOptionalExpression(node *ast.Node, captureThisArg bool, isDelete bool) *ast.Node {
+	r := flattenChain(node)
+	expression := r.expression
+	chain := r.chain
+	left := ch.visitNonOptionalExpression(ast.SkipPartiallyEmittedExpressions(expression), isCallChain(chain[0]), false)
+	var leftThisArg *ast.Expression
+	capturedLeft := left
+	if ast.IsSyntheticReferenceExpression(left) {
+		leftThisArg = left.AsSyntheticReferenceExpression().ThisArg
+		capturedLeft = left.AsSyntheticReferenceExpression().Expression
+	}
+	leftExpression := ch.Factory().RestoreOuterExpressions(expression, capturedLeft, ast.OEKPartiallyEmittedExpressions)
+	if !transformers.IsSimpleCopiableExpression(capturedLeft) {
+		capturedLeft = ch.Factory().NewTempVariable()
+		ch.EmitContext().AddVariableDeclaration(capturedLeft)
+		leftExpression = ch.Factory().NewAssignmentExpression(capturedLeft, leftExpression)
+	}
+	rightExpression := capturedLeft
+	var thisArg *ast.Expression
+
+	for i, segment := range chain {
+		switch segment.Kind {
+		case ast.KindElementAccessExpression, ast.KindPropertyAccessExpression:
+			if i == len(chain)-1 && captureThisArg {
+				if !transformers.IsSimpleCopiableExpression(rightExpression) {
+					thisArg = ch.Factory().NewTempVariable()
+					ch.EmitContext().AddVariableDeclaration(thisArg)
+					rightExpression = ch.Factory().NewAssignmentExpression(thisArg, rightExpression)
+				} else {
+					thisArg = rightExpression
+				}
+			}
+			if segment.Kind == ast.KindElementAccessExpression {
+				rightExpression = ch.Factory().NewElementAccessExpression(rightExpression, nil, ch.Visitor().VisitNode(segment.AsElementAccessExpression().ArgumentExpression), ast.NodeFlagsNone)
+			} else {
+				rightExpression = ch.Factory().NewPropertyAccessExpression(rightExpression, nil, ch.Visitor().VisitNode(segment.AsPropertyAccessExpression().Name()), ast.NodeFlagsNone)
+			}
+		case ast.KindCallExpression:
+			if i == 0 && leftThisArg != nil {
+				if !ch.EmitContext().HasAutoGenerateInfo(leftThisArg) {
+					leftThisArg = leftThisArg.Clone(ch.Factory())
+					ch.EmitContext().AddEmitFlags(leftThisArg, printer.EFNoComments)
+				}
+				callThisArg := leftThisArg
+				if leftThisArg.Kind == ast.KindSuperKeyword {
+					callThisArg = ch.Factory().NewThisExpression()
+				}
+				rightExpression = ch.Factory().NewFunctionCallCall(rightExpression, callThisArg, ch.Visitor().VisitNodes(segment.ArgumentList()).Nodes)
+			} else {
+				rightExpression = ch.Factory().NewCallExpression(
+					rightExpression,
+					nil,
+					nil,
+					ch.Visitor().VisitNodes(segment.ArgumentList()),
+					ast.NodeFlagsNone,
+				)
+			}
+		}
+		ch.EmitContext().SetOriginal(rightExpression, segment)
+	}
+
+	var target *ast.Node
+	if isDelete {
+		target = ch.Factory().NewConditionalExpression(
+			createNotNullCondition(ch.EmitContext(), leftExpression, capturedLeft, true),
+			ch.Factory().NewToken(ast.KindQuestionToken),
+			ch.Factory().NewTrueExpression(),
+			ch.Factory().NewToken(ast.KindColonToken),
+			ch.Factory().NewDeleteExpression(rightExpression),
+		)
+	} else {
+		target = ch.Factory().NewConditionalExpression(
+			createNotNullCondition(ch.EmitContext(), leftExpression, capturedLeft, true),
+			ch.Factory().NewToken(ast.KindQuestionToken),
+			ch.Factory().NewVoidZeroExpression(),
+			ch.Factory().NewToken(ast.KindColonToken),
+			rightExpression,
+		)
+	}
+	target.Loc = node.Loc
+	if thisArg != nil {
+		target = ch.Factory().NewSyntheticReferenceExpression(target, thisArg)
+	}
+	ch.EmitContext().SetOriginal(target, node.AsNode())
+	return target
 }
 
 func newOptionalChainTransformer(emitContext *printer.EmitContext) *transformers.Transformer {

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

@@ -31,5 +31,5 @@ const animal = { type: 'cat', canMeow: true };
 assertEqual(animal.type, 'cat');
 animal.canMeow; // since is cat, should not be an error
 const animalOrUndef = { type: 'cat', canMeow: true };
-assertEqual(animalOrUndef?.type, 'cat');
+assertEqual(animalOrUndef === null || animalOrUndef === void 0 ? void 0 : animalOrUndef.type, 'cat');
 animalOrUndef.canMeow; // since is cat, should not be an error

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

@@ -7,8 +7,4 @@
 -"use strict";
  const animal = { type: 'cat', canMeow: true };
  assertEqual(animal.type, 'cat');
- animal.canMeow; // since is cat, should not be an error
- const animalOrUndef = { type: 'cat', canMeow: true };
--assertEqual(animalOrUndef === null || animalOrUndef === void 0 ? void 0 : animalOrUndef.type, 'cat');
-+assertEqual(animalOrUndef?.type, 'cat');
- animalOrUndef.canMeow; // since is cat, should not be an error
+ animal.canMeow; // since is cat, should not be an error

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

@@ -10,8 +10,9 @@ new A()?.b() // ok
 
 
 //// [invalidOptionalChainFromNewExpression.js]
+var _a, _b;
 class A {
     b() { }
 }
-(new A)?.b(); // error
-new A()?.b(); // ok
+(_a = new A) === null || _a === void 0 ? void 0 : _a.b(); // error
+(_b = new A()) === null || _b === void 0 ? void 0 : _b.b(); // ok