@markw65/monkeyc-optimizer 1.0.42 → 1.0.44

package/build/api.cjs

@@ -466,7 +466,13 @@ function ast_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 };
     }
@@ -518,7 +524,9 @@ function ast_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"];
@@ -829,6 +837,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;
@@ -1408,7 +1422,16 @@ function inlineWithArgs(state, func, call, context) {
     withLocDeep(body, context, context, true);
     return body;
 }
-function inliner_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);
     }
@@ -1419,6 +1442,33 @@ function inliner_inlineFunction(state, func, call, context) {
     state.localsStack[state.localsStack.length - 1].map = map;
     return ret && withLocDeep(ret, call, call, true);
 }
+function inliner_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 = {
@@ -1574,7 +1624,7 @@ function pragma_checker_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();
@@ -3524,7 +3574,7 @@ function getLiteralNode(node) {
             case "-": {
                 const [arg, type] = ast_getNodeValue(node.argument);
                 if (type === "Number" || type === "Long") {
-                    return replacementLiteral(arg, -arg.value, type);
+                    return replacementLiteral(node, -arg.value, type);
                 }
             }
         }
@@ -3574,8 +3624,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") {
@@ -3584,32 +3640,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,
@@ -3622,23 +3835,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;
@@ -3652,23 +3873,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;
         }
@@ -4559,6 +4770,8 @@ const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
 ;// CONCATENATED MODULE: ./src/resources.ts
 
 
