mlogjs 0.4.8 → 0.4.10

package/dist/operators.d.ts

@@ -2,24 +2,25 @@ export declare const arithmeticBinaryOperators: readonly ["*", "**", "+", "-", "
 export declare const comparisonBinaryOperators: readonly ["!=", "!==", "<", "<=", "==", "===", ">", ">="];
 export declare const bitwiseBinaryOperators: readonly ["&", "<<", ">>", ">>>", "^", "|"];
 export declare const binaryOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in"];
-export declare type BinaryOperator = typeof binaryOperators[number];
+export type BinaryOperator = typeof binaryOperators[number];
 export declare const logicalOperators: readonly ["&&", "??", "||"];
-export declare type LogicalOperator = typeof logicalOperators[number];
+export type LogicalOperator = typeof logicalOperators[number];
 export declare const arithmeticAssignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/="];
 export declare const logicalAssignmentOperators: readonly ["&&=", "||=", "??="];
 export declare const bitwiseAssignmentOperators: readonly ["<<=", ">>=", ">>>=", "^=", "|="];
 export declare const assignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "??=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
-export declare type AssignementOperator = typeof assignmentOperators[number];
+export type AssignementOperator = typeof assignmentOperators[number];
 export declare const leftRightOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "??=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
-export declare type LeftRightOperator = typeof leftRightOperators[number];
+export type LeftRightOperator = typeof leftRightOperators[number];
 export declare const unaryOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~"];
-export declare type UnaryOperator = typeof unaryOperators[number];
+export type UnaryOperator = typeof unaryOperators[number];
 export declare const updateOperators: readonly ["++", "--"];
-export declare type UpdateOperator = typeof updateOperators[number];
+export type UpdateOperator = typeof updateOperators[number];
 export declare const singleOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
-export declare type SingleOperator = typeof singleOperators[number];
+export type SingleOperator = typeof singleOperators[number];
 export declare const operators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "??=", "<<=", ">>=", ">>>=", "^=", "|=", "=", "!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
-export declare type Operator = typeof operators[number];
+export type Operator = typeof operators[number];
 export declare const operatorMap: {
     [k in Exclude<BinaryOperator, "instanceof" | "in"> | Exclude<LogicalOperator, "??">]: string;
 };
+export declare const orderIndependentOperators: readonly Operator[];

package/dist/types.d.ts

@@ -35,8 +35,8 @@ export interface IInstruction {
  *
  * An IValue means that the handler should try to use `this` as the output value.
  */
-export declare type TEOutput = IValue | string;
-export declare type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, out: TEOutput | undefined, arg: any) => TValueInstructions<T>;
+export type TEOutput = IValue | string;
+export type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, out: TEOutput | undefined, arg: any) => TValueInstructions<T>;
 /**
  * The scope manages the source code generated variables and their owners,
  * as well as break and continue statements and they also work as function
@@ -63,6 +63,13 @@ export interface IScope {
     function: IFunctionValue;
     /** Counts the number of temp variables generated during compilaton */
     ntemp: number;
+    /**
+     * A record of the cached value operations, maps the id
+     * of an operation to a previously computed value.
+     */
+    operationCache: Record<string, IValue>;
+    /** Tracks the dependency relation beteween values and cached operations */
+    cacheDependencies: Record<string, string[]>;
     /**
      * Creates a new scope that has `this` as it's parent.
      */
