mlogjs 0.3.0-beta.0 → 0.4.0

package/dist/values/FunctionValue.d.ts

@@ -0,0 +1,47 @@
+import { Compiler } from "../Compiler";
+import { EMutability, es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
+import { StoreValue } from "./StoreValue";
+import { VoidValue } from "./VoidValue";
+export declare type TFunctionValueInitParams = (childScope: IScope) => {
+    paramStores: StoreValue[];
+    paramNames: string[];
+};
+export declare class FunctionValue extends VoidValue implements IFunctionValue {
+    mutability: EMutability;
+    macro: boolean;
+    private node;
+    private childScope;
+    private params;
+    private paramOwners;
+    private inst;
+    private addr;
+    private temp;
+    private ret;
+    private inline;
+    private tryingInline;
+    private body;
+    private c;
+    private callSize;
+    private inlineTemp;
+    private inlineEnd?;
+    private bundled;
+    private initialized;
+    constructor({ scope, params, body, c, node, }: {
+        scope: IScope;
+        body: es.BlockStatement;
+        c: Compiler;
+        node: es.Function;
+        params: es.Identifier[];
+    });
+    typeof(scope: IScope): TValueInstructions;
+    private initScope;
+    private ensureInit;
+    private normalReturn;
+    private normalCall;
+    private inlineReturn;
+    private inlineCall;
+    call(scope: IScope, args: IValue[]): TValueInstructions;
+    return(scope: IScope, arg: IValue | null): TValueInstructions<IValue | null>;
+    eval(_scope: IScope): TValueInstructions;
+    consume(_scope: IScope): TValueInstructions;
+}

package/dist/values/LiteralValue.d.ts

@@ -0,0 +1,13 @@
+import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue, EMutability } from "../types";
+import { BaseValue } from ".";
+export declare class LiteralValue extends BaseValue implements IBindableValue {
+    data: TLiteral;
+    mutability: EMutability;
+    constructor(scope: IScope, data: TLiteral);
+    eval(_scope: IScope): TValueInstructions;
+    consume(_scope: IScope): TValueInstructions;
+    toString(): string;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    get num(): number;
+    typeof(scope: IScope): TValueInstructions;
+}

package/dist/values/ObjectValue.d.ts

@@ -0,0 +1,23 @@
+import { MacroFunction } from "../macros";
+import { EMutability, IOwnedValue, IScope, IValue, TOperatorMacroMap, TValueInstructions } from "../types";
+import { LiteralValue } from "./LiteralValue";
+import { VoidValue } from "./VoidValue";
+export interface IObjectValueData extends TOperatorMacroMap {
+    [k: string]: IValue | undefined;
+    $get?: MacroFunction<IValue>;
+    $eval?: MacroFunction<IValue>;
+    $consume?: MacroFunction<IValue>;
+}
+export declare class ObjectValue extends VoidValue {
+    mutability: EMutability;
+    macro: boolean;
+    data: IObjectValueData;
+    constructor(scope: IScope, data?: IObjectValueData);
+    static fromArray(scope: IScope, items: IObjectValueData[keyof IObjectValueData][], intialData?: IObjectValueData): ObjectValue;
+    typeof(scope: IScope): TValueInstructions;
+    get(scope: IScope, key: LiteralValue): TValueInstructions;
+    eval(scope: IScope): TValueInstructions;
+    consume(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+    ensureOwned(): asserts this is IOwnedValue;
+}

package/dist/values/SenseableValue.d.ts

@@ -0,0 +1,23 @@
+import { EMutability, IScope, IValue, TValueInstructions } from "../types";
+import { StoreValue } from "./StoreValue";
+/**
+ * Senseable values are "objects" in the mlog runtime that
+ * have special properties that can be accessed
+ * via the `sense` instruction.
+ *
+ * This class extends `StoreValue` to allow dynamic behavior
+ * that is not possible with object macros.
+ *
+ * Note that these values are constant by default, so make sure
+ * to set that field to `false` if you want them to be assignable. Example:
+ * ```
+ * const value = assign(new SenseableValue(scope), {
+ *   mutability: EMutability.mutable
+ * })
+ * ```
+ */
+export declare class SenseableValue extends StoreValue {
+    mutability: EMutability;
+    constructor(scope: IScope);
+    get(scope: IScope, prop: IValue): TValueInstructions<IValue>;
+}

package/dist/{types/values/StackValue.d.ts → values/StoreValue.d.ts}

@@ -1,16 +1,15 @@
 import { BaseValue } from ".";
-import { IScope, IValue, TValueInstructions } from "../types";
+import { EMutability, IScope, IValue, TValueInstructions } from "../types";
 /**
- * `StackValue` represents values unknown at compile time inside a stack memory,
+ * `StoreValue` represents values unknown at compile time,
  * mostly used with mutable variables and temporary values
  */
-export declare class StackValue extends BaseValue implements IValue {
-    constant: boolean;
-    offset: number;
+export declare class StoreValue extends BaseValue implements IValue {
+    mutability: EMutability;
     constructor(scope: IScope);
     typeof(scope: IScope): TValueInstructions;
     "="(scope: IScope, value: IValue): TValueInstructions;
-    eval(scope: IScope): TValueInstructions;
+    eval(_scope: IScope): TValueInstructions;
     consume(_scope: IScope): TValueInstructions;
     toString(): string;
 }

package/dist/values/ValueOwner.d.ts

@@ -0,0 +1,27 @@
+import { IScope, IValue, IValueOwner } from "../types";
+export interface IValueOwnerParams<T extends IValue> {
+    scope: IScope;
+    constant?: boolean;
+    value: T;
+    /** The identifier of the variable that `this` represents */
+    identifier?: string;
+    /** The name that the variable will have during transpilation to mlog */
+    name?: string;
+}
+export declare class ValueOwner<T extends IValue = IValue> implements IValueOwner<T> {
+    scope: IScope;
+    constant: boolean;
+    value: T;
+    owned: Set<T>;
+    identifier?: string;
+    name: string;
+    persistent: boolean;
+    /**
+     * Creates a new `ValueOwner`, if `value` is already owned,
+     * `this` will be aliased to `value`, else `this` will own `value`
+     */
+    constructor({ scope, constant, value, identifier, name, }: IValueOwnerParams<T>);
+    own(target: T): void;
+    replace(target: T): void;
+    moveInto(owner: IValueOwner<T>): void;
+}

package/dist/values/VoidValue.d.ts

@@ -0,0 +1,16 @@
+import { EMutability, IScope, IValue, IValueOperators, IValueOwner, TValueInstructions } from "../types";
+export declare class VoidValue implements IValue {
+    owner: IValueOwner | null;
+    scope: IScope;
+    mutability: EMutability;
+    macro: boolean;
+    constructor(scope: IScope);
+    eval(_scope: IScope): TValueInstructions;
+    consume(_scope: IScope): TValueInstructions<IValue>;
+    call(_scope: IScope, _args: IValue[]): TValueInstructions<IValue | null>;
+    get(_scope: IScope, _name: IValue): TValueInstructions;
+    ensureOwned(): void;
+    toString(): string;
+}
+export interface VoidValue extends IValueOperators {
+}

package/dist/values/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./VoidValue";
+export * from "./BaseValue";
+export * from "./LiteralValue";
+export * from "./StoreValue";
+export * from "./ObjectValue";
+export * from "./SenseableValue";
+export * from "./DestructuringValue";