@markw65/monkeyc-optimizer 1.0.1 → 1.0.2

package/README.md

@@ -8,4 +8,14 @@ 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.
+
 ---

package/build/api.cjs

@@ -0,0 +1,487 @@
+/******/ (() => { // 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];
+  };
+
+  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
+          }
+          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.post) ret = state.post(node);
+        if (state.stack.slice(-1).pop().node === node) {
+          state.stack.pop();
+        }
+        return ret;
+      } catch (e) {
+        handleException(state, node, e);
+      }
+    }
+  );
+  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 });
+/******/ })()
+;