mlogjs 0.5.2 → 0.6.0

package/dist/utils/general.d.ts

@@ -2,24 +2,23 @@ import { es } from "../types";
 /**
  * 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].
+ * 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"
- * ```
+ *   ```
+ *   camelToDashCase("camelCase") // returns "camel-case"
+ *   ```;
  */
 export declare function camelToDashCase(name: string): string;
-/**
- * A more type safe version of `Object.assign`
- */
-export declare function assign<T extends {}>(obj: T, props: {
+/** A more type safe version of `Object.assign` */
+export declare function assign<T extends object>(obj: T, props: {
     [K in keyof T as T[K] extends Function ? never : K]?: T[K];
 }): T;
 /** Lazily computes and caches an expression */

package/dist/utils/instruction.d.ts

@@ -4,6 +4,10 @@ export declare function appendSourceLocations<T extends IValue | null>(valueInst
 export declare function withAlwaysRuns<T extends IValue | null>(valueInst: TValueInstructions<T>, value: boolean): TValueInstructions<T>;
 /** Removes jump instructions that point right to the next line */
 export declare function hideRedundantJumps(inst: IInstruction[]): void;
-/** A helper that appends the instructions from `value` into `inst` and returns it's `IValue` instance */
+/**
+ * A helper that appends the instructions from `value` into `inst` and returns
+ * it's `IValue` instance
+ */
 export declare function pipeInsts<T extends IValue | null>(value: TValueInstructions<T>, inst: IInstruction[]): T;
 export declare function usesAddressResolver(resolver: AddressResolver, instructions: IInstruction[]): boolean;
+export declare function formatInstructionArgs(args: (IValue | string | null)[]): string[];

package/dist/utils/value.d.ts

@@ -11,10 +11,13 @@ export declare function isTemplateObjectArray(value: IValue): value is ObjectVal
     };
 };
 export declare function extractOutName(out: TEOutput | undefined): string | undefined;
-export declare function extractDestrucuringOut(out: TEOutput | undefined, field: string | number): string | IValue | undefined;
+export declare function extractDestrucuringOut(out: TEOutput | undefined, field: string | number): "&_" | IValue | undefined;
 /** Asserts that `value` is a `LiteralValue` that contains a string */
 export declare function assertStringLiteral(value: IValue | undefined, name: string): asserts value is LiteralValue<string>;
-/** Asserts that `value` is a string literal that is part of a given set of `members`*/
+/**
+ * Asserts that `value` is a string literal that is part of a given set of
+ * `members`
+ */
 export declare function assertLiteralOneOf<T extends readonly string[]>(value: IValue | undefined, members: T, name: string): asserts value is LiteralValue<T[number]>;
 /** Asserts that `value` is either a store or a literal */
 export declare function assertIsRuntimeValue(value: IValue | undefined, name: string): asserts value is LiteralValue | StoreValue;
@@ -26,9 +29,15 @@ export declare function assertIsArrayMacro(value: IValue | undefined, name: stri
         length: LiteralValue<number>;
     };
 };
-/** Helper type used to describe the overloads of a macro function. See {@link assertObjectFields} */
+/**
+ * Helper type used to describe the overloads of a macro function. See
+ * {@link assertObjectFields}
+ */
 export type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
