descend into basic control structures

Author: samthor

lib/extractor.ts

@@ -315,8 +315,18 @@ export class StaticExtractor {
     return this.addCodeToStatic({ node: c, analysis });
   }
 
-  liftExpression(e: acorn.Expression) {
+  /**
+   * Lifts the given expression.
+   * If any of the variables used in `dirty` are used (r/rw), skip.
+   */
+  liftExpression(e: acorn.Expression, dirty: string[] = []) {
     const analysis = analyzeBlock(createBlock(createExpressionStatement(e)));
+    for (const d of dirty) {
+      if (analysis.vars.has(d)) {
+        return null;
+      }
+    }
+
     return this.addCodeToStatic({ node: e, analysis, var: true });
   }
 

lib/internal/analyze/block.ts

@@ -189,7 +189,7 @@ export type AnalyzeBlock = {
   hasNested: boolean;
 };
 
-export function analyzeBlock(b: acorn.BlockStatement): AnalyzeBlock {
+export function analyzeBlock(b: acorn.BlockStatement, args?: { nest?: boolean }): AnalyzeBlock {
   const out: AnalyzeBlock = { vars: new Map(), hasNested: false };
   const mark: MarkIdentifierFn = (name, { nested, writes }) => {
     if (name === '') {
@@ -220,6 +220,10 @@ export function analyzeBlock(b: acorn.BlockStatement): AnalyzeBlock {
     const simple = reductifyStatement(raw) ?? { type: 'EmptyStatement' };
     switch (simple.type) {
       case 'BlockStatement': {
+        if (args?.nest === false) {
+          break; // we can skip descending in some cases
+        }
+
         const inner = analyzeBlock(simple);
 
         for (const [key, info] of inner.vars) {

lib/internal/analyze/expression.ts

@@ -38,6 +38,26 @@ function createIife(body: acorn.Statement[]): acorn.CallExpression {
   };
 }
 
+export function patternsToDeclaration(...p: acorn.Pattern[]): acorn.VariableDeclaration {
+  const decl: acorn.VariableDeclaration = {
+    type: 'VariableDeclaration',
+    start: -1,
+    end: -1,
+    kind: 'var',
+    declarations: p.map((id): acorn.VariableDeclarator => {
+      return {
+        type: 'VariableDeclarator',
+        start: id.start,
+        end: id.end,
+        id,
+      };
+    }),
+  };
+  return decl;
+}
+
+export function namesFromDeclaration(d: acorn.VariableDeclaration) {}
+
 /**
  * Returns the given "class" as a number of simple component parts.
  * This can't be used or run but is the same from an analysis point of view.
@@ -84,7 +104,7 @@ function reductifyClassParts(c: acorn.Class): acorn.Expression {
   return e.length === 1 ? e[0] : createSequenceExpression(...e);
 }
 
-function reductifyFunction(f: acorn.Function): acorn.BlockStatement {
+export function reductifyFunction(f: acorn.Function): acorn.BlockStatement {
   const body: acorn.Statement[] = [];
 
   // our own function name becomes something we can reference
@@ -107,21 +127,7 @@ function reductifyFunction(f: acorn.Function): acorn.BlockStatement {
   }
 
   if (f.params.length) {
-    const decl: acorn.VariableDeclaration = {
-      type: 'VariableDeclaration',
-      start: -1,
-      end: -1,
-      kind: 'var',
-      declarations: f.params.map((id): acorn.VariableDeclarator => {
-        return {
-          type: 'VariableDeclarator',
-          start: id.start,
-          end: id.end,
-          id,
-        };
-      }),
-    };
-    body.push(decl);
+    body.push(patternsToDeclaration(...f.params));
   } else if (f.body.type === 'BlockStatement') {
     return f.body;
   }

lib/lift.ts

@@ -1,5 +1,8 @@
 import { StaticExtractor } from './extractor.ts';
 import type * as acorn from 'acorn';
+import { analyzeBlock } from './internal/analyze/block.ts';
+import { reductifyFunction } from './internal/analyze/expression.ts';
+import { createBlock } from './internal/analyze/helper.ts';
 
 export function liftDefault(e: StaticExtractor, minSize: number) {
   const stats = {
@@ -10,6 +13,106 @@ export function liftDefault(e: StaticExtractor, minSize: number) {
     _skip: 0,
   };
 
+  // lift a subpath of a complex statement
+  const innerLiftMaybeBlock = (b: acorn.Statement | null | undefined, dirty: string[]) => {
+    if (!b) {
+      return;
+    }
+    if (b.type !== 'BlockStatement') {
+      if (b.type === 'VariableDeclaration') {
+        // only valid thing is 'if (1) var x = ...', nope nope nope
+        return;
+      }
+      b = createBlock(b); // treat as miniblock
+    } else {
+      const a = analyzeBlock(b, { nest: false });
+      const declaredHere: string[] = [];
+      a.vars.forEach((info, key) => {
+        if (info.local?.kind) {
+          declaredHere.push(key);
+        }
+      });
+      dirty = dirty.concat(declaredHere);
+    }
+
+    innerLift(b, dirty);
+  };
+
+  const innerLift = (b: acorn.BlockStatement, dirty: string[]) => {
+    const maybeLift = (expr: acorn.Expression | null | undefined, ok: () => void) => {
+      if (!expr) {
+        return;
+      }
+      const size = expr.end - expr.start;
+      if (size < minSize) {
+        return;
+      }
+      if (e.liftExpression(expr, dirty)) {
+        ok();
+      } else {
+        ++stats._skip;
+      }
+    };
+
+    for (const part of b.body) {
+      switch (part.type) {
+        case 'ExpressionStatement':
+          if (
+            part.expression.type === 'CallExpression' &&
+            (part.expression.callee.type === 'FunctionExpression' ||
+              part.expression.callee.type === 'ArrowFunctionExpression')
+          ) {
+            // IIFE
+            const r = reductifyFunction(part.expression.callee);
+            innerLiftMaybeBlock(r, dirty);
+          } else if (part.expression.type === 'AssignmentExpression') {
+            // find things on the right of "="
+            // this won't lift normally (the left part changes)
+            maybeLift(part.expression.right, () => stats.assignment++);
+          } else {
+            // try the whole thing? :shrug:
+            maybeLift(part.expression, () => stats.expr++);
+          }
+          continue;
+
+        case 'VariableDeclaration':
+          for (const decl of part.declarations) {
+            maybeLift(decl.init, () => stats.assignment++);
+          }
+          continue;
+
+        case 'ReturnStatement':
+          // why not? might be big
+          maybeLift(part.argument, () => stats.expr++);
+          continue;
+
+        // -- nested control statements below here
+
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+          innerLiftMaybeBlock(part.body, dirty);
+          break;
+
+        case 'IfStatement':
+          innerLiftMaybeBlock(part.consequent, dirty);
+          innerLiftMaybeBlock(part.alternate, dirty);
+          break;
+
+        case 'BlockStatement':
+          innerLiftMaybeBlock(part, dirty);
+          break;
+
+        case 'TryStatement':
+          innerLiftMaybeBlock(part.block, dirty);
+          // TODO: include handler (maybe declares var)
+          innerLiftMaybeBlock(part.finalizer, dirty);
+          break;
+
+        // TODO: include for/etc which can declare vars
+      }
+    }
+  };
+
   // lift top-level fn blocks
   for (const part of e.block.body) {
     const size = part.end - part.start;
@@ -37,46 +140,8 @@ export function liftDefault(e: StaticExtractor, minSize: number) {
     }
   }
 
-  // lift expressions in a few places (all top-level though?)
-  const maybeLift = (expr: acorn.Expression | null | undefined, ok: () => void) => {
-    if (!expr) {
-      return;
-    }
-    const size = expr.end - expr.start;
-    if (size < minSize) {
-      return;
-    }
-    if (e.liftExpression(expr)) {
-      ok();
-    } else {
-      ++stats._skip;
-    }
-  };
-  for (const part of e.block.body) {
-    switch (part.type) {
-      case 'ExpressionStatement':
-        if (part.expression.type === 'AssignmentExpression') {
-          // find things on the right of "="
-          // this won't lift normally (the left part changes)
-          maybeLift(part.expression.right, () => stats.assignment++);
-        } else {
-          // try the whole thing? :shrug:
-          maybeLift(part.expression, () => stats.expr++);
-        }
-        continue;
-
-      case 'VariableDeclaration':
-        for (const decl of part.declarations) {
-          maybeLift(decl.init, () => stats.assignment++);
-        }
-        continue;
-
-      case 'ReturnStatement':
-        // why not? might be big
-        maybeLift(part.argument, () => stats.expr++);
-        continue;
-    }
-  }
+  // follow top-level statements
+  innerLift(e.block, []);
 
   return stats;
 }

test/cases/iife.js

@@ -0,0 +1,13 @@
+(function (q) {
+  console.info('Kuto should extract this long statement', q);
+  something_long_call(123, 'hello there long');
+  foo.bar(q);
+})();
+
+if (1) {
+  var x = 123;
+  console.info('long statement that uses inner var', x);
+  console.info('long statement that is otherwise boring AF');
+}
+
+if (1) console.info('long thing that can be yeetyed');