add transform implementation for converting then() calls to async/await pattern

Author: Asa Rudick

bin/importTypescript.ts

@@ -1,12 +1,17 @@
 import ts from 'typescript';
 import fs from 'fs';
 import requireFromString from 'require-from-string';
+import path from 'path';
 
 // There's no alternative way to import a typescript file in what will be JS (after building).
-export function importTypescript(path) {
-  const contents = fs.readFileSync(path);
+export function importTypescript(src) {
+  const contents = fs.readFileSync(src);
   let result = ts.transpileModule(contents.toString(), {
-    compilerOptions: { module: ts.ModuleKind.CommonJS },
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2020,
+    },
   }).outputText;
-  return requireFromString(result);
+
+  return requireFromString(result, src, { prependPaths: [path.dirname(src)] });
 }

bin/sasquatch.ts

@@ -128,7 +128,7 @@ class Cli {
     let config: any;
 
     const finalPath = path ?? configPath;
-
+    
     try {
       config = importTypescript(finalPath).default;
       console.log(chalk.green(`Using ${finalPath}`));

mock/input.ts

@@ -49,8 +49,9 @@ export class Foo {
     'f' || true || false || true || false || true || false;
   }
 
-  baz() {
-    this.promiseReturner().then(a => {});
+  async baz() {
+    const a = await this.promiseReturner();
+    setTimeout(() => {}, 0);
   }
   static $inject: string[] = ['$rootScope', '$timeout', '$window', '$q'];
 
@@ -60,6 +61,18 @@ export class Foo {
     });
   }
 }
+class a {
+  promiseReturner() {
+    return new Promise((resolve, reject) => {
+      'a';
+    });
+  }
+}
+const fn = async () => {
+  const b = new a();
+  await b.promiseReturner()
+  let c = 'something';
+};
 //
 // function Bar($rootScope: ng.IRootScopeService) {
 //   'ngInject';

package.json

@@ -27,7 +27,7 @@
   "scripts": {
     "start": "npm run build && node ./lib/bin/sasquatch.js",
     "build": "tsc -p \"./tsconfig.json\"",
-    "test": "npm run build && node ./lib/bin/sasquatch.js -- \"./mock/input.ts\" \"./src/default.config.ts\"",
+    "test": "npm run build && node ./lib/bin/sasquatch.js -- \"./mock/input.ts\"",
     "debug": "npm run build && node --inspect-brk ./lib/bin/sasquatch.js"
   },
   "bugs": "https://github.com/asarudick/sasquatch/issues/",

res/default.config.ts