+
+
 /*
  * This is unavoidably ad-hoc. Garmin has arbitrary rules for how
  * resources can be nested, which we need to mimic here.
@@ -4711,7 +4924,7 @@ function visit_resources(elements, parent, v) {
             visitor.post(e);
     });
 }
-function add_resources_to_ast(ast, resources, manifestXML) {
+function add_resources_to_ast(state, ast, resources, manifestXML) {
     const modules = {
         Drawables: true,
         Fonts: true,
@@ -4748,10 +4961,12 @@ function add_resources_to_ast(ast, resources, manifestXML) {
         body.push(rez);
         const hiddenRez = makeModule("*Rez*");
         rez.body.body.push(hiddenRez);
-        if (manifestXML && manifestXML.body instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Nodes) {
+        if (barrel === "" &&
+            manifestXML &&
+            manifestXML.body instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Nodes) {
             manifestXML.body
                 .children("iq:application")
-                .elements.forEach((e) => add_one_resource(rez, e));
+                .elements.forEach((e) => add_one_resource(state, manifestXML, rez, e));
         }
         const rezModules = Object.fromEntries(Object.entries(modules).map(([moduleName, isPublic]) => {
             const module = makeModule(moduleName);
@@ -4767,7 +4982,7 @@ function add_resources_to_ast(ast, resources, manifestXML) {
                 if (!ast_hasProperty(rezModules, s))
                     return;
                 const module = rezModules[s];
-                add_one_resource(module, e);
+                add_one_resource(state, rez, module, e);
             });
         });
     });
@@ -4785,7 +5000,7 @@ function makeMemberExpression(object, property) {
 }
 function makeScopedName(dotted, l) {
     const loc = l && adjustLoc(l, 0, l.start.offset - l.end.offset);
-    return dotted.split(".").reduce(({ cur, offset }, next) => {
+    return dotted.split(/\s*\.\s*/).reduce(({ cur, offset }, next) => {
         const id = makeIdentifier(next, loc && adjustLoc(loc, offset, offset + next.length));
         if (!cur) {
             cur = id;
@@ -4797,44 +5012,144 @@ function makeScopedName(dotted, l) {
         return { cur, offset };
     }, { cur: null, offset: 0 }).cur;
 }
-function visit_resource_refs(e) {
+const drawableSkips = {
+    x: { center: true, left: true, right: true, start: true },
+    y: { center: true, top: true, bottom: true, start: true },
+    width: { fill: true },
+    height: { fill: true },
+    a: { fill: true },
+    b: { fill: true },
+    color: {},
+    corner_radius: {},
+    radius: {},
+    border_width: {},
+    border_color: {},
+    foreground: {},
+    background: {},
+    font: {},
+    justification: {},
+};
+function addPositions(base, pos) {
+    const result = { ...base };
+    if (pos.line > 1) {
+        result.line += pos.line - 1;
+        result.column = pos.column;
+    }
+    else {
+        result.column += pos.column - 1;
+    }
+    result.offset += pos.offset;
+    return result;
+}
+function visit_resource_refs(state, doc, e) {
     const result = [];
-    const stringToScopedName = (element, id, dotted, l) => {
-        const match = dotted.match(/^(@)?([\w_$]+\s*\.\s*)*[\w_$]+$/);
-        if (!match)
-            return;
-        let offset = 0;
-        if (match[1]) {
-            offset = 1;
+    const parseArg = (name, loc, skip) => {
+        if (name.startsWith("@")) {
+            name = name.substring(1);
+            loc = adjustLoc(loc, 1, 0);
         }
-        else if ((element === "drawable" && id === "class") ||
-            (element === "iq:application" && id === "entry")) {
-            // nothing to do
+        if (ast_hasProperty(skip, name)) {
+            return;
         }
-        else {
+        if (/^([\w_$]+\s*\.\s*)*[\w_$]+$/.test(name)) {
+            const dn = makeScopedName(name, loc);
+            if (dn)
+                result.push(dn);
             return;
         }
-        const dn = makeScopedName(dotted.substring(offset), adjustLoc(l, offset, 0));
-        if (dn)
-            result.push(dn);
+        // We wrap the expression in parentheses, so adjust
+        // the start position by 1 character to compensate
+        // for the opening '('
+        const startPos = adjustLoc(loc, -1, 0).start;
+        try {
+            const expr = prettier_plugin_monkeyc_default().parsers.monkeyc.parse(`(${name})`, null, {
+                filepath: loc.source || undefined,
+                singleExpression: true,
+            });
+            ast_traverseAst(expr, (node) => {
+                if (node.loc) {
+                    node.loc = {
+                        source: node.loc.source,
+                        start: addPositions(startPos, node.loc.start),
+                        end: addPositions(startPos, node.loc.end),
+                    };
+                    node.start = (node.start || 0) + startPos.offset;
+                    node.end = (node.end || 0) + startPos.offset;
+                }
+            });
+            result.push(expr);
+        }
+        catch (ex) {
+            if (state) {
+                const check = state.config?.checkInvalidSymbols;
+                if (check !== "OFF" && ex instanceof Error) {
+                    const error = ex;
+                    if (error.location) {
+                        const location = {
+                            source: error.location.source,
+                            start: addPositions(startPos, error.location.start),
+                            end: addPositions(startPos, error.location.end),
+                        };
+                        inliner_diagnostic(state, location, ex.message, check || "WARNING");
+                    }
+                }
+            }
+        }
     };
-    visit_resources([e], null, {
-        pre(node) {
-            if (node.type === "element") {
-                Object.values(node.attr).forEach((attr) => {
-                    if (!attr || !attr.value.loc)
-                        return;
-                    const loc = adjustLoc(attr.value.loc);
-                    attr &&
-                        stringToScopedName(node.name, attr.name.value, attr.value.value, loc);
-                });
-                if (node.children &&
-                    node.children.length === 1 &&
-                    node.children[0].type === "chardata") {
-                    stringToScopedName(node.name, null, node.children[0].value, node.children[0].loc);
+    const stringToScopedName = (element, id, dotted, l) => {
+        dotted = doc.processRefs(dotted);
+        if (dotted.startsWith("@")) {
+            return parseArg(dotted, l);
+        }
+        if (/^\s*(true|false|null|NaN|(0x|#)[0-9a-f]+|[-+]?\d+%?)\s*$/i.test(dotted)) {
+            return;
+        }
+        switch (element.name) {
+            case "param":
+                if (id === null) {
+                    parseArg(dotted, l);
+                }
+                return;
+            case "drawable":
+                if (id === "class") {
+                    parseArg(dotted, l);
                 }
                 return;
+            case "shape":
+            case "bitmap":
+            case "drawable-list":
+            case "text-area":
+            case "label":
+                if (id && ast_hasProperty(drawableSkips, id)) {
+                    parseArg(dotted, l, drawableSkips[id]);
+                }
+                return;
+            case "iq:application":
+                if (id === "entry") {
+                    parseArg(dotted, l);
+                }
+                return;
+            default:
+                return;
+        }
+    };
+    external_sdk_util_cjs_namespaceObject.xmlUtil.visit_xml([e], {
+        pre(node) {
+            if (node.type !== "element")
+                return false;
+            Object.values(node.attr).forEach((attr) => {
+                if (!attr || !attr.value.loc)
+                    return;
+                const loc = adjustLoc(attr.value.loc);
+                attr &&
+                    stringToScopedName(node, attr.name.value, attr.value.value, loc);
+            });
+            const content = doc.textContent(node);
+            if (content) {
+                stringToScopedName(node, null, content, locRange(node.children[0].loc, node.children[node.children.length - 1].loc));
+                return false;
             }
+            return;
         },
     });
     return result;
@@ -4870,7 +5185,7 @@ function adjustLoc(loc, start = 1, end = -1) {
         },
     };
 }
-function add_one_resource(module, e) {
+function add_one_resource(state, doc, module, e) {
     let id;
     let func;
     const varDecl = () => {
@@ -4883,24 +5198,24 @@ function add_one_resource(module, e) {
                     kind: "var",
                     id: makeIdentifier(id ? id.value.value : "*invalid*", loc),
                     init,
-                }, loc),
+                }, e.loc),
             ],
             kind: "var",
-        }, loc);
+        }, e.loc);
     };
     const classDecl = (parent) => {
         if (!id)
             return null;
         const loc = id.value.loc;
         const items = init
-            ? [{ type: "ClassElement", item: varDecl(), loc }]
+            ? [{ type: "ClassElement", item: varDecl(), loc: e.loc }]
             : [];
         return {
             type: "ClassDeclaration",
-            body: { type: "ClassBody", body: items, loc },
+            body: { type: "ClassBody", body: items, loc: e.loc },
             id: makeIdentifier(id.value.value, loc),
             superClass: makeScopedName(parent),
-            loc,
+            loc: e.loc,
         };
     };
     switch (e.name) {
@@ -4942,7 +5257,7 @@ function add_one_resource(module, e) {
     }
     if (!func)
         return;
-    const elements = visit_resource_refs(e);
+    const elements = visit_resource_refs(state, doc, e);
     const init = elements.length
         ? { type: "ArrayExpression", elements }
         : undefined;
@@ -5178,7 +5493,7 @@ async function api_getApiMapping(state, resourcesMap, manifestXML) {
             const rezAst = state
                 ? state.rezAst || { type: "Program", body: [] }
                 : ast;
-            add_resources_to_ast(rezAst, resourcesMap, manifestXML);
+            add_resources_to_ast(state, rezAst, resourcesMap, manifestXML);
             if (state) {
                 state.rezAst = rezAst;
                 state.manifestXML = manifestXML;