@markw65/monkeyc-optimizer 1.0.14 → 1.0.15

package/README.md

@@ -155,3 +155,9 @@ More fixes found via open source projects.
   - npm upgrade to pickup ts 4.7.2
   - Add types to package exports for ts 4.7.2
   - Better handling of program-logic errors
+
+### 1.0.15
+
+- Bug fixes
+  - Inject the superclass name into the classes namespace
+  - Separate type vs value lookup, and use the correct one based on context.

package/build/api.cjs

@@ -248,11 +248,21 @@ function processImports(allImports, lookup) {
             if (!parent.decls)
                 parent.decls = {};
             const decls = parent.decls;
-            if (!hasProperty(parent.decls, name))
-                parent.decls[name] = [];
+            if (!hasProperty(decls, name))
+                decls[name] = [];
             module.forEach((m) => {
                 if (isStateNode(m) && m.type == "ModuleDeclaration") {
                     pushUnique(decls[name], m);
+                    if (node.type == "ImportModule" && m.type_decls) {
+                        if (!parent.type_decls)
+                            parent.type_decls = {};
+                        const tdecls = parent.type_decls;
+                        Object.entries(m.type_decls).forEach(([name, decls]) => {
+                            if (!hasProperty(tdecls, name))
+                                tdecls[name] = [];
+                            decls.forEach((decl) => pushUnique(tdecls[name], decl));
+                        });
+                    }
                 }
             });
         }
