@markw65/monkeyc-optimizer 1.0.6 → 1.0.7

package/build/api.cjs

@@ -40,12 +40,12 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "LiteralIntegerRe": () => (/* binding */ LiteralIntegerRe),
-  "collectNamespaces": () => (/* binding */ collectNamespaces),
+  "LiteralIntegerRe": () => (/* binding */ api_LiteralIntegerRe),
+  "collectNamespaces": () => (/* binding */ api_collectNamespaces),
   "formatAst": () => (/* binding */ formatAst),
-  "getApiMapping": () => (/* binding */ getApiMapping),
-  "hasProperty": () => (/* binding */ hasProperty),
-  "traverseAst": () => (/* binding */ traverseAst)
+  "getApiMapping": () => (/* binding */ api_getApiMapping),
+  "hasProperty": () => (/* binding */ api_hasProperty),
+  "traverseAst": () => (/* binding */ api_traverseAst)
 });
 
 ;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
@@ -112,6 +112,663 @@ const negativeFixups = [
   "Toybox.WatchUi.LAYOUT_HALIGN_LEFT",
 ];
 
+;// CONCATENATED MODULE: external "./api.cjs"
+const external_api_cjs_namespaceObject = require("./api.cjs");
+;// CONCATENATED MODULE: ./src/mc-rewrite.js
+
+
+
+
+
+function processImports(allImports, lookup) {
+  allImports.forEach(({ node, stack }) => {
+    const [name, module] = lookup(node.id, node.as && node.as.name, stack);
+    if (name && module) {
+      const [parent] = stack.slice(-1);
+      if (!parent.decls) parent.decls = {};
+      if (!hasProperty(parent.decls, name)) parent.decls[name] = [];
+      module.forEach((m) => {
+        if (m.type == "ModuleDeclaration") {
+          pushUnique(parent.decls[name], m);
+        }
+      });
+    }
+  });
+}
+
+function collectClassInfo(state) {
+  state.allClasses.forEach((elm) => {
+    if (elm.node.superClass) {
+      const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+      if (classes) {
+        elm.superClass = classes.filter((c) => c.type == "ClassDeclaration");
+      }
+      // set it "true" if there is a superClass, but we can't find it.
+      if (!elm.superClass || !elm.superClass.length) elm.superClass = true;
+    }
+  });
+
+  const markOverrides = (cls, scls) => {
+    if (scls === true) return;
+    scls.forEach((c) => {
+      c.decls &&
+        Object.values(c.decls).forEach((f) => {
+          if (f.type == "FunctionDeclaration") {
+            if (hasProperty(cls.decls, f.name)) {
+              f.hasOverride = true;
+            }
+          }
+        });
+      if (c.superClass) markOverrides(cls, c.superClass);
+    });
+  };
+
+  state.allClasses.forEach((elm) => {
+    if (elm.superClass) markOverrides(elm, elm.superClass);
+  });
+}
+
+async function analyze(fileNames, buildConfig) {
+  const excludeAnnotations =
+    buildConfig && buildConfig.excludeAnnotations
+      ? Object.fromEntries(buildConfig.excludeAnnotations.map((a) => [a, true]))
+      : {};
+
+  const allImports = [];
+  const state = {
+    allFunctions: [],
+    allClasses: [],
+    shouldExclude(node) {
+      if (node.attrs && node.attrs.attrs) {
+        if (
+          node.attrs.attrs.filter((attr) => {
+            if (attr.type != "UnaryExpression") return false;
+            if (attr.argument.type != "Identifier") return false;
+            return hasProperty(excludeAnnotations, attr.argument.name);
+          }).length
+        ) {
+          return true;
+        }
+      }
+    },
+    post(node) {
+      switch (node.type) {
+        case "FunctionDeclaration":
+        case "ClassDeclaration": {
+          const [scope] = state.stack.slice(-1);
+          const stack = state.stack.slice(0, -1);
+          scope.stack = stack;
+          (node.type == "FunctionDeclaration"
+            ? state.allFunctions
+            : state.allClasses
+          ).push(scope);
+          return;
+        }
+        case "Using":
+        case "ImportModule":
+          allImports.push({ node, stack: state.stack.slice() });
+          return;
+      }
+    },
+  };
+
+  await getApiMapping(state);
+
+  // Mark all functions from api.mir as "special" by
+  // setting their bodies to null. In api.mir, they're
+  // all empty, which makes it look like they're
+  // do-nothing functions.
+  const markApi = (node) => {
+    if (node.type == "FunctionDeclaration") {
+      node.node.body = null;
+    }
+    if (node.decls) {
+      Object.values(node.decls).forEach(markApi);
+    }
+  };
+  markApi(state.stack[0]);
+
+  const files = await Promise.all(
+    fileNames.map(async (name) => ({
+      name,
+      monkeyCSource: (await fs.readFile(name))
+        .toString()
+        .replace(/\r\n/g, "\n"),
+    }))
+  );
+
+  files.forEach((f) => {
+    f.ast = MonkeyC.parsers.monkeyc.parse(f.monkeyCSource, {
+      grammarSource: f.name,
+    });
+    f.ast.source = f.name;
+    f.ast.monkeyCSource = f.monkeyCSource;
+    delete f.monkeyCSource;
+    collectNamespaces(f.ast, state);
+  });
+
+  delete state.shouldExclude;
+  delete state.post;
+
+  processImports(allImports, state.lookup);
+  collectClassInfo(state);
+
+  return { files, state };
+}
+
+function getLiteralNode(node) {
+  if (Array.isArray(node)) {
+    if (!node.length) return null;
+    if (node.length === 1) return getLiteralNode(node[0]);
+    let result;
+    if (
+      node.every((n) => {
+        const lit = getLiteralNode(n);
+        if (!lit) return false;
+        if (!result) {
+          result = lit;
+        } else {
+          if (lit.value !== result.value) return false;
+        }
+        return true;
+      })
+    ) {
+      return result;
+    }
+    return null;
+  }
+  if (node.type == "Literal") return node;
+  if (node.type == "BinaryExpression" && node.operator == "as") {
+    return getLiteralNode(node.left) && node;
+  }
+  if (node.type == "UnaryExpression") {
+    if (node.argument.type != "Literal") return null;
+    switch (node.operator) {
+      case "-":
+        if (typeof node.argument.value == "number") {
+          return {
+            ...node.argument,
+            value: -node.argument.value,
+            raw: "-" + node.argument.value,
+            enumType: node.enumType,
+          };
+        }
+    }
+  }
+}
+
+function getNodeValue(node) {
+  if (
+    node.type == "BinaryExpression" &&
+    node.operator == "as" &&
+    node.right.type == "TypeSpecList" &&
+    node.right.ts.length == 1 &&
+    typeof node.right.ts[0] == "string"
+  ) {
+    // this is a cast we inserted to retain the type of an enum
+    // any arithmetic on it will revert to "Number", or "Long",
+    // so just ignore it.
+    return getNodeValue(node.left);
+  }
+  if (node.type != "Literal") {
+    return [null, null];
+  }
+  let type = node.value === null ? "Null" : typeof node.value;
+  if (type === "number") {
+    const match = LiteralIntegerRe.exec(node.raw);
+    if (match) {
+      type = match[2] == "l" ? "Long" : "Number";
+    } else if (node.raw.endsWith("d")) {
+      type = "Double";
+    } else {
+      type = "Float";
+    }
+  } else if (type === "string") {
+    type = "String";
+  } else if (type === "boolean") {
+    type = "Boolean";
+  } else {
+    type = "Unknown";
+  }
+  return [node, type];
+}
+
+function optimizeNode(node) {
+  switch (node.type) {
+    case "UnaryExpression": {
+      const [arg, type] = getNodeValue(node.argument);
+      if (arg === null) break;
+      switch (node.operator) {
+        case "+":
+          if (type === "Number" || type === "Long") {
+            return arg;
+          }
+          break;
+        case "-":
+          if (type === "Number" || type === "Long") {
+            return {
+              ...arg,
+              value: -arg.value,
+              raw: (-arg.value).toString() + (type === "Long" ? "l" : ""),
+            };
+          }
+          break;
+        case "!":
+        case "~":
+          {
+            let value;
+            if (type === "Number" || type === "Long") {
+              value = -arg.value - 1;
+            } else if (type === "Boolean" && node.operator == "!") {
+              value = !arg.value;
+            }
+            if (value !== undefined) {
+              return {
+                ...arg,
+                value,
+                raw: value.toString() + (type === "Long" ? "l" : ""),
+              };
+            }
+          }
+          break;
+      }
+      break;
+    }
+    case "BinaryExpression": {
+      const operators = {
+        "+": (left, right) => left + right,
+        "-": (left, right) => left - right,
+        "*": (left, right) => left * right,
+        "/": (left, right) => Math.trunc(left / right),
+        "%": (left, right) => left % right,
+        "&": (left, right, type) => (type === "Number" ? left & right : null),
+        "|": (left, right, type) => (type === "Number" ? left | right : null),
+        "<<": (left, right, type) => (type === "Number" ? left << right : null),
+        ">>": (left, right, type) => (type === "Number" ? left >> right : null),
+      };
+      const op = operators[node.operator];
+      if (op) {
+        const [left, left_type] = getNodeValue(node.left);
+        const [right, right_type] = getNodeValue(node.right);
+        if (!left || !right) break;
+        if (
+          left_type != right_type ||
+          (left_type != "Number" && left_type != "Long")
+        ) {
+          break;
+        }
+        const value = op(left.value, right.value, left_type);
+        if (value === null) break;
+        return {
+          ...left,
+          value,
+          raw: value.toString() + (left_type === "Long" ? "l" : ""),
+        };
+      }
+      break;
+    }
+    case "FunctionDeclaration":
+      if (node.body && evaluateFunction(node, null) !== false) {
+        node.optimizable = true;
+      }
+      break;
+  }
+}
+
+function evaluateFunction(func, args) {
+  if (args && args.length != func.params.length) {
+    return false;
+  }
+  const paramValues =
+    args && Object.fromEntries(func.params.map((p, i) => [p.name, args[i]]));
+  let ret = null;
+  const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+  try {
+    traverseAst(
+      body,
+      (node) => {
+        switch (node.type) {
+          case "BlockStatement":
+          case "ReturnStatement":
+          case "UnaryExpression":
+          case "BinaryExpression":
+          case "Literal":
+          case "Identifier":
+            return;
+          default:
+            throw new Error("Bad node type");
+        }
+      },
+      args &&
+        ((node) => {
+          switch (node.type) {
+            case "ReturnStatement":
+              ret = node.argument;
+              return;
+            case "BlockStatement":
+            case "Literal":
+              return;
+            case "Identifier":
+              if (hasProperty(paramValues, node.name)) {
+                return paramValues[node.name];
+              }
+            // fall through;
+            default: {
+              const repl = optimizeNode(node);
+              if (repl && repl.type === "Literal") return repl;
+              throw new Error("Didn't optimize");
+            }
+          }
+        })
+    );
+    return ret;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function optimizeMonkeyC(fileNames, buildConfig) {
+  const { files, state } = await analyze(fileNames, buildConfig);
+  const replace = (node, obj) => {
+    for (const k of Object.keys(node)) {
+      delete node[k];
+    }
+    if (obj.enumType) {
+      obj = {
+        type: "BinaryExpression",
+        operator: "as",
+        left: obj,
+        right: { type: "TypeSpecList", ts: [obj.enumType] },
+      };
+    }
+    for (const [k, v] of Object.entries(obj)) {
+      node[k] = v;
+    }
+  };
+  const lookupAndReplace = (node) => {
+    const [, objects] = state.lookup(node);
+    if (!objects) {
+      return false;
+    }
+    const obj = getLiteralNode(objects);
+    if (!obj) {
+      return false;
+    }
+    replace(node, obj);
+    return true;
+  };
+
+  /*
+   * Might this function be called from somewhere, including
+   * callbacks from the api (eg getSettingsView, etc).
+   */
+  const maybeCalled = (func) => {
+    if (!func.body) {
+      // this is an api.mir function. It can be called
+      return true;
+    }
+    if (hasProperty(state.exposed, func.id.name)) return true;
+    if (hasProperty(state.calledFunctions, func.id.name)) {
+      return (
+        state.calledFunctions[func.id.name].find((f) => f === func) !== null
+      );
+    }
+  };
+  /*
+   * Does elm (a class) have a maybeCalled function called name,
+   * anywhere in its superClass chain.
+   */
+  const checkInherited = (elm, name) =>
+    elm.superClass === true ||
+    elm.superClass.some(
+      (sc) =>
+        (hasProperty(sc.decls, name) &&
+          sc.decls[name].some(
+            (f) => f.type == "FunctionDeclaration" && maybeCalled(f)
+          )) ||
+        (sc.superClass && checkInherited(sc, name))
+    );
+
+  state.exposed = {};
+  state.calledFunctions = {};
+  state.pre = (node) => {
+    switch (node.type) {
+      case "ConditionalExpression":
+      case "IfStatement":
+      case "DoWhileStatement":
+      case "WhileStatement":
+        state.traverse(node.test);
+        const [value, type] = getNodeValue(node.test);
+        if (value) {
+          let result = null;
+          if (type === "Null") {
+            result = false;
+          } else if (
+            type === "Boolean" ||
+            type === "Number" ||
+            type === "Long"
+          ) {
+            result = !!value.value;
+          }
+          if (result !== null) {
+            if (
+              node.type === "IfStatement" ||
+              node.type === "ConditionalExpression"
+            ) {
+              if (result === false) {
+                node.consequent = null;
+              } else {
+                node.alternate = null;
+              }
+              node.test = result;
+            } else if (node.type === "WhileStatement") {
+              if (result === false) {
+                node.body = null;
+              }
+            } else if (node.type === "DoWhileStatement") {
+              if (result === false) {
+                node.test = null;
+              }
+            } else {
+              throw new Error("Unexpected Node type");
+            }
+          }
+        }
+        return;
+
+      case "EnumDeclaration":
+        return false;
+      case "VariableDeclarator":
+        return ["init"];
+      case "UnaryExpression":
+        if (node.operator == ":") {
+          // If we produce a Symbol, for a given name,
+          // its possible that someone uses that symbol
+          // indirectly, so we can't remove any enums or
+          // constants with that name (we can still replace
+          // uses of those constants though).
+          state.exposed[node.argument.name] = true;
+          // In any case, we can't replace *this* use of the
+          // symbol with its value...
+          return false;
+        }
+        break;
+      case "Identifier": {
+        if (hasProperty(state.index, node.name)) {
+          if (!lookupAndReplace(node)) {
+            state.exposed[node.name] = true;
+          }
+        }
+        return false;
+      }
+      case "MemberExpression":
+        if (node.property.type === "Identifier" && !node.computed) {
+          if (hasProperty(state.index, node.property.name)) {
+            if (lookupAndReplace(node)) {
+              return false;
+            } else {
+              state.exposed[node.property.name] = true;
+            }
+          }
+          // Don't optimize the property.
+          return ["object"];
+        }
+        break;
+      case "FunctionDeclaration": {
+        const [parent] = state.stack.slice(-2);
+        if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
+          let used = false;
+          if (node.id.name == "initialize") {
+            used = true;
+          } else if (parent.superClass) {
+            used = checkInherited(parent, node.id.name);
+          }
+          if (used) {
+            if (!hasProperty(state.calledFunctions, node.id.name)) {
+              state.calledFunctions[node.id.name] = [];
+            }
+            state.calledFunctions[node.id.name].push(node);
+          }
+        }
+      }
+    }
+  };
+  state.post = (node) => {
+    const opt = optimizeNode(node);
+    if (opt) {
+      replace(node, opt);
+      return;
+    }
+    switch (node.type) {
+      case "ConditionalExpression":
+      case "IfStatement":
+        if (typeof node.test === "boolean") {
+          const rep = node.test ? node.consequent : node.alternate;
+          if (!rep) return false;
+          replace(node, rep);
+        }
+        break;
+      case "WhileStatement":
+        if (!node.body) return false;
+        break;
+      case "DoWhileStatement":
+        if (!node.test) return node.body;
+        break;
+
+      case "CallExpression": {
+        const [name, callees] = state.lookup(node.callee);
+        if (!callees || !callees.length) {
+          const n =
+            name ||
+            node.callee.name ||
+            (node.callee.property && node.callee.property.name);
+          if (n) {
+            state.exposed[n] = true;
+          } else {
+            // There are unnamed CallExpressions, such as new [size]
+            // So there's nothing to do here.
+          }
+          return;
+        }
+        if (callees.length == 1) {
+          const callee = callees[0].node;
+          if (
+            callee.optimizable &&
+            !callee.hasOverride &&
+            node.arguments.every((n) => getNodeValue(n)[0] !== null)
+          ) {
+            const ret = evaluateFunction(callee, node.arguments);
+            if (ret) {
+              replace(node, ret);
+              return;
+            }
+          }
+        }
+        if (!hasProperty(state.calledFunctions, name)) {
+          state.calledFunctions[name] = [];
+        }
+        callees.forEach((c) => state.calledFunctions[name].push(c.node));
+        break;
+      }
+    }
+  };
+  files.forEach((f) => {
+    collectNamespaces(f.ast, state);
+  });
+  files.forEach((f) => {
+    traverseAst(f.ast, null, (node) => {
+      switch (node.type) {
+        case "EnumStringBody":
+          if (
+            node.members.every((m) => {
+              const name = m.name || m.id.name;
+              return (
+                hasProperty(state.index, name) &&
+                !hasProperty(state.exposed, name)
+              );
+            })
+          ) {
+            node.enumType = [
+              ...new Set(
+                node.members.map((m) => {
+                  if (!m.init) return "Number";
+                  const [node, type] = getNodeValue(m.init);
+                  if (!node) {
+                    throw new Error("Failed to get type for eliminated enum");
+                  }
+                  return type;
+                })
+              ),
+            ].join(" or ");
+            node.members.splice(0);
+          }
+          break;
+        case "EnumDeclaration":
+          if (!node.body.members.length) {
+            if (!node.id) return false;
+            if (!node.body.enumType) {
+              throw new Error("Missing enumType on optimized enum");
+            }
+            replace(node, {
+              type: "TypedefDeclaration",
+              id: node.id,
+              ts: {
+                type: "UnaryExpression",
+                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                prefix: true,
+                operator: " as",
+              },
+            });
+          }
+          break;
+        case "VariableDeclaration": {
+          node.declarations = node.declarations.filter(
+            (d) =>
+              !hasProperty(state.index, d.id.name) ||
+              hasProperty(state.exposed, d.id.name)
+          );
+          if (!node.declarations.length) {
+            return false;
+          }
+          break;
+        }
+        case "ClassElement":
+          if (!node.item) {
+            return false;
+          }
+          break;
+        case "FunctionDeclaration":
+          if (!maybeCalled(node)) {
+            return false;
+          }
+          break;
+      }
+    });
+  });
+
+  return files;
+}
+
 ;// CONCATENATED MODULE: ./src/api.js
 
 
@@ -119,7 +776,8 @@ const negativeFixups = [
 
 
 
-const LiteralIntegerRe = /^(0x[0-9a-f]+|\d+)(l)?$/;
+
+const api_LiteralIntegerRe = /^(0x[0-9a-f]+|\d+)(l)?$/;
 /*
  * This is an unfortunate hack. I want to be able to extract things
  * like the types of all of a Class's variables (in particular the type
@@ -131,7 +789,7 @@ const LiteralIntegerRe = /^(0x[0-9a-f]+|\d+)(l)?$/;
  */
 
 // Extract all enum values from api.mir
-async function getApiMapping(state) {
+async function api_getApiMapping(state) {
   // get the path to the currently active sdk
   const parser = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc;
 
@@ -145,7 +803,7 @@ async function getApiMapping(state) {
     .replace(/^(\s*type)\s/gm, "$1def ");
 
   try {
-    const result = collectNamespaces(parser.parse(api, {}), state);
+    const result = api_collectNamespaces(parser.parse(api, {}), state);
     negativeFixups.forEach((fixup) => {
       const value = fixup.split(".").reduce((state, part) => {
         const decls = state.decls[part];
@@ -170,18 +828,18 @@ async function getApiMapping(state) {
   }
 }
 
-function hasProperty(obj, prop) {
+function api_hasProperty(obj, prop) {
   return obj && Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-function collectNamespaces(ast, state) {
+function api_collectNamespaces(ast, state) {
   state = state || {};
   if (!state.index) state.index = {};
   if (!state.stack) {
     state.stack = [{ type: "Program", name: "$", fullName: "$" }];
   }
   const checkOne = (ns, name) => {
-    if (hasProperty(ns.decls, name)) {
+    if (api_hasProperty(ns.decls, name)) {
       return ns.decls[name];
     }
     return null;
@@ -219,7 +877,7 @@ function collectNamespaces(ast, state) {
   };
 
   state.traverse = (root) =>
-    traverseAst(
+    api_traverseAst(
       root,
       (node) => {
         try {
@@ -263,7 +921,7 @@ function collectNamespaces(ast, state) {
                   .join(".");
                 if (elm.name) {
                   if (!parent.decls) parent.decls = {};
-                  if (hasProperty(parent.decls, elm.name)) {
+                  if (api_hasProperty(parent.decls, elm.name)) {
                     const what =
                       node.type == "ModuleDeclaration" ? "type" : "node";
                     const e = parent.decls[elm.name].find(
@@ -296,7 +954,7 @@ function collectNamespaces(ast, state) {
             case "TypedefDeclaration": {
               const [parent] = state.stack.slice(-1);
               if (!parent.decls) parent.decls = {};
-              if (!hasProperty(parent.decls, node.id.name)) {
+              if (!api_hasProperty(parent.decls, node.id.name)) {
                 parent.decls[node.id.name] = [];
               }
               (0,external_util_cjs_namespaceObject.pushUnique)(
@@ -309,12 +967,12 @@ function collectNamespaces(ast, state) {
               const [parent] = state.stack.slice(-1);
               if (!parent.decls) parent.decls = {};
               node.declarations.forEach((decl) => {
-                if (!hasProperty(parent.decls, decl.id.name)) {
+                if (!api_hasProperty(parent.decls, decl.id.name)) {
                   parent.decls[decl.id.name] = [];
                 }
                 if (node.kind == "const") {
                   (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[decl.id.name], decl.init);
-                  if (!hasProperty(state.index, decl.id.name)) {
+                  if (!api_hasProperty(state.index, decl.id.name)) {
                     state.index[decl.id.name] = [];
                   }
                   (0,external_util_cjs_namespaceObject.pushUnique)(state.index[decl.id.name], parent);
@@ -335,10 +993,16 @@ function collectNamespaces(ast, state) {
                 let name, init;
                 if (m.type == "EnumStringMember") {
                   name = m.id.name;
-                  init = m.init;
+                  init = getLiteralNode(m.init);
+                  if (!init) {
+                    throw new Error("Unexpected enum initializer");
+                  }
+                  if (init != m.init) {
+                    m.init = init;
+                  }
                   if (
                     init.type == "Literal" &&
-                    LiteralIntegerRe.test(init.raw)
+                    api_LiteralIntegerRe.test(init.raw)
                   ) {
                     prev = init.value;
                   }
@@ -359,11 +1023,11 @@ function collectNamespaces(ast, state) {
                     };
                   }
                 }
-                if (!hasProperty(values, name)) {
+                if (!api_hasProperty(values, name)) {
                   values[name] = [];
                 }
                 (0,external_util_cjs_namespaceObject.pushUnique)(values[name], init);
-                if (!hasProperty(state.index, name)) {
+                if (!api_hasProperty(state.index, name)) {
                   state.index[name] = [];
                 }
                 (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
@@ -413,7 +1077,7 @@ function collectNamespaces(ast, state) {
  *  - if post returns false, the node it was called on is
  *    removed.
  */
-function traverseAst(node, pre, post) {
+function api_traverseAst(node, pre, post) {
   const nodes = pre && pre(node);
   if (nodes === false) return;
   for (const key of nodes || Object.keys(node)) {
@@ -421,7 +1085,7 @@ function traverseAst(node, pre, post) {
     if (!value) continue;
     if (Array.isArray(value)) {
       const deletions = value.reduce((state, obj, i) => {
-        const repl = traverseAst(obj, pre, post);
+        const repl = api_traverseAst(obj, pre, post);
         if (repl === false) {
           if (!state) state = {};
           state[i] = true;
@@ -438,7 +1102,7 @@ function traverseAst(node, pre, post) {
         );
       }
     } else if (typeof value == "object" && value.type) {
-      const repl = traverseAst(value, pre, post);
+      const repl = api_traverseAst(value, pre, post);
       if (repl === false) {
         delete node[key];
       } else if (repl != null) {