@markw65/monkeyc-optimizer 1.1.0 → 1.1.1

package/README.md

@@ -574,3 +574,7 @@ Bug Fixes
 - Bug fixes
   - Fixes a bug that could ignore side effects from Method.invoke
   - Fixes a crash in the inliner, when trying to inline a function with multiple returns
+
+### 1.1.1
+
+- Fix the package spec to include the new .d.ts files

package/build/optimizer.cjs

@@ -12233,7 +12233,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 && 1673220499844 < opt_time) {
+        if (source_time < opt_time && 1673222947102 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -12260,7 +12260,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.0",
+                optimizerVersion: "1.1.1",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));

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

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function couldBe(a: ExactOrUnion, b: ExactOrUnion): boolean;

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

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ExactOrUnion } from "./types";
+export declare function evaluateBinaryTypes(op: mctree.BinaryOperator | "instanceof", left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;
+export declare function evaluateLogicalTypes(op: mctree.LogicalOperator, left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;

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

@@ -0,0 +1,4 @@
+import { ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion } from "./types";
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function evaluateCall(state: ProgramStateAnalysis, node: mctree.CallExpression, callee: ExactOrUnion, _args: ExactOrUnion[]): ExactOrUnion;

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

@@ -0,0 +1,23 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion } from "./types";
+export declare type TypeMap = Map<mctree.Node, ExactOrUnion>;
+export declare type InterpStackElem = {
+    value: ExactOrUnion;
+    embeddedEffects: boolean;
+    node: mctree.Expression | mctree.TypeSpecList | mctree.InstanceOfCase;
+};
+export declare type InterpState = {
+    state: ProgramStateAnalysis;
+    stack: InterpStackElem[];
+    typeMap?: TypeMap;
+    func?: FunctionStateNode;
+    pre?: (node: mctree.Node) => mctree.Node | false | null | void;
+    post?: (node: mctree.Node) => mctree.Node | false | null | void;
+};
+export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
+export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
+export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
+export declare function roundToFloat(value: number): number;

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

@@ -0,0 +1,4 @@
+import { ExactOrUnion } from "./types";
+export declare function expandTypedef(t: ExactOrUnion): ExactOrUnion;
+export declare function intersection(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;
+export declare function restrictByEquality(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;

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

@@ -0,0 +1,6 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { InterpState } from "./interp";
+export declare function optimizeFunction(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function beforeEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;
+export declare function afterEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;

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

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function subtypeOf(a: ExactOrUnion, b: ExactOrUnion): boolean;

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

@@ -0,0 +1,201 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl, TypedefStateNode } from "../optimizer-types";
+/**
+ * TypeBit gives the position of the 1 bit in TypeTag
+ */
+export declare enum TypeBit {
+    Null = 0,
+    False = 1,
+    True = 2,
+    Number = 3,
+    Long = 4,
+    Float = 5,
+    Double = 6,
+    Char = 7,
+    String = 8,
+    Array = 9,
+    Dictionary = 10,
+    Module = 11,
+    Function = 12,
+    Class = 13,
+    Object = 14,
+    Enum = 15,
+    Symbol = 16,
+    Typedef = 17
+}
+export declare enum TypeTag {
+    Never = 0,
+    Null = 1,
+    False = 2,
+    True = 4,
+    Boolean = 6,
+    Number = 8,
+    Long = 16,
+    Float = 32,
+    Double = 64,
+    Numeric = 120,
+    Char = 128,
+    String = 256,
+    Array = 512,
+    Dictionary = 1024,
+    Module = 2048,
+    Function = 4096,
+    Class = 8192,
+    Object = 16384,
+    Enum = 32768,
+    Symbol = 65536,
+    Typedef = 131072,
+    Any = 262143
+}
+export declare const SingleTonTypeTagsConst: number;
+export declare const UnionDataTypeTagsConst: number;
+export declare const ValueTypeTagsConst: number;
+export declare const ObjectLikeTagsConst: number;
+declare type ExactTypeTags = TypeTag.Null | TypeTag.False | TypeTag.True | TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double | TypeTag.Char | TypeTag.String | TypeTag.Array | TypeTag.Dictionary | TypeTag.Module | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Symbol | TypeTag.Typedef;
+export declare type EnumeratedTypeTags = ExactTypeTags | TypeTag.Never | TypeTag.Any;
+export declare type UnionTypeTags = number;
+interface AbstractValue {
+    type: UnionTypeTags;
+    value?: unknown;
+}
+export declare type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType | TypedefType;
+declare type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : T & {
+    value: NonNullable<T["value"]>;
+} : never;
+export declare type ValueTypes = WithValue<ExactTypes>;
+export declare type ExtendedTypes = ExactTypes | NeverType | AnyType;
+export interface NeverType extends AbstractValue {
+    type: 0;
+    value?: undefined;
+}
+export interface NullType extends AbstractValue {
+    type: TypeTag.Null;
+    value?: undefined;
+}
+export interface FalseType extends AbstractValue {
+    type: TypeTag.False;
+    value?: undefined;
+}
+export interface TrueType extends AbstractValue {
+    type: TypeTag.True;
+    value?: undefined;
+}
+export interface NumberType extends AbstractValue {
+    type: TypeTag.Number;
+    value?: number | undefined;
+}
+export interface LongType extends AbstractValue {
+    type: TypeTag.Long;
+    value?: bigint | undefined;
+}
+export interface FloatType extends AbstractValue {
+    type: TypeTag.Float;
+    value?: number | undefined;
+}
+export interface DoubleType extends AbstractValue {
+    type: TypeTag.Double;
+    value?: number | undefined;
+}
+export interface CharType extends AbstractValue {
+    type: TypeTag.Char;
+    value?: string | undefined;
+}
+export interface StringType extends AbstractValue {
+    type: TypeTag.String;
+    value?: string | undefined;
+}
+export interface ArrayType extends AbstractValue {
+    type: TypeTag.Array;
+    value?: ExactOrUnion | undefined;
+}
+export interface DictionaryType extends AbstractValue {
+    type: TypeTag.Dictionary;
+    value?: {
+        key: ExactOrUnion;
+        value: ExactOrUnion;
+    } | undefined;
+}
+export interface ModuleType extends AbstractValue {
+    type: TypeTag.Module;
+    value?: ModuleStateNode | ModuleStateNode[] | undefined;
+}
+export interface FunctionType extends AbstractValue {
+    type: TypeTag.Function;
+    value?: FunctionStateNode | FunctionStateNode[] | undefined;
+}
+export interface ClassType extends AbstractValue {
+    type: TypeTag.Class;
+    value?: ClassStateNode | ClassStateNode[] | undefined;
+}
+export interface TypedefType extends AbstractValue {
+    type: TypeTag.Typedef;
+    value?: TypedefStateNode | TypedefStateNode[] | undefined;
+}
+export interface ObjectType extends AbstractValue {
+    type: TypeTag.Object;
+    value?: {
+        klass: ClassType;
+        obj?: Record<string, ExactOrUnion>;
+    } | undefined;
+}
+export interface EnumType extends AbstractValue {
+    type: TypeTag.Enum;
+    value?: {
+        enum: EnumStateNode;
+        value?: ExactOrUnion | undefined;
+    } | undefined;
+}
+export interface SymbolType extends AbstractValue {
+    type: TypeTag.Symbol;
+    value?: string | undefined;
+}
+export interface AnyType extends AbstractValue {
+    type: -1;
+    value?: undefined;
+}
+export declare type SingletonType = NullType | FalseType | TrueType;
+export declare type UnionData = {
+    mask: TypeTag;
+    [TypeTag.Array]?: NonNullable<ArrayType["value"]>;
+    [TypeTag.Dictionary]?: NonNullable<DictionaryType["value"]>;
+    [TypeTag.Module]?: NonNullable<ModuleType["value"]>;
+    [TypeTag.Function]?: NonNullable<FunctionType["value"]>;
+    [TypeTag.Class]?: NonNullable<ClassType["value"]>;
+    [TypeTag.Object]?: NonNullable<ObjectType["value"]>;
+    [TypeTag.Enum]?: NonNullable<EnumType["value"]>;
+};
+export declare type UnionDataKey = Exclude<keyof UnionData, "mask">;
+export interface UnionType extends AbstractValue {
+    value?: UnionData | undefined;
+}
+export declare type ExactOrUnion = UnionType | ExactTypes;
+export declare type SingleValue = NonNullable<ValueTypes["value"]>;
+declare type TagValue<TAG> = Extract<ValueTypes, {
+    type: TAG;
+}>["value"];
+export declare type ArrayValueType = TagValue<TypeTag.Array>;
+export declare type DictionaryValueType = TagValue<TypeTag.Dictionary>;
+export declare type ObjectValueType = TagValue<TypeTag.Object>;
+export declare type EnumValueType = TagValue<TypeTag.Enum>;
+export declare type TypedefValueType = TagValue<TypeTag.Typedef>;
+export declare type StateDeclValueType = TagValue<TypeTag.Module> | TagValue<TypeTag.Function> | TagValue<TypeTag.Class>;
+export declare function isExact(v: AbstractValue): v is ExactTypes;
+export declare function isUnion(v: AbstractValue): v is UnionType;
+export declare function isSingleton(v: AbstractValue): v is SingletonType;
+export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
+export declare function cloneType<T extends ExactOrUnion>(t: T): T;
+export declare function typeFromTypeStateNode(state: ProgramStateAnalysis, sn: StateNodeDecl, classVsObj?: boolean): ExactOrUnion;
+export declare function typeFromTypeStateNodes(state: ProgramStateAnalysis, sns: StateNodeDecl[], classVsObj?: boolean): ExactOrUnion;
+export declare function typeFromTypespec(state: ProgramStateAnalysis, ts: mctree.TypeSpecList, stack?: ProgramStateStack | undefined): ExactOrUnion;
+export declare function typeFromLiteral(literal: mctree.Literal): ExactTypes;
+export declare function mcExprFromType(type: ValueTypes): mctree.Expression | null;
+export declare function castType(type: ExactOrUnion, target: UnionTypeTags): ExactOrUnion;
+export declare const TruthyTypes: number;
+export declare function mustBeTrue(arg: ExactOrUnion): boolean;
+export declare function mustBeFalse(arg: ExactOrUnion): boolean;
+export declare function display(type: ExactOrUnion): string;
+export declare function hasUnionData(tag: TypeTag): boolean;
+export declare function getObjectValue(t: ExactOrUnion): ObjectType["value"] | null;
+export declare function forEachUnionComponent(v: ExactOrUnion, bits: TypeTag, fn: (tag: UnionDataKey, value: SingleValue | null | undefined) => boolean | void): void;
+export declare function getUnionComponent(v: ExactOrUnion, tag: TypeTag): SingleValue | null;
+export {};

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

@@ -0,0 +1,3 @@
+import { ExactOrUnion, TypeTag } from "./types";
+export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
+export declare function clearValuesUnder(v: ExactOrUnion, tag: TypeTag, clearTag?: boolean): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -35,7 +35,7 @@
     "build/util.cjs",
     "build/sdk-util.cjs",
     "build/api.cjs",
-    "build/src/*.d.ts"
+    "build/src/**/*.d.ts"
   ],
   "author": "markw65",
   "license": "MIT",