Try out array destructuring

Author: JoviDeCroock

resources/build-npm.ts

@@ -6,6 +6,7 @@ import ts from 'typescript';
 
 import { changeExtensionInImportPaths } from './change-extension-in-import-paths.js';
 import { inlineInvariant } from './inline-invariant.js';
+import { optimizeArrayDestructuring } from './optimize-array-destructuring.js';
 import { optimizeForOf } from './optimize-for-of.js';
 import {
   prettify,
@@ -146,7 +147,7 @@ function emitTSFiles(options: {
 
   const tsProgram = ts.createProgram(['src/index.ts'], tsOptions, tsHost);
   const tsResult = tsProgram.emit(undefined, undefined, undefined, undefined, {
-    before: [optimizeForOf(tsProgram)],
+    before: [optimizeForOf(tsProgram), optimizeArrayDestructuring()],
     after: [changeExtensionInImportPaths({ extension }), inlineInvariant],
   });
   assert(

resources/optimize-array-destructuring.ts

@@ -0,0 +1,36 @@
+import ts from 'typescript';
+
+export function optimizeArrayDestructuring() {
+  const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
+    const { factory } = context;
+
+    return (sourceFile: ts.SourceFile): ts.SourceFile => {
+      const visitor = (node: ts.Node): ts.Node => {
+        if (ts.isArrayBindingPattern(node)) {
+          const elements = node.elements
+            .map((el, i) => {
+              if (!el.getText()) {
+                return undefined;
+              }
+              return { key: String(i), name: el.getText() };
+            })
+            .filter(Boolean) as Array<{ key: string; name: string }>;
+
+          const objectBindingPattern = factory.createObjectBindingPattern(
+            elements.map((el) => {
+              const key = factory.createIdentifier(el.key);
+              const name = factory.createIdentifier(el.name);
+              return factory.createBindingElement(undefined, key, name);
+            }),
+          );
+          return objectBindingPattern;
+        }
+
+        return ts.visitEachChild(node, visitor, context);
+      };
+      return ts.visitNode(sourceFile, visitor) as ts.SourceFile;
+    };
+  };
+
+  return transformer;
+}

resources/optimize-for-of.ts

@@ -37,12 +37,50 @@ export function optimizeForOf(program: ts.Program) {
       return ts.visitNode(sourceFile, visitNode) as ts.SourceFile;
 
       function visitNode(node: ts.Node): ts.Node {
+        // TODO: add Set support
+        // TODO: potentially add support for for..in statements as well
         if (isArrayForOfStatement(node)) {
           return convertForOfStatementForArray(node);
+        } else if (isMapForOfStatement(node)) {
+          return convertForOfStatementForMap(node);
         }
+
         return ts.visitEachChild(node, visitNode, context);
       }
 
+      function isMapForOfStatement(node: ts.Node): node is ts.ForOfStatement {
+        if (!ts.isForOfStatement(node) || node.awaitModifier != null) {
+          return false;
+        }
+
+        const { expression } = node;
+
+        const expressionType = typeChecker.getTypeAtLocation(expression);
+
+        for (const subType of unionTypeParts(expressionType)) {
+          assert(
+            !(subType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)),
+            'Can not use any or unknown values in for-of loop: ' +
+              nodeLocationString(node),
+          );
+
+          if (subType.flags & ts.TypeFlags.StringLike) {
+            continue;
+          }
+
+          const typeName = subType.getSymbol()?.getName();
+          assert(typeName != null);
+
+          if (typeName === 'Map') {
+            continue;
+          }
+
+          return false;
+        }
+
+        return true;
+      }
+
       function isArrayForOfStatement(node: ts.Node): node is ts.ForOfStatement {
         if (!ts.isForOfStatement(node) || node.awaitModifier != null) {
           return false;
@@ -91,6 +129,78 @@ export function optimizeForOf(program: ts.Program) {
         return (type.flags & ts.TypeFlags.Union) !== 0;
       }
 
+      function convertForOfStatementForMap(
+        forOfNode: ts.ForOfStatement,
+      ): ts.Statement {
+        const counter = factory.createLoopVariable();
+        const forDeclarations = [
+          factory.createVariableDeclaration(
+            counter,
+            undefined, // exclamationToken
+            undefined, // type
+            factory.createNumericLiteral(0),
+          ),
+        ];
+
+        // In the case where the user wrote an identifier as the RHS, like this:
+        //
+        //     for (let v of arr) { }
+        //
+        // we don't want to emit a temporary variable for the RHS, just use it directly.
+        const variableDeclarations = []
+        let reference: ts.Identifier
+        if (ts.isIdentifier(forOfNode.expression)) {
+          reference = forOfNode.expression;
+        } else {
+          const temp = factory.createTempVariable(
+            (identifier) => reference = identifier, // recordTempVariable
+          );
+          variableDeclarations.push(
+            factory.createVariableDeclaration(
+              temp,
+              undefined, // exclamationToken
+              undefined, // type
+              forOfNode.expression,
+            ))
+        }
+        const valuesExpression = factory.createCallExpression(factory.createPropertyAccessExpression(reference!, factory.createIdentifier('values')), undefined, []);
+        variableDeclarations.push(factory.createVariableDeclaration(`_${reference!.text}`, undefined, undefined, valuesExpression));
+        const rhsReference = factory.createIdentifier(`_${reference!.text}`);
+
+        const forInitializer = factory.createVariableDeclarationList(
+          forDeclarations,
+          ts.NodeFlags.Let,
+        );
+
+        const forCondition = factory.createLessThan(
+          counter,
+          factory.createPropertyAccessExpression(rhsReference, 'length'),
+        );
+        const forIncrementor = factory.createPostfixIncrement(counter);
+
+        assert(ts.isVariableDeclarationList(forOfNode.initializer));
+        // It will use rhsIterationValue _a[_i] as the initializer.
+        const itemAssignment = convertForOfInitializer(
+          forOfNode.initializer,
+          factory.createElementAccessExpression(rhsReference, counter),
+        );
+
+        assert(ts.isBlock(forOfNode.statement));
+        const forBody = factory.updateBlock(forOfNode.statement, [
+          itemAssignment,
+          ...forOfNode.statement.statements,
+        ]);
+
+        const forStatement = factory.createForStatement(
+          forInitializer,
+          forCondition,
+          forIncrementor,
+          forBody,
+        );
+
+        return factory.createBlock([factory.createVariableStatement(undefined, variableDeclarations), forStatement]);
+      }
+
       function convertForOfStatementForArray(
         forOfNode: ts.ForOfStatement,
       ): ts.Statement {
@@ -126,7 +236,7 @@ export function optimizeForOf(program: ts.Program) {
           );
         }
 
-        const forInitiliazer = factory.createVariableDeclarationList(
+        const forInitializer = factory.createVariableDeclarationList(
           forDeclarations,
           ts.NodeFlags.Let,
         );
@@ -151,7 +261,7 @@ export function optimizeForOf(program: ts.Program) {
         ]);
 
         return factory.createForStatement(
-          forInitiliazer,
+          forInitializer,
           forCondition,
           forIncrementor,
           forBody,