@markw65/monkeyc-optimizer 1.0.25 → 1.0.28

package/README.md

@@ -285,3 +285,21 @@ More fixes found via open source projects.
 
 - Bug fix
   - estree-types was missing the returnType on FunctionDeclaration. Update to latest prettier-plugin, and fix ast.ts.
+
+### 1.0.26
+
+- Bug fixes
+  - Use `self.` rather than `ClassName.` to qualify names that would otherwise collide with locals, since that works with both public and private variables
+  - Fix a bug that caused the inliner to fail to qualify certain names, even if there was a collision with an existing local variables
+  - Fix some name lookup issues relating to whether the lookup is done as a type or a value.
+
+### 1.0.27
+
+- Bug fixes
+  - Update to `@markw65/prettier-plugin-monkeyc@1.0.29` to fix certain obscure comment related bugs
+  - When replacing a node (espcially when inlining), delete any comments contained in the old node.
+
+### 1.0.28
+
+- Bug fixes
+  - In some circumstances, while inlining, a parameter could be substituted, and then reprocessed. During reprocessing, it would attempt to lookup the replacement symbol, and if that was a local from the calling function it would fail (since an inline function never has access to the caller's locals). Prevent the reprocessing step from happening.

package/build/api.cjs

@@ -441,11 +441,29 @@ function inliner_shouldInline(state, func, call, context) {
     }
     return false;
 }
-function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
+// We still need to keep track of every local name that was
+// already in use before we started inlining, but we don't want to
+// use any of its renames. We also want to know whether a local is
+// from the function being inlined, or the calling function, so
+// set every element to false.
+function fixupLocalsMap(state) {
+    if (!state.localsStack)
+        throw new Error("No local variable map!");
+    const locals = state.localsStack[state.localsStack.length - 1];
+    const { map } = locals;
+    if (!map)
+        throw new Error("No local variable map!");
+    const original = { ...map };
+    Object.keys(map).forEach((key) => (map[key] = false));
+    return original;
+}
+function processInlineBody(state, func, call, root, params) {
     let failed = false;
     const pre = state.pre;
     const post = state.post;
     state.inlining = true;
+    let insertedVariableDecls = null;
+    const replacements = new Set();
     try {
         state.pre = (node) => {
             if (failed)
@@ -453,19 +471,14 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
             node.start = call.start;
             node.end = call.end;
             node.loc = call.loc;
-            if (node === insertedVariableDecls)
+            if (replacements.has(node))
                 return false;
             const result = pre(node, state);
             if (!insertedVariableDecls && node.type === "BlockStatement") {
+                // the block just created a new locals map, so we don't
+                // need to restore it at the end.
+                fixupLocalsMap(state);
                 const locals = state.localsStack[state.localsStack.length - 1];
-                const { map } = locals;
-                if (!map)
-                    throw new Error("No local variable map!");
-                // We still need to keep track of every local name that was
-                // already in use, but we don't want to use any of its renames.
-                // We also want to know whether a local is from the function being
-                // inlined, or the calling function, so set every element to false.
-                Object.keys(map).forEach((key) => (map[key] = false));
                 const declarations = func.node.params
                     .map((param, i) => {
                     const paramName = variableDeclarationName(param);
@@ -486,6 +499,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     kind: "var",
                 };
                 node.body.unshift(insertedVariableDecls);
+                replacements.add(insertedVariableDecls);
             }
             return result;
         };
@@ -501,6 +515,8 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                         const ix = params[node.name];
                         if (ix >= 0) {
                             replacement = call.arguments[ix];
+                            replacements.add(replacement);
+                            return replacement;
                         }
                         break;
                     }
@@ -542,6 +558,8 @@ function inliner_unused(expression, top) {
             return [];
         case "Identifier":
             return [];
+        case "ThisExpression":
+            return [];
         case "BinaryExpression":
             if (expression.operator === "as") {
                 return inliner_unused(expression.left);
@@ -644,7 +662,7 @@ function inlineWithArgs(state, func, call, context) {
         const name = variableDeclarationName(param);
         return [name, argnum];
     }));
-    if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
+    if (!processInlineBody(state, func, call, body, params)) {
         return null;
     }
     inliner_diagnostic(state, call.loc, null);
@@ -676,7 +694,10 @@ function inliner_inlineFunction(state, func, call, context) {
     }
     const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
     const params = Object.fromEntries(func.node.params.map((param, i) => [variableDeclarationName(param), i]));
-    return processInlineBody(state, func, call, retArg, true, params);
+    const map = fixupLocalsMap(state);
+    const ret = processInlineBody(state, func, call, retArg, params);
+    state.localsStack[state.localsStack.length - 1].map = map;
+    return ret;
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -729,6 +750,15 @@ function fixNodeScope(state, lookupNode, nodeStack) {
         return "";
     }))
         .flat();
