mlogjs 0.2.1 → 0.3.0

package/dist/types/utils.d.ts

@@ -0,0 +1,30 @@
+import { es } from "./types";
+/**
+ * The prefix for internal variables inside the compiler output
+ */
+export declare const internalPrefix = "&";
+export declare const discardedName: string;
+/**
+ * Returns a string that has the format: [line]:[column].
+ *
+ * If `name` is provided, and it is a string, the resulting string will
+ * have the format: [name]:[line]:[column].
+ */
+export declare function nodeName(node: es.Node, name?: false | string): string;
+/**
+ * Converts a camel case string into a dash case one.
+ *
+ * As an example `camelCase` becomes `camel-case`
+ * @example
+ * ```
+ * camelToDashCase("camelCase") // returns "camel-case"
+ * ```
+ */
+export declare function camelToDashCase(name: string): string;
+export declare const itemNames: string[];
+/**
+ * A more type safe version of `Object.assign`
+ */
+export declare function assign<T>(obj: T, props: {
+    [K in keyof T as T[K] extends Function ? never : K]?: T[K];
+}): T;

package/dist/types/values/BaseValue.d.ts

@@ -0,0 +1,7 @@
+import { IOwnedValue, IScope, IValue, TValueInstructions } from "../types";
+import { VoidValue } from ".";
+export declare class BaseValue extends VoidValue implements IValue {
+    "u-"(scope: IScope): TValueInstructions;
+    "u+"(scope: IScope): TValueInstructions;
+    ensureOwned(): asserts this is IOwnedValue;
+}

package/dist/types/values/DestructuringValue.d.ts

@@ -0,0 +1,17 @@
+import { IScope, IValue, TValueInstructions } from "../types";
+import { VoidValue } from "./VoidValue";
+/**
+ * Specific case class, required on the ArrayPattern and ObjectPattern handlers
+ * in order to keep the separation of concerns and make the code more modular.
+ *
+ * When it is assign a value, it will get it's own properties and recursively assign
+ * each of them to their counterparts on the right hand value.
+ */
+export declare class DestructuringValue extends VoidValue {
+    members: Map<IValue, IValue>;
+    macro: boolean;
+    constructor(scope: IScope, members: Map<IValue, IValue>);
+    "="(scope: IScope, right: IValue): TValueInstructions;
+    eval(_scope: IScope): TValueInstructions<IValue>;
+    consume(_scope: IScope): TValueInstructions<IValue>;
+}

package/dist/types/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/{build → dist/types}/values/LiteralValue.d.ts

@@ -1,12 +1,13 @@
-import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue } from "../types";
-import { BaseValue } from ".";
-export declare class LiteralValue extends BaseValue implements IBindableValue {
-    data: TLiteral;
-    constant: boolean;
-    constructor(scope: IScope, data: TLiteral);
-    eval(scope: IScope): TValueInstructions;
-    toString(): string;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    get num(): number;
-    typeof(scope: IScope): TValueInstructions;
-}
+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/types/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][]): 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/types/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

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

package/dist/types/values/StoreValue.d.ts

@@ -0,0 +1,15 @@
+import { BaseValue } from ".";
+import { EMutability, IScope, IValue, TValueInstructions } from "../types";
+/**
+ * `StoreValue` represents values unknown at compile time,
+ * mostly used with mutable variables and temporary values
+ */
+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;
+    consume(_scope: IScope): TValueInstructions;
+    toString(): string;
+}

package/{build → dist/types}/values/TempValue.d.ts

@@ -1,12 +1,19 @@
-import { IInstruction, IScope, IValue, TValueInstructions } from "../types";
-import { StoreValue } from "./";
-export declare class TempValue extends StoreValue {
-    proxied: IValue;
-    canProxy: boolean;
-    setInst: IInstruction;
-    constructor(scope: IScope, name?: string);
-    eval(scope: IScope): TValueInstructions;
-    "="(scope: IScope, value: IValue): TValueInstructions;
-    proxy(value: IValue): TValueInstructions;
-    noProxy(): void;
-}
+import { IInstruction, IScope, IValue, TValueInstructions } from "../types";
+import { StoreValue } from "./";
+export interface TempValueOptions {
+    scope: IScope;
+    name?: string;
+    renameable?: boolean;
+}
+export declare class TempValue extends StoreValue implements IValue {
+    proxied: IValue;
+    canProxy: boolean;
+    setInst: IInstruction;
+    renameable: boolean;
+    constructor({ scope, name, renameable }: TempValueOptions);
+    eval(scope: IScope): TValueInstructions;
+    "="(scope: IScope, value: IValue): TValueInstructions;
+    proxy(value: IValue): TValueInstructions;
+    noProxy(): void;
+    rename(name: string): void;
+}

package/dist/types/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/types/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/{build → dist/types}/values/index.d.ts

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