@markw65/monkeyc-optimizer 1.0.2 → 1.0.6

package/README.md

@@ -18,4 +18,24 @@ 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`
+
+### 1.0.4
+
+- Fix a bug resulting in a failure to fully optimize constants initialized by constant conditional expressions
+- Make the generated .cjs files work better with es modules (vscode doesn't work with es modules, so prettier-extension-monkeyc doesn't care - but for other projects importing this package it improves the behavior)
+- Generate separate debug/release jungle files.
+
+### 1.0.5
+
+- Bump to version 1.0.11 of `@markw65/prettier-plugin-monkeyc` to fix an ObjectLiteral parsing issue.
+
+### 1.0.6
+
+- Bump to version 1.0.12 of `@markw65/prettier-plugin-monkeyc` to fix multiple parser bugs
+- Add lots of open source projects as tests. For now, just verify that optimizing the sources succeeds, not that the generated source is actually correct.
+
 ---

package/build/api.cjs

@@ -1,3 +1,4 @@
+0 && (module.exports = {LiteralIntegerRe,getApiMapping,hasProperty,collectNamespaces,traverseAst,formatAst});
 /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	// The require scope
@@ -217,169 +218,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

@@ -1,3 +1,4 @@
+0 && (module.exports = {copyRecursiveAsNeeded,launchSimulator,defaultConfig,buildOptimizedProject,generateOptimizedProject,generateApiMirTests});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -7439,6 +7440,7 @@ function resolve_node(state, node) {
 }
 
 function resolve_filename(literal, default_source) {
+  if (typeof literal === "string") return literal;
   const root = external_path_namespaceObject.dirname(literal.source || default_source);
   return external_path_namespaceObject.resolve(root, literal.value);
 }
@@ -7479,10 +7481,14 @@ async function resolve_literals(qualifier, default_source) {
   await resolve_one_file_list(qualifier, "resourcePath");
   await resolve_one_file_list(qualifier, "barrelPath");
   const lang = qualifier["lang"];
-  await Promise.all(
-    Object.keys(lang).map((key) => resolve_one_file_list(lang, key))
-  );
-  if (Object.keys(lang).length === 0) delete qualifier["lang"];
+  if (lang) {
+    await Promise.all(
+      Object.keys(lang).map((key) => resolve_one_file_list(lang, key))
+    );
+    if (Object.keys(lang).length === 0) delete qualifier["lang"];
+  } else {
+    delete qualifier["lang"];
+  }
 
   const resolve_literal_list = (base, name) => {
     const literals = base[name];
@@ -7634,7 +7640,7 @@ const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugi
 
 function processImports(allImports, lookup) {
   allImports.forEach(({ node, stack }) => {
-    const [name, module] = lookup(node.id, node.as && node.as.id.name, 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 = {};
@@ -7685,34 +7691,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 +7764,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 +8050,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":
@@ -8088,6 +8127,8 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
               state.exposed[node.name] = true;
             }
           }
+          // Don't optimize the property.
+          return ["object"];
         }
         break;
       case "FunctionDeclaration": {
@@ -8115,38 +8156,56 @@ 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;
+          if (!rep) return false;
+          replace(node, rep);
         }
-        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 +8307,7 @@ async function getVSCodeSettings(path) {
 }
 
 const defaultConfig = {
-  outputPath: "optimized",
+  outputPath: "bin/optimized",
   workspace: "./",
 };
 
@@ -8287,6 +8346,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 +8360,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 +8372,21 @@ 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;
+      if (p.group.optimizerConfig["excludeAnnotations"] == null) {
+        p.group.optimizerConfig["excludeAnnotations"] = [];
+      }
+      // 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 +8426,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);
@@ -8372,7 +8440,10 @@ async function generateOptimizedProject(options) {
     }
   });
 
-  const jungleFiles = external_path_namespaceObject.join(jungle_dir, "monkey.jungle");
+  const jungleFiles = external_path_namespaceObject.join(
+    jungle_dir,
+    `${config.releaseBuild ? "release" : "debug"}.jungle`
+  );
   promises.push(promises_namespaceObject.writeFile(jungleFiles, parts.join("\n")));
   await Promise.all(promises);
   return { jungleFiles, program: external_path_namespaceObject.basename(external_path_namespaceObject.dirname(manifest)) };

package/build/util.cjs

@@ -1,3 +1,4 @@
+0 && (module.exports = {isWin,appSupport,connectiq,getSdkPath,globa,last_modified,first_modified,pushUnique,spawnByLine,readByLine,promiseAll,copyRecursiveAsNeeded});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "exports": {
@@ -23,7 +23,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.10"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.12"
   },
   "devDependencies": {
     "eslint": "^8.12.0",