-/** Describes an object destructuring paremeter. Generally used with `assertObjectFields` */
+/**
+ * Describes an object destructuring paremeter. Generally used with
+ * `assertObjectFields`
+ */
 export interface IParameterDescriptor {
     key: string;
     name?: string;
@@ -36,6 +45,6 @@ export interface IParameterDescriptor {
     /** Throw an error on invalid values */
     validate?(value: IValue): void;
 }
-/** Asserts that all of the fields described are present on `value`*/
+/** Asserts that all of the fields described are present on `value` */
 export declare function assertObjectFields(value: ObjectValue, fields: (string | IParameterDescriptor)[]): (IValue | string)[];
 export declare function isDiscardedOut(out: TEOutput | undefined): boolean;

package/dist/values/AssignmentValue.d.ts

@@ -7,5 +7,5 @@ export declare class AssignmentValue extends VoidValue {
     "="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
     toOut(): IValue;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }

package/dist/values/BaseValue.d.ts

@@ -1,10 +1,12 @@
-import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { IScope, IValue, TEOutput, TLineRef, TValueInstructions } from "../types";
 import { VoidValue } from ".";
 export declare class BaseValue extends VoidValue implements IValue {
     "u-"(scope: IScope, out?: TEOutput): TValueInstructions;
     "u+"(scope: IScope, out?: TEOutput): TValueInstructions;
     "!"(scope: IScope, out?: TEOutput): TValueInstructions;
     "~"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    "??"(scope: IScope, other: IValue, out?: TEOutput, endAddress?: TLineRef): TValueInstructions;
     "!=="(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    "&&"(scope: IScope, value: IValue, out?: TEOutput, endAddress?: TLineRef): TValueInstructions;
+    "||"(scope: IScope, value: IValue, out?: TEOutput, endAddress?: TLineRef): TValueInstructions;
 }

package/dist/values/DestructuringValue.d.ts

@@ -2,17 +2,15 @@ import { IScope, IValue, TValueInstructions } from "../types";
 import { VoidValue } from "./VoidValue";
 export type TDestructuringMembers = Map<IValue, {
     value: IValue;
-    /**
-     * Handles the input value, is responsible for the assignment.
-     */
-    handler(get: () => TValueInstructions, propExists: () => boolean, scope: IScope): TValueInstructions<IValue | null>;
+    /** Handles the input value, is responsible for the assignment. */
+    handler(this: void, get: () => TValueInstructions, propExists: () => boolean, scope: IScope): TValueInstructions<IValue | null>;
 }>;
 /**
  * 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.
+ * 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: TDestructuringMembers;
@@ -28,5 +26,5 @@ export declare class DestructuringValue extends VoidValue {
     "="(scope: IScope, right: IValue): TValueInstructions;
     eval(_scope: IScope): TValueInstructions<IValue>;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }

package/dist/values/FunctionValue.d.ts

@@ -1,16 +1,18 @@
 import { Compiler } from "../Compiler";
-import { EMutability, es, IFunctionValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { EInlineType, EMutability, es, IFunctionValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { StoreValue } from "./StoreValue";
 import { VoidValue } from "./VoidValue";
 export type TFunctionValueInitParams = (childScope: IScope) => {
     paramStores: StoreValue[];
     paramNames: string[];
 };
+type FunctionParam = es.Function["params"][number];
 export declare class FunctionValue extends VoidValue implements IFunctionValue {
     name: string;
     mutability: EMutability;
     macro: boolean;
     scope: IScope;
+    inlineType: EInlineType;
     private childScope;
     private params;
     private paramValues;
@@ -23,7 +25,6 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private addr;
     private temp;
     private ret;
-    private inline;
     private tryingInline;
     private body;
     private c;
@@ -32,14 +33,14 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private inlineEnd?;
     private bundled;
     private initialized;
-    constructor({ scope, params, body, c, out, }: {
+    constructor({ scope, params, body, c, out, inlineType, }: {
         scope: IScope;
         body: es.BlockStatement;
         c: Compiler;
-        params: es.Identifier[];
+        params: FunctionParam[];
         out?: TEOutput;
+        inlineType: EInlineType;
     });
-    typeof(): TValueInstructions;
     private initScope;
     private ensureInit;
     private normalReturn;
@@ -51,7 +52,8 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     eval(_scope: IScope): TValueInstructions;
     preCall(): readonly IValue[] | undefined;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
     private unwrapParameter;
     private hardSetParameter;
 }
+export {};

package/dist/values/JumpOutValue.d.ts

@@ -1,5 +1,5 @@
 import { EJumpKind, JumpInstruction } from "../instructions";
-import { es, IBindableValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { es, IScope, IValue, TEOutput, TLineRef, TValueInstructions } from "../types";
 import { VoidValue } from "./VoidValue";
 declare const operatorMap: {
     readonly "!=": EJumpKind.NotEqual;
@@ -23,14 +23,14 @@ type TWhenFalseOperator = keyof typeof invertedOperatorMap;
 type TWhenTrueOperator = keyof typeof operatorMap;
 export declare class JumpOutValue extends VoidValue {
     node: es.Node;
-    address: IBindableValue<number | null>;
+    address: TLineRef;
     whenTrue: boolean;
     macro: boolean;
-    constructor(node: es.Node, address: IBindableValue<number | null>, whenTrue: boolean);
+    constructor(node: es.Node, address: TLineRef, whenTrue: boolean);
     canHandle(operator: string): operator is TWhenTrueOperator | TWhenFalseOperator;
     handle(operator: TWhenTrueOperator | TWhenFalseOperator, left: IValue, right: IValue): JumpInstruction;
     eval(_scope: IScope, _out?: TEOutput): TValueInstructions<IValue>;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }
 export {};

package/dist/values/LazyValue.d.ts

@@ -1,11 +1,11 @@
 import { IValue } from "../types";
 import { VoidValue } from "./VoidValue";
 /**
- * This class is used to handle some cases where the value
- * can't be directly evaluated by the node handler
+ * This class is used to handle some cases where the value can't be directly
+ * evaluated by the node handler
  */
 export declare class LazyValue extends VoidValue {
     constructor(evalutate: IValue["eval"]);
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }

package/dist/values/LiteralValue.d.ts

@@ -6,12 +6,11 @@ export declare class LiteralValue<T extends TLiteral | null = TLiteral> extends
     mutability: EMutability;
     constructor(data: T);
     eval(_scope: IScope): TValueInstructions;
-    toString(): string;
+    toMlogString(): string;
     get(scope: IScope, name: IValue): TValueInstructions;
     hasProperty(scope: IScope, prop: IValue): boolean;
-    get num(): 1 | 0 | (T & {});
+    get num(): number;
     "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
-    typeof(): TValueInstructions;
     isString(): this is LiteralValue<string>;
     isNumber(): this is LiteralValue<number>;
     debugString(): string;

package/dist/values/ObjectValue.d.ts

@@ -1,10 +1,7 @@
-import { MacroFunction } from "../macros";
-import { EMutability, IScope, IValue, TEOutput, TOperatorMacroMap, TValueInstructions } from "../types";
+import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { VoidValue } from "./VoidValue";
-export interface IObjectValueData extends TOperatorMacroMap {
-    [k: string]: IValue | undefined;
-    $get?: MacroFunction<IValue>;
-    $eval?: MacroFunction<IValue>;
+export interface IObjectValueData {
+    [k: string]: IValue;
 }
 export declare class ObjectValue extends VoidValue {
     mutability: EMutability;
@@ -12,12 +9,10 @@ export declare class ObjectValue extends VoidValue {
     data: IObjectValueData;
     constructor(data?: IObjectValueData);
     static fromArray(items: IObjectValueData[keyof IObjectValueData][], initialData?: IObjectValueData): ObjectValue;
-    typeof(scope: IScope, out?: TEOutput): TValueInstructions;
     get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions;
     hasProperty(scope: IScope, prop: IValue): boolean;
-    eval(scope: IScope, out?: TEOutput): TValueInstructions;
-    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<IValue | null>;
-    "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    eval(): TValueInstructions;
+    "??"(): TValueInstructions;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }

package/dist/values/StoreValue.d.ts

@@ -1,22 +1,27 @@
 import { BaseValue } from ".";
 import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 /**
- * `StoreValue` represents values unknown at compile time,
- * mostly used with mutable variables and temporary values
+ * `StoreValue` represents values unknown at compile time, mostly used with
+ * mutable variables and temporary values.
+ *
+ * Stores are mutable by default.
  */
 export declare class StoreValue extends BaseValue implements IValue {
     name: string;
     mutability: EMutability;
-    constructor(name: string, mutability?: EMutability);
+    temporary: boolean;
+    constructor(name: string, mutability?: EMutability, { temporary, volatile, }?: Partial<Pick<StoreValue, "temporary" | "volatile">>);
     static from(scope: IScope, out?: TEOutput, mutability?: EMutability): StoreValue;
     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;
+    get(scope: IScope, prop: IValue, out?: TEOutput): TValueInstructions<IValue>;
+    hasProperty(scope: IScope, prop: IValue): boolean;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }
+export declare function formatSenseablePropName(name: string): string;

package/dist/values/VoidValue.d.ts

@@ -3,6 +3,7 @@ export declare class VoidValue implements IValue {
     name?: string;
     mutability: EMutability;
     macro: boolean;
+    volatile: boolean;
     eval(_scope: IScope, _out?: TEOutput): TValueInstructions;
     call(_scope: IScope, _args: IValue[], _out?: TEOutput): TValueInstructions<IValue | null>;
     get(_scope: IScope, name: IValue): TValueInstructions;
@@ -11,7 +12,7 @@ export declare class VoidValue implements IValue {
     postCall(_scope: IScope): void;
     toOut(): IValue;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }
 export interface VoidValue extends IValueOperators {
 }

package/dist/values/index.d.ts

@@ -3,7 +3,6 @@ export * from "./BaseValue";
 export * from "./LiteralValue";
 export * from "./StoreValue";
 export * from "./ObjectValue";
-export * from "./SenseableValue";
 export * from "./DestructuringValue";
 export * from "./LazyValue";
 export * from "./AssignmentValue";