occam-verify-cli 0.0.678 → 0.0.680

package/lib/verifier/node/metastatement.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _node = /*#__PURE__*/ _interop_require_default(require("../../verifier/node"));
+var _ruleNames = require("../../ruleNames");
+var _query = require("../../utilities/query");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var MetastatementNodeVerifier = /*#__PURE__*/ function(NodeVerifier) {
+    _inherits(MetastatementNodeVerifier, NodeVerifier);
+    var _super = _create_super(MetastatementNodeVerifier);
+    function MetastatementNodeVerifier() {
+        _class_call_check(this, MetastatementNodeVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(MetastatementNodeVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead) {
+                var nonTerminalNodeVerified;
+                var ruleName = nonTerminalNode.getRuleName(); ///
+                switch(ruleName){
+                    case _ruleNames.METAVARIABLE_RULE_NAME:
+                        {
+                            var metavariableNode = nonTerminalNode, metavariableVerified = verifyMetavariable(metavariableNode, metaproofContext, verifyAhead), metavariableNodeVerified = metavariableVerified; ///
+                            nonTerminalNodeVerified = metavariableNodeVerified; ///
+                            break;
+                        }
+                    default:
+                        {
+                            nonTerminalNodeVerified = _get(_get_prototype_of(MetastatementNodeVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNode, metaproofContext, verifyAhead);
+                            break;
+                        }
+                }
+                return nonTerminalNodeVerified;
+            }
+        }
+    ]);
+    return MetastatementNodeVerifier;
+}(_node.default);
+var metastatementNodeVerifier = new MetastatementNodeVerifier();
+var _default = metastatementNodeVerifier;
+function verifyMetavariable(metavariableNode, metaproofContext, verifyAhead) {
+    var metavariableVerified;
+    var metavariableString = metaproofContext.nodeAsString(metavariableNode);
+    metaproofContext.trace("Verifying the '".concat(metavariableString, "' metavariable..."), metavariableNode);
+    var metavariableName = (0, _query.metavariableNameFromMetavariableNode)(metavariableNode), metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
+    if (metavariablePresent) {
+        var verifiedAhead = verifyAhead();
+        metavariableVerified = verifiedAhead; ///
+    }
+    if (metavariableVerified) {
+        metaproofContext.debug("...verified the '".concat(metavariableString, "' metavariable."), metavariableNode);
+    }
+    return metavariableVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verifier/node/statementAsCombinator.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _node = /*#__PURE__*/ _interop_require_default(require("../../verifier/node"));
+var _statement = /*#__PURE__*/ _interop_require_default(require("../../verify/statement"));
+var _termAsConstructor = require("./../../verifier/node/termAsConstructor");
+var _ruleNames = require("../../ruleNames");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var StatementAsCombinatorNodeVerifier = /*#__PURE__*/ function(NodeVerifier) {
+    _inherits(StatementAsCombinatorNodeVerifier, NodeVerifier);
+    var _super = _create_super(StatementAsCombinatorNodeVerifier);
+    function StatementAsCombinatorNodeVerifier() {
+        _class_call_check(this, StatementAsCombinatorNodeVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(StatementAsCombinatorNodeVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+                var nonTerminalNodeVerified;
+                var ruleName = nonTerminalNode.getRuleName();
+                switch(ruleName){
+                    case _ruleNames.TYPE_RULE_NAME:
+                        {
+                            var typeNode = nonTerminalNode, typeVerified = (0, _termAsConstructor.verifyType)(typeNode, fileContext, verifyAhead), typeNodeVerified = typeVerified; ///
+                            nonTerminalNodeVerified = typeNodeVerified; ///
+                            break;
+                        }
+                    case _ruleNames.TERM_RULE_NAME:
+                        {
+                            var termNode = nonTerminalNode, standaloneTermVerified = (0, _termAsConstructor.verifyStandaloneTerm)(termNode, fileContext, verifyAhead), termNodeVerified = standaloneTermVerified; ///
+                            nonTerminalNodeVerified = termNodeVerified; ///
+                            break;
+                        }
+                    case _ruleNames.STATEMENT_RULE_NAME:
+                        {
+                            var statementNode = nonTerminalNode, standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead), statementNodeVerified = standaloneStatementVerified; ///
+                            nonTerminalNodeVerified = statementNodeVerified; ///
+                            break;
+                        }
+                    default:
+                        {
+                            nonTerminalNodeVerified = _get(_get_prototype_of(StatementAsCombinatorNodeVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNode, fileContext, verifyAhead); ///
+                            break;
+                        }
+                }
+                return nonTerminalNodeVerified;
+            }
+        }
+    ]);
+    return StatementAsCombinatorNodeVerifier;
+}(_node.default);
+var statementAsCombinatorNodeVerifier = new StatementAsCombinatorNodeVerifier();
+var _default = statementAsCombinatorNodeVerifier;
+function verifyStandaloneStatement(statementNode, fileContext, verifyAhead) {
+    var standaloneStatementVerified;
+    var statementString = fileContext.nodeAsString(statementNode);
+    fileContext.trace("Verifying the '".concat(statementString, "' standalone statement..."), statementNode);
+    var context = fileContext, derived = false, assignments = [], statementVerified = (0, _statement.default)(statementNode, assignments, derived, context, verifyAhead);
+    standaloneStatementVerified = statementVerified; ///
+    if (standaloneStatementVerified) {
+        fileContext.debug("...verified the '".concat(statementString, "' standalone statement."), statementNode);
+    }
+    return standaloneStatementVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verifier/node/termAsConstructor.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    verifyStandaloneTerm: function() {
+        return verifyStandaloneTerm;
+    },
+    verifyType: function() {
+        return verifyType;
+    }
+});
+var _term = /*#__PURE__*/ _interop_require_default(require("../../verify/term"));
+var _node = /*#__PURE__*/ _interop_require_default(require("../../verifier/node"));
+var _query = require("../../utilities/query");
+var _ruleNames = require("../../ruleNames");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var typeNodeQuery = (0, _query.nodeQuery)("/argument/type"), termNodeQuery = (0, _query.nodeQuery)("/argument/term");
+var TermAsConstructorNodeVerifier = /*#__PURE__*/ function(NodeVerifier) {
+    _inherits(TermAsConstructorNodeVerifier, NodeVerifier);
+    var _super = _create_super(TermAsConstructorNodeVerifier);
+    function TermAsConstructorNodeVerifier() {
+        _class_call_check(this, TermAsConstructorNodeVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(TermAsConstructorNodeVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+                var nonTerminalNodeVerified;
+                var ruleName = nonTerminalNode.getRuleName();
+                switch(ruleName){
+                    case _ruleNames.TERM_RULE_NAME:
+                        {
+                            var termNode = nonTerminalNode, standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead), termNodeVerified = standaloneTermVerified; ///
+                            nonTerminalNodeVerified = termNodeVerified; ///
+                            break;
+                        }
+                    case _ruleNames.ARGUMENT_RULE_NAME:
+                        {
+                            var argumentNode = nonTerminalNode, argumentVerified = verifyArgument(argumentNode, fileContext, verifyAhead), argumentNodeVerified = argumentVerified; ///
+                            nonTerminalNodeVerified = argumentNodeVerified; ///
+                            break;
+                        }
+                    default:
+                        {
+                            nonTerminalNodeVerified = _get(_get_prototype_of(TermAsConstructorNodeVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNode, fileContext, verifyAhead);
+                            break;
+                        }
+                }
+                return nonTerminalNodeVerified;
+            }
+        }
+    ]);
+    return TermAsConstructorNodeVerifier;
+}(_node.default);
+var termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();
+var _default = termAsConstructorNodeVerifier;
+function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
+    var standaloneTermVerified;
+    var termString = fileContext.nodeAsString(termNode);
+    fileContext.trace("Verifying the '".concat(termString, "' standalone term..."), termNode);
+    var types = [], context = fileContext, termVerified = (0, _term.default)(termNode, types, context, verifyAhead);
+    standaloneTermVerified = termVerified; ///
+    if (standaloneTermVerified) {
+        fileContext.debug("...verified the '".concat(termString, "' standalone term."), termNode);
+    }
+    return standaloneTermVerified;
+}
+function verifyType(typeNode, fileContext, verifyAhead) {
+    var typeVerified = false;
+    var typeString = fileContext.nodeAsString(typeNode);
+    fileContext.trace("Verifying the '".concat(typeString, "' type..."), typeNode);
+    var typeName = (0, _query.typeNameFromTypeNode)(typeNode), typePresent = fileContext.isTypePresentByTypeName(typeName);
+    if (!typePresent) {
+        fileContext.debug("The type '".concat(typeName, "' is not present."), typeNode);
+    } else {
+        fileContext.debug("...verified the '".concat(typeString, "' type."), typeNode);
+        var verifiedAhead = verifyAhead();
+        typeVerified = verifiedAhead; ///
+    }
+    return typeVerified;
+}
+function verifyArgument(argumentNode, fileContext, verifyAhead) {
+    var argumentVerified;
+    var argumentString = fileContext.nodeAsString(argumentNode);
+    fileContext.trace("Verifying the '".concat(argumentString, "' argument..."), argumentNode);
+    var typeNode = typeNodeQuery(argumentNode), termNode = termNodeQuery(argumentNode);
+    if (typeNode !== null) {
+        var typeVerified = verifyType(typeNode, fileContext, verifyAhead);
+        argumentVerified = typeVerified; ///
+    }
+    if (termNode !== null) {
+        var standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead);
+        argumentVerified = standaloneTermVerified; ///
+    }
+    if (argumentVerified) {
+        fileContext.debug("...verified the '".concat(argumentString, "' argument."), argumentNode);
+    }
+    return argumentVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/node/termAsConstructor.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../../verify/term\";\nimport NodeVerifier from \"../../verifier/node\";\n\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\nimport { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from \"../../ruleNames\";\n\nconst typeNodeQuery = nodeQuery(\"/argument/type\"),\n      termNodeQuery = nodeQuery(\"/argument/term\");\n\nclass TermAsConstructorNodeVerifier extends NodeVerifier {\n  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {\n    let nonTerminalNodeVerified;\n\n    const ruleName = nonTerminalNode.getRuleName();\n\n    switch (ruleName) {\n      case TERM_RULE_NAME: {\n        const termNode = nonTerminalNode, ///\n              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),\n              termNodeVerified = standaloneTermVerified;  ///\n\n        nonTerminalNodeVerified = termNodeVerified; ///\n\n        break;\n      }\n\n      case ARGUMENT_RULE_NAME: {\n        const argumentNode = nonTerminalNode, ///\n              argumentVerified = verifyArgument(argumentNode, fileContext, verifyAhead),\n              argumentNodeVerified = argumentVerified;  ///\n\n        nonTerminalNodeVerified = argumentNodeVerified; ///\n\n        break;\n      }\n\n      default: {\n        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead);\n\n        break;\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n}\n\nconst termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();\n\nexport default termAsConstructorNodeVerifier;\n\nexport function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {\n  let standaloneTermVerified;\n\n  const termString = fileContext.nodeAsString(termNode);\n\n  fileContext.trace(`Verifying the '${termString}' standalone term...`, termNode);\n\n  const types = [],\n        context = fileContext,  ///\n        termVerified = verifyTerm(termNode, types, context, verifyAhead);\n\n  standaloneTermVerified = termVerified;  ///\n\n  if (standaloneTermVerified) {\n    fileContext.debug(`...verified the '${termString}' standalone term.`, termNode);\n  }\n\n  return standaloneTermVerified;\n}\n\nexport function verifyType(typeNode, fileContext, verifyAhead) {\n  let typeVerified = false;\n\n  const typeString = fileContext.nodeAsString(typeNode);\n\n  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);\n\n  const typeName = typeNameFromTypeNode(typeNode),\n        typePresent = fileContext.isTypePresentByTypeName(typeName);\n\n  if (!typePresent) {\n    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);\n  } else {\n    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);\n\n    const verifiedAhead = verifyAhead();\n\n    typeVerified = verifiedAhead; ///\n  }\n\n  return typeVerified;\n}\n\nfunction verifyArgument(argumentNode, fileContext, verifyAhead) {\n  let argumentVerified;\n\n  const argumentString = fileContext.nodeAsString(argumentNode);\n\n  fileContext.trace(`Verifying the '${argumentString}' argument...`, argumentNode);\n\n  const typeNode = typeNodeQuery(argumentNode),\n        termNode = termNodeQuery(argumentNode);\n\n  if (typeNode !== null) {\n    const typeVerified = verifyType(typeNode, fileContext, verifyAhead);\n\n    argumentVerified = typeVerified; ///\n  }\n\n  if (termNode !== null) {\n    const standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead);\n\n    argumentVerified = standaloneTermVerified;  ///\n  }\n\n  if (argumentVerified) {\n    fileContext.debug(`...verified the '${argumentString}' argument.`, argumentNode);\n  }\n\n  return argumentVerified;\n}\n"],"names":["verifyStandaloneTerm","verifyType","typeNodeQuery","nodeQuery","termNodeQuery","TermAsConstructorNodeVerifier","verifyNonTerminalNode","nonTerminalNode","fileContext","verifyAhead","nonTerminalNodeVerified","ruleName","getRuleName","TERM_RULE_NAME","termNode","standaloneTermVerified","termNodeVerified","ARGUMENT_RULE_NAME","argumentNode","argumentVerified","verifyArgument","argumentNodeVerified","NodeVerifier","termAsConstructorNodeVerifier","termString","nodeAsString","trace","types","context","termVerified","verifyTerm","debug","typeNode","typeVerified","typeString","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","verifiedAhead","argumentString"],"mappings":"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"}