@markw65/monkeyc-optimizer 1.0.20 → 1.0.21

package/README.md

@@ -235,3 +235,12 @@ More fixes found via open source projects.
 
 - Code cleanup
   - Called function cleanup
+
+### 1.0.21
+
+- Bug fixes
+
+  - Parameters from the calling function should be treated just line locals when inlining
+  - Upgrade to @markw65/prettier-plugin-monkeyc@1.0.24
+    - fixes crash with comments following an attribute: `(:foo) /* comment */ function foo() {}`
+  - Fix issues with recursive inlining

package/build/api.cjs

@@ -132,23 +132,32 @@ function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
     const getSafety = (decl) => {
-        // enums are constant, they cant change
-        if (decl.type === "EnumStringMember")
-            return true;
-        if (decl.type === "VariableDeclarator") {
-            // constants also can't change
-            if (decl.node.kind === "const")
+        switch (decl.type) {
+            // enums are constant, they cant change
+            case "EnumStringMember":
                 return true;
-            // if decl is a local, it also can't be changed
-            // by a call to another function.
-            for (let i = 0;; i++) {
-                if (!state.stack[i] || decl.stack[i] !== state.stack[i])
-                    return false;
-                if (state.stack[i].type === "FunctionDeclaration")
+            case "VariableDeclarator": {
+                // constants also can't change
+                if (decl.node.kind === "const")
                     return true;
+                // if decl is a local, it also can't be changed
+                // by a call to another function.
+                for (let i = 0;; i++) {
+                    if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                        return false;
+                    if (state.stack[i].type === "FunctionDeclaration")
+                        return true;
+                }
             }
+            case "Identifier":
+            case "BinaryExpression":
+                // This is a parameter of the calling function.
+                // It also can't be changed during the execution
+                // of the inlined function
+                return true;
+            default:
+                return null;
         }
-        return null;
     };
     const safeArgs = [];
     let allSafe = true;
@@ -267,8 +276,8 @@ function inlineRequested(state, func) {
         state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
         {};
     if (func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+        func.node.attrs.attributes &&
+        func.node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" &&
             (attr.argument.name === "inline" ||
                 (attr.argument.name.startsWith("inline_") &&
                     hasProperty(excludeAnnotations, attr.argument.name.substring(7)))))) {
@@ -277,6 +286,8 @@ function inlineRequested(state, func) {
     return false;
 }
 function inliner_shouldInline(state, func, call, context) {
+    if (state.inlining)
+        return false;
     let autoInline = false;
     let inlineAsExpression = false;
     const args = call.arguments;
@@ -309,6 +320,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     let failed = false;
     const pre = state.pre;
     const post = state.post;
+    state.inlining = true;
     try {
         state.pre = (node) => {
             if (failed)
@@ -354,7 +366,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
         };
         state.post = (node) => {
             if (failed)
-                return null;
+                return post(node, state);
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -371,12 +383,13 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     if (!replacement) {
                         failed = true;
                         inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
-                        return null;
+                        return post(node, state);
                     }
                     break;
                 }
             }
-            return post(replacement || node, state) || replacement;
+            const ret = post(replacement || node, state);
+            return ret === false || ret ? ret : replacement;
         };
         let ret = state.traverse(root);
         if (failed) {
@@ -395,6 +408,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     finally {
         state.pre = pre;
         state.post = post;
+        delete state.inlining;
     }
 }
 function inliner_unused(expression, top) {
@@ -779,12 +793,12 @@ async function analyze(fnMap) {
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
-                "attrs" in node.attrs &&
-                node.attrs.attrs &&
+                "attributes" in node.attrs &&
+                node.attrs.attributes &&
                 node.loc?.source) {
                 const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
                 if (excludeAnnotations) {
-                    return node.attrs.attrs.reduce((drop, attr) => {
+                    return node.attrs.attributes.elements.reduce((drop, attr) => {
                         if (attr.type != "UnaryExpression")
                             return drop;
                         if (attr.argument.type != "Identifier")
@@ -1100,7 +1114,13 @@ async function optimizeMonkeyC(fnMap) {
         exposed: {},
         calledFunctions: {},
     };
-    const replace = (node, obj) => {
+    const replace = (node) => {
+        if (node === false || node === null)
+            return node;
+        const rep = state.traverse(node);
+        return rep === false || rep ? rep : node;
+    };
+    const inPlaceReplacement = (node, obj) => {
         for (const k of Object.keys(node)) {
             delete node[k];
         }
@@ -1125,7 +1145,7 @@ async function optimizeMonkeyC(fnMap) {
         if (!obj) {
             return false;
         }
-        replace(node, obj);
+        inPlaceReplacement(node, obj);
         return true;
     };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
@@ -1141,8 +1161,8 @@ async function optimizeMonkeyC(fnMap) {
         if (hasProperty(state.exposed, func.id.name))
             return true;
         if (func.attrs &&
-            func.attrs.attrs &&
-            func.attrs.attrs.some((attr) => {
+            func.attrs.attributes &&
+            func.attrs.attributes.elements.some((attr) => {
                 if (attr.type != "UnaryExpression")
                     return false;
                 if (attr.argument.type != "Identifier")
@@ -1315,8 +1335,7 @@ async function optimizeMonkeyC(fnMap) {
         }
         const opt = optimizeNode(node);
         if (opt) {
-            replace(node, opt);
-            return null;
+            return replace(opt);
         }
         switch (node.type) {
             case "ConditionalExpression":
@@ -1326,7 +1345,7 @@ async function optimizeMonkeyC(fnMap) {
                     const rep = node.test.value ? node.consequent : node.alternate;
                     if (!rep)
                         return false;
-                    replace(node, rep);
+                    return replace(rep);
                 }
                 break;
             case "WhileStatement":
@@ -1341,15 +1360,11 @@ async function optimizeMonkeyC(fnMap) {
                 break;
             case "ReturnStatement":
                 if (node.argument && node.argument.type === "CallExpression") {
-                    return optimizeCall(state, node.argument, node);
+                    return replace(optimizeCall(state, node.argument, node));
                 }
                 break;
             case "CallExpression": {
-                const ret = optimizeCall(state, node, null);
-                if (ret) {
-                    replace(node, ret);
-                }
-                break;
+                return replace(optimizeCall(state, node, null));
             }
             case "AssignmentExpression":
                 if (node.operator === "=" &&
@@ -1361,7 +1376,7 @@ async function optimizeMonkeyC(fnMap) {
                 break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    return optimizeCall(state, node.expression, node);
+                    return replace(optimizeCall(state, node.expression, node));
                 }
                 else if (node.expression.type === "AssignmentExpression") {
                     if (node.expression.right.type === "CallExpression") {
@@ -1376,11 +1391,7 @@ async function optimizeMonkeyC(fnMap) {
                             ok = result != null;
                         }
                         if (ok) {
-                            const ret = optimizeCall(state, node.expression.right, node.expression);
-                            if (ret && ret.type === "BlockStatement") {
-                                const r2 = state.traverse(ret);
-                                return r2 === false || r2 ? r2 : ret;
-                            }
+                            return replace(optimizeCall(state, node.expression.right, node.expression));
                         }
                     }
                 }
@@ -1388,12 +1399,9 @@ async function optimizeMonkeyC(fnMap) {
                     const ret = unused(node.expression, true);
                     if (ret) {
                         return ret
-                            .map((s) => {
-                            const r2 = state.traverse(s);
-                            return r2 === false || r2 ? r2 : s;
-                        })
+                            .map(replace)
                             .flat(1)
-                            .filter((s) => s !== false);
+                            .filter((s) => !!s);
                     }
                 }
                 break;
@@ -1436,19 +1444,24 @@ async function optimizeMonkeyC(fnMap) {
                 if (!node.body.members.length) {
                     if (!node.id)
                         return false;
-                    if (!node.body["enumType"]) {
+                    if (!node.body.enumType) {
                         throw new Error("Missing enumType on optimized enum");
                     }
-                    replace(node, {
+                    return {
                         type: "TypedefDeclaration",
                         id: node.id,
                         ts: {
                             type: "UnaryExpression",
-                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            argument: {
+                                type: "TypeSpecList",
+                                ts: [
+                                    node.body.enumType,
+                                ],
+                            },
                             prefix: true,
                             operator: " as",
                         },
-                    });
+                    };
                 }
                 break;
             case "VariableDeclaration": {
@@ -2055,15 +2068,6 @@ function api_traverseAst(node, pre, post) {
     return post && post(node);
 }
 function formatAst(node, monkeyCSource = null) {
-    if ("comments" in node && !monkeyCSource) {
-        // 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;
-    }
     /*
      * The estree printer sometimes looks at the parent node without
      * checking that there *is* a parent node (eg it assumes all

package/build/optimizer.cjs

@@ -10853,23 +10853,32 @@ function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
     const getSafety = (decl) => {
-        // enums are constant, they cant change
-        if (decl.type === "EnumStringMember")
-            return true;
-        if (decl.type === "VariableDeclarator") {
-            // constants also can't change
-            if (decl.node.kind === "const")
+        switch (decl.type) {
+            // enums are constant, they cant change
+            case "EnumStringMember":
                 return true;
-            // if decl is a local, it also can't be changed
-            // by a call to another function.
-            for (let i = 0;; i++) {
-                if (!state.stack[i] || decl.stack[i] !== state.stack[i])
-                    return false;
-                if (state.stack[i].type === "FunctionDeclaration")
+            case "VariableDeclarator": {
+                // constants also can't change
+                if (decl.node.kind === "const")
                     return true;
+                // if decl is a local, it also can't be changed
+                // by a call to another function.
+                for (let i = 0;; i++) {
+                    if (!state.stack[i] || decl.stack[i] !== state.stack[i])
+                        return false;
+                    if (state.stack[i].type === "FunctionDeclaration")
+                        return true;
+                }
             }
+            case "Identifier":
+            case "BinaryExpression":
+                // This is a parameter of the calling function.
+                // It also can't be changed during the execution
+                // of the inlined function
+                return true;
+            default:
+                return null;
         }
-        return null;
     };
     const safeArgs = [];
     let allSafe = true;
@@ -10988,8 +10997,8 @@ function inlineRequested(state, func) {
         state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
         {};
     if (func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+        func.node.attrs.attributes &&
+        func.node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" &&
             (attr.argument.name === "inline" ||
                 (attr.argument.name.startsWith("inline_") &&
                     (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name.substring(7)))))) {
@@ -10998,6 +11007,8 @@ function inlineRequested(state, func) {
     return false;
 }
 function shouldInline(state, func, call, context) {
+    if (state.inlining)
+        return false;
     let autoInline = false;
     let inlineAsExpression = false;
     const args = call.arguments;
@@ -11030,6 +11041,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     let failed = false;
     const pre = state.pre;
     const post = state.post;
+    state.inlining = true;
     try {
         state.pre = (node) => {
             if (failed)
@@ -11075,7 +11087,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
         };
         state.post = (node) => {
             if (failed)
-                return null;
+                return post(node, state);
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -11092,12 +11104,13 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     if (!replacement) {
                         failed = true;
                         inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
-                        return null;
+                        return post(node, state);
                     }
                     break;
                 }
             }
-            return post(replacement || node, state) || replacement;
+            const ret = post(replacement || node, state);
+            return ret === false || ret ? ret : replacement;
         };
         let ret = state.traverse(root);
         if (failed) {
@@ -11116,6 +11129,7 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
     finally {
         state.pre = pre;
         state.post = post;
+        delete state.inlining;
     }
 }
 function unused(expression, top) {
@@ -11497,12 +11511,12 @@ async function analyze(fnMap) {
         shouldExclude(node) {
             if ("attrs" in node &&
                 node.attrs &&
-                "attrs" in node.attrs &&
-                node.attrs.attrs &&
+                "attributes" in node.attrs &&
+                node.attrs.attributes &&
                 node.loc?.source) {
                 const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
                 if (excludeAnnotations) {
-                    return node.attrs.attrs.reduce((drop, attr) => {
+                    return node.attrs.attributes.elements.reduce((drop, attr) => {
                         if (attr.type != "UnaryExpression")
                             return drop;
                         if (attr.argument.type != "Identifier")
@@ -11818,7 +11832,13 @@ async function optimizeMonkeyC(fnMap) {
         exposed: {},
         calledFunctions: {},
     };
-    const replace = (node, obj) => {
+    const replace = (node) => {
+        if (node === false || node === null)
+            return node;
+        const rep = state.traverse(node);
+        return rep === false || rep ? rep : node;
+    };
+    const inPlaceReplacement = (node, obj) => {
         for (const k of Object.keys(node)) {
             delete node[k];
         }
@@ -11843,7 +11863,7 @@ async function optimizeMonkeyC(fnMap) {
         if (!obj) {
             return false;
         }
-        replace(node, obj);
+        inPlaceReplacement(node, obj);
         return true;
     };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
@@ -11859,8 +11879,8 @@ async function optimizeMonkeyC(fnMap) {
         if ((0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, func.id.name))
             return true;
         if (func.attrs &&
-            func.attrs.attrs &&
-            func.attrs.attrs.some((attr) => {
+            func.attrs.attributes &&
+            func.attrs.attributes.elements.some((attr) => {
                 if (attr.type != "UnaryExpression")
                     return false;
                 if (attr.argument.type != "Identifier")
@@ -12033,8 +12053,7 @@ async function optimizeMonkeyC(fnMap) {
         }
         const opt = optimizeNode(node);
         if (opt) {
-            replace(node, opt);
-            return null;
+            return replace(opt);
         }
         switch (node.type) {
             case "ConditionalExpression":
@@ -12044,7 +12063,7 @@ async function optimizeMonkeyC(fnMap) {
                     const rep = node.test.value ? node.consequent : node.alternate;
                     if (!rep)
                         return false;
-                    replace(node, rep);
+                    return replace(rep);
                 }
                 break;
             case "WhileStatement":
@@ -12059,15 +12078,11 @@ async function optimizeMonkeyC(fnMap) {
                 break;
             case "ReturnStatement":
                 if (node.argument && node.argument.type === "CallExpression") {
-                    return optimizeCall(state, node.argument, node);
+                    return replace(optimizeCall(state, node.argument, node));
                 }
                 break;
             case "CallExpression": {
-                const ret = optimizeCall(state, node, null);
-                if (ret) {
-                    replace(node, ret);
-                }
-                break;
+                return replace(optimizeCall(state, node, null));
             }
             case "AssignmentExpression":
                 if (node.operator === "=" &&
@@ -12079,7 +12094,7 @@ async function optimizeMonkeyC(fnMap) {
                 break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    return optimizeCall(state, node.expression, node);
+                    return replace(optimizeCall(state, node.expression, node));
                 }
                 else if (node.expression.type === "AssignmentExpression") {
                     if (node.expression.right.type === "CallExpression") {
@@ -12094,11 +12109,7 @@ async function optimizeMonkeyC(fnMap) {
                             ok = result != null;
                         }
                         if (ok) {
-                            const ret = optimizeCall(state, node.expression.right, node.expression);
-                            if (ret && ret.type === "BlockStatement") {
-                                const r2 = state.traverse(ret);
-                                return r2 === false || r2 ? r2 : ret;
-                            }
+                            return replace(optimizeCall(state, node.expression.right, node.expression));
                         }
                     }
                 }
@@ -12106,12 +12117,9 @@ async function optimizeMonkeyC(fnMap) {
                     const ret = unused(node.expression, true);
                     if (ret) {
                         return ret
-                            .map((s) => {
-                            const r2 = state.traverse(s);
-                            return r2 === false || r2 ? r2 : s;
-                        })
+                            .map(replace)
                             .flat(1)
-                            .filter((s) => s !== false);
+                            .filter((s) => !!s);
                     }
                 }
                 break;
@@ -12154,19 +12162,24 @@ async function optimizeMonkeyC(fnMap) {
                 if (!node.body.members.length) {
                     if (!node.id)
                         return false;
-                    if (!node.body["enumType"]) {
+                    if (!node.body.enumType) {
                         throw new Error("Missing enumType on optimized enum");
                     }
-                    replace(node, {
+                    return {
                         type: "TypedefDeclaration",
                         id: node.id,
                         ts: {
                             type: "UnaryExpression",
-                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            argument: {
+                                type: "TypeSpecList",
+                                ts: [
+                                    node.body.enumType,
+                                ],
+                            },
                             prefix: true,
                             operator: " as",
                         },
-                    });
+                    };
                 }
                 break;
             case "VariableDeclaration": {
@@ -12740,7 +12753,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 && 1654708837029 < opt_time) {
+        if (source_time < opt_time && 1654811717108 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }

package/build/src/optimizer.d.ts

@@ -117,6 +117,7 @@ declare global {
         lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
         traverse?: (node: mctree.Node) => void | null | false | mctree.Node | mctree.Node[];
         inType?: boolean;
+        inlining?: true;
         exposed?: {
             [key: string]: true;
         };

package/package.json

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