@markw65/monkeyc-optimizer 1.1.4 → 1.1.5

package/README.md

@@ -636,3 +636,9 @@ Bug Fixes
 - Code cleanup
   - refactor some of the type code for better type safety
   - turn on the eslint rule eqeqeq and fix all the issues
+
+### 1.1.5
+
+- Bug fixes
+  - Always evaluate a constant's initializer to determine its type
+  - Fix a bug refining the object type based on the properties it accesses that could lose the type of the object.

package/build/api.cjs

@@ -3022,45 +3022,115 @@ function printBlockState(block, state, indent = "") {
         console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state, key) : ""}`);
     });
 }
-function filterDecls(decls, possible) {
+/*
+ * We have an object, and a MemberExpression object.<name>
+ *  - decls are the StateNodes associated with the known type
+ *    of object.
+ *  - possible are all the StateNodes that declare <name>
+ *
+ * We want to find all the elements of possible which are
+ * "compatible" with decls, which tells us the set of things
+ * that object.<name> could correspond to, and also what that
+ * tells us about object.
+ *
+ * The return value is two arrays of StateNode. The first
+ * gives the refined type of object, and the second is the
+ * array of StateNodes that could declare <name>
+ */
+function filterDecls(decls, possible, name) {
     if (!possible)
-        return null;
-    return decls.reduce((cur, decl) => {
+        return [null, null];
+    const result = decls.reduce((cur, decl) => {
         const found = possible.reduce((flag, poss) => {
             if (decl === poss ||
-                (poss.type === "ClassDeclaration" &&
-                    (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(poss)?.has(decl)) ||
-                (decl.type === "ClassDeclaration" && (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(decl)?.has(poss))) {
-                if (!cur)
-                    cur = [poss];
-                else
-                    cur.push(poss);
+                (poss.type === "ClassDeclaration" && (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(poss)?.has(decl))) {
+                // poss extends decl, so decl must actually be a poss
+                // eg we know obj is an Object, and we call obj.toNumber
+                // so possible includes all the classes that declare toNumber
+                // so we can refine obj's type to the union of those types
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(poss);
+                cur[1].add(poss);
+                return true;
+            }
+            else if (decl.type === "ClassDeclaration" &&
+                (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(decl)?.has(poss)) {
+                // decl extends poss, so decl remains unchanged
+                // eg we know obj is Menu2, we call obj.toString
+                // Menu2 doesn't define toString, but Object does
+                // so poss is Object. But we still know that
+                // obj is Menu2
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(decl);
+                cur[1].add(poss);
                 return true;
             }
             return flag;
         }, false);
         if (!found) {
-            possible.some((poss) => {
-                if (decl.stack?.some((sn) => sn.decls === poss.decls)) {
-                    if (!cur)
-                        cur = [poss];
-                    else
-                        cur.push(poss);
-                    return true;
-                }
-                return false;
-            });
+            // If we didn't find the property in any of the
+            // standard places, the runtime might still find
+            // it by searching up the Module stack (and up
+            // the module stack from any super classes)
+            //
+            // eg
+            //
+            //  obj = Application.getApp();
+            //  obj.Properties.whatever
+            //
+            // Properties doesn't exist on AppBase, but AppBase
+            // is declared in Application, and Application
+            // does declare Properties. So Application.Properties
+            // is (one of) the declarations we should find; but we
+            // must not refine obj's type to include Application.
+            let d = [decl];
+            do {
+                d.forEach((d) => {
+                    const stack = d.stack;
+                    possible.forEach((poss) => {
+                        for (let i = stack.length; i--;) {
+                            const sn = stack[i];
+                            if (sn.decls === poss.decls) {
+                                if (!cur[0]) {
+                                    cur = [new Set(), new Set()];
+                                }
+                                cur[0].add(decl);
+                                cur[1].add(poss);
+                                break;
+                            }
+                            if ((0,_api__WEBPACK_IMPORTED_MODULE_0__.hasProperty)(sn.decls, name)) {
+                                break;
+                            }
+                        }
+                    });
+                });
+                d = d.flatMap((d) => {
+                    if (d.type !== "ClassDeclaration" ||
+                        !d.superClass ||
+                        d.superClass === true) {
+                        return [];
+                    }
+                    return d.superClass;
+                });
+            } while (d.length);
         }
         return cur;
-    }, null);
+    }, [null, null]);
+    if (!result[0])
+        return [null, null];
+    return [Array.from(result[0]), Array.from(result[1])];
 }
 function findObjectDeclsByProperty(state, object, next) {
     const decls = (0,_type_flow_types__WEBPACK_IMPORTED_MODULE_11__/* .getStateNodeDeclsFromType */ .iX)(state, object);
     if (!decls)
-        return null;
+        return [null, null];
     const possibleDecls = (0,_api__WEBPACK_IMPORTED_MODULE_0__.hasProperty)(state.allDeclarations, next.property.name) &&
         state.allDeclarations[next.property.name];
-    return filterDecls(decls, possibleDecls);
+    return filterDecls(decls, possibleDecls, next.property.name);
 }
 function refineObjectTypeByDecls(istate, object, trueDecls) {
     const refinedType = typeFromTypeStateNodes(istate.state, trueDecls);
@@ -3076,13 +3146,13 @@ function findNextObjectType(istate, trueDecls, next) {
     }, { type: 0 /* TypeTag.Never */ });
 }
 function resolveDottedMember(istate, object, next) {
-    const decls = findObjectDeclsByProperty(istate.state, object, next);
-    if (!decls)
+    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, object, next);
+    if (!objDecls)
         return null;
-    const property = findNextObjectType(istate, decls, next);
+    const property = findNextObjectType(istate, trueDecls, next);
     if (!property)
         return null;
-    const type = refineObjectTypeByDecls(istate, object, decls);
+    const type = refineObjectTypeByDecls(istate, object, objDecls);
     const mayThrow = !subtypeOf(object, type);
     return { mayThrow, object: type, property };
 }
@@ -3119,11 +3189,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                     next = value.obj[me.property.name];
                 }
                 else {
-                    const trueDecls = findObjectDeclsByProperty(istate.state, cur, me);
-                    if (!trueDecls) {
+                    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, cur, me);
+                    if (!objDecls) {
                         return null;
                     }
-                    cur = refineObjectTypeByDecls(istate, cur, trueDecls);
+                    cur = refineObjectTypeByDecls(istate, cur, objDecls);
                     next = findNextObjectType(istate, trueDecls, me);
                 }
             }
@@ -5288,9 +5358,9 @@ function getLhsConstraint(istate, node) {
         }
         const object = istate.typeMap.get(node.object);
         if (object && !node.computed) {
-            const objDecls = findObjectDeclsByProperty(istate.state, object, node);
-            if (objDecls) {
-                lookupDefs = lookupNext(istate.state, [{ parent: null, results: objDecls }], "decls", node.property);
+            const [, trueDecls] = findObjectDeclsByProperty(istate.state, object, node);
+            if (trueDecls) {
+                lookupDefs = lookupNext(istate.state, [{ parent: null, results: trueDecls }], "decls", node.property);
             }
         }
     }
@@ -6643,6 +6713,8 @@ function printBlockTrailer(block) {
 /* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_4__);
 /* harmony import */ var _interp__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7161);
 /* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(757);
+/* harmony import */ var _intersection_type__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6973);
+
 
 
 
@@ -6866,24 +6938,47 @@ function typeFromTypeStateNode(state, sn, classVsObj) {
             sn.resolvedType = result;
             return result;
         }
-        case "VariableDeclarator":
+        case "VariableDeclarator": {
+            if (sn.resolvedType)
+                return sn.resolvedType;
+            let declared = null;
+            if (sn.node.id.type === "BinaryExpression") {
+                declared = typeFromTypespec(state, sn.node.id.right, sn.stack);
+            }
             if (sn.node.kind === "const" && sn.node.init) {
-                let node = sn.node.init;
-                if (node.type === "Literal") {
-                    return typeFromLiteral(node);
+                if (hasProperty(sn, "resolvedType")) {
+                    // The constant is defined recursively
+                    return declared ?? { type: 524287 /* TypeTag.Any */ };
+                }
+                // set the marker in case the constant appears in its
+                // own initializer.
+                sn.resolvedType = undefined;
+                const stack = state.stack;
+                let resolved;
+                try {
+                    state.stack = sn.stack;
+                    resolved = evaluateExpr(state, sn.node.init).value;
+                }
+                finally {
+                    state.stack = stack;
                 }
-                while (node.type === "BinaryExpression" && node.operator === "as") {
-                    node = node.left;
+                if (resolved.type === 0 /* TypeTag.Never */) {
+                    resolved = declared ?? { type: 524287 /* TypeTag.Any */ };
                 }
-                if (node.type === "Literal" ||
-                    (node.type === "UnaryExpression" && node.operator === ":")) {
-                    return evaluateExpr(state, sn.node.init).value;
+                else if (declared) {
+                    resolved = intersection(resolved, declared);
+                    if (resolved.type === 0 /* TypeTag.Never */) {
+                        resolved = declared;
+                    }
                 }
+                sn.resolvedType = resolved;
+                return resolved;
             }
             if (sn.node.id.type === "BinaryExpression") {
                 return typeFromTypespec(state, sn.node.id.right, sn.stack);
             }
             return { type: 524287 /* TypeTag.Any */ };
+        }
     }
     throw new Error(`Internal error: Unexpected StateNodeDecl.type: ${sn.type}`);
 }
@@ -8602,7 +8697,7 @@ function visitReferences(state, ast, name, defn, callback, includeDefs = false,
             const objectType = typeMap.get(node.object);
             if (!objectType)
                 return results;
-            const decls = (0,type_flow/* findObjectDeclsByProperty */.nK)(state, objectType, node);
+            const [, decls] = (0,type_flow/* findObjectDeclsByProperty */.nK)(state, objectType, node);
             if (decls) {
                 const next = (0,external_api_cjs_.lookupNext)(state, [{ parent: null, results: decls }], "decls", node.property);
                 if (next) {

package/build/optimizer.cjs

@@ -9257,6 +9257,7 @@ function widenType(t) {
 
 
 
+
 function typeTagName(tag) {
     switch (tag) {
         case 0 /* TypeTag.Never */:
@@ -9473,24 +9474,47 @@ function typeFromTypeStateNode(state, sn, classVsObj) {
             sn.resolvedType = result;
             return result;
         }
-        case "VariableDeclarator":
+        case "VariableDeclarator": {
+            if (sn.resolvedType)
+                return sn.resolvedType;
+            let declared = null;
+            if (sn.node.id.type === "BinaryExpression") {
+                declared = typeFromTypespec(state, sn.node.id.right, sn.stack);
+            }
             if (sn.node.kind === "const" && sn.node.init) {
-                let node = sn.node.init;
-                if (node.type === "Literal") {
-                    return typeFromLiteral(node);
+                if (hasProperty(sn, "resolvedType")) {
+                    // The constant is defined recursively
+                    return declared ?? { type: 524287 /* TypeTag.Any */ };
                 }
-                while (node.type === "BinaryExpression" && node.operator === "as") {
-                    node = node.left;
+                // set the marker in case the constant appears in its
+                // own initializer.
+                sn.resolvedType = undefined;
+                const stack = state.stack;
+                let resolved;
+                try {
+                    state.stack = sn.stack;
+                    resolved = evaluateExpr(state, sn.node.init).value;
                 }
-                if (node.type === "Literal" ||
-                    (node.type === "UnaryExpression" && node.operator === ":")) {
-                    return evaluateExpr(state, sn.node.init).value;
+                finally {
+                    state.stack = stack;
                 }
+                if (resolved.type === 0 /* TypeTag.Never */) {
+                    resolved = declared ?? { type: 524287 /* TypeTag.Any */ };
+                }
+                else if (declared) {
+                    resolved = intersection(resolved, declared);
+                    if (resolved.type === 0 /* TypeTag.Never */) {
+                        resolved = declared;
+                    }
+                }
+                sn.resolvedType = resolved;
+                return resolved;
             }
             if (sn.node.id.type === "BinaryExpression") {
                 return typeFromTypespec(state, sn.node.id.right, sn.stack);
             }
             return { type: 524287 /* TypeTag.Any */ };
+        }
     }
     throw new Error(`Internal error: Unexpected StateNodeDecl.type: ${sn.type}`);
 }
@@ -11203,9 +11227,9 @@ function getLhsConstraint(istate, node) {
         }
         const object = istate.typeMap.get(node.object);
         if (object && !node.computed) {
-            const objDecls = findObjectDeclsByProperty(istate.state, object, node);
-            if (objDecls) {
-                lookupDefs = (0,external_api_cjs_namespaceObject.lookupNext)(istate.state, [{ parent: null, results: objDecls }], "decls", node.property);
+            const [, trueDecls] = findObjectDeclsByProperty(istate.state, object, node);
+            if (trueDecls) {
+                lookupDefs = (0,external_api_cjs_namespaceObject.lookupNext)(istate.state, [{ parent: null, results: trueDecls }], "decls", node.property);
             }
         }
     }
@@ -12009,45 +12033,115 @@ function printBlockState(block, state, indent = "") {
         console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state, key) : ""}`);
     });
 }