@@ -1,4 +1,4 @@
-import { StandardModule, SasquatchConfig } from 'sasquatch';
+import { StandardModule, SasquatchConfig } from '../src/';
 import { IndentationText, QuoteKind } from 'ts-morph';
 
 export default {

src/modules/standard.ts

@@ -1,5 +1,6 @@
 import { Module } from '../types';
 import * as analyzers from '../analyzers';
+import * as transforms from '../transforms';
 
 // The 'standard' module. Comes with the most fundamental and basic transforms
 // and analyzers.
@@ -11,6 +12,7 @@ import * as analyzers from '../analyzers';
 export const StandardModule: Module = {
   plugin: {
     analyzers,
+    transforms,
   },
   analyzers: {
     use: {
@@ -34,4 +36,9 @@ export const StandardModule: Module = {
       },
     },
   },
+  transforms: {
+    use: {
+      promiseToAsync: {},
+    },
+  },
 };

src/transforms/promiseToAsync.ts

@@ -11,6 +11,9 @@ import {
   Block,
   FunctionExpression,
   Statement,
+  FunctionDeclaration,
+  Node,
+  Expression,
 } from 'ts-morph';
 
 function hasThenCallExpression(expression: CallExpression): boolean {
@@ -22,7 +25,7 @@ function hasThenCallExpression(expression: CallExpression): boolean {
 function isThenPropertyAccessExpression(
   expression: PropertyAccessExpression,
 ): boolean {
-  return expression.getName() === 'then';
+  return expression.getName && expression.getName() === 'then';
 }
 
 function getCaller(expression) {}
@@ -72,86 +75,59 @@ export function promiseToAsync(sources: SourceFile[], options) {
       // First then call.
       const call: CallExpression = calls[0];
 
-      // Reference to then property access.
-      const expression = call.getExpression() as PropertyAccessExpression;
-
       // The arguments passed to then().
-      const args: any = call.getArguments();
+      const args = call.getArguments();
 
       // The arrow function. e.g. promise.then(() => {})
-      const fn: FunctionExpression = args.length && args[0];
+      const fn: FunctionExpression =
+        args.length && (args[0] as FunctionExpression);
 
       let s: Statement;
 
-      if (fn) {
-        // Create awaited assignment statement with all args as destructured assignment.
-        s = source.addVariableStatement({
+      // Reference to then property access.
+      const expression = call.getExpression() as PropertyAccessExpression;
+
+      // The containing parent block.
+      const block: Block = statement.getParent() as Block;
+
+      const params = fn.getParameters();
+
+      // We only care to declare a variable is there is a corresponding
+      // parameter in a function passed to the then() call.1
+      if (fn && params.length) {
+        // Create awaited assignment statement with all args as an assignment.
+        // TODO: Account for multiple params with destructuring
+        s = block.insertVariableStatement(statement.getChildIndex(), {
           declarationKind: VariableDeclarationKind.Const, // defaults to "let"
           declarations: [
             {
               // Move the variable from argument list in the then arrow function
               // to a constant reference.
-              name: args.getParameters()[0].toString(),
+              name: params[0].getName(),
 
               // 'await' and the name of the promise being awaited.
-              initializer: 'await ' + expression.getExpression().getFullText(),
+              initializer: 'await ' + expression.getExpression().getText(),
             },
           ],
         });
       } else {
-        s = source.addStatements([
-          'await ' + expression.getExpression().getFullText(),
+        s = block.addStatements([
+          'await ' + expression.getExpression().getText(),
         ])[0];
       }
 
-      // The containing parent block.
-      const parent: Block = statement.getParent() as Block;
-
       // Copy the body of the function expression to below the new await expression.
-      parent.insertStatements(
-        s.getChildIndex(),
-        fn.getStatementsWithComments().map(i => i.toString()),
-      );
+      fn &&
+        block.insertStatements(
+          s.getChildIndex() + 1,
+          fn.getStatementsWithComments().map((s: Statement) => s.getText()),
+        );
+
+      const functionDeclaration: FunctionDeclaration = block.getParent() as FunctionDeclaration;
+      functionDeclaration.toggleModifier('async', true);
 
       // Clean up.
       statement.remove();
-
-      // If only 1 argument, don't wrap with destructuring.
     });
   });
 }
-// export default (sources, options) => {
-//   sources.forEach(source => {
-//     const classes = source.getClasses();
-//
-//     classes.forEach(c => {
-//       const constructors = c.getConstructors();
-//       constructors.forEach(constructor => {
-//         const body = constructor.getBody();
-//         const statements = body.getStatements();
-//
-//         // Find ngInject
-//         const ngInject = statements.find((statement: Statement) => {
-//           return statement.getText().includes("'ngInject'");
-//         });
-//
-//         if (!ngInject) {
-//           return;
-//         }
-//
-//         ngInject.remove();
-//
-//         const arr = constructor.getParameters().map(param => param.getName());
-//
-//         const prop = c.addProperty({
-//           isStatic: true,
-//           name: '$inject',
-//           type: 'string[]',
-//         });
-//         const expression =
-//           '[' + arr.map(i => "'" + i.toString() + "'").join(', ') + ']';
-//         prop.setInitializer(expression);
-//       });
-//     });
-//   });
-// };

tsconfig.json

@@ -6,7 +6,7 @@
     "app/*": ["src/app/*"]
   },
   "compilerOptions": {
-    "lib": ["ES2015", "ES2016", "ES2017", "ES2018", "ES2019"],
+    "lib": ["ES2015", "ES2016", "ES2017", "ES2018", "ES2019", "ES2020"],
     "allowSyntheticDefaultImports": true,
     "module": "commonjs",
     "moduleResolution": "node",