tsll/lib/common/error.js

Compiler frontend for translating Typescript to LLVM IR

"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.TypeMismatchError = exports.TypeUndefinedError = exports.DuplicateError = exports.SyntaxNotSupportedError = exports.VariableUndefinedError = exports.FunctionUndefinedError = exports.InstantiateError = void 0;
var InstantiateError = (function (_super) {
    __extends(InstantiateError, _super);
    function InstantiateError(message) {
        return _super.call(this, "Error instantiating class; " + message) || this;
    }
    return InstantiateError;
}(Error));
exports.InstantiateError = InstantiateError;
var FunctionUndefinedError = (function (_super) {
    __extends(FunctionUndefinedError, _super);
    function FunctionUndefinedError(message) {
        return _super.call(this, "Function undefined; " + message) || this;
    }
    return FunctionUndefinedError;
}(Error));
exports.FunctionUndefinedError = FunctionUndefinedError;
var VariableUndefinedError = (function (_super) {
    __extends(VariableUndefinedError, _super);
    function VariableUndefinedError(message) {
        return _super.call(this, "Variable undefined; " + message) || this;
    }
    return VariableUndefinedError;
}(Error));
exports.VariableUndefinedError = VariableUndefinedError;
var SyntaxNotSupportedError = (function (_super) {
    __extends(SyntaxNotSupportedError, _super);
    function SyntaxNotSupportedError(message) {
        return _super.call(this, "Syntax not supported; " + message) || this;
    }
    return SyntaxNotSupportedError;
}(Error));
exports.SyntaxNotSupportedError = SyntaxNotSupportedError;
var DuplicateError = (function (_super) {
    __extends(DuplicateError, _super);
    function DuplicateError(message) {
        return _super.call(this, "Duplicate definition; " + message) || this;
    }
    return DuplicateError;
}(Error));
exports.DuplicateError = DuplicateError;
var TypeUndefinedError = (function (_super) {
    __extends(TypeUndefinedError, _super);
    function TypeUndefinedError(message) {
        return _super.call(this, "Type undefined; " + message) || this;
    }
    return TypeUndefinedError;
}(Error));
exports.TypeUndefinedError = TypeUndefinedError;
var TypeMismatchError = (function (_super) {
    __extends(TypeMismatchError, _super);
    function TypeMismatchError(message) {
        return _super.call(this, "Type undefined; " + message) || this;
    }
    return TypeMismatchError;
}(Error));
exports.TypeMismatchError = TypeMismatchError;
//# sourceMappingURL=error.js.map