-function filterDecls(decls, possible) {
+/*
+ * We have an object, and a MemberExpression object.<name>
+ *  - decls are the StateNodes associated with the known type
+ *    of object.
+ *  - possible are all the StateNodes that declare <name>
+ *
+ * We want to find all the elements of possible which are
+ * "compatible" with decls, which tells us the set of things
+ * that object.<name> could correspond to, and also what that
+ * tells us about object.
+ *
+ * The return value is two arrays of StateNode. The first
+ * gives the refined type of object, and the second is the
+ * array of StateNodes that could declare <name>
+ */
+function filterDecls(decls, possible, name) {
     if (!possible)
-        return null;
-    return decls.reduce((cur, decl) => {
+        return [null, null];
+    const result = decls.reduce((cur, decl) => {
         const found = possible.reduce((flag, poss) => {
             if (decl === poss ||
-                (poss.type === "ClassDeclaration" &&
-                    (0,external_api_cjs_namespaceObject.getSuperClasses)(poss)?.has(decl)) ||
-                (decl.type === "ClassDeclaration" && (0,external_api_cjs_namespaceObject.getSuperClasses)(decl)?.has(poss))) {
-                if (!cur)
-                    cur = [poss];
-                else
-                    cur.push(poss);
+                (poss.type === "ClassDeclaration" && (0,external_api_cjs_namespaceObject.getSuperClasses)(poss)?.has(decl))) {
+                // poss extends decl, so decl must actually be a poss
+                // eg we know obj is an Object, and we call obj.toNumber
+                // so possible includes all the classes that declare toNumber
+                // so we can refine obj's type to the union of those types
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(poss);
+                cur[1].add(poss);
+                return true;
+            }
+            else if (decl.type === "ClassDeclaration" &&
+                (0,external_api_cjs_namespaceObject.getSuperClasses)(decl)?.has(poss)) {
+                // decl extends poss, so decl remains unchanged
+                // eg we know obj is Menu2, we call obj.toString
+                // Menu2 doesn't define toString, but Object does
+                // so poss is Object. But we still know that
+                // obj is Menu2
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(decl);
+                cur[1].add(poss);
                 return true;
             }
             return flag;
         }, false);
         if (!found) {
-            possible.some((poss) => {
-                if (decl.stack?.some((sn) => sn.decls === poss.decls)) {
-                    if (!cur)
-                        cur = [poss];
-                    else
-                        cur.push(poss);
-                    return true;
-                }
-                return false;
-            });
+            // If we didn't find the property in any of the
+            // standard places, the runtime might still find
+            // it by searching up the Module stack (and up
+            // the module stack from any super classes)
+            //
+            // eg
+            //
+            //  obj = Application.getApp();
+            //  obj.Properties.whatever
+            //
+            // Properties doesn't exist on AppBase, but AppBase
+            // is declared in Application, and Application
+            // does declare Properties. So Application.Properties
+            // is (one of) the declarations we should find; but we
+            // must not refine obj's type to include Application.
+            let d = [decl];
+            do {
+                d.forEach((d) => {
+                    const stack = d.stack;
+                    possible.forEach((poss) => {
+                        for (let i = stack.length; i--;) {
+                            const sn = stack[i];
+                            if (sn.decls === poss.decls) {
+                                if (!cur[0]) {
+                                    cur = [new Set(), new Set()];
+                                }
+                                cur[0].add(decl);
+                                cur[1].add(poss);
+                                break;
+                            }
+                            if ((0,external_api_cjs_namespaceObject.hasProperty)(sn.decls, name)) {
+                                break;
+                            }
+                        }
+                    });
+                });
+                d = d.flatMap((d) => {
+                    if (d.type !== "ClassDeclaration" ||
+                        !d.superClass ||
+                        d.superClass === true) {
+                        return [];
+                    }
+                    return d.superClass;
+                });
+            } while (d.length);
         }
         return cur;
-    }, null);
+    }, [null, null]);
+    if (!result[0])
+        return [null, null];
+    return [Array.from(result[0]), Array.from(result[1])];
 }
 function findObjectDeclsByProperty(state, object, next) {
     const decls = getStateNodeDeclsFromType(state, object);
     if (!decls)
-        return null;
+        return [null, null];
     const possibleDecls = (0,external_api_cjs_namespaceObject.hasProperty)(state.allDeclarations, next.property.name) &&
         state.allDeclarations[next.property.name];
-    return filterDecls(decls, possibleDecls);
+    return filterDecls(decls, possibleDecls, next.property.name);
 }
 function refineObjectTypeByDecls(istate, object, trueDecls) {
     const refinedType = typeFromTypeStateNodes(istate.state, trueDecls);
@@ -12063,13 +12157,13 @@ function findNextObjectType(istate, trueDecls, next) {
     }, { type: 0 /* TypeTag.Never */ });
 }
 function resolveDottedMember(istate, object, next) {
-    const decls = findObjectDeclsByProperty(istate.state, object, next);
-    if (!decls)
+    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, object, next);
+    if (!objDecls)
         return null;
