@markw65/monkeyc-optimizer 1.0.18 → 1.0.19

package/README.md

@@ -198,3 +198,25 @@ More fixes found via open source projects.
 
 - Bug Fixes
   - The new inliner was too agressive at constant propagating literal parameters to their point of use.
+
+### 1.0.19
+
+- Upgrade to @markw65/prettier-plugin-monkeyc@1.0.22
+
+  - fixes some minor typing issues for mctree
+  - special handling for certain parenthesized expressions.
+
+- Optimizer
+
+  - Handle more unused expressions, add tests, and prettify the OptimizerTests project
+  - Allow statement-style inlining in assignent and return contexts
+  - Add diagnostics for failure to inline
+
+- Tests
+
+  - More tweaks to pragma-checker
+  - Add launch and task configs for building/running tests
+
+- Code cleanup
+  - Properly type the results of JSON.parse
+  - Switch over to using ParenthesizedExpression for formatAst (depends on @markw65/prettier-plugin-monkeyc@1.0.22)

package/build/api.cjs

@@ -256,15 +256,30 @@ function inliningLooksUseful(func, node) {
     }
     return false;
 }
-var inliner_InlineStatus;
+var InlineStatus;
 (function (InlineStatus) {
     InlineStatus[InlineStatus["Never"] = 0] = "Never";
     InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
     InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
-})(inliner_InlineStatus || (inliner_InlineStatus = {}));
-function inliner_shouldInline(state, func, args) {
+})(InlineStatus || (InlineStatus = {}));
+function inlineRequested(state, func) {
+    const excludeAnnotations = (func.node.loc?.source &&
+        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
+        {};
+    if (func.node.attrs &&
+        func.node.attrs.attrs &&
+        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
+            (attr.argument.name === "inline" ||
+                (attr.argument.name.startsWith("inline_") &&
+                    hasProperty(excludeAnnotations, attr.argument.name.substring(7)))))) {
+        return true;
+    }
+    return false;
+}
+function inliner_shouldInline(state, func, call, context) {
     let autoInline = false;
     let inlineAsExpression = false;
+    const args = call.arguments;
     if (func.node.body &&
         func.node.body.body.length === 1 &&
         func.node.body.body[0].type === "ReturnStatement" &&
@@ -274,39 +289,30 @@ function inliner_shouldInline(state, func, args) {
         autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
     }
     if (autoInline === 1) {
-        return inliner_InlineStatus.AsExpression;
+        return true;
     }
-    const excludeAnnotations = (func.node.loc?.source &&
-        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
-        {};
-    const inlineRequested = func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.some((attr) => attr.type === "UnaryExpression" &&
-            (attr.argument.name === "inline" ||
-                (attr.argument.name.startsWith("inline_") &&
-                    hasProperty(excludeAnnotations, attr.argument.name.substring(7)))));
-    if (autoInline || inlineRequested) {
-        return inlineAsExpression && canInline(state, func, args)
-            ? inliner_InlineStatus.AsExpression
-            : inliner_InlineStatus.AsStatement;
+    const requested = inlineRequested(state, func);
+    if (autoInline || requested) {
+        if (inlineAsExpression) {
+            if (canInline(state, func, args)) {
+                return true;
+            }
+        }
+        if (!context && requested) {
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+        }
+        return context != null;
     }
-    return inliner_InlineStatus.Never;
+    return false;
 }
 function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
-    if (!params) {
-        const safeArgs = getArgSafety(state, func, call.arguments, false);
-        params = Object.fromEntries(func.node.params.map((param, i) => {
-            const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
-                ? i
-                : -1;
-            const name = variableDeclarationName(param);
-            return [name, argnum];
-        }));
-    }
+    let failed = false;
     const pre = state.pre;
     const post = state.post;
     try {
         state.pre = (node) => {
+            if (failed)
+                return [];
             node.start = call.start;
             node.end = call.end;
             node.loc = call.loc;
@@ -318,6 +324,11 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                 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);
@@ -342,6 +353,8 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
             return result;
         };
         state.post = (node) => {
+            if (failed)
+                return null;
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -356,22 +369,28 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     }
                     replacement = fixNodeScope(state, node, func.stack);
                     if (!replacement) {
-                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                        failed = true;
+                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+                        return null;
                     }
                     break;
                 }
             }
             return post(replacement || node, state) || replacement;
         };
