@markw65/monkeyc-optimizer 1.0.37 → 1.0.38

package/README.md

@@ -420,3 +420,15 @@ Bug Fixes
 - Update to [@markw65/prettier-plugin-monkeyc@1.0.35](https://github.com/markw65/prettier-plugin-monkeyc#1035).
   - Fixes [prettier-plugin-monkeyc#1](https://github.com/markw65/prettier-plugin-monkeyc/issues/1)
   - Fixes [monkeyc-optimizer#1](https://github.com/markw65/monkeyc-optimizer/issues/1)
+
+### 1.0.37
+
+- Update the testing framework to launch the simulator before each test run, rather than start it once at the beginning. This is because the latest beta crashes after successfully completing.
+- Update launchSimulator to check if the simulator is already running. This avoids lots of screen switching when the simulator is running on a separate desktop.
+- Add optimizerVersion and extensionVersion to build-info.json.
+
+### 1.0.38
+
+- Allow inlining the argument to an if-statement, with the same constraints as inlining in assignment context
+- Expand `assignment`, `declaration` and `if` contexts to include (recursively) the left operand of any binary operator, the operand of any unary operator, the `test` operand of any conditional operator or the `object` of a member-expression. So now it will inline `inlinableFunction` in:
+  - `var x = !((inlinableFunction() + 4) == 42 ? foo() : bar());`

package/build/api.cjs

@@ -655,8 +655,13 @@ function function_info_findCalleesForNew(lookupDefs) {
 
 function variable_renamer_renameVariable(state, locals, declName) {
     const map = locals.map;
-    if (!hasProperty(map, declName))
-        return null;
+    if (declName) {
+        if (!hasProperty(map, declName))
+            return null;
+    }
+    else {
+        declName = "tmp";
+    }
     let suffix = 0;
     let node_name = declName;
     const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
@@ -711,6 +716,69 @@ function variable_renamer_renameVariable(state, locals, declName) {
 
 
 
+// Note: Keep in sync with replaceInlinedSubExpression below
+function inliner_inlinableSubExpression(expr) {
+    while (true) {
+        if (expr.type === "BinaryExpression" || expr.type === "LogicalExpression") {
+            expr = expr.left;
+        }
+        else if (expr.type === "UnaryExpression") {
+            expr = expr.argument;
+        }
+        else if (expr.type === "ConditionalExpression") {
+            expr = expr.test;
+        }
+        else if (expr.type === "MemberExpression") {
+            expr = expr.object;
+        }
+        else if (expr.type === "CallExpression") {
+            return expr;
+        }
+        else {
+            return null;
+        }
+    }
+}
+// Note: Keep in sync with inlinableSubExpression above
+function replaceInlinedSubExpression(top, call, repl) {
+    if (top === call)
+        return repl;
+    let expr = top;
+    while (true) {
+        if (expr.type === "LogicalExpression" || expr.type === "BinaryExpression") {
+            if (expr.left === call) {
+                expr.left = repl;
+                break;
+            }
+            expr = expr.left;
+        }
+        else if (expr.type === "UnaryExpression") {
+            if (expr.argument === call) {
+                expr.argument = repl;
+                break;
+            }
+            expr = expr.argument;
+        }
+        else if (expr.type === "ConditionalExpression") {
+            if (expr.test === call) {
+                expr.test = repl;
+                break;
+            }
+            expr = expr.test;
+        }
+        else if (expr.type === "MemberExpression") {
+            if (expr.object === call) {
+                expr.object = repl;
+                break;
+            }
+            expr = expr.object;
+        }
+        else {
+            throw new Error("Internal error: Didn't find CallExpression");
+        }
+    }
+    return top;
+}
 function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
@@ -938,7 +1006,7 @@ function inliner_shouldInline(state, func, call, context) {
             }
         }
         if (!context && requested) {
-            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, if or return contexts");
         }
         return context != null;
     }
@@ -1198,7 +1266,8 @@ function inlineWithArgs(state, func, call, context) {
             inlineDiagnostic(state, func, call, "Function had more than one return statement");
         }
         else if ((context.type === "AssignmentExpression" ||
-            context.type === "VariableDeclarator") &&
+            context.type === "VariableDeclarator" ||
+            context.type === "IfStatement") &&
             retStmtCount !== 1) {
             inlineDiagnostic(state, func, call, "Function did not have a return statement");
             return null;
@@ -1208,7 +1277,8 @@ function inlineWithArgs(state, func, call, context) {
             if (!last ||
                 last.type !== "ReturnStatement" ||
                 ((context.type === "AssignmentExpression" ||
-                    context.type === "VariableDeclarator") &&
+                    context.type === "VariableDeclarator" ||
+                    context.type === "IfStatement") &&
                     !last.argument)) {
                 inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
                 return null;
@@ -1235,14 +1305,15 @@ function inlineWithArgs(state, func, call, context) {
         }
         if (last.argument) {
             if (context.type === "AssignmentExpression") {
-                context.right = last.argument;
+                context.right = replaceInlinedSubExpression(context.right, call, last.argument);
                 block.body[block.body.length - 1] = {
                     type: "ExpressionStatement",
                     expression: context,
                 };
             }
             else if (context.type === "VariableDeclarator") {
-                const { id, init: _init, kind: _kind, ...rest } = context;
+                const { id, init, kind: _kind, ...rest } = context;
+                const right = replaceInlinedSubExpression(init, call, last.argument);
                 block.body[block.body.length - 1] = {
                     ...rest,
                     type: "ExpressionStatement",
@@ -1251,9 +1322,52 @@ function inlineWithArgs(state, func, call, context) {
                         type: "AssignmentExpression",
                         operator: "=",
                         left: id.type === "Identifier" ? id : id.left,
+                        right,
+                    },
+                };
+            }
+            else if (context.type === "IfStatement") {
+                // Generate a pmcr_tmp name that doesn't conflict with anything
+                const locals = state.localsStack[state.localsStack.length - 1];
+                const name = renameVariable(state, locals, null);
+                locals.map[name] = true;
+                // Replace the inlined function's return statement
+                // with an assignment to pmcr_tmp
+                block.body[block.body.length - 1] = {
+                    type: "ExpressionStatement",
+                    expression: {
+                        type: "AssignmentExpression",
+                        operator: "=",
+                        left: { type: "Identifier", name },
                         right: last.argument,
                     },
                 };
+                // The IfStatement either has the call as its test, or as
+                // the leftmost argument to a series of Binary/Logical expressions
+                // Either way, replace the call with pmcr_tmp
+                const repl = { type: "Identifier", name };
+                context.test = replaceInlinedSubExpression(context.test, call, repl);
+                // Wrap the inlined body so it looks like
+                // {
+                //   var pmcr_tmp;
+                //   { /* inlined body, with assignment to pmcr_tmp */ }
+                //   if (context) {} // original if statement
+                // }
+                body.body = [
+                    {
+                        type: "VariableDeclaration",
+                        kind: "var",
+                        declarations: [
+                            {
+                                type: "VariableDeclarator",
+                                kind: "var",
+                                id: { type: "Identifier", name },
+                            },
+                        ],
+                    },
+                    { type: "BlockStatement", body: body.body },
+                    context,
+                ];
             }
             else {
                 const side_exprs = inliner_unused(last.argument);
@@ -1427,7 +1541,7 @@ function pragma_checker_pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@(\d+)/g, "(pre_)?$1(_\\d+)?"));
+        const re = new RegExp(needle.replace(/@([\d\w]+)/g, "(pre_)?$1(_\\d+)?"));
         return re.test(haystack);
     };
     next();
@@ -4048,11 +4162,18 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         return false;
                     return replace(rep, rep);
                 }
-                else if (node.type === "IfStatement" &&
-                    node.alternate &&
-                    node.alternate.type === "BlockStatement" &&
-                    !node.alternate.body.length) {
-                    delete node.alternate;
+                else if (node.type === "IfStatement") {
+                    if (node.alternate &&
+                        node.alternate.type === "BlockStatement" &&
+                        !node.alternate.body.length) {
+                        delete node.alternate;
+                    }
+                    else {
+                        const call = inlinableSubExpression(node.test);
+                        if (call) {
+                            return replace(optimizeCall(state, call, node), node.test);
+                        }
+                    }
                 }
                 break;
             case "WhileStatement":
@@ -4095,8 +4216,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     let j = 0;
                     while (i < node.declarations.length) {
                         const decl = declarations[i++];
-                        if (decl.init && decl.init.type === "CallExpression") {
-                            const inlined = replace(optimizeCall(state, decl.init, decl), decl.init);
+                        if (!decl.init)
+                            continue;
+                        const call = inlinableSubExpression(decl.init);
+                        if (call) {
+                            const inlined = replace(optimizeCall(state, call, decl), decl.init);
                             if (!inlined)
                                 continue;
                             if (Array.isArray(inlined) || inlined.type != "BlockStatement") {
@@ -4131,7 +4255,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     return replace(optimizeCall(state, node.expression, node), node.expression);
                 }
                 else if (node.expression.type === "AssignmentExpression") {
-                    if (node.expression.right.type === "CallExpression") {
+                    const call = inlinableSubExpression(node.expression.right);
+                    if (call) {
                         let ok = false;
                         if (node.expression.left.type === "Identifier") {
                             if (hasProperty(topLocals().map, node.expression.left.type)) {
@@ -4143,7 +4268,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                             ok = !!result;
                         }
                         if (ok) {
-                            return replace(optimizeCall(state, node.expression.right, node.expression), node.expression.right);
+                            return replace(optimizeCall(state, call, node.expression), node.expression.right);
                         }
                     }
                 }

package/build/optimizer.cjs

@@ -11370,8 +11370,13 @@ function findCalleesForNew(lookupDefs) {
 
 function renameVariable(state, locals, declName) {
     const map = locals.map;
-    if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, declName))
-        return null;
+    if (declName) {
+        if (!(0,external_api_cjs_namespaceObject.hasProperty)(map, declName))
+            return null;
+    }
+    else {
+        declName = "tmp";
+    }
     let suffix = 0;
     let node_name = declName;
     const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
@@ -11426,6 +11431,69 @@ function renameVariable(state, locals, declName) {
 
 
 
+// Note: Keep in sync with replaceInlinedSubExpression below
+function inlinableSubExpression(expr) {
+    while (true) {
+        if (expr.type === "BinaryExpression" || expr.type === "LogicalExpression") {
+            expr = expr.left;
+        }
+        else if (expr.type === "UnaryExpression") {
+            expr = expr.argument;
+        }
+        else if (expr.type === "ConditionalExpression") {
+            expr = expr.test;
+        }
+        else if (expr.type === "MemberExpression") {
+            expr = expr.object;
+        }
+        else if (expr.type === "CallExpression") {
+            return expr;
+        }
+        else {
+            return null;
+        }
+    }
+}
+// Note: Keep in sync with inlinableSubExpression above
+function replaceInlinedSubExpression(top, call, repl) {
+    if (top === call)
+        return repl;
+    let expr = top;
+    while (true) {
+        if (expr.type === "LogicalExpression" || expr.type === "BinaryExpression") {
+            if (expr.left === call) {
+                expr.left = repl;
+                break;
+            }
+            expr = expr.left;
+        }
+        else if (expr.type === "UnaryExpression") {
+            if (expr.argument === call) {
+                expr.argument = repl;
+                break;
+            }
+            expr = expr.argument;
+        }
+        else if (expr.type === "ConditionalExpression") {
+            if (expr.test === call) {
+                expr.test = repl;
+                break;
+            }
+            expr = expr.test;
+        }
+        else if (expr.type === "MemberExpression") {
+            if (expr.object === call) {
+                expr.object = repl;
+                break;
+            }
+            expr = expr.object;
+        }
+        else {
+            throw new Error("Internal error: Didn't find CallExpression");
+        }
+    }
+    return top;
+}
 function getArgSafety(state, func, args, requireAll) {
     // determine whether decl might be changed by a function call
     // or assignment during the evaluation of FunctionStateNode.
@@ -11653,7 +11721,7 @@ function shouldInline(state, func, call, context) {
             }
         }
         if (!context && requested) {
-            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, if or return contexts");
         }
         return context != null;
     }
@@ -11913,7 +11981,8 @@ function inlineWithArgs(state, func, call, context) {
             inlineDiagnostic(state, func, call, "Function had more than one return statement");
         }
         else if ((context.type === "AssignmentExpression" ||
-            context.type === "VariableDeclarator") &&
+            context.type === "VariableDeclarator" ||
+            context.type === "IfStatement") &&
             retStmtCount !== 1) {
             inlineDiagnostic(state, func, call, "Function did not have a return statement");
             return null;
@@ -11923,7 +11992,8 @@ function inlineWithArgs(state, func, call, context) {
             if (!last ||
                 last.type !== "ReturnStatement" ||
                 ((context.type === "AssignmentExpression" ||
-                    context.type === "VariableDeclarator") &&
+                    context.type === "VariableDeclarator" ||
+                    context.type === "IfStatement") &&
                     !last.argument)) {
                 inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
                 return null;
@@ -11950,14 +12020,15 @@ function inlineWithArgs(state, func, call, context) {
         }
         if (last.argument) {
             if (context.type === "AssignmentExpression") {
-                context.right = last.argument;
+                context.right = replaceInlinedSubExpression(context.right, call, last.argument);
                 block.body[block.body.length - 1] = {
                     type: "ExpressionStatement",
                     expression: context,
                 };
             }
             else if (context.type === "VariableDeclarator") {
-                const { id, init: _init, kind: _kind, ...rest } = context;
+                const { id, init, kind: _kind, ...rest } = context;
+                const right = replaceInlinedSubExpression(init, call, last.argument);
                 block.body[block.body.length - 1] = {
                     ...rest,
                     type: "ExpressionStatement",
@@ -11966,9 +12037,52 @@ function inlineWithArgs(state, func, call, context) {
                         type: "AssignmentExpression",
                         operator: "=",
                         left: id.type === "Identifier" ? id : id.left,
+                        right,
+                    },
+                };
+            }
+            else if (context.type === "IfStatement") {
+                // Generate a pmcr_tmp name that doesn't conflict with anything
+                const locals = state.localsStack[state.localsStack.length - 1];
+                const name = renameVariable(state, locals, null);
+                locals.map[name] = true;
+                // Replace the inlined function's return statement
+                // with an assignment to pmcr_tmp
+                block.body[block.body.length - 1] = {
+                    type: "ExpressionStatement",
+                    expression: {
+                        type: "AssignmentExpression",
+                        operator: "=",
+                        left: { type: "Identifier", name },
                         right: last.argument,
                     },
                 };
+                // The IfStatement either has the call as its test, or as
+                // the leftmost argument to a series of Binary/Logical expressions
+                // Either way, replace the call with pmcr_tmp
+                const repl = { type: "Identifier", name };
+                context.test = replaceInlinedSubExpression(context.test, call, repl);
+                // Wrap the inlined body so it looks like
+                // {
+                //   var pmcr_tmp;
+                //   { /* inlined body, with assignment to pmcr_tmp */ }
+                //   if (context) {} // original if statement
+                // }
+                body.body = [
+                    {
+                        type: "VariableDeclaration",
+                        kind: "var",
+                        declarations: [
+                            {
+                                type: "VariableDeclarator",
+                                kind: "var",
+                                id: { type: "Identifier", name },
+                            },
+                        ],
+                    },
+                    { type: "BlockStatement", body: body.body },
+                    context,
+                ];
             }
             else {
                 const side_exprs = unused(last.argument);
@@ -12142,7 +12256,7 @@ function pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@(\d+)/g, "(pre_)?$1(_\\d+)?"));
+        const re = new RegExp(needle.replace(/@([\d\w]+)/g, "(pre_)?$1(_\\d+)?"));
         return re.test(haystack);
     };
     next();
@@ -14760,11 +14874,18 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                         return false;
                     return replace(rep, rep);
                 }
-                else if (node.type === "IfStatement" &&
-                    node.alternate &&
-                    node.alternate.type === "BlockStatement" &&
-                    !node.alternate.body.length) {
-                    delete node.alternate;
+                else if (node.type === "IfStatement") {
+                    if (node.alternate &&
+                        node.alternate.type === "BlockStatement" &&
+                        !node.alternate.body.length) {
+                        delete node.alternate;
+                    }
+                    else {
+                        const call = inlinableSubExpression(node.test);
+                        if (call) {
+                            return replace(optimizeCall(state, call, node), node.test);
+                        }
+                    }
                 }
                 break;
             case "WhileStatement":
@@ -14807,8 +14928,11 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     let j = 0;
                     while (i < node.declarations.length) {
                         const decl = declarations[i++];
-                        if (decl.init && decl.init.type === "CallExpression") {
-                            const inlined = replace(optimizeCall(state, decl.init, decl), decl.init);
+                        if (!decl.init)
+                            continue;
+                        const call = inlinableSubExpression(decl.init);
+                        if (call) {
+                            const inlined = replace(optimizeCall(state, call, decl), decl.init);
                             if (!inlined)
                                 continue;
                             if (Array.isArray(inlined) || inlined.type != "BlockStatement") {
@@ -14843,7 +14967,8 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                     return replace(optimizeCall(state, node.expression, node), node.expression);
                 }
                 else if (node.expression.type === "AssignmentExpression") {
-                    if (node.expression.right.type === "CallExpression") {
+                    const call = inlinableSubExpression(node.expression.right);
+                    if (call) {
                         let ok = false;
                         if (node.expression.left.type === "Identifier") {
                             if ((0,external_api_cjs_namespaceObject.hasProperty)(topLocals().map, node.expression.left.type)) {
@@ -14855,7 +14980,7 @@ async function optimizeMonkeyC(fnMap, barrelList, config) {
                             ok = !!result;
                         }
                         if (ok) {
-                            return replace(optimizeCall(state, node.expression.right, node.expression), node.expression.right);
+                            return replace(optimizeCall(state, call, node.expression), node.expression.right);
                         }
                     }
                 }
@@ -15509,7 +15634,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 && 1666558228929 < opt_time) {
+        if (source_time < opt_time && 1666827670006 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -15534,7 +15659,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.0.37",
+                optimizerVersion: "1.0.38",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));

package/build/src/inliner.d.ts

@@ -1,11 +1,12 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { FunctionStateNode, ProgramStateAnalysis, ProgramStateLive } from "./optimizer-types";
+export declare function inlinableSubExpression(expr: mctree.Expression): mctree.SimpleCallExpression | null;
 export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): boolean;
 declare type InlineBody = mctree.BlockStatement | mctree.ExpressionStatement["expression"];
 export declare function unused(expression: mctree.ExpressionStatement["expression"]): mctree.Statement[];
 export declare function unused(expression: mctree.ExpressionStatement["expression"], top: true): mctree.Statement[] | null;
 export declare function diagnostic(state: ProgramStateLive, loc: mctree.Node["loc"], message: string | null, type?: NonNullable<ProgramStateAnalysis["diagnostics"]>[string][number]["type"]): void;
-export declare type InlineContext = mctree.ReturnStatement | mctree.AssignmentExpression | mctree.ExpressionStatement | mctree.VariableDeclarator;
+export declare type InlineContext = mctree.ReturnStatement | mctree.IfStatement | mctree.AssignmentExpression | mctree.ExpressionStatement | mctree.VariableDeclarator;
 export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, context: InlineContext | null): InlineBody | null;
 export declare function applyTypeIfNeeded(node: mctree.Node): mctree.Node;
 export {};

package/build/src/variable-renamer.d.ts

@@ -1,2 +1,2 @@
 import { ProgramStateAnalysis } from "./optimizer-types";
-export declare function renameVariable(state: ProgramStateAnalysis, locals: NonNullable<ProgramStateAnalysis["localsStack"]>[number], declName: string): string | null;
+export declare function renameVariable(state: ProgramStateAnalysis, locals: NonNullable<ProgramStateAnalysis["localsStack"]>[number], declName: string | null): string | null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.37",
+  "version": "1.0.38",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",