-    const property = findNextObjectType(istate, decls, next);
+    const property = findNextObjectType(istate, trueDecls, next);
     if (!property)
         return null;
-    const type = refineObjectTypeByDecls(istate, object, decls);
+    const type = refineObjectTypeByDecls(istate, object, objDecls);
     const mayThrow = !subtypeOf(object, type);
     return { mayThrow, object: type, property };
 }
@@ -12106,11 +12200,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                     next = value.obj[me.property.name];
                 }
                 else {
-                    const trueDecls = findObjectDeclsByProperty(istate.state, cur, me);
-                    if (!trueDecls) {
+                    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, cur, me);
+                    if (!objDecls) {
                         return null;
                     }
-                    cur = refineObjectTypeByDecls(istate, cur, trueDecls);
+                    cur = refineObjectTypeByDecls(istate, cur, objDecls);
                     next = findNextObjectType(istate, trueDecls, me);
                 }
             }
@@ -15231,7 +15325,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 && 1674613939459 < opt_time) {
+        if (source_time < opt_time && 1674683508654 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -15258,7 +15352,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.1.4",
+                optimizerVersion: "1.1.5",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));

package/build/src/optimizer-types.d.ts

@@ -129,6 +129,7 @@ export interface VariableStateNode extends BaseStateNode {
     fullName: string;
     stack: ProgramStateStack;
     used?: true;
+    resolvedType?: ExactOrUnion | undefined;
 }
 export interface EnumStateNode extends BaseStateNode {
     type: "EnumDeclaration";

package/build/src/type-flow.d.ts

@@ -4,7 +4,7 @@ import { InterpState } from "./type-flow/interp";
 import { ExactOrUnion } from "./type-flow/types";
 export declare const missingNullWorkaround = true;
 export declare function buildTypeInfo(state: ProgramStateAnalysis, func: FunctionStateNode, optimizeEquivalencies: boolean): InterpState | undefined;
-export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): StateNode[] | null;
+export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): [StateNode[], StateNode[]] | readonly [null, null];
 export declare function resolveDottedMember(istate: InterpState, object: ExactOrUnion, next: mctree.DottedMemberExpression): {
     mayThrow: boolean;
     object: ExactOrUnion;

package/package.json

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