@markw65/monkeyc-optimizer 1.0.2 → 1.0.3

package/README.md

@@ -18,4 +18,9 @@ Initial release
 - Better error reporting when something goes wrong internally
 - Fix an order dependency when processing imports. Previously, if the import statement was seen before the module being imported, we would fail to properly handle the import.
 
+### 1.0.3
+
+- Split the build into release and debug, so we can exclude code based on (:release) and (:debug)
+- Optimize away `if (constant)`, `while (false)` and `constant ? E1 : E2`. Convert `do BODY while(false)` to `BODY`
+
 ---

package/build/api.cjs

@@ -217,169 +217,182 @@ function collectNamespaces(ast, state) {
     return [null, null];
   };
 
-  traverseAst(
-    ast,
-    (node) => {
-      try {
-        switch (node.type) {
-          case "Program":
-            if (state.stack.length != 1) {
-              throw new Error("Unexpected stack length for Program node");
-            }
-            if (node.source) {
-              state.stack[0].source = node.source;
-            }
-            break;
-          case "BlockStatement": {
-            const [parent] = state.stack.slice(-1);
-            if (
-              parent.type != "FunctionDeclaration" &&
-              parent.type != "BlockStatement"
-            ) {
-              break;
-            }
-            // fall through
+  state.traverse = (root) =>
+    traverseAst(
+      root,
+      (node) => {
+        try {
+          if (state.shouldExclude && state.shouldExclude(node)) {
+            // don't visit any children, but do call post
+            return [];
           }
-          case "ClassDeclaration":
-          case "FunctionDeclaration":
-          case "ModuleDeclaration":
-            if (node.id || node.type == "BlockStatement") {
+          switch (node.type) {
+            case "Program":
+              if (state.stack.length != 1) {
+                throw new Error("Unexpected stack length for Program node");
+              }
+              if (node.source) {
+                state.stack[0].source = node.source;
+              }
+              break;
+            case "BlockStatement": {
               const [parent] = state.stack.slice(-1);
-              const elm = {
-                type: node.type,
-                name: node.id && node.id.name,
-                node,
-              };
-              state.stack.push(elm);
-              elm.fullName = state.stack
-                .map((e) => e.name)
-                .filter((e) => e != null)
-                .join(".");
-              if (elm.name) {
-                if (!parent.decls) parent.decls = {};
-                if (hasProperty(parent.decls, elm.name)) {
-                  const what =
-                    node.type == "ModuleDeclaration" ? "type" : "node";
-                  const e = parent.decls[elm.name].find(
-                    (d) => d[what] == elm[what]
-                  );
-                  if (e != null) {
-                    e.node = node;
-                    state.stack.splice(-1, 1, e);
-                    break;
+              if (
+                parent.type != "FunctionDeclaration" &&
+                parent.type != "BlockStatement"
+              ) {
+                break;
+              }
+              // fall through
+            }
+            case "ClassDeclaration":
+            case "FunctionDeclaration":
+            case "ModuleDeclaration":
+              if (node.id || node.type == "BlockStatement") {
+                const [parent] = state.stack.slice(-1);
+                const elm = {
+                  type: node.type,
+                  name: node.id && node.id.name,
+                  node,
+                };
+                state.stack.push(elm);
+                elm.fullName = state.stack
+                  .map((e) => e.name)
+                  .filter((e) => e != null)
+                  .join(".");
+                if (elm.name) {
+                  if (!parent.decls) parent.decls = {};
+                  if (hasProperty(parent.decls, elm.name)) {
+                    const what =
+                      node.type == "ModuleDeclaration" ? "type" : "node";
+                    const e = parent.decls[elm.name].find(
+                      (d) => d[what] == elm[what]
+                    );
+                    if (e != null) {
+                      e.node = node;
+                      state.stack.splice(-1, 1, e);
+                      break;
+                    }
+                  } else {
+                    parent.decls[elm.name] = [];
                   }
-                } else {
-                  parent.decls[elm.name] = [];
+                  parent.decls[elm.name].push(elm);
                 }
-                parent.decls[elm.name].push(elm);
               }
+              break;
+            // an EnumDeclaration doesn't create a scope, but
+            // it does create a type (if it has a name)
+            case "EnumDeclaration": {
+              if (!node.id) break;
+              const [parent] = state.stack.slice(-1);
+              const name = (parent.fullName + "." + node.id.name).replace(
+                /^\$\./,
+                ""
+              );
+              node.body.members.forEach((m) => ((m.init || m).enumType = name));
             }
-            break;
-          // an EnumDeclaration doesn't create a scope, but
-          // it does create a type (if it has a name)
-          case "EnumDeclaration": {
-            if (!node.id) break;
-            const [parent] = state.stack.slice(-1);
-            const name = (parent.fullName + "." + node.id.name).replace(
-              /^\$\./,
-              ""
-            );
-            node.body.members.forEach((m) => ((m.init || m).enumType = name));
-          }
-          // fall through
-          case "TypedefDeclaration": {
-            const [parent] = state.stack.slice(-1);
-            if (!parent.decls) parent.decls = {};
-            if (!hasProperty(parent.decls, node.id.name)) {
-              parent.decls[node.id.name] = [];
-            }
-            (0,external_util_cjs_namespaceObject.pushUnique)(
-              parent.decls[node.id.name],
-              node.ts ? formatAst(node.ts.argument) : node.id.name
-            );
-            break;
-          }
-          case "VariableDeclaration": {
-            const [parent] = state.stack.slice(-1);
-            if (!parent.decls) parent.decls = {};
-            node.declarations.forEach((decl) => {
-              if (!hasProperty(parent.decls, decl.id.name)) {
-                parent.decls[decl.id.name] = [];
+            // fall through
+            case "TypedefDeclaration": {
+              const [parent] = state.stack.slice(-1);
+              if (!parent.decls) parent.decls = {};
+              if (!hasProperty(parent.decls, node.id.name)) {
+                parent.decls[node.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)) {
-                  state.index[decl.id.name] = [];
+              (0,external_util_cjs_namespaceObject.pushUnique)(
+                parent.decls[node.id.name],
+                node.ts ? formatAst(node.ts.argument) : node.id.name
+              );
+              break;
+            }
+            case "VariableDeclaration": {
+              const [parent] = state.stack.slice(-1);
+              if (!parent.decls) parent.decls = {};
+              node.declarations.forEach((decl) => {
+                if (!hasProperty(parent.decls, decl.id.name)) {
+                  parent.decls[decl.id.name] = [];
                 }
-                (0,external_util_cjs_namespaceObject.pushUnique)(state.index[decl.id.name], parent);
-              } else if (decl.id.ts) {
-                (0,external_util_cjs_namespaceObject.pushUnique)(
-                  parent.decls[decl.id.name],
-                  formatAst(decl.id.ts.argument)
-                );
-              }
-            });
-            break;
-          }
-          case "EnumStringBody": {
-            const [parent] = state.stack.slice(-1);
-            const values = parent.decls || (parent.decls = {});
-            let prev = -1;
-            node.members.forEach((m) => {
-              let name, init;
-              if (m.type == "EnumStringMember") {
-                name = m.id.name;
-                init = m.init;
-                if (init.type == "Literal" && LiteralIntegerRe.test(init.raw)) {
-                  prev = init.value;
+                if (node.kind == "const") {
+                  (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[decl.id.name], decl.init);
+                  if (!hasProperty(state.index, decl.id.name)) {
+                    state.index[decl.id.name] = [];
+                  }
+                  (0,external_util_cjs_namespaceObject.pushUnique)(state.index[decl.id.name], parent);
+                } else if (decl.id.ts) {
+                  (0,external_util_cjs_namespaceObject.pushUnique)(
+                    parent.decls[decl.id.name],
+                    formatAst(decl.id.ts.argument)
+                  );
                 }
-              } else {
-                name = m.name;
-                prev += 1;
-                if (!state.constants) {
-                  state.constants = {};
+              });
+              break;
+            }
+            case "EnumStringBody": {
+              const [parent] = state.stack.slice(-1);
+              const values = parent.decls || (parent.decls = {});
+              let prev = -1;
+              node.members.forEach((m) => {
+                let name, init;
+                if (m.type == "EnumStringMember") {
+                  name = m.id.name;
+                  init = m.init;
+                  if (
+                    init.type == "Literal" &&
+                    LiteralIntegerRe.test(init.raw)
+                  ) {
+                    prev = init.value;
+                  }
+                } else {
+                  name = m.name;
+                  prev += 1;
+                  if (!state.constants) {
+                    state.constants = {};
+                  }
+                  const key = m.enumType ? `${m.enumType}:${prev}` : prev;
+                  init = state.constants[key];
+                  if (!init) {
+                    init = state.constants[key] = {
+                      type: "Literal",
+                      value: prev,
+                      raw: prev.toString(),
+                      enumType: m.enumType,
+                    };
+                  }
                 }
-                const key = m.enumType ? `${m.enumType}:${prev}` : prev;
-                init = state.constants[key];
-                if (!init) {
-                  init = state.constants[key] = {
-                    type: "Literal",
-                    value: prev,
-                    raw: prev.toString(),
-                    enumType: m.enumType,
-                  };
+                if (!hasProperty(values, name)) {
+                  values[name] = [];
                 }
-              }
-              if (!hasProperty(values, name)) {
-                values[name] = [];
-              }
-              (0,external_util_cjs_namespaceObject.pushUnique)(values[name], init);
-              if (!hasProperty(state.index, name)) {
-                state.index[name] = [];
-              }
-              (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
-            });
-            break;
+                (0,external_util_cjs_namespaceObject.pushUnique)(values[name], init);
+                if (!hasProperty(state.index, name)) {
+                  state.index[name] = [];
+                }
+                (0,external_util_cjs_namespaceObject.pushUnique)(state.index[name], parent);
+              });
+              break;
+            }
           }
+          if (state.pre) return state.pre(node);
+        } catch (e) {
+          handleException(state, node, e);
         }
-        if (state.pre) return state.pre(node);
-      } catch (e) {
-        handleException(state, node, e);
-      }
-    },
-    (node) => {
-      try {
-        let ret;
-        if (state.post) ret = state.post(node);
-        if (state.stack.slice(-1).pop().node === node) {
-          state.stack.pop();
+      },
+      (node) => {
+        try {
+          let ret;
+          if (state.shouldExclude && state.shouldExclude(node)) {
+            // delete the node.
+            return false;
+          }
+          if (state.post) ret = state.post(node);
+          if (state.stack.slice(-1).pop().node === node) {
+            state.stack.pop();
+          }
+          return ret;
+        } catch (e) {
+          handleException(state, node, e);
         }
-        return ret;
-      } catch (e) {
-        handleException(state, node, e);
       }
-    }
-  );
+    );
+  state.traverse(ast);
   if (state.stack.length != 1) {
     throw new Error("Invalid AST!");
   }

package/build/optimizer.cjs

@@ -7685,34 +7685,24 @@ async function analyze(fileNames, buildConfig) {
       ? Object.fromEntries(buildConfig.excludeAnnotations.map((a) => [a, true]))
       : {};
 
-  const 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 (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name);
-        }).length
-      ) {
-        return true;
-      }
-    }
-  };
   const allImports = [];
   const state = {
     allFunctions: [],
     allClasses: [],
-    pre(node) {
-      if (shouldExclude(node)) {
-        // don't visit any children, but do call post
-        return [];
+    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 (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name);
+          }).length
+        ) {
+          return true;
+        }
       }
     },
     post(node) {
-      if (shouldExclude(node)) {
-        // delete the node.
-        return false;
-      }
       switch (node.type) {
         case "FunctionDeclaration":
         case "ClassDeclaration": {
@@ -7768,7 +7758,7 @@ async function analyze(fileNames, buildConfig) {
     (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
   });
 
-  delete state.pre;
+  delete state.shouldExclude;
   delete state.post;
 
   processImports(allImports, state.lookup);
@@ -8054,6 +8044,49 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
   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":
@@ -8115,38 +8148,55 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
       replace(node, opt);
       return;
     }
-    if (node.type == "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 {
-          throw new Error("What?");
+    switch (node.type) {
+      case "ConditionalExpression":
+      case "IfStatement":
+        if (typeof node.test === "boolean") {
+          const rep = node.test ? node.consequent : node.alternate;
+          return rep || false;
         }
-        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;
+        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 {
+            throw new Error("What?");
           }
+          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 (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
+          state.calledFunctions[name] = [];
+        }
+        callees.forEach((c) => state.calledFunctions[name].push(c.node));
+        break;
       }
-      if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
-        state.calledFunctions[name] = [];
-      }
-      callees.forEach((c) => state.calledFunctions[name].push(c.node));
     }
   };
   files.forEach((f) => {
@@ -8248,7 +8298,7 @@ async function getVSCodeSettings(path) {
 }
 
 const defaultConfig = {
-  outputPath: "optimized",
+  outputPath: "bin/optimized",
   workspace: "./",
 };
 
@@ -8287,6 +8337,8 @@ async function buildOptimizedProject(product, options) {
   const config = await getConfig(options);
   if (product) {
     config.products = [product];
+  } else if (!(0,external_api_cjs_namespaceObject.hasProperty)(config, "releaseBuild")) {
+    config.releaseBuild = true;
   }
   const { jungleFiles, program } = await generateOptimizedProject(config);
   config.jungleFiles = jungleFiles;
@@ -8299,9 +8351,6 @@ async function buildOptimizedProject(product, options) {
   } else {
     bin = external_path_namespaceObject.join(bin, "exported");
     name = `${program}.iq`;
-    if (!(0,external_api_cjs_namespaceObject.hasProperty)(config, "releaseBuild")) {
-      config.releaseBuild = true;
-    }
   }
   config.program = external_path_namespaceObject.join(bin, name);
   return build_project(product, config);
@@ -8314,11 +8363,18 @@ async function generateOptimizedProject(options) {
   const { manifest, targets } = await get_jungle(config.jungleFiles, config);
   const buildConfigs = {};
   targets.forEach((p) => {
-    if (!(0,external_api_cjs_namespaceObject.hasProperty)(buildConfigs, p.group.key)) {
-      buildConfigs[p.group.key] = null;
+    const key = p.group.key + (config.releaseBuild ? "-release" : "-debug");
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(buildConfigs, key)) {
+      p.group.dir = key;
+      buildConfigs[key] = null;
+      // Note that we exclude (:debug) in release builds, and we
+      // exclude (:release) in debug builds. This isn't backwards!
+      p.group.optimizerConfig["excludeAnnotations"].push(
+        config.releaseBuild ? "debug" : "release"
+      );
     }
     if (!options.products || options.products.includes(p.product)) {
-      buildConfigs[p.group.key] = p.group.optimizerConfig;
+      buildConfigs[key] = p.group.optimizerConfig;
     }
   });
 
@@ -8358,7 +8414,7 @@ async function generateOptimizedProject(options) {
     const { product, qualifier, group } = jungle;
     const prefix = `${product}.`;
     process_field(prefix, qualifier, "sourcePath", (s) =>
-      external_path_namespaceObject.join(group.key.toString(), external_path_namespaceObject.relative(workspace, s))
+      external_path_namespaceObject.join(group.dir, external_path_namespaceObject.relative(workspace, s))
         .replace(/(\/\*\*)\/\*/g, "$1")
     );
     process_field(prefix, qualifier, "resourcePath", relative_path);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "exports": {