@markw65/monkeyc-optimizer 1.0.43 → 1.0.44

package/README.md

@@ -518,3 +518,13 @@ Bug Fixes
 - Add Symbols (`:name`) to the list of things the inliner knows are constants
 - Propagate `:typecheck(false)` to the caller when inlining
 - Fix an issue with bogus undefined symbols being reported against manifest.xml in some projects that use barrels.
+
+### 1.0.44
+
+- Update to [@markw65/prettier-plugin-monkeyc@1.0.40](https://github.com/markw65/prettier-plugin-monkeyc#1040)
+
+  - Fixes location ranges associated with parenthesized expressions
+  - Fixes parsing of Lang.Char literals
+
+- Add more parsing of expressions embedded in resource files. This should now be complete, in that the analasis pass should see every symbol definition and reference from anywhere in the project.
+- Generalize constant folding to (nearly) all supported types. We don't fold additions between Float or Double and String, because the exact behavior is [buggy and upredictable](https://forums.garmin.com/developer/connect-iq/i/bug-reports/sdk-4-1-7-constant-folds-floats-strings-incorrectly)

package/build/api.cjs

@@ -524,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"];
@@ -1622,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();
@@ -3572,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);
                 }
             }
         }
@@ -3622,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") {
@@ -3632,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,
@@ -3670,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;
@@ -3700,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;
         }
@@ -4607,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.
@@ -4759,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,
@@ -4801,7 +4966,7 @@ function add_resources_to_ast(ast, resources, 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);
@@ -4817,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);
             });
         });
     });
@@ -4835,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;
@@ -4847,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;
@@ -4920,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 = () => {
@@ -4933,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) {
@@ -4992,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;
@@ -5228,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;