greybel-interpreter 4.5.13 → 4.6.0

package/dist/bytecode-generator/expression.js

@@ -0,0 +1,640 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytecodeExpressionGenerator = void 0;
+const greybel_core_1 = require("greybel-core");
+const miniscript_core_1 = require("miniscript-core");
+const path_1 = require("path");
+const default_1 = require("../types/default");
+const number_1 = require("../types/number");
+const string_1 = require("../types/string");
+const error_1 = require("../utils/error");
+const instruction_1 = require("./instruction");
+const keywords_1 = require("./keywords");
+const utils_1 = require("./utils");
+class BytecodeExpressionGenerator {
+    constructor(context, parseCodeFunction, stmtGenerator) {
+        this.context = context;
+        this.parseCode = parseCodeFunction;
+        this.stmtGenerator = stmtGenerator;
+    }
+    process(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            switch (node.type) {
+                case miniscript_core_1.ASTType.MemberExpression:
+                    yield this.processMemberExpression(node, context);
+                    return;
+                case miniscript_core_1.ASTType.IndexExpression:
+                    yield this.processIndexExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.SliceExpression:
+                    yield this.processSliceExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.Identifier:
+                    yield this.processIdentifier(node);
+                    return;
+                case miniscript_core_1.ASTType.BooleanLiteral:
+                case miniscript_core_1.ASTType.StringLiteral:
+                case miniscript_core_1.ASTType.NumericLiteral:
+                case miniscript_core_1.ASTType.NilLiteral:
+                    yield this.processLiteral(node);
+                    return;
+                case miniscript_core_1.ASTType.IsaExpression:
+                case miniscript_core_1.ASTType.BinaryExpression:
+                case miniscript_core_1.ASTType.LogicalExpression:
+                    yield this.processEvaluationExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.MapConstructorExpression:
+                    yield this.processMapConstructorExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.ListConstructorExpression:
+                    yield this.processListConstructorExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.FunctionDeclaration:
+                    yield this.processFunctionDeclaration(node, context);
+                    return;
+                case miniscript_core_1.ASTType.ParenthesisExpression:
+                    yield this.process(node.expression);
+                    return;
+                case miniscript_core_1.ASTType.BinaryNegatedExpression:
+                case miniscript_core_1.ASTType.UnaryExpression:
+                case miniscript_core_1.ASTType.NegationExpression:
+                    yield this.processUnaryExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.CallExpression:
+                    yield this.processCallExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.EmptyExpression:
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(node),
+                        value: default_1.DefaultType.Void
+                    });
+                    return;
+                case greybel_core_1.ASTType.FeatureEnvarExpression:
+                    yield this.processEnvarExpression(node);
+                    return;
+                case greybel_core_1.ASTType.FeatureLineExpression:
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(node),
+                        value: new number_1.CustomNumber(node.start.line)
+                    });
+                    return;
+                case greybel_core_1.ASTType.FeatureFileExpression:
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(node),
+                        value: new string_1.CustomString((0, path_1.basename)(this.context.target.peek()))
+                    });
+                    return;
+                case miniscript_core_1.ASTType.Comment:
+                    return;
+                default: {
+                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
+                        target: this.context.target.peek(),
+                        range
+                    });
+                }
+            }
+        });
+    }
+    processMemberExpression(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const base = (0, utils_1.unwrap)(node.base);
+            if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(node.identifier),
+                    value: new string_1.CustomString(node.identifier.name)
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
+                    source: mod.getSourceLocation(node.identifier),
+                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference)
+                });
+            }
+            else {
+                yield this.process(base);
+                yield this.processIdentifier(node.identifier, {
+                    isDescending: true,
+                    isReference: !!(context === null || context === void 0 ? void 0 : context.isReference)
+                });
+            }
+        });
+    }
+    processIndexExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const base = (0, utils_1.unwrap)(node.base);
+            if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                yield this.process(node.index);
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
+                    source: mod.getSourceLocation(node.index, node.type),
+                    invoke: false
+                });
+            }
+            else {
+                yield this.process(base);
+                yield this.process(node.index);
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: mod.getSourceLocation(node.index, node.type),
+                    invoke: false
+                });
+            }
+        });
+    }
+    processSliceExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            yield this.process(node.base);
+            yield this.process(node.left);
+            yield this.process(node.right);
+            mod.pushCode({
+                op: instruction_1.OpCode.SLICE,
+                source: mod.getSourceLocation(node)
+            });
+        });
+    }
+    processIdentifier(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            if (!(context === null || context === void 0 ? void 0 : context.isDescending)) {
+                switch (node.name) {
+                    case keywords_1.RuntimeKeyword.Self: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_SELF,
+                            source: mod.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case keywords_1.RuntimeKeyword.Super: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_SUPER,
+                            source: mod.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case keywords_1.RuntimeKeyword.Outer: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_OUTER,
+                            source: mod.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case keywords_1.RuntimeKeyword.Locals: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_LOCALS,
+                            source: mod.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case keywords_1.RuntimeKeyword.Globals: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_GLOBALS,
+                            source: mod.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    default: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_VARIABLE,
+                            source: mod.getSourceLocation(node),
+                            property: new string_1.CustomString(node.name),
+                            invoke: !(context === null || context === void 0 ? void 0 : context.isReference)
+                        });
+                    }
+                }
+            }
+            else {
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(node),
+                    value: new string_1.CustomString(node.name)
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: mod.getSourceLocation(node),
+                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference)
+                });
+            }
+        });
+    }
+    processLiteral(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const value = (0, utils_1.generateCustomValueFromASTLiteral)(node);
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH,
+                source: mod.getSourceLocation(node),
+                value
+            });
+        });
+    }
+    processEvaluationExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const skip = {
+                op: instruction_1.OpCode.NOOP,
+                source: mod.getSourceLocation(node)
+            };
+            yield this.process(node.left);
+            if (node.operator === miniscript_core_1.Operator.And) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.GOTO_A_IF_FALSE_AND_PUSH,
+                    source: mod.getSourceLocation(node),
+                    goto: skip
+                });
+            }
+            else if (node.operator === miniscript_core_1.Operator.Or) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.GOTO_A_IF_TRUE_AND_PUSH,
+                    source: mod.getSourceLocation(node),
+                    goto: skip
+                });
+            }
+            yield this.process(node.right);
+            switch (node.operator) {
+                case miniscript_core_1.Operator.Isa: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.ISA,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Equal: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.EQUAL,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.NotEqual: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.NOT_EQUAL,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.LessThan: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.LESS_THAN,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.LessThanOrEqual: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.LESS_THAN_OR_EQUAL,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.GreaterThan: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.GREATER_THAN,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.GreaterThanOrEqual: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.GREATER_THAN_OR_EQUAL,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.And: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.AND,
+                        source: mod.getSourceLocation(node)
+                    });
+                    mod.pushCode(skip);
+                    break;
+                }
+                case miniscript_core_1.Operator.Or: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.OR,
+                        source: mod.getSourceLocation(node)
+                    });
+                    mod.pushCode(skip);
+                    break;
+                }
+                case miniscript_core_1.Operator.Plus: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.ADD,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Minus: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.SUB,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Asterik: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.MUL,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Slash: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.DIV,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Modulo: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.MOD,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Power: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.POW,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.BitwiseAnd: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.BITWISE_AND,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.BitwiseOr: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.BITWISE_OR,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.LeftShift: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.BITWISE_LEFT_SHIFT,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.RightShift: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.BITWISE_RIGHT_SHIFT,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.UnsignedRightShift: {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.BITWISE_UNSIGNED_RIGHT_SHIFT,
+                        source: mod.getSourceLocation(node)
+                    });
+                    break;
+                }
+                default:
+                    throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
+            }
+        });
+    }
+    processMapConstructorExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            for (const field of node.fields) {
+                yield this.process(field.key);
+                yield this.process(field.value);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.CONSTRUCT_MAP,
+                source: mod.getSourceLocation(node),
+                length: node.fields.length
+            });
+        });
+    }
+    processListConstructorExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            for (const field of node.fields) {
+                yield this.process(field.value);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.CONSTRUCT_LIST,
+                source: mod.getSourceLocation(node),
+                length: node.fields.length
+            });
+        });
+    }
+    processFunctionDeclaration(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = [];
+            for (const item of node.parameters) {
+                if (item instanceof miniscript_core_1.ASTIdentifier) {
+                    args.push({
+                        name: new string_1.CustomString(item.name),
+                        defaultValue: default_1.DefaultType.Void
+                    });
+                }
+                else if (item instanceof miniscript_core_1.ASTAssignmentStatement) {
+                    let defaultValue = default_1.DefaultType.Void;
+                    if (item.init instanceof miniscript_core_1.ASTLiteral) {
+                        defaultValue = (0, utils_1.generateCustomValueFromASTLiteral)(item.init);
+                    }
+                    args.push({
+                        name: new string_1.CustomString(item.variable.name),
+                        defaultValue
+                    });
+                }
+            }
+            const mod = this.context.module.peek();
+            mod.pushContext();
+            for (const item of node.body) {
+                yield this.stmtGenerator.process(item);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH,
+                source: mod.getInternalLocation(),
+                value: default_1.DefaultType.Void
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.RETURN,
+                source: mod.getInternalLocation()
+            });
+            const fnCode = mod.popContext().code;
+            mod.pushCode({
+                op: instruction_1.OpCode.FUNCTION_DEFINITION,
+                source: mod.getSourceLocation(node),
+                arguments: args,
+                code: fnCode,
+                /*
+                  Can be removed after MiniScript fixed outer context bug.
+                */
+                ignoreOuter: !(context === null || context === void 0 ? void 0 : context.includeOuter)
+            });
+        });
+    }
+    processUnaryExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const arg = (0, utils_1.unwrap)(node.argument);
+            switch (node.operator) {
+                case miniscript_core_1.Operator.Reference:
+                    if (arg instanceof miniscript_core_1.ASTMemberExpression) {
+                        yield this.processMemberExpression(arg, { isReference: true });
+                    }
+                    else if (arg instanceof miniscript_core_1.ASTIndexExpression) {
+                        yield this.processIndexExpression(arg);
+                    }
+                    else if (arg instanceof miniscript_core_1.ASTIdentifier) {
+                        yield this.processIdentifier(arg, {
+                            isDescending: false,
+                            isReference: true
+                        });
+                    }
+                    else {
+                        yield this.process(arg);
+                    }
+                    return;
+                case miniscript_core_1.Operator.Not: {
+                    yield this.process(arg);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.FALSIFY,
+                        source: mod.getSourceLocation(node)
+                    });
+                    return;
+                }
+                case miniscript_core_1.Operator.Minus: {
+                    yield this.process(arg);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.NEGATE,
+                        source: mod.getSourceLocation(node)
+                    });
+                    return;
+                }
+                case miniscript_core_1.Operator.New: {
+                    yield this.process(arg);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.NEW,
+                        source: mod.getSourceLocation(node)
+                    });
+                }
+            }
+        });
+    }
+    processCallExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const pushArgs = () => __awaiter(this, void 0, void 0, function* () {
+                for (const arg of node.arguments) {
+                    yield this.process(arg);
+                }
+            });
+            const left = (0, utils_1.unwrap)(node.base);
+            if (left instanceof miniscript_core_1.ASTMemberExpression) {
+                const base = (0, utils_1.unwrap)(left.base);
+                if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(left.identifier),
+                        value: new string_1.CustomString(left.identifier.name)
+                    });
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
+                        source: mod.getSourceLocation(node.base, node.type),
+                        length: node.arguments.length
+                    });
+                }
+                else {
+                    yield this.process(base);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(left.identifier),
+                        value: new string_1.CustomString(left.identifier.name)
+                    });
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
+                        source: mod.getSourceLocation(left.identifier, node.type),
+                        length: node.arguments.length
+                    });
+                }
+            }
+            else if (left instanceof miniscript_core_1.ASTIndexExpression) {
+                const base = (0, utils_1.unwrap)(left.base);
+                if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                    yield this.process(left.index);
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
+                        source: mod.getSourceLocation(left.index, node.type),
+                        length: node.arguments.length
+                    });
+                }
+                else {
+                    yield this.process(base);
+                    yield this.process(left.index);
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
+                        source: mod.getSourceLocation(left.index, node.type),
+                        length: node.arguments.length
+                    });
+                }
+            }
+            else if (left instanceof miniscript_core_1.ASTIdentifier) {
+                yield this.processIdentifier(left, {
+                    isDescending: false,
+                    isReference: true
+                });
+                yield pushArgs();
+                mod.pushCode({
+                    op: instruction_1.OpCode.CALL,
+                    source: mod.getSourceLocation(left, node.type),
+                    length: node.arguments.length
+                });
+            }
+            else {
+                yield this.process(left);
+                yield pushArgs();
+                mod.pushCode({
+                    op: instruction_1.OpCode.CALL,
+                    source: mod.getSourceLocation(left, node.type),
+                    length: node.arguments.length
+                });
+            }
+        });
+    }
+    processEnvarExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH,
+                source: mod.getSourceLocation(node),
+                value: new string_1.CustomString(node.name)
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.GET_ENVAR,
+                source: mod.getSourceLocation(node)
+            });
+        });
+    }
+}
+exports.BytecodeExpressionGenerator = BytecodeExpressionGenerator;