@@ -109,6 +116,16 @@ export interface IScope {
     copy(): IScope;
     /** Creates a temporary mlog variable name */
     makeTempName(): string;
+    /** Adds the result of an operation to the local cache */
+    addCachedOperation(op: string, result: IValue, left: IValue, right?: IValue): void;
+    /** Attempts to get an operation cached in this or in a parent scope. */
+    getCachedOperation(op: string, left: IValue, right?: IValue): IValue | undefined;
+    /**
+     * Removes all cached operations dependent on the given value.
+     *
+     * Affects this scope and all of its parents.
+     */
+    clearDependentCache(value: IValue): void;
 }
 export interface IValueOperators {
     "!"(scope: IScope, out?: TEOutput): TValueInstructions;
@@ -202,7 +219,7 @@ export interface IValue extends IValueOperators {
 export interface INamedValue extends IValue {
     name: string;
 }
-export declare type TLiteral = string | number;
+export type TLiteral = string | number;
 export interface IBindableValue<T extends TLiteral | null = TLiteral> extends IValue {
     data: T;
 }
@@ -210,11 +227,11 @@ export interface IFunctionValue extends IValue {
     return(scope: IScope, argument: IValue | null, out?: TEOutput): TValueInstructions<IValue | null>;
 }
 /** Contains a value and the instructions required to compute it */
-export declare type TValueInstructions<Content extends IValue | null = IValue> = [
+export type TValueInstructions<Content extends IValue | null = IValue> = [
     Content,
     IInstruction[]
 ];
 /** Map of overridable operators in object macros */
-export declare type TOperatorMacroMap = {
+export type TOperatorMacroMap = {
     [K in UnaryOperator | UpdateOperator | LeftRightOperator as `$${K}`]?: MacroFunction;
 };

package/dist/utils/general.d.ts

@@ -22,3 +22,5 @@ export declare function camelToDashCase(name: string): string;
 export declare function assign<T extends {}>(obj: T, props: {
     [K in keyof T as T[K] extends Function ? never : K]?: T[K];
 }): T;
+/** Lazily computes and caches an expression */
+export declare function lazy<T>(fn: () => T): () => T;

package/dist/utils/value.d.ts

@@ -23,7 +23,7 @@ export declare function assertIsObjectMacro(value: IValue | undefined, name: str
 /** Asserts that `value` is an `ObjectValue` that has a length property */
 export declare function assertIsArrayMacro(value: IValue | undefined, name: string): asserts value is ObjectValue;
 /** Helper type used to describe the overloads of a macro function. See {@link assertObjectFields} */
-export declare type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
+export type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
 /** Describes an object destructuring paremeter. Generally used with `assertObjectFields` */
 export interface IParameterDescriptor {
     key: string;

package/dist/values/BaseValue.d.ts

@@ -6,4 +6,5 @@ export declare class BaseValue extends VoidValue implements IValue {
     "!"(scope: IScope, out?: TEOutput): TValueInstructions;
     "~"(scope: IScope, out?: TEOutput): TValueInstructions;
     "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    "!=="(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
 }

package/dist/values/DestructuringValue.d.ts

@@ -1,6 +1,6 @@
 import { IScope, IValue, TValueInstructions } from "../types";
 import { VoidValue } from "./VoidValue";
-export declare type TDestructuringMembers = Map<IValue, {
+export type TDestructuringMembers = Map<IValue, {
     value: IValue;
     /**
      * Handles the input value, is responsible for the assignment.

package/dist/values/FunctionValue.d.ts

@@ -2,7 +2,7 @@ import { Compiler } from "../Compiler";
 import { EMutability, es, IFunctionValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { StoreValue } from "./StoreValue";
 import { VoidValue } from "./VoidValue";
-export declare type TFunctionValueInitParams = (childScope: IScope) => {
+export type TFunctionValueInitParams = (childScope: IScope) => {
     paramStores: StoreValue[];
     paramNames: string[];
 };

package/dist/values/StoreValue.d.ts

@@ -12,6 +12,10 @@ export declare class StoreValue extends BaseValue implements IValue {
     static out(scope: IScope, out?: TEOutput, mutability?: EMutability): IValue;
     typeof(): TValueInstructions;
     "="(scope: IScope, value: IValue): TValueInstructions;
+    "=="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "==="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "!="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "!=="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
     eval(_scope: IScope): TValueInstructions;
     toString(): string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlogjs",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Compiler that compiles Javascript to Mindustry Logic Code.",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",