feat: support augmented assignment operators in runtimehelper

Author: boblat

src/runtime-helpers.ts

@@ -20,7 +20,30 @@ export function switchableValue(x: unknown): bigint | string | boolean {
 //   internalError(`Cannot wrap ${nameOfType(x)}`)
 // }
 
-type BinaryOps = '+' | '-' | '*' | '**' | '/' | '%' | '>' | '>=' | '<' | '<=' | '===' | '!==' | '<<' | '>>' | '&' | '|' | '^'
+type BinaryOps =
+  | '+'
+  | '-'
+  | '*'
+  | '**'
+  | '/'
+  | '%'
+  | '>'
+  | '>='
+  | '<'
+  | '<='
+  | '==='
+  | '!=='
+  | '<<'
+  | '>>'
+  | '&'
+  | '|'
+  | '^'
+  | '+='
+  | '-='
+  | '/='
+  | '*='
+  | '**='
+  | '%='
 type UnaryOps = '~'
 
 function tryGetBigInt(value: unknown): bigint | undefined {
@@ -72,19 +95,25 @@ function uint64BinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOps
   const result = (function () {
     switch (op) {
       case '+':
+      case '+=':
         return lbi + rbi
       case '-':
+      case '-=':
         return lbi - rbi
       case '*':
+      case '*=':
         return lbi * rbi
       case '**':
+      case '**=':
         if (lbi === 0n && rbi === 0n) {
           throw internal.errors.codeError('0 ** 0 is undefined')
         }
         return lbi ** rbi
       case '/':
+      case '/=':
         return lbi / rbi
       case '%':
+      case '%=':
         return lbi % rbi
       case '>>':
         if (rbi > 63n) {
@@ -127,19 +156,25 @@ function bigUintBinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOp
   const result = (function () {
     switch (op) {
       case '+':
+      case '+=':
         return lbi + rbi
       case '-':
+      case '-=':
         return lbi - rbi
       case '*':
+      case '*=':
         return lbi * rbi
       case '**':
+      case '**=':
         if (lbi === 0n && rbi === 0n) {
           throw internal.errors.codeError('0 ** 0 is undefined')
         }
         return lbi ** rbi
       case '/':
+      case '/=':
         return lbi / rbi
       case '%':
+      case '%=':
         return lbi % rbi
       case '>>':
         throw new internal.errors.CodeError('BigUint does not support >> operator')
@@ -207,19 +242,25 @@ function bytesBinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOps)
 function defaultBinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOps): DeliberateAny {
   switch (op) {
     case '+':
+    case '+=':
       return left + right
     case '-':
+    case '-=':
       return left - right
     case '*':
+    case '*=':
       return left * right
     case '**':
+    case '**=':
       if (left === 0n && right === 0n) {
         throw new internal.errors.CodeError('0 ** 0 is undefined')
       }
       return left ** right
     case '/':
+    case '/=':
       return left / right
     case '%':
+    case '%=':
       return left % right
     case '>>':
       if (typeof left === 'bigint' && typeof right === 'bigint') {

src/test-transformer/node-factory.ts

@@ -28,6 +28,16 @@ export const nodeFactory = {
       [left, right, factory.createStringLiteral(op)],
     )
   },
+  augmentedAssignmentBinaryOp(left: ts.Expression, right: ts.Expression, op: string) {
+    return factory.createAssignment(
+      left,
+      factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier('runtimeHelpers'), factory.createIdentifier('binaryOp')),
+        undefined,
+        [left, right, factory.createStringLiteral(op)],
+      ),
+    )
+  },
 
   prefixUnaryOp(operand: ts.Expression, op: string) {
     return factory.createCallExpression(

src/test-transformer/supported-binary-op-string.ts

@@ -40,8 +40,6 @@ export function supportedBinaryOpString(x: BinaryOperator): string | undefined {
     case ts.SyntaxKind.AmpersandAmpersandEqualsToken:
     case ts.SyntaxKind.AmpersandAmpersandToken:
     case ts.SyntaxKind.AmpersandEqualsToken:
-    case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
-    case ts.SyntaxKind.AsteriskEqualsToken:
     case ts.SyntaxKind.BarBarEqualsToken:
     case ts.SyntaxKind.BarBarToken:
     case ts.SyntaxKind.BarEqualsToken:
@@ -52,11 +50,7 @@ export function supportedBinaryOpString(x: BinaryOperator): string | undefined {
     case ts.SyntaxKind.ExclamationEqualsToken:
     case ts.SyntaxKind.InKeyword:
     case ts.SyntaxKind.InstanceOfKeyword:
-    case ts.SyntaxKind.PercentEqualsToken:
-    case ts.SyntaxKind.PlusEqualsToken:
     case ts.SyntaxKind.QuestionQuestionEqualsToken:
-    case ts.SyntaxKind.MinusEqualsToken:
-    case ts.SyntaxKind.SlashEqualsToken:
     case ts.SyntaxKind.QuestionQuestionToken:
     case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
     case ts.SyntaxKind.LessThanLessThanEqualsToken:
@@ -66,6 +60,25 @@ export function supportedBinaryOpString(x: BinaryOperator): string | undefined {
   }
 }
 
+export function supportedAugmentedAssignmentBinaryOpString(x: BinaryOperator): string | undefined {
+  switch (x) {
+    case ts.SyntaxKind.PlusEqualsToken:
+      return '+='
+    case ts.SyntaxKind.MinusEqualsToken:
+      return '-='
+    case ts.SyntaxKind.SlashEqualsToken:
+      return '/='
+    case ts.SyntaxKind.AsteriskEqualsToken:
+      return '*='
+    case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
+      return '**='
+    case ts.SyntaxKind.PercentEqualsToken:
+      return '%='
+    default:
+      return undefined
+  }
+}
+
 export function supportedPrefixUnaryOpString(x: PrefixUnaryOperator): string | undefined {
   switch (x) {
     case ts.SyntaxKind.TildeToken:

src/test-transformer/visitors.ts

@@ -4,7 +4,11 @@ import type { TypeInfo } from '../encoders'
 import { DeliberateAny } from '../typescript-helpers'
 import { TransformerConfig } from './index'
 import { nodeFactory } from './node-factory'
-import { supportedBinaryOpString, supportedPrefixUnaryOpString } from './supported-binary-op-string'
+import {
+  supportedAugmentedAssignmentBinaryOpString,
+  supportedBinaryOpString,
+  supportedPrefixUnaryOpString,
+} from './supported-binary-op-string'
 
 const { factory } = ts
 
@@ -81,9 +85,13 @@ class FunctionOrMethodVisitor {
     }
 
     if (ts.isBinaryExpression(node)) {
-      const tokenText = supportedBinaryOpString(node.operatorToken.kind)
-      if (tokenText) {
-        return nodeFactory.binaryOp(node.left, node.right, tokenText)
+      const opTokenText = supportedBinaryOpString(node.operatorToken.kind)
+      if (opTokenText) {
+        return nodeFactory.binaryOp(node.left, node.right, opTokenText)
+      }
+      const augmentedAssignmentOpTokenText = supportedAugmentedAssignmentBinaryOpString(node.operatorToken.kind)
+      if (augmentedAssignmentOpTokenText) {
+        return nodeFactory.augmentedAssignmentBinaryOp(node.left, node.right, augmentedAssignmentOpTokenText)
       }
     }
     if (ts.isPrefixUnaryExpression(node)) {