+    const member = (object, property) => ({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+        start: node.start,
+        end: node.end,
+        loc: node.loc,
+    });
     if (prefixes.length &&
         prefixes[0].startsWith("$.") &&
         prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
@@ -742,38 +772,32 @@ function fixNodeScope(state, lookupNode, nodeStack) {
                 found = true;
                 return current;
             }
-            const object = typeof name === "string"
-                ? {
-                    type: "Identifier",
-                    name,
-                    start: node.start,
-                    end: node.end,
-                    loc: node.loc,
-                }
-                : name;
-            let root = null;
-            let property = current;
-            while (property.type !== "Identifier") {
-                root = property;
-                property = property.object;
-            }
-            const mb = {
-                type: "MemberExpression",
-                object,
-                property,
-                computed: false,
+            const object = {
+                type: "Identifier",
+                name,
                 start: node.start,
                 end: node.end,
                 loc: node.loc,
             };
-            if (root) {
-                root.object = mb;
-            }
-            else {
-                current = mb;
+            let root = null;
+            let property = current;
+            do {
+                root = property;
+                property = property.object;
+            } while (property.type === "MemberExpression");
+            if (property.type === "ThisExpression") {
+                root.object = object;
+                return root;
             }
+            root.object = member(object, property);
             return current;
-        }, node);
+        }, member({
+            type: "ThisExpression",
+            text: "self",
+            start: node.start,
+            end: node.end,
+            loc: node.loc,
+        }, node));
     }
     return null;
 }
