@markw65/monkeyc-optimizer 1.0.0 → 1.0.3

package/README.md

@@ -8,4 +8,19 @@ This module is a set of utilities for optimizing Garmin Monkey-C code. Its the e
 
 Initial release
 
+#### 1.0.1
+
+- Make a better attempt to fix all the negative constants in api.mir
+- Make export explicitly do a release build by default.
+
+#### 1.0.2
+
+- 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

@@ -0,0 +1,500 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "LiteralIntegerRe": () => (/* binding */ LiteralIntegerRe),
+  "collectNamespaces": () => (/* binding */ collectNamespaces),
+  "formatAst": () => (/* binding */ formatAst),
+  "getApiMapping": () => (/* binding */ getApiMapping),
+  "hasProperty": () => (/* binding */ hasProperty),
+  "traverseAst": () => (/* binding */ traverseAst)
+});
+
+;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
+const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
+;// CONCATENATED MODULE: external "fs/promises"
+const promises_namespaceObject = require("fs/promises");
+;// CONCATENATED MODULE: external "prettier/standalone.js"
+const standalone_js_namespaceObject = require("prettier/standalone.js");
+;// CONCATENATED MODULE: external "./util.cjs"
+const external_util_cjs_namespaceObject = require("./util.cjs");
+;// CONCATENATED MODULE: ./src/negative-fixups.js
+/*
+ * This is strange. It pretty much has to be a bug in the sdk,
+ * but its the same in every sdk.
+ *
+ * ${sdk}/bin/api.mir describes the Toybox api down to every module,
+ * class, function, enum and constant, together with the enum
+ * and constant values.
+ *
+ * The problem is that every enum or constant with a negative
+ * value, appears with the corresponding positive value in api.mir.
+ * So eg Graphics.COLOR_TRANSPARENT should be -1, but instead, it has
+ * the value 1.
+ *
+ * This is a (currently somewhat ad-hoc) list of the negative constants
+ * so we can fix them after reading api.mir.
+ */
+const negativeFixups = [
+  "Toybox.Communications.BLE_CONNECTION_UNAVAILABLE",
+  "Toybox.Communications.INVALID_HTTP_BODY_IN_REQUEST",
+  "Toybox.Communications.REQUEST_CANCELLED",
+  "Toybox.Communications.UNSUPPORTED_CONTENT_TYPE_IN_RESPONSE",
+  "Toybox.Communications.UNABLE_TO_PROCESS_IMAGE",
+  "Toybox.Communications.NETWORK_RESPONSE_OUT_OF_MEMORY",
+  "Toybox.Communications.BLE_REQUEST_CANCELLED",
+  "Toybox.Communications.INVALID_HTTP_METHOD_IN_REQUEST",
+  "Toybox.Communications.BLE_NO_DATA",
+  "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_REQUEST",
+  "Toybox.Communications.BLE_ERROR",
+  "Toybox.Communications.NETWORK_RESPONSE_TOO_LARGE",
+  "Toybox.Communications.INVALID_HTTP_BODY_IN_NETWORK_RESPONSE",
+  "Toybox.Communications.BLE_REQUEST_TOO_LARGE",
+  "Toybox.Communications.UNABLE_TO_PROCESS_MEDIA",
+  "Toybox.Communications.REQUEST_CONNECTION_DROPPED",
+  "Toybox.Communications.BLE_UNKNOWN_SEND_ERROR",
+  "Toybox.Communications.BLE_QUEUE_FULL",
+  "Toybox.Communications.STORAGE_FULL",
+  "Toybox.Communications.BLE_SERVER_TIMEOUT",
+  "Toybox.Communications.INVALID_HTTP_HEADER_FIELDS_IN_NETWORK_RESPONSE",
+  "Toybox.Communications.SECURE_CONNECTION_REQUIRED",
+  "Toybox.Communications.NETWORK_REQUEST_TIMED_OUT",
+  "Toybox.Communications.BLE_HOST_TIMEOUT",
+  "Toybox.Communications.UNABLE_TO_PROCESS_HLS",
+  "Toybox.Graphics.COLOR_TRANSPARENT",
+  "Toybox.AntPlus.INVALID_SPEED",
+  "Toybox.AntPlus.INVALID_CADENCE",
+  "Toybox.WatchUi.LAYOUT_VALIGN_START",
+  "Toybox.WatchUi.LAYOUT_VALIGN_TOP",
+  "Toybox.WatchUi.LAYOUT_VALIGN_BOTTOM",
+  "Toybox.WatchUi.LAYOUT_VALIGN_CENTER",
+  "Toybox.WatchUi.LAYOUT_HALIGN_RIGHT",
+  "Toybox.WatchUi.LAYOUT_HALIGN_CENTER",
+  "Toybox.WatchUi.LAYOUT_HALIGN_START",
+  "Toybox.WatchUi.LAYOUT_HALIGN_LEFT",
+];
+
+;// CONCATENATED MODULE: ./src/api.js
+
+
+
+
+
+
+const 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
+ * of each member of Activity.Info), and also map things like enum names
+ * to their values (eg to take font names, and color names to their values).
+ * The only place I can find this information is in api.mir, which is totally
+ * undocumented. The same could be said of compiler.json and simulator.json,
+ * but those are at least in a standard format.
+ */
+
+// Extract all enum values from api.mir
+async function getApiMapping(state) {
+  // get the path to the currently active sdk
+  const parser = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc;
+
+  const sdk = await (0,external_util_cjs_namespaceObject.getSdkPath)();
+
+  const api = (await promises_namespaceObject.readFile(`${sdk}bin/api.mir`))
+    .toString()
+    .replace(/\r\n/g, "\n")
+    .replace(/^\s*\[.*?\]\s*$/gm, "")
+    //.replace(/(COLOR_TRANSPARENT|LAYOUT_[HV]ALIGN_\w+) = (\d+)/gm, "$1 = -$2")
+    .replace(/^(\s*type)\s/gm, "$1def ");
+
+  try {
+    const result = collectNamespaces(parser.parse(api, {}), state);
+    negativeFixups.forEach((fixup) => {
+      const value = fixup.split(".").reduce((state, part) => {
+        const decls = state.decls[part];
+        if (!Array.isArray(decls) || decls.length != 1 || !decls[0]) {
+          throw `Failed to find and fix negative constant ${fixup}`;
+        }
+        return decls[0];
+      }, result);
+      if (value.type != "Literal") {
+        throw `Negative constant ${fixup} was not a Literal`;
+      }
+      if (value.value > 0) {
+        value.value = -value.value;
+        value.raw = "-" + value.raw;
+      } else {
+        console.log(`Negative fixup ${fixup} was already negative!`);
+      }
+    });
+    return result;
+  } catch (e) {
+    console.error(e.toString());
+  }
+}
+
+function hasProperty(obj, prop) {
+  return obj && Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+function 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)) {
+      return ns.decls[name];
+    }
+    return null;
+  };
+  state.lookup = (node, name, stack) => {
+    stack || (stack = state.stack);
+    switch (node.type) {
+      case "MemberExpression": {
+        if (node.property.type != "Identifier" || node.computed) break;
+        const [, module] = state.lookup(node.object, name, stack);
+        if (module && module.length === 1) {
+          const result = checkOne(module[0], node.property.name);
+          if (result) {
+            return [name || node.property.name, result];
+          }
+        }
+        break;
+      }
+      case "ThisExpression":
+        return [name, stack.slice(-1)];
+      case "Identifier": {
+        if (node.name == "$") {
+          return [name || node.name, [stack[0]]];
+        }
+        for (let i = stack.length; i--; ) {
+          const result = checkOne(stack[i], node.name);
+          if (result) {
+            return [name || node.name, result];
+          }
+        }
+        break;
+      }
+    }
+    return [null, null];
+  };
+
+  state.traverse = (root) =>
+    traverseAst(
+      root,
+      (node) => {
+        try {
+          if (state.shouldExclude && state.shouldExclude(node)) {
+            // don't visit any children, but do call post
+            return [];
+          }
+          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
+            }
+            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] = [];
+                  }
+                  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));
+            }
+            // 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] = [];
+                }
+                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)
+                  );
+                }
+              });
+              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,
+                    };
+                  }
+                }
+                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;
+            }
+          }
+          if (state.pre) return state.pre(node);
+        } catch (e) {
+          handleException(state, node, e);
+        }
+      },
+      (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);
+        }
+      }
+    );
+  state.traverse(ast);
+  if (state.stack.length != 1) {
+    throw new Error("Invalid AST!");
+  }
+  return state.stack[0];
+}
+
+/*
+ * Traverse the ast rooted at node, calling pre before
+ * visiting each node, and post after.
+ *
+ *  - if pre returns false, the node is not traversed, and
+ *    post is not called;
+ *  - if pre returns a list of child nodes, only those will
+ *    be traversed
+ *  - otherwise all child nodes are traversed
+ *
+ *  - if post returns false, the node it was called on is
+ *    removed.
+ */
+function traverseAst(node, pre, post) {
+  const nodes = pre && pre(node);
+  if (nodes === false) return;
+  for (const key of nodes || Object.keys(node)) {
+    const value = node[key];
+    if (!value) continue;
+    if (Array.isArray(value)) {
+      const deletions = value.reduce((state, obj, i) => {
+        const repl = traverseAst(obj, pre, post);
+        if (repl === false) {
+          if (!state) state = {};
+          state[i] = true;
+        } else if (repl != null) {
+          value[i] = repl;
+        }
+        return state;
+      }, null);
+      if (deletions) {
+        value.splice(
+          0,
+          value.length,
+          ...value.filter((obj, i) => deletions[i] !== true)
+        );
+      }
+    } else if (typeof value == "object" && value.type) {
+      const repl = traverseAst(value, pre, post);
+      if (repl === false) {
+        delete node[key];
+      } else if (repl != null) {
+        node[key] = repl;
+      }
+    }
+  }
+  return post && post(node);
+}
+
+function formatAst(node, options) {
+  if (!node.monkeyCSource && node.comments) {
+    // Prettier inserts comments by using the source location to
+    // find the original comment, rather than using the contents
+    // of the comment as reported by the comment nodes themselves.
+    // If all we've got is the ast, rather than the actual
+    // source code, this goes horribly wrong, so just drop all
+    // the comments.
+    delete node.comments;
+  }
+  // If we *do* have the original source, pass that in ahead of the
+  // json. The parser knows to just treat the last line of the input
+  // as the ast itself, and the printers will find what they're
+  // looking for in the source.
+  const source =
+    (node.monkeyCSource ? node.monkeyCSource + "\n" : "") +
+    JSON.stringify(node);
+  return standalone_js_namespaceObject.format(source, {
+    ...(options || {}),
+    parser: "monkeyc-json",
+    plugins: [prettier_plugin_monkeyc_namespaceObject],
+    endOfLine: "lf",
+  });
+}
+
+function handleException(state, node, exception) {
+  let message;
+  try {
+    const fullName = state.stack
+      .map((e) => e.name)
+      .concat(node.name)
+      .filter((e) => e != null)
+      .join(".");
+    const location = state.stack[0].source
+      ? `${state.stack[0].source}:${node.start || 0}:${node.end || 0}`
+      : "<unknown>";
+    message = `Got exception \`${exception.toString()}' while processing node ${fullName}:${
+      node.type
+    } from ${location}`;
+  } catch {
+    throw exception;
+  }
+  throw new Error(message);
+}
+
+var __webpack_export_target__ = exports;
+for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];
+if(__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });
+/******/ })()
+;