greybel-interpreter 1.8.5 → 1.8.6

package/dist/operations/function.d.ts

@@ -5,10 +5,14 @@ import { CustomString } from '../types/string';
 import { CPSVisit, Operation } from './operation';
 export declare const SELF_PROPERTY: CustomString;
 export declare const SUPER_PROPERTY: CustomString;
+export interface FunctionOperationArgument {
+    name: string;
+    op: Operation;
+}
 export declare class FunctionOperation extends Operation {
     readonly item: ASTFunctionStatement;
     block: Operation;
-    args: Map<string, Operation>;
+    args: FunctionOperationArgument[];
     constructor(item: ASTFunctionStatement, target?: string);
     build(visit: CPSVisit): Promise<Operation>;
     handle(ctx: OperationContext): Promise<CustomValue>;

package/dist/operations/function.js

@@ -18,8 +18,8 @@ const string_1 = require("../types/string");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
 const reference_1 = require("./reference");
-exports.SELF_PROPERTY = new string_1.CustomString('self');
-exports.SUPER_PROPERTY = new string_1.CustomString('super');
+exports.SELF_PROPERTY = new string_1.CustomString(function_1.SELF_NAMESPACE);
+exports.SUPER_PROPERTY = new string_1.CustomString(function_1.SUPER_NAMESPACE);
 class FunctionOperation extends operation_1.Operation {
     constructor(item, target) {
         super(null, target);
@@ -29,18 +29,24 @@ class FunctionOperation extends operation_1.Operation {
         return __awaiter(this, void 0, void 0, function* () {
             const stack = yield Promise.all(this.item.body.map((child) => visit(child)));
             this.block = new block_1.Block(this.item, stack);
-            this.args = new Map();
+            this.args = [];
             const defers = this.item.parameters.map((child) => __awaiter(this, void 0, void 0, function* () {
                 switch (child.type) {
                     case greyscript_core_1.ASTType.AssignmentStatement: {
                         const assignStatement = child;
                         const assignKey = assignStatement.variable;
-                        this.args.set(assignKey.name, yield visit(assignStatement.init));
+                        this.args.push({
+                            name: assignKey.name,
+                            op: yield visit(assignStatement.init)
+                        });
                         break;
                     }
                     case greyscript_core_1.ASTType.Identifier: {
                         const identifierKey = child;
-                        this.args.set(identifierKey.name, new reference_1.Reference(default_1.DefaultType.Void));
+                        this.args.push({
+                            name: identifierKey.name,
+                            op: new reference_1.Reference(default_1.DefaultType.Void)
+                        });
                         break;
                     }
                     default:
@@ -69,8 +75,8 @@ class FunctionOperation extends operation_1.Operation {
             yield this.block.handle(fnCtx);
             return functionState.value;
         }));
-        for (const [key, value] of this.args) {
-            func.addArgument(key, value);
+        for (const item of this.args) {
+            func.addArgument(item.name, item.op);
         }
         return Promise.resolve(func);
     }

package/dist/operations/resolve.js

@@ -79,7 +79,7 @@ class SegmentContainer {
     isSuper() {
         return (this.path.length === 2 &&
             this.path[0] instanceof IdentifierSegment &&
-            this.path[0].value === 'super');
+            this.path[0].value === function_1.SUPER_NAMESPACE);
     }
     getLast() {
         return this.path[this.path.length - 1];
@@ -177,7 +177,7 @@ class Resolve extends operation_1.Operation {
                     }
                     if (handle instanceof function_1.CustomFunction) {
                         if (index === 1 &&
-                            traversedPath.toString() === 'super' &&
+                            traversedPath.toString() === function_1.SUPER_NAMESPACE &&
                             ctx.functionState.context &&
                             previous instanceof map_1.CustomMap) {
                             handle = yield handle.run(ctx.functionState.context, [], ctx, previous.isa);

package/dist/types/function.d.ts

@@ -5,6 +5,9 @@ import { CustomMap } from './map';
 export interface Callback {
     (ctx: OperationContext, self: CustomValue, args: Map<string, CustomValue>, next?: CustomValue): Promise<NonNullable<CustomValue>>;
 }
+export declare const DEFAULT_FUNCTION_NAME = "anonymous";
+export declare const SELF_NAMESPACE = "self";
+export declare const SUPER_NAMESPACE = "super";
 export declare class Argument {
     readonly name: string;
     readonly defaultValue: Operation;
@@ -15,13 +18,11 @@ export declare class CustomFunction extends CustomValue {
     readonly scope?: OperationContext;
     readonly name: string;
     readonly value: Callback;
-    private injectSelf;
     readonly argumentDefs: Array<Argument>;
     static createExternalAnonymous(callback: Callback): CustomFunction;
     static createExternal(name: string, callback: Callback): CustomFunction;
     static createExternalWithSelf(name: string, callback: Callback): CustomFunction;
-    constructor(scope: OperationContext, name: string, callback: Callback, injectSelf?: boolean);
-    setInjectSelf(injectSelf: boolean): CustomFunction;
+    constructor(scope: OperationContext, name: string, callback: Callback);
     addArgument(name: string, defaultValue?: Operation | CustomValue): CustomFunction;
     fork(): CustomValue;
     getCustomType(): string;

package/dist/types/function.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomFunction = exports.Argument = void 0;
+exports.CustomFunction = exports.Argument = exports.SUPER_NAMESPACE = exports.SELF_NAMESPACE = exports.DEFAULT_FUNCTION_NAME = void 0;
 const context_1 = require("../context");
 const operation_1 = require("../operations/operation");
 const reference_1 = require("../operations/reference");
@@ -17,6 +17,9 @@ const base_1 = require("./base");
 const default_1 = require("./default");
 const map_1 = require("./map");
 const nil_1 = require("./nil");
+exports.DEFAULT_FUNCTION_NAME = 'anonymous';
+exports.SELF_NAMESPACE = 'self';
+exports.SUPER_NAMESPACE = 'super';
 class Argument {
     static createWithCustomValue(name, defaultValue) {
         return new Argument(name, new reference_1.Reference(defaultValue));
@@ -37,26 +40,21 @@ class Argument {
 exports.Argument = Argument;
 class CustomFunction extends base_1.CustomValue {
     static createExternalAnonymous(callback) {
-        return new CustomFunction(null, 'anonymous', callback);
+        return new CustomFunction(null, exports.DEFAULT_FUNCTION_NAME, callback);
     }
     static createExternal(name, callback) {
         return new CustomFunction(null, name, callback);
     }
     static createExternalWithSelf(name, callback) {
-        return new CustomFunction(null, name, callback, true).addArgument('self');
+        return new CustomFunction(null, name, callback).addArgument(exports.SELF_NAMESPACE);
     }
-    constructor(scope, name, callback, injectSelf = false) {
+    constructor(scope, name, callback) {
         super();
         this.scope = scope;
         this.name = name;
         this.value = callback;
-        this.injectSelf = injectSelf;
         this.argumentDefs = [];
     }
-    setInjectSelf(injectSelf) {
-        this.injectSelf = injectSelf;
-        return this;
-    }
     addArgument(name, defaultValue = default_1.DefaultType.Void) {
         this.argumentDefs.push(new Argument(name, defaultValue));
         return this;
@@ -94,12 +92,16 @@ class CustomFunction extends base_1.CustomValue {
                 state: context_1.ContextState.Default
             });
             const argMap = new Map();
-            if (this.injectSelf && !(self instanceof nil_1.CustomNil)) {
-                args.unshift(self);
-            }
+            const isSelfNull = self instanceof nil_1.CustomNil;
+            let argIndex = 0;
             for (let index = 0; index < this.argumentDefs.length; index++) {
                 const item = this.argumentDefs[index];
-                argMap.set(item.name, args[index] || (yield item.defaultValue.handle(fnCtx)));
+                if (!isSelfNull && item.name === exports.SELF_NAMESPACE)
+                    continue;
+                argMap.set(item.name, args[argIndex++] || (yield item.defaultValue.handle(fnCtx)));
+            }
+            if (!isSelfNull) {
+                argMap.set(exports.SELF_NAMESPACE, self);
             }
             const isa = next || (self instanceof map_1.CustomMap ? self.isa : null);
             return this.value(fnCtx || callContext, self, argMap, isa);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "1.8.5",
+    "version": "1.8.6",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",