@@ -2213,6 +2237,7 @@ function api_collectNamespaces(ast, stateIn) {
                     state.stack[0].node = node;
                     break;
                 case "TypeSpecList":
+                case "TypeSpecPart":
                     state.inType = true;
                     break;
                 case "ImportModule":
@@ -2454,6 +2479,11 @@ function api_collectNamespaces(ast, stateIn) {
                 if (state.post)
                     ret = state.post(node, state);
                 switch (type) {
+                    // Don't clear inType for TypeSpecPart, since they
+                    // generally occur in TypeSpecLists. But do clear it for
+                    // SizedArrayExpression, since thats the only place they
+                    // happen on their own.
+                    case "SizedArrayExpression":
                     case "TypeSpecList":
                     case "TypedefDeclaration":
                     case "EnumDeclaration":
@@ -2473,7 +2503,7 @@ function api_collectNamespaces(ast, stateIn) {
                     }
                 }
             }
-            if (ret === false) {
+            if (ret != null) {
                 state.removeNodeComments(node, ast);
             }
             return ret;

package/build/optimizer.cjs

@@ -11165,11 +11165,29 @@ function shouldInline(state, func, call, context) {
     }
     return false;
 }
-function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
+// We still need to keep track of every local name that was
+// already in use before we started inlining, but we don't want to
+// use any of its renames. We also want to know whether a local is
+// from the function being inlined, or the calling function, so
+// set every element to false.
+function fixupLocalsMap(state) {
+    if (!state.localsStack)
+        throw new Error("No local variable map!");
+    const locals = state.localsStack[state.localsStack.length - 1];
+    const { map } = locals;
+    if (!map)
+        throw new Error("No local variable map!");
+    const original = { ...map };
+    Object.keys(map).forEach((key) => (map[key] = false));
+    return original;
+}
+function processInlineBody(state, func, call, root, params) {
     let failed = false;
     const pre = state.pre;
     const post = state.post;
     state.inlining = true;
+    let insertedVariableDecls = null;
+    const replacements = new Set();
     try {
         state.pre = (node) => {
             if (failed)
@@ -11177,19 +11195,14 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
             node.start = call.start;
             node.end = call.end;
             node.loc = call.loc;
-            if (node === insertedVariableDecls)
+            if (replacements.has(node))
                 return false;
             const result = pre(node, state);
             if (!insertedVariableDecls && node.type === "BlockStatement") {
+                // the block just created a new locals map, so we don't
+                // need to restore it at the end.
+                fixupLocalsMap(state);
                 const locals = state.localsStack[state.localsStack.length - 1];
-                const { map } = locals;
-                if (!map)
-                    throw new Error("No local variable map!");
-                // We still need to keep track of every local name that was
-                // already in use, but we don't want to use any of its renames.
-                // We also want to know whether a local is from the function being
-                // inlined, or the calling function, so set every element to false.
-                Object.keys(map).forEach((key) => (map[key] = false));
                 const declarations = func.node.params
                     .map((param, i) => {
                     const paramName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
@@ -11210,6 +11223,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     kind: "var",
                 };
                 node.body.unshift(insertedVariableDecls);
+                replacements.add(insertedVariableDecls);
             }
             return result;
         };
@@ -11225,6 +11239,8 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                         const ix = params[node.name];
                         if (ix >= 0) {
                             replacement = call.arguments[ix];
+                            replacements.add(replacement);
+                            return replacement;
                         }
                         break;
                     }
@@ -11266,6 +11282,8 @@ function unused(expression, top) {
             return [];
         case "Identifier":
             return [];
+        case "ThisExpression":
+            return [];
         case "BinaryExpression":
             if (expression.operator === "as") {
                 return unused(expression.left);
@@ -11368,7 +11386,7 @@ function inlineWithArgs(state, func, call, context) {
         const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
         return [name, argnum];
     }));
-    if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
+    if (!processInlineBody(state, func, call, body, params)) {
         return null;
     }
     diagnostic(state, call.loc, null);
@@ -11400,7 +11418,10 @@ function inlineFunction(state, func, call, context) {
     }
     const retArg = JSON.parse(JSON.stringify(func.node.body.body[0].argument));
     const params = Object.fromEntries(func.node.params.map((param, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(param), i]));
-    return processInlineBody(state, func, call, retArg, true, params);
+    const map = fixupLocalsMap(state);
+    const ret = processInlineBody(state, func, call, retArg, params);
+    state.localsStack[state.localsStack.length - 1].map = map;
+    return ret;
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -11453,6 +11474,15 @@ function fixNodeScope(state, lookupNode, nodeStack) {
         return "";
     }))
         .flat();
+    const member = (object, property) => ({
+        type: "MemberExpression",
+        object,
+        property,
+        computed: false,
+        start: node.start,
+        end: node.end,
+        loc: node.loc,
+    });
     if (prefixes.length &&
         prefixes[0].startsWith("$.") &&
         prefixes.every((prefix, i) => !i || prefix === prefixes[i - 1])) {
@@ -11466,38 +11496,32 @@ function fixNodeScope(state, lookupNode, nodeStack) {
                 found = true;
                 return current;
             }
-            const object = typeof name === "string"
-                ? {
-                    type: "Identifier",
-                    name,
-                    start: node.start,
-                    end: node.end,
-                    loc: node.loc,
-                }
-                : name;
-            let root = null;
-            let property = current;
-            while (property.type !== "Identifier") {
-                root = property;
-                property = property.object;
-            }
-            const mb = {
-                type: "MemberExpression",
-                object,
-                property,
-                computed: false,
+            const object = {
+                type: "Identifier",
+                name,
                 start: node.start,
                 end: node.end,
                 loc: node.loc,
             };
-            if (root) {
-                root.object = mb;
-            }
-            else {
-                current = mb;
+            let root = null;
+            let property = current;
+            do {
+                root = property;
+                property = property.object;
+            } while (property.type === "MemberExpression");
+            if (property.type === "ThisExpression") {
+                root.object = object;
+                return root;
             }
+            root.object = member(object, property);
             return current;
-        }, node);
+        }, member({
+            type: "ThisExpression",
+            text: "self",
+            start: node.start,
+            end: node.end,
+            loc: node.loc,
+        }, node));
     }
     return null;
 }
@@ -13085,7 +13109,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1655681973607 < opt_time) {
+        if (source_time < opt_time && 1655916886685 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }

package/build/src/pre.d.ts

@@ -0,0 +1 @@
+export declare function sizeBasedPRE(state: ProgramStateAnalysis, func: FunctionStateNode): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.25",
+  "version": "1.0.28",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -37,7 +37,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.28"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.29"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",