@markw65/monkeyc-optimizer 1.0.42 → 1.0.44

package/build/optimizer.cjs

@@ -4731,7 +4731,13 @@ function withLoc(node, start, end) {
             node.end = start.end;
         node.loc = { ...(node.loc || start.loc), start: start.loc.start };
     }
-    if (end && end.loc) {
+    if (end === false) {
+        if (node.loc) {
+            node.loc.end = node.loc.start;
+            node.end = node.start;
+        }
+    }
+    else if (end && end.loc) {
         node.end = end.end;
         node.loc = { ...(node.loc || end.loc), end: end.loc.end };
     }
@@ -4783,7 +4789,9 @@ function getNodeValue(node) {
         return [node, "Long"];
     }
     if (type === "string") {
-        return [node, "String"];
+        return node.raw.startsWith("'")
+            ? [node, "Char"]
+            : [node, "String"];
     }
     if (type === "boolean") {
         return [node, "Boolean"];
@@ -5092,6 +5100,12 @@ function getArgSafety(state, func, args, requireAll) {
     let allSafe = true;
     if (!args.every((arg, i) => {
         switch (arg.type) {
+            case "UnaryExpression":
+                if (arg.operator === ":") {
+                    safeArgs.push(true);
+                    return true;
+                }
+                break;
             case "Literal":
                 safeArgs.push(true);
                 return true;
@@ -5671,7 +5685,16 @@ function inlineWithArgs(state, func, call, context) {
     withLocDeep(body, context, context, true);
     return body;
 }
-function inlineFunction(state, func, call, context) {
+function isTypecheckArg(node, arg) {
+    return (node.type === "CallExpression" &&
+        node.callee.type === "Identifier" &&
+        node.callee.name === ":typecheck" &&
+        (arg === null ||
+            (node.arguments.length === 1 &&
+                node.arguments[0].type === "Literal" &&
+                node.arguments[0].value === arg)));
+}
+function inlineFunctionHelper(state, func, call, context) {
     if (context) {
         return inlineWithArgs(state, func, call, context);
     }
@@ -5682,6 +5705,33 @@ function inlineFunction(state, func, call, context) {
     state.localsStack[state.localsStack.length - 1].map = map;
     return ret && withLocDeep(ret, call, call, true);
 }
+function inlineFunction(state, func, call, context) {
+    const ret = inlineFunctionHelper(state, func, call, context);
+    if (!ret)
+        return ret;
+    const typecheckFalse = func.node.attrs?.attributes?.elements.find((attr) => isTypecheckArg(attr, false));
+    if (!typecheckFalse) {
+        return ret;
+    }
+    const callerSn = state.stack.find((sn) => sn.type === "FunctionDeclaration");
+    if (!callerSn) {
+        return ret;
+    }
+    const caller = callerSn.node;
+    if (!caller.attrs) {
+        caller.attrs = withLoc({
+            type: "AttributeList",
+        }, caller, false);
+    }
+    if (!caller.attrs.attributes) {
+        caller.attrs.attributes = withLoc({ type: "Attributes", elements: [] }, caller.attrs, false);
+    }
+    if (caller.attrs.attributes.elements.find((attr) => isTypecheckArg(attr, null))) {
+        return ret;
+    }
+    caller.attrs.attributes.elements.unshift(withLocDeep({ ...typecheckFalse }, caller.attrs, false));
+    return ret;
+}
 function applyTypeIfNeeded(node) {
     if ("enumType" in node && node.enumType) {
         node = {
@@ -5837,7 +5887,7 @@ function pragmaChecker(state, ast, diagnostics) {
         if (quote == '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@([\d\w]+)/g, "(pre_)?$1(_\\d+)?"));
+        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/[".]/g, "_")}(?:_\\d+)?)`));
         return re.test(haystack);
     };
     next();
@@ -7784,7 +7834,7 @@ function getLiteralNode(node) {
             case "-": {
                 const [arg, type] = getNodeValue(node.argument);
                 if (type === "Number" || type === "Long") {
-                    return replacementLiteral(arg, -arg.value, type);
+                    return replacementLiteral(node, -arg.value, type);
                 }
             }
         }
@@ -7834,8 +7884,14 @@ function isBooleanExpression(state, node) {
     }
     return false;
 }
+function roundToFloat(value) {
+    return new Float32Array([value])[0];
+}
 function replacementLiteral(arg, value, type) {
-    if (typeof value === "boolean") {
+    if (value === null) {
+        type = "Null";
+    }
+    else if (typeof value === "boolean") {
         type = "Boolean";
     }
     else if (type === "Number") {
@@ -7844,32 +7900,189 @@ function replacementLiteral(arg, value, type) {
     else if (type === "Long") {
         value = BigInt.asIntN(64, BigInt(value));
     }
+    else if (type === "Float") {
+        value = roundToFloat(Number(value));
+    }
+    let raw = type === "String"
+        ? JSON.stringify(value)
+        : type === "Char"
+            ? value === "'"
+                ? "'\\''"
+                : "'" + JSON.stringify(value).slice(1, -1) + "'"
+            : value == null
+                ? "null"
+                : value.toString();
+    if (type === "Long") {
+        raw += "l";
+    }
+    else if (type === "Double") {
+        raw += "d";
+    }
+    else if (type === "Float" && prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.test(raw)) {
+        raw += "f";
+    }
+    const { start, end, loc } = arg;
     return {
-        ...arg,
+        type: "Literal",
         value,
-        raw: value.toString() + (type === "Long" ? "l" : ""),
+        raw,
+        start,
+        end,
+        loc,
     };
 }
+function classify(arg) {
+    switch (arg) {
+        case "Number":
+            return { big: false, int: true };
+        case "Long":
+            return { big: true, int: true };
+        case "Float":
+            return { big: false, int: false };
+        case "Double":
+            return { big: true, int: false };
+    }
+    return null;
+}
+function common_arith_types(left, right) {
+    const l = classify(left);
+    if (!l)
+        return null;
+    const r = classify(right);
+    if (!r)
+        return null;
+    if (l.big || r.big) {
+        return l.int && r.int
+            ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
+            : ["Double", (v) => Number(v)];
+    }
+    else {
+        return l.int && r.int
+            ? ["Number", (v) => BigInt.asIntN(32, BigInt(v))]
+            : ["Float", (v) => roundToFloat(Number(v))];
+    }
+}
+function common_bitwise_types(left, right) {
+    if (left === "Boolean" && right === "Boolean") {
+        return ["Boolean", (v) => (v ? true : false)];
+    }
+    const l = classify(left);
+    if (!l)
+        return null;
+    const r = classify(right);
+    if (!r)
+        return null;
+    if (!l.int || !r.int)
+        return null;
+    return l.big || r.big
+        ? ["Long", (v) => BigInt.asIntN(64, BigInt(v))]
+        : ["Number", (v) => Number(BigInt.asIntN(32, BigInt(v)))];
+}
+function plus_types(left, right) {
+    if (left === "String" || right === "String") {
+        // Boolean + String is an error, and
+        // Float/Double + String is legal, but its hard to predict
+        // the way the float will be formatted (and it won't match
+        // what javascript would do by default)
+        if (/Float|Double|Boolean/.test(left + right)) {
+            return null;
+        }
+        return ["String", String];
+    }
+    if (left === "Char" || right === "Char") {
+        if (left === right) {
+            // adding two chars produces a string
+            return ["String", String];
+        }
+        if (/Number|Long/.test(left + right)) {
+            return ["Char", (v) => v];
+        }
+    }
+    return common_arith_types(left, right);
+}
+function shift_mod_types(left, right) {
+    const result = common_bitwise_types(left, right);
+    if (result && result[0] === "Boolean") {
+        return null;
+    }
+    return result;
+}
 const operators = {
-    "+": (left, right) => left + right,
-    "-": (left, right) => left - right,
-    "*": (left, right) => left * right,
-    "/": (left, right) => left / right,
-    "%": (left, right) => left % right,
-    "&": (left, right) => left & right,
-    "|": (left, right) => left | right,
-    "^": (left, right) => left ^ right,
-    "<<": (left, right) => left << (right & 127n),
-    ">>": (left, right) => left >> (right & 127n),
-    "==": (left, right) => 
-    // two string literals will compare unequal, becuase string
-    // equality is object equality.
-    typeof left === "string" ? false : left === right,
-    "!=": (left, right) => typeof left === "string" ? true : left !== right,
-    "<=": (left, right) => left <= right,
-    ">=": (left, right) => left >= right,
-    "<": (left, right) => left < right,
-    ">": (left, right) => left > right,
+    "+": {
+        typeFn: plus_types,
+        valueFn: (left, right) => typeof left === "string" && typeof right !== "string"
+            ? String.fromCharCode(left.charCodeAt(0) + Number(right))
+            : typeof left !== "string" && typeof right === "string"
+                ? String.fromCharCode(right.charCodeAt(0) + Number(left))
+                : left + right,
+    },
+    "-": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left - right,
+    },
+    "*": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left * right,
+    },
+    "/": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left / right,
+    },
+    "%": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => left % right,
+    },
+    "&": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left & right,
+    },
+    "|": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left | right,
+    },
+    "^": {
+        typeFn: common_bitwise_types,
+        valueFn: (left, right) => left ^ right,
+    },
+    "<<": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => typeof right === "bigint"
+            ? left << right
+            : left << right,
+    },
+    ">>": {
+        typeFn: shift_mod_types,
+        valueFn: (left, right) => typeof right === "bigint"
+            ? left >> right
+            : left >> right,
+    },
+    "==": {
+        typeFn: () => ["Boolean", (v) => v],
+        valueFn: (left, right) => 
+        // two string literals will compare unequal, becuase string
+        // equality is object equality.
+        typeof left === "string" ? false : left === right,
+    },
+    "!=": {
+        typeFn: () => ["Boolean", (v) => v],
+        valueFn: (left, right) => typeof left === "string" ? true : left !== right,
+    },
+    "<=": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left <= right,
+    },
+    ">=": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left >= right,
+    },
+    "<": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left < right,
+    },
+    ">": {
+        typeFn: common_arith_types,
+        valueFn: (left, right) => left > right,
+    },
     as: null,
     instanceof: null,
     has: null,
@@ -7882,23 +8095,31 @@ function optimizeNode(state, node) {
                 break;
             switch (node.operator) {
                 case "+":
-                    if (type === "Number" || type === "Long") {
+                    if (type === "Number" ||
+                        type === "Long" ||
+                        type === "Float" ||
+                        type === "Double" ||
+                        type === "Char" ||
+                        type === "String") {
                         return arg;
                     }
                     break;
                 case "-":
-                    if (type === "Number" || type === "Long") {
-                        return replacementLiteral(arg, -arg.value, type);
+                    if (type === "Number" ||
+                        type === "Long" ||
+                        type === "Float" ||
+                        type === "Double") {
+                        return replacementLiteral(node, -arg.value, type);
                     }
                     break;
                 case "!":
                 case "~":
                     {
                         if (type === "Number" || type === "Long") {
-                            return replacementLiteral(arg, ~BigInt(arg.value), type);
+                            return replacementLiteral(node, ~BigInt(arg.value), type);
                         }
                         if (type === "Boolean" && node.operator == "!") {
-                            return replacementLiteral(arg, !arg.value, type);
+                            return replacementLiteral(node, !arg.value, type);
                         }
                     }
                     break;
@@ -7912,23 +8133,13 @@ function optimizeNode(state, node) {
                 const [right, right_type] = getNodeValue(node.right);
                 if (!left || !right)
                     break;
-                let value = null;
-                let type;
-                if ((left_type != "Number" && left_type != "Long") ||
-                    left_type != right_type) {
-                    if (node.operator !== "==" && node.operator !== "!=") {
-                        break;
-                    }
-                    value = operators[node.operator](left.value, right.value);
-                    type = "Boolean";
-                }
-                else {
-                    type = left_type;
-                    value = op(BigInt(left.value), BigInt(right.value));
-                }
+                const type = op.typeFn(left_type, right_type);
+                if (!type)
+                    break;
+                const value = op.valueFn(type[1](left.value), type[1](right.value));
                 if (value === null)
                     break;
-                return replacementLiteral(left, value, type);
+                return replacementLiteral(node, value, type[0]);
             }
             break;
         }
@@ -9218,7 +9429,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
         // 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 && 1670349312602 < opt_time) {
+        if (source_time < opt_time && 1670782882733 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -9245,7 +9456,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.0.42",
+                optimizerVersion: "1.0.44",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));