Port es2021 transform (#1372)

Author: weswigham

internal/transformers/estransforms/logicalassignment.go

@@ -11,7 +11,101 @@ type logicalAssignmentTransformer struct {
 }
 
 func (ch *logicalAssignmentTransformer) visit(node *ast.Node) *ast.Node {
-	return node // !!!
+	if node.SubtreeFacts()&ast.SubtreeContainsLogicalAssignments == 0 {
+		return node
+	}
+	switch node.Kind {
+	case ast.KindBinaryExpression:
+		return ch.visitBinaryExpression(node.AsBinaryExpression())
+	default:
+		return ch.Visitor().VisitEachChild(node)
+	}
+}
+
+func (ch *logicalAssignmentTransformer) visitBinaryExpression(node *ast.BinaryExpression) *ast.Node {
+	var nonAssignmentOperator ast.Kind
+	switch node.OperatorToken.Kind {
+	case ast.KindBarBarEqualsToken:
+		nonAssignmentOperator = ast.KindBarBarToken
+	case ast.KindAmpersandAmpersandEqualsToken:
+		nonAssignmentOperator = ast.KindAmpersandAmpersandToken
+	case ast.KindQuestionQuestionEqualsToken:
+		nonAssignmentOperator = ast.KindQuestionQuestionToken
+	default:
+		return ch.Visitor().VisitEachChild(node.AsNode())
+	}
+
+	left := ast.SkipParentheses(ch.Visitor().VisitNode(node.Left))
+	assignmentTarget := left
+	right := ast.SkipParentheses(ch.Visitor().VisitNode(node.Right))
+
+	if ast.IsAccessExpression(left) {
+		propertyAccessTargetSimpleCopiable := transformers.IsSimpleCopiableExpression(left.Expression())
+		propertyAccessTarget := left.Expression()
+		propertyAccessTargetAssignment := left.Expression()
+		if !propertyAccessTargetSimpleCopiable {
+			propertyAccessTarget = ch.Factory().NewTempVariable()
+			ch.EmitContext().AddVariableDeclaration(propertyAccessTarget)
+			propertyAccessTargetAssignment = ch.Factory().NewAssignmentExpression(
+				propertyAccessTarget,
+				left.Expression(),
+			)
+		}
+
+		if ast.IsPropertyAccessExpression(left) {
+			assignmentTarget = ch.Factory().NewPropertyAccessExpression(
+				propertyAccessTarget,
+				nil,
+				left.Name(),
+				ast.NodeFlagsNone,
+			)
+			left = ch.Factory().NewPropertyAccessExpression(
+				propertyAccessTargetAssignment,
+				nil,
+				left.Name(),
+				ast.NodeFlagsNone,
+			)
+		} else {
+			elementAccessArgumentSimpleCopiable := transformers.IsSimpleCopiableExpression(left.AsElementAccessExpression().ArgumentExpression)
+			elementAccessArgument := left.AsElementAccessExpression().ArgumentExpression
+			argumentExpr := elementAccessArgument
+			if !elementAccessArgumentSimpleCopiable {
+				elementAccessArgument = ch.Factory().NewTempVariable()
+				ch.EmitContext().AddVariableDeclaration(elementAccessArgument)
+				argumentExpr = ch.Factory().NewAssignmentExpression(
+					elementAccessArgument,
+					left.AsElementAccessExpression().ArgumentExpression,
+				)
+			}
+
+			assignmentTarget = ch.Factory().NewElementAccessExpression(
+				propertyAccessTarget,
+				nil,
+				elementAccessArgument,
+				ast.NodeFlagsNone,
+			)
+			left = ch.Factory().NewElementAccessExpression(
+				propertyAccessTargetAssignment,
+				nil,
+				argumentExpr,
+				ast.NodeFlagsNone,
+			)
+		}
+
+	}
+
+	return ch.Factory().NewBinaryExpression(
+		nil,
+		left,
+		nil,
+		ch.Factory().NewToken(nonAssignmentOperator),
+		ch.Factory().NewParenthesizedExpression(
+			ch.Factory().NewAssignmentExpression(
+				assignmentTarget,
+				right,
+			),
+		),
+	)
 }
 
 func newLogicalAssignmentTransformer(emitContext *printer.EmitContext) *transformers.Transformer {

internal/transformers/moduletransforms/utilities.go

@@ -5,6 +5,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/outputpaths"
 	"github.com/microsoft/typescript-go/internal/printer"
+	"github.com/microsoft/typescript-go/internal/transformers"
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
@@ -113,20 +114,9 @@ func isFileLevelReservedGeneratedIdentifier(emitContext *printer.EmitContext, na
 		info.Flags.IsReservedInNestedScopes()
 }
 
-// Used in the module transformer to check if an expression is reasonably without sideeffect,
-//
-//	and thus better to copy into multiple places rather than to cache in a temporary variable
-//	- this is mostly subjective beyond the requirement that the expression not be sideeffecting
-func isSimpleCopiableExpression(expression *ast.Expression) bool {
-	return ast.IsStringLiteralLike(expression) ||
-		ast.IsNumericLiteral(expression) ||
-		ast.IsKeywordKind(expression.Kind) ||
-		ast.IsIdentifier(expression)
-}
-
 // A simple inlinable expression is an expression which can be copied into multiple locations
 // without risk of repeating any sideeffects and whose value could not possibly change between
 // any such locations
 func isSimpleInlineableExpression(expression *ast.Expression) bool {
-	return !ast.IsIdentifier(expression) && isSimpleCopiableExpression(expression)
+	return !ast.IsIdentifier(expression) && transformers.IsSimpleCopiableExpression(expression)
 }

internal/transformers/utilities.go

@@ -231,3 +231,17 @@ func SingleOrMany(nodes []*ast.Node, factory *printer.NodeFactory) *ast.Node {
 	}
 	return factory.NewSyntaxList(nodes)
 }
+
+// Used in the module transformer to check if an expression is reasonably without sideeffect,
+//
+//	and thus better to copy into multiple places rather than to cache in a temporary variable
+//	- this is mostly subjective beyond the requirement that the expression not be sideeffecting
+//
+// Also used by the logical assignment downleveling transform to skip temp variables when they're
+// not needed.
+func IsSimpleCopiableExpression(expression *ast.Expression) bool {
+	return ast.IsStringLiteralLike(expression) ||
+		ast.IsNumericLiteral(expression) ||
+		ast.IsKeywordKind(expression.Kind) ||
+		ast.IsIdentifier(expression)
+}

testdata/baselines/reference/submodule/conformance/equalityWithtNullishCoalescingAssignment(strict=false).js

@@ -21,15 +21,15 @@ function f2() {
 
 //// [equalityWithtNullishCoalescingAssignment.js]
 function f1(a) {
-    a ??= true;
+    a ?? (a = true);
     if (a === false) {
         console.log(a);
     }
 }
 f1(false);
 function f2() {
     let x = 0;
-    x ??= 1;
+    x ?? (x = 1);
     if (x === 0) {
         console.log(x);
     }

testdata/baselines/reference/submodule/conformance/equalityWithtNullishCoalescingAssignment(strict=false).js.diff

@@ -5,7 +5,7 @@
  //// [equalityWithtNullishCoalescingAssignment.js]
  function f1(a) {
 -    a !== null && a !== void 0 ? a : (a = true);
-+    a ??= true;
++    a ?? (a = true);
      if (a === false) {
          console.log(a);
      }
@@ -14,7 +14,7 @@
  function f2() {
      let x = 0;
 -    x !== null && x !== void 0 ? x : (x = 1);
-+    x ??= 1;
++    x ?? (x = 1);
      if (x === 0) {
          console.log(x);
      }

testdata/baselines/reference/submodule/conformance/equalityWithtNullishCoalescingAssignment(strict=true).js

@@ -21,15 +21,15 @@ function f2() {
 
 //// [equalityWithtNullishCoalescingAssignment.js]
 function f1(a) {
-    a ??= true;
+    a ?? (a = true);
     if (a === false) {
         console.log(a);
     }
 }
 f1(false);
 function f2() {
     let x = 0;
-    x ??= 1;
+    x ?? (x = 1);
     if (x === 0) {
         console.log(x);
     }

testdata/baselines/reference/submodule/conformance/equalityWithtNullishCoalescingAssignment(strict=true).js.diff

@@ -7,7 +7,7 @@
 -"use strict";
  function f1(a) {
 -    a !== null && a !== void 0 ? a : (a = true);
-+    a ??= true;
++    a ?? (a = true);
      if (a === false) {
          console.log(a);
      }
@@ -16,7 +16,7 @@
  function f2() {
      let x = 0;
 -    x !== null && x !== void 0 ? x : (x = 1);
-+    x ??= 1;
++    x ?? (x = 1);
      if (x === 0) {
          console.log(x);
      }

testdata/baselines/reference/submodule/conformance/logicalAssignment1(target=es2015).js

@@ -29,12 +29,12 @@ i ??= 42
 
 
 //// [logicalAssignment1.js]
-a &&= "foo";
-b ||= "foo";
-c ??= "foo";
-d &&= 42;
-e ||= 42;
-f ??= 42;
-g &&= 42;
-h ||= 42;
-i ??= 42;
+a && (a = "foo");
+b || (b = "foo");
+c ?? (c = "foo");
+d && (d = 42);
+e || (e = 42);
+f ?? (f = 42);
+g && (g = 42);
+h || (h = 42);
+i ?? (i = 42);

testdata/baselines/reference/submodule/conformance/logicalAssignment1(target=es2015).js.diff

@@ -5,21 +5,15 @@
 
  //// [logicalAssignment1.js]
 -"use strict";
--a && (a = "foo");
--b || (b = "foo");
+ a && (a = "foo");
+ b || (b = "foo");
 -c !== null && c !== void 0 ? c : (c = "foo");
--d && (d = 42);
--e || (e = 42);
++c ?? (c = "foo");
+ d && (d = 42);
+ e || (e = 42);
 -f !== null && f !== void 0 ? f : (f = 42);
--g && (g = 42);
--h || (h = 42);
++f ?? (f = 42);
+ g && (g = 42);
+ h || (h = 42);
 -i !== null && i !== void 0 ? i : (i = 42);
-+a &&= "foo";
-+b ||= "foo";
-+c ??= "foo";
-+d &&= 42;
-+e ||= 42;
-+f ??= 42;
-+g &&= 42;
-+h ||= 42;
-+i ??= 42;
++i ?? (i = 42);

testdata/baselines/reference/submodule/conformance/logicalAssignment1(target=es2020).js

@@ -29,12 +29,12 @@ i ??= 42
 
 
 //// [logicalAssignment1.js]
-a &&= "foo";
-b ||= "foo";
-c ??= "foo";
-d &&= 42;
-e ||= 42;
-f ??= 42;
-g &&= 42;
-h ||= 42;
-i ??= 42;
+a && (a = "foo");
+b || (b = "foo");
+c ?? (c = "foo");
+d && (d = 42);
+e || (e = 42);
+f ?? (f = 42);
+g && (g = 42);
+h || (h = 42);
+i ?? (i = 42);