@sudoo/marked/evaluate/class-declaration.js

JavaScript & TypeScript code runner in JavaScript, safe with marked territory, asynchronous

"use strict";
/**
 * @author WMXPY
 * @namespace Evaluate
 * @description Class Declaration
 */
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.classDeclarationEvaluation = exports.mountClassDeclaration = void 0;
const error_code_1 = require("../declare/error-code");
const variable_1 = require("../declare/variable");
const error_1 = require("../util/error/error");
const sand_class_1 = require("../variable/sand-class/sand-class");
const trace_class_1 = require("../variable/trace/trace-class");
const mountClassDeclaration = (sandbox) => {
    sandbox.mount("ClassDeclaration", exports.classDeclarationEvaluation);
};
exports.mountClassDeclaration = mountClassDeclaration;
const classDeclarationEvaluation = function (node, scope, trace) {
    return __awaiter(this, void 0, void 0, function* () {
        if (!node.id) {
            throw (0, error_1.error)(error_code_1.ERROR_CODE.UNKNOWN_ERROR, void 0, node, trace);
        }
        if (node.id.type !== "Identifier") {
            throw (0, error_1.error)(error_code_1.ERROR_CODE.UNKNOWN_ERROR, void 0, node, trace);
        }
        if (typeof node.id.name !== "string") {
            throw (0, error_1.error)(error_code_1.ERROR_CODE.UNKNOWN_ERROR, void 0, node, trace);
        }
        const rawName = node.id.name;
        const sandClass = sand_class_1.SandClass.create(rawName);
        if (node.superClass) {
            const superClass = yield this.execute(node.superClass, scope, trace);
            if (!(superClass instanceof sand_class_1.SandClass)) {
                throw (0, error_1.error)(error_code_1.ERROR_CODE.INTERNAL_ERROR, "Super class node is not sand class", node, trace);
            }
            sandClass.setSuperClass(superClass);
        }
        const nextTrace = trace_class_1.TraceClass.fromStack(trace, node, sandClass);
        yield this.execute(node.body, scope, nextTrace);
        scope.register(variable_1.VARIABLE_TYPE.CONSTANT)(rawName, sandClass);
        return sandClass;
    });
};
exports.classDeclarationEvaluation = classDeclarationEvaluation;