@@ -261,11 +271,39 @@ function processImports(allImports, lookup) {
 function collectClassInfo(state) {
     state.allClasses.forEach((elm) => {
         if (elm.node.superClass) {
-            const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+            const [name, classes] = state.lookup(elm.node.superClass, null, elm.stack);
             const superClass = classes &&
                 classes.filter((c) => isStateNode(c) && c.type === "ClassDeclaration");
             // set it "true" if there is a superClass, but we can't find it.
             elm.superClass = superClass && superClass.length ? superClass : true;
+            if (name && elm.superClass !== true) {
+                /*
+                 * The runtime behavior of monkeyc is strange. Lookups
+                 * of the name of the superclass, either bare, or via self.<name>
+                 * always find the superclass, even if there's a member variable
+                 * or method of the same name. So its ok to just overwrite
+                 * elm.decls[name] here.
+                 *
+                 * ie
+                 *
+                 * class A { function foo() as Number { return 1; } }
+                 * class B { function foo() as String { return "B"; } }
+                 * class C extends A {
+                 *   var A as B = new B();
+                 *   function initialize() {
+                 *     A.initialize(); // class A's initialize
+                 *     A.foo(); // returns 1
+                 *     self.A.foo(); // still returns 1
+                 *   }
+                 * }
+                 *
+                 * The typechecker seems to get confused in some circumstances
+                 * though (ie it doesn't always use the same rules)
+                 */
+                if (!elm.decls)
+                    elm.decls = {};
+                elm.decls[name] = elm.superClass;
+            }
         }
     });
     const markOverrides = (cls, scls) => {
@@ -700,11 +738,12 @@ async function optimizeMonkeyC(fnMap) {
      * anywhere in its superClass chain.
      */
     const checkInherited = (elm, name) => elm.superClass === true ||
-        elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
-            sc.decls[name].some((f) => isStateNode(f) &&
-                f.type == "FunctionDeclaration" &&
-                maybeCalled(f.node))) ||
-            (sc.superClass && checkInherited(sc, name)));
+        (elm.superClass != null &&
+            elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
+                sc.decls[name].some((f) => isStateNode(f) &&
+                    f.type == "FunctionDeclaration" &&
+                    maybeCalled(f.node))) ||
+                (sc.superClass && checkInherited(sc, name))));
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
@@ -1181,6 +1220,57 @@ function api_isStateNode(node) {
 function api_variableDeclarationName(node) {
     return ("left" in node ? node.left : node).name;
 }
+function checkOne(ns, decls, name) {
+    if (api_isStateNode(ns) && api_hasProperty(ns[decls], name)) {
+        return ns[decls][name];
+    }
+    return null;
+}
+function lookup(state, decls, node, name, stack) {
+    stack || (stack = state.stack);
+    switch (node.type) {
+        case "MemberExpression": {
+            if (node.property.type != "Identifier" || node.computed)
+                break;
+            const [, module, where] = state.lookup(node.object, name, stack);
+            if (module && module.length === 1) {
+                const result = checkOne(module[0], decls, node.property.name);
+                if (result) {
+                    return [
+                        name || node.property.name,
+                        result,
+                        where.concat(module[0]),
+                    ];
+                }
+            }
+            break;
+        }
+        case "ThisExpression": {
+            for (let i = stack.length; i--;) {
+                const si = stack[i];
+                if (si.type == "ModuleDeclaration" ||
+                    si.type == "ClassDeclaration" ||
+                    !i) {
+                    return [name || si.name, [si], stack.slice(0, i)];
+                }
+            }
+            break;
+        }
+        case "Identifier": {
+            if (node.name == "$") {
+                return [name || node.name, [stack[0]], []];
+            }
+            for (let i = stack.length; i--;) {
+                const result = checkOne(stack[i], decls, node.name);
+                if (result) {
+                    return [name || node.name, result, stack.slice(0, i + 1)];
+                }
+            }
+            break;
+        }
+    }
+    return [null, null, null];
+}
 function api_collectNamespaces(ast, stateIn) {
     const state = (stateIn || {});
     if (!state.index)
@@ -1190,12 +1280,6 @@ function api_collectNamespaces(ast, stateIn) {
             { type: "Program", name: "$", fullName: "$", node: undefined },
         ];
     }
-    const checkOne = (ns, name) => {
-        if (api_isStateNode(ns) && api_hasProperty(ns.decls, name)) {
-            return ns.decls[name];
-        }
-        return null;
-    };
     state.removeNodeComments = (node, ast) => {
         if (node.start && node.end && ast.comments && ast.comments.length) {
             let low = 0, high = ast.comments.length;
@@ -1220,51 +1304,10 @@ function api_collectNamespaces(ast, stateIn) {
             }
         }
     };
-    state.lookup = (node, name, stack) => {
-        stack || (stack = state.stack);
-        switch (node.type) {
-            case "MemberExpression": {
-                if (node.property.type != "Identifier" || node.computed)
-                    break;
-                const [, module, where] = state.lookup(node.object, name, stack);
-                if (module && module.length === 1) {
-                    const result = checkOne(module[0], node.property.name);
-                    if (result) {
-                        return [
-                            name || node.property.name,
-                            result,
-                            where.concat(module[0]),
-                        ];
-                    }
-                }
-                break;
-            }
-            case "ThisExpression": {
-                for (let i = stack.length; i--;) {
-                    const si = stack[i];
-                    if (si.type == "ModuleDeclaration" ||
-                        si.type == "ClassDeclaration" ||
-                        !i) {
-                        return [name || si.name, [si], stack.slice(0, i)];
-                    }
-                }
-                break;
-            }
-            case "Identifier": {
-                if (node.name == "$") {
-                    return [name || node.name, [stack[0]], []];
-                }
-                for (let i = stack.length; i--;) {
-                    const result = checkOne(stack[i], node.name);
-                    if (result) {
-                        return [name || node.name, result, stack.slice(0, i + 1)];
-                    }
-                }
-                break;
-            }
-        }
-        return [null, null, null];
-    };
+    state.lookup = (node, name, stack) => lookup(state, state.inType ? "type_decls" : "decls", node, name, stack);
+    state.lookupValue = (node, name, stack) => lookup(state, "decls", node, name, stack);
+    state.lookupType = (node, name, stack) => lookup(state, "type_decls", node, name, stack);
+    state.inType = false;
     state.traverse = (root) => api_traverseAst(root, (node) => {
         try {
             if (state.shouldExclude && state.shouldExclude(node)) {
@@ -1277,6 +1320,9 @@ function api_collectNamespaces(ast, stateIn) {
                         throw new Error("Unexpected stack length for Program node");
                     }
                     break;
+                case "TypeSpecList":
+                    state.inType = true;
+                    break;
                 case "BlockStatement": {
                     const [parent] = state.stack.slice(-1);
                     if (parent.type != "FunctionDeclaration" &&
@@ -1289,7 +1335,7 @@ function api_collectNamespaces(ast, stateIn) {
                 case "FunctionDeclaration":
                 case "ModuleDeclaration": {
                     const [parent] = state.stack.slice(-1);
-                    const name = "id" in node ? node.id && node.id.name : null;
+                    const name = "id" in node ? node.id && node.id.name : undefined;
                     const fullName = state.stack
                         .map((e) => e.name)
                         .concat(name)
@@ -1324,6 +1370,15 @@ function api_collectNamespaces(ast, stateIn) {
                             node.params.forEach((p) => (decls[api_variableDeclarationName(p)] = [p]));
                         }
                         parent.decls[name].push(elm);
+                        if (node.type == "ModuleDeclaration" ||
+                            node.type == "ClassDeclaration") {
+                            if (!parent.type_decls)
+                                parent.type_decls = {};
+                            if (!api_hasProperty(parent.type_decls, name)) {
+                                parent.type_decls[name] = [];
+                            }
+                            parent.type_decls[name].push(elm);
+                        }
                     }
                     break;
                 }
@@ -1338,14 +1393,15 @@ function api_collectNamespaces(ast, stateIn) {
                 }
                 // fall through
                 case "TypedefDeclaration": {
+                    state.inType = true;
                     const name = node.id.name;
                     const [parent] = state.stack.slice(-1);
-                    if (!parent.decls)
-                        parent.decls = {};
-                    if (!api_hasProperty(parent.decls, name)) {
-                        parent.decls[name] = [];
+                    if (!parent.type_decls)
+                        parent.type_decls = {};
+                    if (!api_hasProperty(parent.type_decls, name)) {
+                        parent.type_decls[name] = [];
                     }
-                    (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[name], node);
+                    (0,external_util_cjs_namespaceObject.pushUnique)(parent.type_decls[name], node);
                     break;
                 }
                 case "VariableDeclaration": {
@@ -1370,6 +1426,7 @@ function api_collectNamespaces(ast, stateIn) {
                     break;
                 }
                 case "EnumStringBody": {
+                    state.inType = false;
                     const [parent] = state.stack.slice(-1);
                     const values = parent.decls || (parent.decls = {});
                     let prev = -1;
@@ -1433,8 +1490,19 @@ function api_collectNamespaces(ast, stateIn) {
                 ret = false;
             }
             else {
+                const type = node.type;
                 if (state.post)
                     ret = state.post(node, state);
+                switch (type) {
+                    case "TypeSpecList":
+                    case "TypedefDeclaration":
+                    case "EnumDeclaration":
+                        state.inType = false;
+                        break;
+                    case "EnumStringBody":
+                        state.inType = true;
+                        break;
+                }
                 if (state.stack.slice(-1).pop()?.node === node) {
                     state.stack.pop();
                 }
@@ -1538,7 +1606,7 @@ function handleException(state, node, exception) {
     try {
         const fullName = state.stack
             .map((e) => e.name)
-            .concat("name" in node && typeof node.name === "string" ? node.name : null)
+            .concat("name" in node && typeof node.name === "string" ? node.name : undefined)
             .filter((e) => e != null)
             .join(".");
         const location = node.loc && node.loc.source

package/build/optimizer.cjs

@@ -10804,11 +10804,21 @@ function processImports(allImports, lookup) {
             if (!parent.decls)
                 parent.decls = {};
             const decls = parent.decls;
-            if (!(0,external_api_cjs_namespaceObject.hasProperty)(parent.decls, name))
-                parent.decls[name] = [];
+            if (!(0,external_api_cjs_namespaceObject.hasProperty)(decls, name))
+                decls[name] = [];
             module.forEach((m) => {
                 if ((0,external_api_cjs_namespaceObject.isStateNode)(m) && m.type == "ModuleDeclaration") {
                     (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], m);
+                    if (node.type == "ImportModule" && m.type_decls) {
+                        if (!parent.type_decls)
+                            parent.type_decls = {};
+                        const tdecls = parent.type_decls;
+                        Object.entries(m.type_decls).forEach(([name, decls]) => {
+                            if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
+                                tdecls[name] = [];
+                            decls.forEach((decl) => (0,external_util_cjs_namespaceObject.pushUnique)(tdecls[name], decl));
+                        });
+                    }
                 }
             });
         }
@@ -10817,11 +10827,39 @@ function processImports(allImports, lookup) {
 function collectClassInfo(state) {
     state.allClasses.forEach((elm) => {
         if (elm.node.superClass) {
-            const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+            const [name, classes] = state.lookup(elm.node.superClass, null, elm.stack);
             const superClass = classes &&
                 classes.filter((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && c.type === "ClassDeclaration");
             // set it "true" if there is a superClass, but we can't find it.
             elm.superClass = superClass && superClass.length ? superClass : true;
+            if (name && elm.superClass !== true) {
+                /*
+                 * The runtime behavior of monkeyc is strange. Lookups
+                 * of the name of the superclass, either bare, or via self.<name>
+                 * always find the superclass, even if there's a member variable
+                 * or method of the same name. So its ok to just overwrite
+                 * elm.decls[name] here.
+                 *
+                 * ie
+                 *
+                 * class A { function foo() as Number { return 1; } }
+                 * class B { function foo() as String { return "B"; } }
+                 * class C extends A {
+                 *   var A as B = new B();
+                 *   function initialize() {
+                 *     A.initialize(); // class A's initialize
+                 *     A.foo(); // returns 1
+                 *     self.A.foo(); // still returns 1
+                 *   }
+                 * }
+                 *
+                 * The typechecker seems to get confused in some circumstances
+                 * though (ie it doesn't always use the same rules)
+                 */
+                if (!elm.decls)
+                    elm.decls = {};
+                elm.decls[name] = elm.superClass;
+            }
         }
     });
     const markOverrides = (cls, scls) => {
@@ -11255,11 +11293,12 @@ async function optimizeMonkeyC(fnMap) {
      * anywhere in its superClass chain.
      */
     const checkInherited = (elm, name) => elm.superClass === true ||
-        elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
-            sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
-                f.type == "FunctionDeclaration" &&
-                maybeCalled(f.node))) ||
-            (sc.superClass && checkInherited(sc, name)));
+        (elm.superClass != null &&
+            elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
+                sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
+                    f.type == "FunctionDeclaration" &&
+                    maybeCalled(f.node))) ||
+                (sc.superClass && checkInherited(sc, name))));
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
@@ -12025,7 +12064,7 @@ 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 && 1653864408816 < opt_time) {
+        if (source_time < opt_time && 1653954367574 < opt_time) {
             return hasTests;
         }
     }

package/build/src/optimizer.d.ts

@@ -43,47 +43,50 @@ declare global {
     type StateNodeDecls = {
         [key: string]: StateNodeDecl[];
     };
-    type ProgramStateNode = {
+    interface BaseStateNode {
+        type: string;
+        node: mctree.Node | null | undefined;
+        name: string | null | undefined;
+        fullName: string | null | undefined;
+        decls?: StateNodeDecls | undefined;
+        type_decls?: StateNodeDecls | undefined;
+        stack?: ProgramStateStack | undefined;
+    }
+    interface ProgramStateNode extends BaseStateNode {
         type: "Program";
         node: null | undefined;
         name: "$";
         fullName: "$";
-        decls?: StateNodeDecls;
-        stack?: null | undefined;
-    };
-    type ModuleStateNode = {
+        stack?: undefined;
+    }
+    interface ModuleStateNode extends BaseStateNode {
         type: "ModuleDeclaration";
+        node: mctree.ModuleDeclaration;
         name: string;
         fullName: string;
-        node: mctree.ModuleDeclaration;
-        stack?: ProgramStateStack;
-        decls?: StateNodeDecls;
-    };
-    type ClassStateNode = {
+    }
+    interface ClassStateNode extends BaseStateNode {
         type: "ClassDeclaration";
+        node: mctree.ClassDeclaration;
         name: string;
         fullName: string;
-        node: mctree.ClassDeclaration;
-        decls?: StateNodeDecls;
-        stack?: ProgramStateStack;
-        superClass: ClassStateNode[] | true;
-    };
-    type FunctionStateNode = {
+        superClass?: ClassStateNode[] | true;
+    }
+    interface FunctionStateNode extends BaseStateNode {
         type: "FunctionDeclaration";
+        node: mctree.FunctionDeclaration;
         name: string;
         fullName: string;
-        node: mctree.FunctionDeclaration;
         stack?: ProgramStateStack;
         decls?: undefined;
-    };
-    type BlockStateNode = {
+    }
+    interface BlockStateNode extends BaseStateNode {
         type: "BlockStatement";
-        name?: null | undefined;
-        fullName?: null | undefined;
+        name: undefined;
+        fullName: undefined;
         node: mctree.BlockStatement;
-        decls?: StateNodeDecls;
-        stack?: null | undefined;
-    };
+        stack?: undefined;
+    }
     type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode;
     type ProgramStateStack = StateNode[];
     export type ProgramState = {
@@ -95,7 +98,10 @@ declare global {
         pre?: (node: mctree.Node, state: ProgramStateLive) => null | false | (keyof mctree.NodeAll)[];
         post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node;
         lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
+        lookupValue?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
+        lookupType?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
         traverse?: (node: mctree.Node) => void | null | false | mctree.Node;
+        inType?: boolean;
         exposed?: {
             [key: string]: true;
         };
@@ -121,7 +127,7 @@ declare global {
     type Finalized<T, Keys extends keyof T> = T & {
         [key in Keys]-?: NonNullable<T[key]>;
     };
-    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "traverse" | "index" | "constants" | "removeNodeComments">;
+    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "lookupValue" | "lookupType" | "traverse" | "index" | "constants" | "removeNodeComments" | "inType">;
     export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions">;
     export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions">;
     type ExcludeAnnotationsMap = {
@@ -175,7 +181,7 @@ declare type RequiredNonNull<T> = {
 export declare type Analysis = {
     fnMap: RequiredNonNull<FilesToOptimizeMap>;
     paths: string[];
-    state: ProgramState;
+    state: ProgramStateAnalysis;
 };
 export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, options: BuildConfig): Promise<Analysis | PreAnalysis>;
 /**

package/package.json

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