-        return state.traverse(root) || null;
-    }
-    catch (ex) {
-        if (ex instanceof Error) {
-            if (ex.message.startsWith("Inliner: ")) {
-                return null;
-            }
+        let ret = state.traverse(root);
+        if (failed) {
+            return null;
+        }
+        if (ret === null) {
+            ret = root;
+        }
+        if (!ret) {
+            inlineDiagnostic(state, func, call, `Internal error`);
+            return null;
         }
-        throw ex;
+        inlineDiagnostic(state, func, call, null);
+        return ret;
     }
     finally {
         state.pre = pre;
@@ -394,7 +413,16 @@ function inliner_unused(expression, top) {
         case "UnaryExpression":
             return inliner_unused(expression.argument);
         case "MemberExpression":
-            return inliner_unused(expression.object).concat(inliner_unused(expression.property));
+            if (expression.computed) {
+                return inliner_unused(expression.object).concat(inliner_unused(expression.property));
+            }
+            return inliner_unused(expression.object);
+        case "ArrayExpression":
+            return expression.elements.map((e) => inliner_unused(e)).flat(1);
+        case "ObjectExpression":
+            return expression.properties
+                .map((p) => inliner_unused(p.key).concat(inliner_unused(p.value)))
+                .flat(1);
     }
     return top
         ? null
@@ -402,30 +430,98 @@ function inliner_unused(expression, top) {
             {
                 type: "ExpressionStatement",
                 expression,
+                start: expression.start,
+                end: expression.end,
+                loc: expression.loc,
             },
         ];
 }
-function inlineWithArgs(state, func, call) {
+function diagnostic(state, loc, message) {
+    if (!loc || !loc.source)
+        return;
+    const source = loc.source;
+    if (!state.diagnostics)
+        state.diagnostics = {};
+    if (!hasProperty(state.diagnostics, source)) {
+        if (!message)
+            return;
+        state.diagnostics[source] = [];
+    }
+    const diags = state.diagnostics[source];
+    let index = diags.findIndex((item) => item.loc === loc);
+    if (message) {
+        if (index < 0)
+            index = diags.length;
+        diags[index] = { type: "INFO", loc, message };
+    }
+    else if (index >= 0) {
+        diags.splice(index, 1);
+    }
+}
+function inlineDiagnostic(state, func, call, message) {
+    if (inlineRequested(state, func)) {
+        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+    }
+}
+function inlineWithArgs(state, func, call, context) {
     if (!func.node || !func.node.body) {
         return null;
     }
     let retStmtCount = 0;
-    traverseAst(func.node.body, (node) => {
-        node.type === "ReturnStatement" && retStmtCount++;
-    });
-    if (retStmtCount > 1 ||
-        (retStmtCount === 1 &&
-            func.node.body.body.slice(-1)[0].type !== "ReturnStatement")) {
-        return null;
+    if (context.type === "ReturnStatement") {
+        const last = func.node.body.body.slice(-1)[0];
+        if (!last || last.type !== "ReturnStatement") {
+            inlineDiagnostic(state, func, call, "Function didn't end with a return statement");
+            return null;
+        }
+    }
+    else {
+        traverseAst(func.node.body, (node) => {
+            node.type === "ReturnStatement" && retStmtCount++;
+        });
+        if (retStmtCount > 1) {
+            inlineDiagnostic(state, func, call, "Function had more than one return statement");
+        }
+        else if (context.type === "AssignmentExpression" && retStmtCount !== 1) {
+            inlineDiagnostic(state, func, call, "Function did not have a return statement");
+            return null;
+        }
+        if (retStmtCount === 1) {
+            const last = func.node.body.body.slice(-1)[0];
+            if (!last ||
+                last.type !== "ReturnStatement" ||
+                (context.type === "AssignmentExpression" && !last.argument)) {
+                inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
+                return null;
+            }
+        }
     }
     const body = JSON.parse(JSON.stringify(func.node.body));
-    processInlineBody(state, func, call, body, func.node.params.length ? false : true);
-    if (retStmtCount) {
+    const safeArgs = getArgSafety(state, func, call.arguments, false);
+    const params = Object.fromEntries(func.node.params.map((param, i) => {
+        const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
+            ? i
+            : -1;
+        const name = variableDeclarationName(param);
+        return [name, argnum];
+    }));
+    if (!processInlineBody(state, func, call, body, func.node.params.length ? false : true, params)) {
+        return null;
+    }
+    diagnostic(state, call.loc, null);
+    if (context.type !== "ReturnStatement" && retStmtCount) {
         const last = body.body[body.body.length - 1];
         if (last.type != "ReturnStatement") {
             throw new Error("ReturnStatement got lost!");
         }
-        if (last.argument) {
+        if (context.type === "AssignmentExpression") {
+            context.right = last.argument;
+            body.body[body.body.length - 1] = {
+                type: "ExpressionStatement",
+                expression: context,
+            };
+        }
+        else if (last.argument) {
             const side_exprs = inliner_unused(last.argument);
             body.body.splice(body.body.length - 1, 1, ...side_exprs);
         }
@@ -435,13 +531,13 @@ function inlineWithArgs(state, func, call) {
     }
     return body;
 }
-function inliner_inlineFunction(state, func, call, inlineStatus) {
-    if (inlineStatus == inliner_InlineStatus.AsStatement) {
-        return inlineWithArgs(state, func, call);
+function inliner_inlineFunction(state, func, call, context) {
+    if (context) {
+        return inlineWithArgs(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) || retArg;
+    return processInlineBody(state, func, call, retArg, true, params);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -456,13 +552,14 @@ function applyTypeIfNeeded(node) {
 }
 function fixNodeScope(state, lookupNode, nodeStack) {
     if (lookupNode.type === "Identifier") {
-        for (let i = state.stack.length; --i > nodeStack.length;) {
-            const si = state.stack[i];
-            if (hasProperty(si.decls, lookupNode.name)) {
-                // its a local from the inlined function.
-                // Nothing to do.
-                return lookupNode;
-            }
+        const locals = state.localsStack[state.localsStack.length - 1];
+        const { map } = locals;
+        if (!map)
+            throw new Error("No local variable map!");
+        if (hasProperty(map, lookupNode.name) && map[lookupNode.name] !== false) {
+            // map[name] !== false means its an entry that was created during inlining
+            // so its definitely one of our locals.
+            return lookupNode;
         }
     }
     const [, original] = state.lookup(lookupNode, null, nodeStack);
@@ -938,13 +1035,15 @@ function optimizeNode(node) {
     return null;
 }
 function evaluateFunction(func, args) {
-    if (args && args.length != func.params.length) {
+    if (!func.body || (args && args.length != func.params.length)) {
         return false;
     }
     const paramValues = args &&
         Object.fromEntries(func.params.map((p, i) => [variableDeclarationName(p), args[i]]));
     let ret = null;
-    const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+    const body = args
+        ? JSON.parse(JSON.stringify(func.body))
+        : func.body;
     try {
         traverseAst(body, (node) => {
             switch (node.type) {
@@ -1145,7 +1244,7 @@ async function optimizeMonkeyC(fnMap) {
                 if (map) {
                     if (hasProperty(map, node.name)) {
                         const name = map[node.name];
-                        if (name !== true) {
+                        if (typeof name === "string") {
                             node.name = name;
                         }
                     }
@@ -1236,21 +1335,49 @@ async function optimizeMonkeyC(fnMap) {
                     return node.body;
                 }
                 break;
+            case "ReturnStatement":
+                if (node.argument && node.argument.type === "CallExpression") {
+                    return optimizeCall(state, node.argument, node);
+                }
+                break;
             case "CallExpression": {
-                const ret = optimizeCall(state, node, false);
+                const ret = optimizeCall(state, node, null);
                 if (ret) {
                     replace(node, ret);
                 }
                 break;
             }
+            case "AssignmentExpression":
+                if (node.operator === "=" &&
+                    node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    return { type: "Literal", value: null, raw: "null" };
+                }
+                break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    const ret = optimizeCall(state, node.expression, true);
-                    if (ret) {
-                        if (ret.type === "BlockStatement") {
-                            return ret;
+                    return optimizeCall(state, node.expression, node);
+                }
+                else if (node.expression.type === "AssignmentExpression") {
+                    if (node.expression.right.type === "CallExpression") {
+                        let ok = false;
+                        if (node.expression.left.type === "Identifier") {
+                            if (hasProperty(topLocals().map, node.expression.left.type)) {
+                                ok = true;
+                            }
+                        }
+                        if (!ok && node.expression.operator == "=") {
+                            const [, result] = state.lookup(node.expression.left);
+                            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;
+                            }
                         }
-                        node.expression = ret;
                     }
                 }
                 else {
@@ -1341,8 +1468,9 @@ async function optimizeMonkeyC(fnMap) {
             return ret;
         });
     });
+    return state.diagnostics;
 }
-function optimizeCall(state, node, asStatement) {
+function optimizeCall(state, node, context) {
     const [name, callees] = state.lookup(node.callee);
     if (!callees || !callees.length) {
         const n = name ||
@@ -1362,7 +1490,8 @@ function optimizeCall(state, node, asStatement) {
     }
     if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
         const callee = callees[0].node;
-        if (callee.optimizable &&
+        if (!context &&
+            callee.optimizable &&
             !callee.hasOverride &&
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
             const ret = evaluateFunction(callee, node.arguments);
@@ -1370,10 +1499,8 @@ function optimizeCall(state, node, asStatement) {
                 return ret;
             }
         }
-        const inlineStatus = shouldInline(state, callees[0], node.arguments);
-        if (inlineStatus === InlineStatus.AsExpression ||
-            (asStatement && inlineStatus === InlineStatus.AsStatement)) {
-            const ret = inlineFunction(state, callees[0], node, inlineStatus);
+        if (shouldInline(state, callees[0], node, context)) {
+            const ret = inlineFunction(state, callees[0], node, context);
             if (ret) {
                 return ret;
             }
@@ -1382,7 +1509,7 @@ function optimizeCall(state, node, asStatement) {
     if (!hasProperty(state.calledFunctions, name)) {
         state.calledFunctions[name] = [];
     }
-    callees.forEach((c) => isStateNode(c) && state.calledFunctions[name].push(c.node));
+    callees.forEach((c) => isStateNode(c) && pushUnique(state.calledFunctions[name], c.node));
     return null;
 }
 
@@ -1927,10 +2054,10 @@ function formatAst(node, monkeyCSource = null) {
      * The estree printer sometimes looks at the parent node without
      * checking that there *is* a parent node (eg it assumes all
      * BinaryExpressions have a parent node, and crashes if they don't).
-     * To avoid issues, wrap nodes in an ExpressionStatement, and
-     * then remove the added ";" from the end.
+     * To avoid issues, wrap nodes in an ParenthesizedExpression.
+     * The printer knows that parentless ParenthesizedExpressions
+     * should be ignored.
      */
-    let unwrap = false;
     switch (node.type) {
         case "Program":
         case "BlockStatement":
@@ -1938,11 +2065,10 @@ function formatAst(node, monkeyCSource = null) {
             break;
         default: {
             const e = {
-                type: "ExpressionStatement",
+                type: "ParenthesizedExpression",
                 expression: node,
             };
             node = e;
-            unwrap = true;
         }
     }
     // If we *do* have the original source, pass that in ahead of the
@@ -1950,15 +2076,11 @@ function formatAst(node, monkeyCSource = null) {
     // as the ast itself, and the printers will find what they're
     // looking for in the source.
     const source = (monkeyCSource || "") + "\n" + JSON.stringify(node);
-    const result = external_prettier_namespaceObject.format(source, {
+    return external_prettier_namespaceObject.format(source, {
         parser: "monkeyc-json",
         plugins: [(prettier_plugin_monkeyc_default())],
         endOfLine: "lf",
     });
-    if (unwrap) {
-        return result.replace(/;$/, "");
-    }
-    return result;
 }
 function handleException(state, node, exception) {
     try {

package/build/optimizer.cjs

@@ -10983,9 +10983,24 @@ var InlineStatus;
     InlineStatus[InlineStatus["AsExpression"] = 1] = "AsExpression";
     InlineStatus[InlineStatus["AsStatement"] = 2] = "AsStatement";
 })(InlineStatus || (InlineStatus = {}));
-function shouldInline(state, func, args) {
+function inlineRequested(state, func) {
+    const excludeAnnotations = (func.node.loc?.source &&
+        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
+        {};
+    if (func.node.attrs &&
+        func.node.attrs.attrs &&
+        func.node.attrs.attrs.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)))))) {
+        return true;
+    }
+    return false;
+}
+function shouldInline(state, func, call, context) {
     let autoInline = false;
     let inlineAsExpression = false;
+    const args = call.arguments;
     if (func.node.body &&
         func.node.body.body.length === 1 &&
         func.node.body.body[0].type === "ReturnStatement" &&
@@ -10995,39 +11010,30 @@ function shouldInline(state, func, args) {
         autoInline = inliningLooksUseful(func.node, func.node.body.body[0].argument);
     }
     if (autoInline === 1) {
-        return InlineStatus.AsExpression;
+        return true;
     }
-    const excludeAnnotations = (func.node.loc?.source &&
-        state.fnMap[func.node.loc?.source]?.excludeAnnotations) ||
-        {};
-    const inlineRequested = func.node.attrs &&
-        func.node.attrs.attrs &&
-        func.node.attrs.attrs.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)))));
-    if (autoInline || inlineRequested) {
-        return inlineAsExpression && canInline(state, func, args)
-            ? InlineStatus.AsExpression
-            : InlineStatus.AsStatement;
+    const requested = inlineRequested(state, func);
+    if (autoInline || requested) {
+        if (inlineAsExpression) {
+            if (canInline(state, func, args)) {
+                return true;
+            }
+        }
+        if (!context && requested) {
+            inlineDiagnostic(state, func, call, "This function can only be inlined in statement, assignment, or return contexts");
+        }
+        return context != null;
     }
-    return InlineStatus.Never;
+    return false;
 }
 function processInlineBody(state, func, call, root, insertedVariableDecls, params) {
-    if (!params) {
-        const safeArgs = getArgSafety(state, func, call.arguments, false);
-        params = Object.fromEntries(func.node.params.map((param, i) => {
-            const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
-                ? i
-                : -1;
-            const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(param);
-            return [name, argnum];
-        }));
-    }
+    let failed = false;
     const pre = state.pre;
     const post = state.post;
     try {
         state.pre = (node) => {
+            if (failed)
+                return [];
             node.start = call.start;
             node.end = call.end;
             node.loc = call.loc;
@@ -11039,6 +11045,11 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                 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);
@@ -11063,6 +11074,8 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
             return result;
         };
         state.post = (node) => {
+            if (failed)
+                return null;
             let replacement = null;
             switch (node.type) {
                 case "Identifier": {
@@ -11077,22 +11090,28 @@ function processInlineBody(state, func, call, root, insertedVariableDecls, param
                     }
                     replacement = fixNodeScope(state, node, func.stack);
                     if (!replacement) {
-                        throw new Error(`Inliner: Couldn't fix the scope of '${node.name}`);
+                        failed = true;
+                        inlineDiagnostic(state, func, call, `Failed to resolve '${node.name}'`);
+                        return null;
                     }
                     break;
                 }
             }
             return post(replacement || node, state) || replacement;
         };
-        return state.traverse(root) || null;
-    }
-    catch (ex) {
-        if (ex instanceof Error) {
-            if (ex.message.startsWith("Inliner: ")) {
-                return null;
-            }
+        let ret = state.traverse(root);
+        if (failed) {
+            return null;
+        }
+        if (ret === null) {
+            ret = root;
         }
-        throw ex;
+        if (!ret) {
+            inlineDiagnostic(state, func, call, `Internal error`);
+            return null;
+        }
+        inlineDiagnostic(state, func, call, null);
+        return ret;
     }
     finally {
         state.pre = pre;
@@ -11115,7 +11134,16 @@ function unused(expression, top) {
         case "UnaryExpression":
             return unused(expression.argument);
         case "MemberExpression":
-            return unused(expression.object).concat(unused(expression.property));
+            if (expression.computed) {
+                return unused(expression.object).concat(unused(expression.property));
+            }
+            return unused(expression.object);
+        case "ArrayExpression":
+            return expression.elements.map((e) => unused(e)).flat(1);
+        case "ObjectExpression":
+            return expression.properties
+                .map((p) => unused(p.key).concat(unused(p.value)))
+                .flat(1);
     }
     return top
         ? null
@@ -11123,30 +11151,98 @@ function unused(expression, top) {
             {
                 type: "ExpressionStatement",
                 expression,
+                start: expression.start,
+                end: expression.end,
+                loc: expression.loc,
             },
         ];
 }
-function inlineWithArgs(state, func, call) {
+function diagnostic(state, loc, message) {
+    if (!loc || !loc.source)
+        return;
+    const source = loc.source;
+    if (!state.diagnostics)
+        state.diagnostics = {};
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.diagnostics, source)) {
+        if (!message)
+            return;
+        state.diagnostics[source] = [];
+    }
+    const diags = state.diagnostics[source];
+    let index = diags.findIndex((item) => item.loc === loc);
+    if (message) {
+        if (index < 0)
+            index = diags.length;
+        diags[index] = { type: "INFO", loc, message };
+    }
+    else if (index >= 0) {
+        diags.splice(index, 1);
+    }
+}
+function inlineDiagnostic(state, func, call, message) {
+    if (inlineRequested(state, func)) {
+        diagnostic(state, call.loc, message && `While inlining ${func.node.id.name}: ${message}`);
+    }
+}
+function inlineWithArgs(state, func, call, context) {
     if (!func.node || !func.node.body) {
         return null;
     }
     let retStmtCount = 0;
-    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
-        node.type === "ReturnStatement" && retStmtCount++;
-    });
-    if (retStmtCount > 1 ||
-        (retStmtCount === 1 &&
-            func.node.body.body.slice(-1)[0].type !== "ReturnStatement")) {
-        return null;
+    if (context.type === "ReturnStatement") {
+        const last = func.node.body.body.slice(-1)[0];
+        if (!last || last.type !== "ReturnStatement") {
+            inlineDiagnostic(state, func, call, "Function didn't end with a return statement");
+            return null;
+        }
+    }
+    else {
+        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+            node.type === "ReturnStatement" && retStmtCount++;
+        });
+        if (retStmtCount > 1) {
+            inlineDiagnostic(state, func, call, "Function had more than one return statement");
+        }
+        else if (context.type === "AssignmentExpression" && retStmtCount !== 1) {
+            inlineDiagnostic(state, func, call, "Function did not have a return statement");
+            return null;
+        }
+        if (retStmtCount === 1) {
+            const last = func.node.body.body.slice(-1)[0];
+            if (!last ||
+                last.type !== "ReturnStatement" ||
+                (context.type === "AssignmentExpression" && !last.argument)) {
+                inlineDiagnostic(state, func, call, "There was a return statement, but not at the end of the function");
+                return null;
+            }
+        }
     }
     const body = JSON.parse(JSON.stringify(func.node.body));
-    processInlineBody(state, func, call, body, func.node.params.length ? false : true);
-    if (retStmtCount) {
+    const safeArgs = getArgSafety(state, func, call.arguments, false);
+    const params = Object.fromEntries(func.node.params.map((param, i) => {
+        const argnum = safeArgs === true || (safeArgs !== false && safeArgs[i] !== null)
+            ? i
+            : -1;
+        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)) {
+        return null;
+    }
+    diagnostic(state, call.loc, null);
+    if (context.type !== "ReturnStatement" && retStmtCount) {
         const last = body.body[body.body.length - 1];
         if (last.type != "ReturnStatement") {
             throw new Error("ReturnStatement got lost!");
         }
-        if (last.argument) {
+        if (context.type === "AssignmentExpression") {
+            context.right = last.argument;
+            body.body[body.body.length - 1] = {
+                type: "ExpressionStatement",
+                expression: context,
+            };
+        }
+        else if (last.argument) {
             const side_exprs = unused(last.argument);
             body.body.splice(body.body.length - 1, 1, ...side_exprs);
         }
@@ -11156,13 +11252,13 @@ function inlineWithArgs(state, func, call) {
     }
     return body;
 }
-function inlineFunction(state, func, call, inlineStatus) {
-    if (inlineStatus == InlineStatus.AsStatement) {
-        return inlineWithArgs(state, func, call);
+function inlineFunction(state, func, call, context) {
+    if (context) {
+        return inlineWithArgs(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) || retArg;
+    return processInlineBody(state, func, call, retArg, true, params);
 }
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
@@ -11177,13 +11273,14 @@ function applyTypeIfNeeded(node) {
 }
 function fixNodeScope(state, lookupNode, nodeStack) {
     if (lookupNode.type === "Identifier") {
-        for (let i = state.stack.length; --i > nodeStack.length;) {
-            const si = state.stack[i];
-            if ((0,external_api_cjs_namespaceObject.hasProperty)(si.decls, lookupNode.name)) {
-                // its a local from the inlined function.
-                // Nothing to do.
-                return lookupNode;
-            }
+        const locals = state.localsStack[state.localsStack.length - 1];
+        const { map } = locals;
+        if (!map)
+            throw new Error("No local variable map!");
+        if ((0,external_api_cjs_namespaceObject.hasProperty)(map, lookupNode.name) && map[lookupNode.name] !== false) {
+            // map[name] !== false means its an entry that was created during inlining
+            // so its definitely one of our locals.
+            return lookupNode;
         }
     }
     const [, original] = state.lookup(lookupNode, null, nodeStack);
@@ -11656,13 +11753,15 @@ function optimizeNode(node) {
     return null;
 }
 function evaluateFunction(func, args) {
-    if (args && args.length != func.params.length) {
+    if (!func.body || (args && args.length != func.params.length)) {
         return false;
     }
     const paramValues = args &&
         Object.fromEntries(func.params.map((p, i) => [(0,external_api_cjs_namespaceObject.variableDeclarationName)(p), args[i]]));
     let ret = null;
-    const body = args ? JSON.parse(JSON.stringify(func.body)) : func.body;
+    const body = args
+        ? JSON.parse(JSON.stringify(func.body))
+        : func.body;
     try {
         (0,external_api_cjs_namespaceObject.traverseAst)(body, (node) => {
             switch (node.type) {
@@ -11863,7 +11962,7 @@ async function optimizeMonkeyC(fnMap) {
                 if (map) {
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
                         const name = map[node.name];
-                        if (name !== true) {
+                        if (typeof name === "string") {
                             node.name = name;
                         }
                     }
@@ -11954,21 +12053,49 @@ async function optimizeMonkeyC(fnMap) {
                     return node.body;
                 }
                 break;
+            case "ReturnStatement":
+                if (node.argument && node.argument.type === "CallExpression") {
+                    return optimizeCall(state, node.argument, node);
+                }
+                break;
             case "CallExpression": {
-                const ret = optimizeCall(state, node, false);
+                const ret = optimizeCall(state, node, null);
                 if (ret) {
                     replace(node, ret);
                 }
                 break;
             }
+            case "AssignmentExpression":
+                if (node.operator === "=" &&
+                    node.left.type === "Identifier" &&
+                    node.right.type === "Identifier" &&
+                    node.left.name === node.right.name) {
+                    return { type: "Literal", value: null, raw: "null" };
+                }
+                break;
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    const ret = optimizeCall(state, node.expression, true);
-                    if (ret) {
-                        if (ret.type === "BlockStatement") {
-                            return ret;
+                    return optimizeCall(state, node.expression, node);
+                }
+                else if (node.expression.type === "AssignmentExpression") {
+                    if (node.expression.right.type === "CallExpression") {
+                        let ok = false;
+                        if (node.expression.left.type === "Identifier") {
+                            if ((0,external_api_cjs_namespaceObject.hasProperty)(topLocals().map, node.expression.left.type)) {
+                                ok = true;
+                            }
+                        }
+                        if (!ok && node.expression.operator == "=") {
+                            const [, result] = state.lookup(node.expression.left);
+                            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;
+                            }
                         }
-                        node.expression = ret;
                     }
                 }
                 else {
@@ -12059,8 +12186,9 @@ async function optimizeMonkeyC(fnMap) {
             return ret;
         });
     });
+    return state.diagnostics;
 }
-function optimizeCall(state, node, asStatement) {
+function optimizeCall(state, node, context) {
     const [name, callees] = state.lookup(node.callee);
     if (!callees || !callees.length) {
         const n = name ||
@@ -12080,7 +12208,8 @@ function optimizeCall(state, node, asStatement) {
     }
     if (callees.length == 1 && callees[0].type === "FunctionDeclaration") {
         const callee = callees[0].node;
-        if (callee.optimizable &&
+        if (!context &&
+            callee.optimizable &&
             !callee.hasOverride &&
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
             const ret = evaluateFunction(callee, node.arguments);
@@ -12088,10 +12217,8 @@ function optimizeCall(state, node, asStatement) {
                 return ret;
             }
         }
-        const inlineStatus = shouldInline(state, callees[0], node.arguments);
-        if (inlineStatus === InlineStatus.AsExpression ||
-            (asStatement && inlineStatus === InlineStatus.AsStatement)) {
-            const ret = inlineFunction(state, callees[0], node, inlineStatus);
+        if (shouldInline(state, callees[0], node, context)) {
+            const ret = inlineFunction(state, callees[0], node, context);
             if (ret) {
                 return ret;
             }
@@ -12100,7 +12227,7 @@ function optimizeCall(state, node, asStatement) {
     if (!(0,external_api_cjs_namespaceObject.hasProperty)(state.calledFunctions, name)) {
         state.calledFunctions[name] = [];
     }
-    callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && state.calledFunctions[name].push(c.node));
+    callees.forEach((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && (0,external_util_cjs_namespaceObject.pushUnique)(state.calledFunctions[name], c.node));
     return null;
 }
 
@@ -12112,12 +12239,31 @@ function pragmaChecker(ast) {
         return;
     let index = -1;
     let comment;
+    let matchers;
     const next = () => {
         while (++index < comments.length) {
             comment = comments[index];
-            if (comment.value.match(/^\s*@match\s+/)) {
+            let match = comment.value.match(/^\s*@match\s+(.+)/);
+            if (!match)
+                continue;
+            let str = match[1];
+            matchers = [];
+            while ((match = str.match(/^([/%&#@"])(.+?(?<!\\)(?:\\{2})*)\1(\s+|$)/))) {
+                matchers.push({ quote: match[1], needle: match[2] });
+                str = str.substring(match[0].length);
+                if (!str.length)
+                    break;
+            }
+            if (!str.length)
                 break;
+            if (!matchers.length) {
+                match = str.match(/^(\S+)\s+$/);
+                if (match) {
+                    matchers.push({ quote: '"', needle: match[1] });
+                    break;
+                }
             }
+            throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
         }
     };
     next();
@@ -12125,29 +12271,23 @@ function pragmaChecker(ast) {
         if (index >= comments.length)
             return false;
         if (node.start && node.start >= (comment.end || Infinity)) {
-            let match = comment.value.match(/^\s*@match\s+([/%&#@"])(.+(?<!\\)(?:\\{2})*)\1\s+$/) || comment.value.match(/^\s*@match\s+(\S+)\s+$/);
-            if (!match) {
-                throw new Error(`Build pragma '${comment.value}' is invalid. In ${comment.loc.source}:${comment.loc.start.line}`);
-            }
+            const { quote, needle } = matchers.shift();
             const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node).replace(/[\r\n]/g, " ");
             let found = false;
-            let needle = match[1];
-            if (match.length == 2) {
+            if (quote == '"') {
                 found = haystack.includes(needle);
             }
             else {
-                if (needle == '"') {
-                    found = haystack.includes((needle = match[2]));
-                }
-                else {
-                    const re = new RegExp((needle = match[2]));
-                    found = re.test(haystack);
-                }
+                const re = new RegExp(needle);
+                found = re.test(haystack);
             }
             if (!found) {
-                throw new Error(`Didn't find '${needle}' in ${comment.loc.source}:${comment.loc.start.line}`);
+                throw new Error(`Didn't find '${needle}' at ${comment.loc.source}:${comment.loc.start.line}`);
+            }
+            if (!matchers.length) {
+                next();
             }
-            next();
+            return false;
         }
         return null;
     });
@@ -12236,7 +12376,7 @@ async function buildOptimizedProject(product, options) {
             config.releaseBuild = true;
         }
     }
-    const { jungleFiles, program, hasTests } = await generateOptimizedProject(config);
+    const { jungleFiles, program, hasTests, diagnostics } = await generateOptimizedProject(config);
     config.jungleFiles = jungleFiles;
     let bin = config.buildDir || "bin";
     let name = `optimized-${program}.prg`;
@@ -12255,6 +12395,7 @@ async function buildOptimizedProject(product, options) {
         delete config.testBuild;
     return build_project(product, config).then((result) => ({
         hasTests,
+        diagnostics,
         ...result,
     }));
 }
@@ -12393,6 +12534,7 @@ async function generateOptimizedProject(options) {
         (await checkManifest(xml, targets.map((t) => t.product)))) &&
         !dropBarrels;
     let hasTests = false;
+    let diagnostics = {};
     const promises = Object.keys(buildConfigs)
         .sort()
         .map((key) => {
@@ -12410,7 +12552,13 @@ async function generateOptimizedProject(options) {
                 e.products = products[key];
                 throw e;
             })
-                .then((t) => t && (hasTests = true))
+                .then((t) => {
+                if (t.hasTests)
+                    hasTests = true;
+                if (t.diagnostics) {
+                    diagnostics = { ...diagnostics, ...t.diagnostics };
+                }
+            })
             : promises_namespaceObject.rm(external_path_.resolve(workspace, outputPath), {
                 recursive: true,
                 force: true,
@@ -12481,6 +12629,7 @@ async function generateOptimizedProject(options) {
         xml,
         program: external_path_.basename(external_path_.dirname(manifest)),
         hasTests,
+        diagnostics,
     };
 }
 async function fileInfoFromConfig(workspace, output, buildConfig, extraExcludes) {
@@ -12559,7 +12708,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     const actualOptimizedFiles = (await (0,external_util_cjs_namespaceObject.globa)(external_path_.join(output, "**", "*.mc"), { mark: true }))
         .filter((file) => !file.endsWith("/"))
         .sort();
-    const { hasTests, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
+    const { hasTests, diagnostics: prevDiagnostics, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
         .catch(() => "{}"));
     // check that the set of files thats actually there is the same as the
     // set of files we're going to generate (in case eg a jungle file change
@@ -12577,13 +12726,13 @@ 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 && 1654389404778 < opt_time) {
-            return hasTests;
+        if (source_time < opt_time && 1654554780017 < opt_time) {
+            return { hasTests, diagnostics: prevDiagnostics };
         }
     }
     await promises_namespaceObject.rm(output, { recursive: true, force: true });
     await promises_namespaceObject.mkdir(output, { recursive: true });
-    await optimizeMonkeyC(fnMap);
+    const diagnostics = await optimizeMonkeyC(fnMap);
     return Promise.all(Object.values(fnMap).map(async (info) => {
         const name = info.output;
         const dir = external_path_.dirname(name);
@@ -12598,9 +12747,10 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         const hasTests = results.some((v) => v);
         return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
             hasTests,
+            diagnostics,
             ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
         }))
-            .then(() => hasTests);
+            .then(() => ({ hasTests, diagnostics }));
     });
 }
 async function getProjectAnalysis(targets, analysis, options) {

package/build/src/inliner.d.ts

@@ -4,10 +4,11 @@ export declare enum InlineStatus {
     AsExpression = 1,
     AsStatement = 2
 }
-export declare function shouldInline(state: ProgramStateAnalysis, func: FunctionStateNode, args: mctree.Node[]): InlineStatus;
+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.ExpressionStatement[];
 export declare function unused(expression: mctree.ExpressionStatement["expression"], top: true): mctree.ExpressionStatement[] | null;
-export declare function inlineFunction(state: ProgramStateAnalysis, func: FunctionStateNode, call: mctree.CallExpression, inlineStatus: InlineStatus): InlineBody | null;
+export declare type InlineContext = mctree.ReturnStatement | mctree.AssignmentExpression | mctree.ExpressionStatement;
+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/mc-rewrite.d.ts

@@ -4,4 +4,11 @@ export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>
 export declare function analyze(fnMap: FilesToOptimizeMap): Promise<ProgramStateAnalysis>;
 export declare function getLiteralFromDecls(decls: StateNodeDecl[]): null;
 export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
-export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap): Promise<void>;
+export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap): Promise<Record<string, {
+    type: "ERROR" | "WARNING" | "INFO";
+    loc: {
+        start: mctree.Position;
+        end: mctree.Position;
+    };
+    message: string;
+}[]> | undefined>;

package/build/src/optimizer.d.ts

@@ -126,7 +126,7 @@ declare global {
         localsStack?: {
             node?: mctree.Node;
             map?: {
-                [key: string]: true | string;
+                [key: string]: boolean | string;
             };
             inners?: {
                 [key: string]: true;
@@ -138,6 +138,14 @@ declare global {
         constants?: {
             [key: string]: mctree.Literal;
         };
+        diagnostics?: Record<string, {
+            type: "ERROR" | "WARNING" | "INFO";
+            loc: {
+                start: mctree.Position;
+                end: mctree.Position;
+            };
+            message: string;
+        }[]>;
     };
     type Finalized<T, Keys extends keyof T> = T & {
         [key in Keys]-?: NonNullable<T[key]>;
@@ -172,17 +180,34 @@ export declare function buildOptimizedProject(product: string | null, options: B
     program: string;
     product: string | null;
     hasTests: boolean | undefined;
+    diagnostics: Record<string, {
+        type: "ERROR" | "WARNING" | "INFO";
+        loc: {
+            start: mctree.Position;
+            end: mctree.Position;
+        };
+        message: string;
+    }[]> | undefined;
 }>;
 export declare function generateOptimizedProject(options: BuildConfig): Promise<{
     jungleFiles: string | undefined;
     program: string;
     xml?: undefined;
     hasTests?: undefined;
+    diagnostics?: undefined;
 } | {
     jungleFiles: string;
     xml: import("./manifest").ManifestXML;
     program: string;
     hasTests: boolean;
+    diagnostics: Record<string, {
+        type: "ERROR" | "WARNING" | "INFO";
+        loc: {
+            start: mctree.Position;
+            end: mctree.Position;
+        };
+        message: string;
+    }[]>;
 }>;
 export declare type PreAnalysis = {
     fnMap: FilesToOptimizeMap;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "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.21"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.22"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",