occam-verify-cli 0.0.678 → 0.0.679

package/lib/verifier/nodes/termForVariable.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return TermForVariableNodesVerifier;
+    }
+});
+var _term = /*#__PURE__*/ _interop_require_default(require("../../verify/term"));
+var _nodes = /*#__PURE__*/ _interop_require_default(require("../../verifier/nodes"));
+var _termForVariable = /*#__PURE__*/ _interop_require_default(require("../../substitution/termForVariable"));
+var _array = require("../../utilities/array");
+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 variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
+var TermForVariableNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
+    _inherits(TermForVariableNodesVerifier, NodesVerifier);
+    var _super = _create_super(TermForVariableNodesVerifier);
+    function TermForVariableNodesVerifier() {
+        _class_call_check(this, TermForVariableNodesVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(TermForVariableNodesVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {
+                var nonTerminalNodeVerified = false;
+                var nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+                if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+                    var nonTerminalNodeARuleNameTermRuleName = nonTerminalNodeARuleName === _ruleNames.TERM_RULE_NAME, nonTerminalNodeBRuleNameTermRuleName = nonTerminalNodeBRuleName === _ruleNames.TERM_RULE_NAME;
+                    if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
+                        var termNodeA = nonTerminalNodeA, termNodeB = nonTerminalNodeB, termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB);
+                        if (termNodeVerified) {
+                            nonTerminalNodeVerified = true; ///
+                        } else {
+                            nonTerminalNodeVerified = _get(_get_prototype_of(TermForVariableNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+                        }
+                    } else {
+                        nonTerminalNodeVerified = _get(_get_prototype_of(TermForVariableNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+                    }
+                }
+                return nonTerminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyTermNode",
+            value: function verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
+                var termNodeVerified = false;
+                var variableNodeA = variableNodeQuery(termNodeA);
+                if (variableNodeA !== null) {
+                    var variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB);
+                    termNodeVerified = variableVerified; ///
+                }
+                return termNodeVerified;
+            }
+        },
+        {
+            key: "verifyVariableNode",
+            value: function verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
+                var variableVerified;
+                var variableNameA = (0, _query.variableNameFromVariableNode)(variableNodeA), substitution = substitutions.find(function(substitution) {
+                    var variableName = substitution.getVariableName();
+                    if (variableName === variableNameA) {
+                        return true;
+                    }
+                }) || null;
+                if (substitution !== null) {
+                    var termNode = termNodeB, substitutionNodesVerified = substitution.matchTermNode(termNode);
+                    variableVerified = substitutionNodesVerified; ///
+                } else {
+                    var createSubstitutions = this.constructor.createSubstitutions;
+                    if (createSubstitutions) {
+                        var variableName = variableNameA, proofContext = proofContextA, variable = proofContext.findVariableByVariableName(variableName);
+                        if (variable !== null) {
+                            var types = [], context = proofContextB, termNode1 = termNodeB, termVerified = (0, _term.default)(termNode1, types, context, verifyAhead);
+                            if (termVerified) {
+                                var firstType = (0, _array.first)(types), termType = firstType, variableType = variable.getType(), variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+                                if (variableTypeEqualToOrSuperTypeOfTermType) {
+                                    var termForVariableSubstitution = _termForVariable.default.fromVariableNameAndTermNode(variableName, termNode1), substitution1 = termForVariableSubstitution; ///
+                                    substitutions.push(substitution1);
+                                    variableVerified = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                return variableVerified;
+            }
+        }
+    ]);
+    return TermForVariableNodesVerifier;
+}(_nodes.default);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/termForVariable.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../../verify/term\";\nimport NodesVerifier from \"../../verifier/nodes\";\nimport TermForVariableSubstitution from \"../../substitution/termForVariable\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeQuery } from \"../../utilities/query\";\nimport { TERM_RULE_NAME } from \"../../ruleNames\";\nimport { variableNameFromVariableNode } from \"../../utilities/query\";\n\nconst variableNodeQuery = nodeQuery('/term/variable!');\n\nexport default class TermForVariableNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),\n          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();\n\n    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {\n      const nonTerminalNodeARuleNameTermRuleName = (nonTerminalNodeARuleName === TERM_RULE_NAME),\n            nonTerminalNodeBRuleNameTermRuleName = (nonTerminalNodeBRuleName === TERM_RULE_NAME);\n\n      if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {\n        const termNodeA = nonTerminalNodeA,  ///\n              termNodeB = nonTerminalNodeB,  ///\n              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB);\n\n        if (termNodeVerified) {\n          nonTerminalNodeVerified = true;  ///\n        } else {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);\n        }\n      } else {\n        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB) {\n    let termNodeVerified = false;\n\n    const variableNodeA = variableNodeQuery(termNodeA);\n\n    if (variableNodeA !== null) {\n      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB);\n\n      termNodeVerified = variableVerified; ///\n    }\n\n    return termNodeVerified;\n  }\n\n  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB) {\n    let variableVerified;\n\n    const variableNameA = variableNameFromVariableNode(variableNodeA),\n          substitution = substitutions.find((substitution) => {\n            const variableName = substitution.getVariableName();\n\n            if (variableName === variableNameA) {\n              return true;\n            }\n          }) || null;\n\n    if (substitution !== null) {\n      const termNode = termNodeB, ///\n            substitutionNodesVerified = substitution.matchTermNode(termNode);\n\n      variableVerified = substitutionNodesVerified;  ///\n    } else {\n      const { createSubstitutions } = this.constructor;\n\n      if (createSubstitutions) {\n        const variableName = variableNameA, ///\n              proofContext = proofContextA, ///\n              variable = proofContext.findVariableByVariableName(variableName);\n\n        if (variable !== null) {\n          const types = [],\n                context = proofContextB, ///\n                termNode = termNodeB, ///\n                termVerified = verifyTerm(termNode, types, context, verifyAhead);\n\n          if (termVerified) {\n            const firstType = first(types),\n                  termType = firstType,\n                  variableType = variable.getType(),\n                  variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);\n\n            if (variableTypeEqualToOrSuperTypeOfTermType) {\n              const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),\n                    substitution = termForVariableSubstitution;  ///\n\n              substitutions.push(substitution);\n\n              variableVerified = true;\n            }\n          }\n        }\n      }\n    }\n\n    return variableVerified;\n  }\n}\n"],"names":["TermForVariableNodesVerifier","variableNodeQuery","nodeQuery","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","substitutions","proofContextA","proofContextB","nonTerminalNodeVerified","nonTerminalNodeARuleName","getRuleName","nonTerminalNodeBRuleName","nonTerminalNodeARuleNameTermRuleName","TERM_RULE_NAME","nonTerminalNodeBRuleNameTermRuleName","termNodeA","termNodeB","termNodeVerified","verifyTermNode","variableNodeA","variableVerified","verifyVariableNode","variableNameA","variableNameFromVariableNode","substitution","find","variableName","getVariableName","termNode","substitutionNodesVerified","matchTermNode","createSubstitutions","constructor","proofContext","variable","findVariableByVariableName","types","context","termVerified","verifyTerm","verifyAhead","firstType","first","termType","variableType","getType","variableTypeEqualToOrSuperTypeOfTermType","isEqualToOrSuperTypeOf","termForVariableSubstitution","TermForVariableSubstitution","fromVariableNameAndTermNode","push","NodesVerifier"],"mappings":"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"}

package/lib/verifier/nodes.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return NodesVerifier;
+    }
+});
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var NodesVerifier = /*#__PURE__*/ function() {
+    function NodesVerifier() {
+        _class_call_check(this, NodesVerifier);
+    }
+    _create_class(NodesVerifier, [
+        {
+            key: "verifyNode",
+            value: function verifyNode(nodeA, nodeB) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    remainingArguments[_key - 2] = arguments[_key];
+                }
+                var nodeVerified = false;
+                var nodeATerminalNode = nodeA.isTerminalNode(), nodeBTerminalNode = nodeB.isTerminalNode(), nodeANonTerminalNode = nodeA.isNonTerminalNode(), nodeBNonTerminalNode = nodeB.isNonTerminalNode();
+                if (false) {
+                ///
+                } else if (nodeATerminalNode && nodeBTerminalNode) {
+                    var terminalNodeA = nodeA, terminalNodeB = nodeB, terminalNodeVerified = this.verifyTerminalNode.apply(this, [
+                        terminalNodeA,
+                        terminalNodeB
+                    ].concat(_to_consumable_array(remainingArguments)));
+                    nodeVerified = terminalNodeVerified; ///
+                } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {
+                    var nonTerminalNodeA = nodeA, nonTerminalNodeB = nodeB, nonTerminalNodeVerified = this.verifyNonTerminalNode.apply(this, [
+                        nonTerminalNodeA,
+                        nonTerminalNodeB
+                    ].concat(_to_consumable_array(remainingArguments)));
+                    nodeVerified = nonTerminalNodeVerified; ///
+                }
+                return nodeVerified;
+            }
+        },
+        {
+            key: "verifyChildNodes",
+            value: function verifyChildNodes(childNodesA, childNodesB) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    remainingArguments[_key - 2] = arguments[_key];
+                }
+                var childNodesVerify = false;
+                var childNodesALength = childNodesA.length, childNodesBLength = childNodesB.length;
+                if (childNodesALength === childNodesBLength) {
+                    var index = 0, childNodesVerifyAhead = this.verifyChildNodesAhead.apply(this, [
+                        index,
+                        childNodesA,
+                        childNodesB
+                    ].concat(_to_consumable_array(remainingArguments)));
+                    childNodesVerify = childNodesVerifyAhead; ///
+                }
+                return childNodesVerify;
+            }
+        },
+        {
+            key: "verifyChildNodesAhead",
+            value: function verifyChildNodesAhead(index, childNodesA, childNodesB) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
+                    remainingArguments[_key - 3] = arguments[_key];
+                }
+                var _this = this;
+                var childNodesVerify;
+                var verifyAhead = remainingArguments.pop(), childNodesALength = childNodesA.length;
+                if (index === childNodesALength) {
+                    var verifiedAhead = verifyAhead();
+                    childNodesVerify = verifiedAhead; ///
+                } else {
+                    var childNodeA = childNodesA[index], childNodeB = childNodesB[index], nodeA = childNodeA, nodeB = childNodeB, nodeVerified = this.verifyNode.apply(this, [
+                        nodeA,
+                        nodeB
+                    ].concat(_to_consumable_array(remainingArguments), [
+                        function() {
+                            index++;
+                            remainingArguments.push(verifyAhead); ///
+                            var childNodesVerifyAhead = _this.verifyChildNodesAhead.apply(_this, [
+                                index,
+                                childNodesA,
+                                childNodesB
+                            ].concat(_to_consumable_array(remainingArguments)));
+                            return childNodesVerifyAhead;
+                        }
+                    ]));
+                    childNodesVerify = nodeVerified; ///
+                }
+                return childNodesVerify;
+            }
+        },
+        {
+            key: "verifyTerminalNode",
+            value: function verifyTerminalNode(terminalNodeA, terminalNodeB) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    remainingArguments[_key - 2] = arguments[_key];
+                }
+                var terminalNodeVerified = false;
+                var matches = terminalNodeA.match(terminalNodeB);
+                if (matches) {
+                    var verifyAhead = remainingArguments.pop(), verifiedAhead = verifyAhead();
+                    terminalNodeVerified = verifiedAhead; ///
+                }
+                return terminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    remainingArguments[_key - 2] = arguments[_key];
+                }
+                var nonTerminalNodeVerified = false;
+                var nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+                if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+                    var nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(), nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(), childNodesA = nonTerminalNodeAChildNodes, childNodesB = nonTerminalNodeBChildNodes, childNodesVerify = this.verifyChildNodes.apply(this, [
+                        childNodesA,
+                        childNodesB
+                    ].concat(_to_consumable_array(remainingArguments)));
+                    nonTerminalNodeVerified = childNodesVerify; ///
+                }
+                return nonTerminalNodeVerified;
+            }
+        }
+    ]);
+    return NodesVerifier;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verifier/nodes.js"],"sourcesContent":["\"use strict\";\n\nexport default class NodesVerifier {\n  verifyNode(nodeA, nodeB, ...remainingArguments) {\n    let nodeVerified = false;\n\n    const nodeATerminalNode = nodeA.isTerminalNode(),\n          nodeBTerminalNode = nodeB.isTerminalNode(),\n          nodeANonTerminalNode = nodeA.isNonTerminalNode(),\n          nodeBNonTerminalNode = nodeB.isNonTerminalNode();\n\n    if (false) {\n      ///\n    } else if (nodeATerminalNode && nodeBTerminalNode) {\n      const terminalNodeA = nodeA,  ///\n            terminalNodeB = nodeB,  ///\n            terminalNodeVerified = this.verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);\n\n      nodeVerified = terminalNodeVerified;  ///\n    } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {\n      const nonTerminalNodeA = nodeA,  ///\n            nonTerminalNodeB = nodeB, ///\n            nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);\n\n      nodeVerified = nonTerminalNodeVerified; ///\n    }\n\n    return nodeVerified;\n  }\n\n  verifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {\n    let childNodesVerify = false;\n\n    const childNodesALength = childNodesA.length,\n          childNodesBLength = childNodesB.length;\n\n    if (childNodesALength === childNodesBLength) {\n      const index = 0,\n            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);\n\n      childNodesVerify = childNodesVerifyAhead; ///\n    }\n\n    return childNodesVerify;\n  }\n\n  verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {\n    let childNodesVerify;\n\n    const verifyAhead = remainingArguments.pop(), ///\n          childNodesALength = childNodesA.length;\n\n    if (index === childNodesALength) {\n      const verifiedAhead = verifyAhead();\n\n      childNodesVerify = verifiedAhead; ///\n    } else {\n      const childNodeA = childNodesA[index],\n            childNodeB = childNodesB[index],\n            nodeA = childNodeA, ///\n            nodeB = childNodeB, ///\n            nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments, () => {\n              index++;\n\n              remainingArguments.push(verifyAhead); ///\n\n              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);\n\n              return childNodesVerifyAhead;\n            });\n\n      childNodesVerify = nodeVerified;  ///\n    }\n\n    return childNodesVerify;\n  }\n\n  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {\n    let terminalNodeVerified = false;\n\n    const matches = terminalNodeA.match(terminalNodeB);\n\n    if (matches) {\n      const verifyAhead = remainingArguments.pop(),\n            verifiedAhead = verifyAhead();\n\n      terminalNodeVerified = verifiedAhead;  ///\n    }\n\n    return terminalNodeVerified;\n  }\n\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///\n          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///\n\n    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {\n      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),\n            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),\n            childNodesA = nonTerminalNodeAChildNodes, ///\n            childNodesB = nonTerminalNodeBChildNodes, ///\n            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);\n\n      nonTerminalNodeVerified = childNodesVerify; ///\n    }\n\n    return nonTerminalNodeVerified;\n  }\n}\n"],"names":["NodesVerifier","verifyNode","nodeA","nodeB","remainingArguments","nodeVerified","nodeATerminalNode","isTerminalNode","nodeBTerminalNode","nodeANonTerminalNode","isNonTerminalNode","nodeBNonTerminalNode","terminalNodeA","terminalNodeB","terminalNodeVerified","verifyTerminalNode","nonTerminalNodeA","nonTerminalNodeB","nonTerminalNodeVerified","verifyNonTerminalNode","verifyChildNodes","childNodesA","childNodesB","childNodesVerify","childNodesALength","length","childNodesBLength","index","childNodesVerifyAhead","verifyChildNodesAhead","verifyAhead","pop","verifiedAhead","childNodeA","childNodeB","push","matches","match","nonTerminalNodeARuleName","getRuleName","nonTerminalNodeBRuleName","nonTerminalNodeAChildNodes","getChildNodes","nonTerminalNodeBChildNodes"],"mappings":"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"}

package/lib/verify/assertion/type.js

@@ -30,10 +30,10 @@ var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term!"), typeNodeQuery
 function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {
     var typeAssertionVerified = false;
     var typeAssertionString = context.nodeAsString(typeAssertionNode);
-    context.debug("Verifying the '".concat(typeAssertionString, "' type assertion..."), typeAssertionNode);
+    context.trace("Verifying the '".concat(typeAssertionString, "' type assertion..."), typeAssertionNode);
     var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), typePresent = context.isTypePresentByTypeName(typeName);
     if (!typePresent) {
-        context.error("The '".concat(typeName, "' type is not present."), typeAssertionNode);
+        context.info("The '".concat(typeName, "' type is not present."), typeAssertionNode);
     } else {
         if (!typeAssertionVerified) {
             var variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);
@@ -45,7 +45,7 @@ function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {
         }
     }
     if (typeAssertionVerified) {
-        context.info("Verified the '".concat(typeAssertionString, "' statement type assertion."), typeAssertionNode);
+        context.debug("...verified the '".concat(typeAssertionString, "' statement type assertion."), typeAssertionNode);
     }
     return typeAssertionVerified;
 }
@@ -53,16 +53,18 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
     var variableTypeAssertionVerified = false;
     var variables = [], termNode = termNodeQuery(typeAssertionNode), termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context);
     if (termVerifiedAsVariable) {
+        var typeAssertionString = context.nodeAsString(typeAssertionNode);
+        context.trace("Verifying the '".concat(typeAssertionString, "' variable type assertion..."), typeAssertionNode);
         var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = context.findTypeByTypeName(assertedTypeName);
         if (assertedType === null) {
-            context.error("The '".concat(assertedTypeName, "' asserted type is not present."), typeAssertionNode);
+            context.info("The '".concat(assertedTypeName, "' asserted type is not present."), typeAssertionNode);
         } else {
             var firstVariable = (0, _array.first)(variables), variable = firstVariable, variableName = variable.getName(), variableType = variable.getType();
             if (derived) {
                 var assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);
                 if (!assertedTypeEqualToOrSuperTypeOfVariableType) {
                     var assertedTypeName1 = assertedType.getName(), variableTypeName = variableType.getName();
-                    context.error("The '".concat(assertedTypeName1, "' asserted type is not equal to or a super-type of the '").concat(variableName, "' variable's '").concat(variableTypeName, "' type."), typeAssertionNode);
+                    context.info("The '".concat(assertedTypeName1, "' asserted type is not equal to or a super-type of the '").concat(variableName, "' variable's '").concat(variableTypeName, "' type."), typeAssertionNode);
                 } else {
                     variableTypeAssertionVerified = true;
                 }
@@ -70,7 +72,7 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
                 var assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
                 if (!assertedTypeEqualToOrSubTypeOfVariableType) {
                     var assertedTypeName2 = assertedType.getName(), variableTypeName1 = variableType.getName();
-                    context.error("The '".concat(assertedTypeName2, "' asserted type is not equal to or a sub-type of the '").concat(variableName, "' variable's '").concat(variableTypeName1, "' type."), typeAssertionNode);
+                    context.info("The '".concat(assertedTypeName2, "' asserted type is not equal to or a sub-type of the '").concat(variableName, "' variable's '").concat(variableTypeName1, "' type."), typeAssertionNode);
                 } else {
                     var name = variableName, type = assertedType, variable1 = _variable.default.fromNameAndType(name, type), assignment = _assignment.default.fromVariable(variable1);
                     assignments.push(assignment);
@@ -78,6 +80,9 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
                 }
             }
         }
+        if (variableTypeAssertionVerified) {
+            context.debug("...verified the '".concat(typeAssertionString, "' variable type assertion."), typeAssertionNode);
+        }
     }
     return variableTypeAssertionVerified;
 }
@@ -85,16 +90,18 @@ function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
     var termTypeAssertionVerified = false;
     var types = [], termNode = termNodeQuery(typeAssertionNode), termVerifiedAgainstConstructors = (0, _term.verifyTermAgainstConstructors)(termNode, types, context);
     if (termVerifiedAgainstConstructors) {
+        var typeAssertionString = context.nodeAsString(typeAssertionNode);
+        context.trace("Verifying the '".concat(typeAssertionString, "' term type assertion..."), typeAssertionNode);
         var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = context.findTypeByTypeName(assertedTypeName);
         if (assertedType === null) {
-            context.error("The '".concat(assertedTypeName, "' asserted type is not present."), typeAssertionNode);
+            context.info("The '".concat(assertedTypeName, "' asserted type is not present."), typeAssertionNode);
         } else {
             var firstType = (0, _array.first)(types), termType = firstType; ///
             if (derived) {
                 var assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);
                 if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {
                     var termString = context.nodeAsString(termNode), termTypeName = termType.getName(), assertedTypeName1 = assertedType.getName();
-                    context.error("The '".concat(assertedTypeName1, "' asserted type is not equal to or a super-type of the '").concat(termString, "' term's '").concat(termTypeName, "' type."), typeAssertionNode);
+                    context.info("The '".concat(assertedTypeName1, "' asserted type is not equal to or a super-type of the '").concat(termString, "' term's '").concat(termTypeName, "' type."), typeAssertionNode);
                 } else {
                     termTypeAssertionVerified = true;
                 }
@@ -102,14 +109,17 @@ function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
                 var assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
                 if (!assertedTypeIsEqualToOrSubTypeOfTermType) {
                     var termString1 = context.nodeAsString(termNode), termTypeName1 = termType.getName(), assertedTypeName2 = assertedType.getName();
-                    context.error("The '".concat(assertedTypeName2, "' asserted type is not equal to or a sub-type of the '").concat(termString1, "' term's '").concat(termTypeName1, "' type."), typeAssertionNode);
+                    context.info("The '".concat(assertedTypeName2, "' asserted type is not equal to or a sub-type of the '").concat(termString1, "' term's '").concat(termTypeName1, "' type."), typeAssertionNode);
                 } else {
                     termTypeAssertionVerified = true;
                 }
             }
         }
+        if (termTypeAssertionVerified) {
+            context.debug("...verified the '".concat(typeAssertionString, "' term type assertion."), typeAssertionNode);
+        }
     }
     return termTypeAssertionVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verify/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../../variable\";\nimport Assignment from \"../../assignment\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../../verify/term\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term!\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type!\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {\n  let typeAssertionVerified = false;\n\n  const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n  context.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        typePresent = context.isTypePresentByTypeName(typeName);\n\n  if (!typePresent) {\n    context.error(`The '${typeName}' type is not present.`, typeAssertionNode);\n  } else {\n    if (!typeAssertionVerified) {\n      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);\n\n      typeAssertionVerified = variableTypeAssertionVerified;  ///\n    }\n\n    if (!typeAssertionVerified) {\n      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, derived, context);\n\n      typeAssertionVerified = termTypeAssertionVerified;  ///\n    }\n  }\n\n  if (typeAssertionVerified) {\n    context.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);\n  }\n\n  return typeAssertionVerified;\n}\n\nexport function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {\n  let variableTypeAssertionVerified = false;\n\n  const variables = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n  if (termVerifiedAsVariable) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = context.findTypeByTypeName(assertedTypeName);\n\n    if (assertedType === null) {\n      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);\n    } else {\n      const firstVariable = first(variables),\n            variable = firstVariable, ///\n            variableName = variable.getName(),\n            variableType = variable.getType();\n\n      if (derived) {\n        const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);\n\n        if (!assertedTypeEqualToOrSuperTypeOfVariableType) {\n          const assertedTypeName = assertedType.getName(),\n                variableTypeName = variableType.getName();\n\n          context.error(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);\n        } else {\n          variableTypeAssertionVerified = true;\n        }\n      } else {\n        const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);\n\n        if (!assertedTypeEqualToOrSubTypeOfVariableType) {\n          const assertedTypeName = assertedType.getName(),\n                variableTypeName = variableType.getName();\n\n          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);\n        } else {\n          const name = variableName,  ///\n                type = assertedType,  ///\n                variable = Variable.fromNameAndType(name, type),\n                assignment = Assignment.fromVariable(variable);\n\n          assignments.push(assignment);\n\n          variableTypeAssertionVerified = true;\n        }\n      }\n    }\n  }\n\n  return variableTypeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, derived, context) {\n  let termTypeAssertionVerified = false;\n\n  const types = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n  if (termVerifiedAgainstConstructors) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = context.findTypeByTypeName(assertedTypeName);\n\n    if (assertedType === null) {\n      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);\n    } else {\n      const firstType = first(types),\n            termType = firstType; ///\n\n      if (derived) {\n        const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);\n\n        if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {\n          const termString = context.nodeAsString(termNode),\n                termTypeName = termType.getName(),\n                assertedTypeName = assertedType.getName();\n\n          context.error(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);\n        } else {\n          termTypeAssertionVerified = true;\n        }\n      } else {\n        const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);\n\n        if (!assertedTypeIsEqualToOrSubTypeOfTermType) {\n          const termString = context.nodeAsString(termNode),\n                termTypeName = termType.getName(),\n                assertedTypeName = assertedType.getName();\n\n          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);\n        } else {\n          termTypeAssertionVerified = true;\n        }\n      }\n    }\n  }\n\n  return termTypeAssertionVerified;\n}\n\n"],"names":["verifyTypeAssertion","verifyVariableTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNode","assignments","derived","context","typeAssertionVerified","typeAssertionString","nodeAsString","debug","typeNode","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","error","variableTypeAssertionVerified","termTypeAssertionVerified","verifyTermTypeAssertion","info","variables","termNode","termVerifiedAsVariable","verifyTermAsVariable","assertedTypeName","assertedType","findTypeByTypeName","firstVariable","first","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSuperTypeOfVariableType","isEqualToOrSuperTypeOf","variableTypeName","assertedTypeEqualToOrSubTypeOfVariableType","isEqualToOrSubTypeOf","name","type","Variable","fromNameAndType","assignment","Assignment","fromVariable","push","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","firstType","termType","assertedTypeIsEqualToOrSuperTypeOfTermType","termString","termTypeName","assertedTypeIsEqualToOrSubTypeOfTermType"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verify/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../../variable\";\nimport Assignment from \"../../assignment\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../../verify/term\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term!\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type!\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {\n  let typeAssertionVerified = false;\n\n  const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n  context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        typePresent = context.isTypePresentByTypeName(typeName);\n\n  if (!typePresent) {\n    context.info(`The '${typeName}' type is not present.`, typeAssertionNode);\n  } else {\n    if (!typeAssertionVerified) {\n      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);\n\n      typeAssertionVerified = variableTypeAssertionVerified;  ///\n    }\n\n    if (!typeAssertionVerified) {\n      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, derived, context);\n\n      typeAssertionVerified = termTypeAssertionVerified;  ///\n    }\n  }\n\n  if (typeAssertionVerified) {\n    context.debug(`...verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);\n  }\n\n  return typeAssertionVerified;\n}\n\nexport function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {\n  let variableTypeAssertionVerified = false;\n\n  const variables = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n  if (termVerifiedAsVariable) {\n    const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n    context.trace(`Verifying the '${typeAssertionString}' variable type assertion...`, typeAssertionNode);\n\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = context.findTypeByTypeName(assertedTypeName);\n\n    if (assertedType === null) {\n      context.info(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);\n    } else {\n      const firstVariable = first(variables),\n            variable = firstVariable, ///\n            variableName = variable.getName(),\n            variableType = variable.getType();\n\n      if (derived) {\n        const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);\n\n        if (!assertedTypeEqualToOrSuperTypeOfVariableType) {\n          const assertedTypeName = assertedType.getName(),\n                variableTypeName = variableType.getName();\n\n          context.info(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);\n        } else {\n          variableTypeAssertionVerified = true;\n        }\n      } else {\n        const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);\n\n        if (!assertedTypeEqualToOrSubTypeOfVariableType) {\n          const assertedTypeName = assertedType.getName(),\n                variableTypeName = variableType.getName();\n\n          context.info(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);\n        } else {\n          const name = variableName,  ///\n                type = assertedType,  ///\n                variable = Variable.fromNameAndType(name, type),\n                assignment = Assignment.fromVariable(variable);\n\n          assignments.push(assignment);\n\n          variableTypeAssertionVerified = true;\n        }\n      }\n    }\n\n    if (variableTypeAssertionVerified) {\n      context.debug(`...verified the '${typeAssertionString}' variable type assertion.`, typeAssertionNode);\n    }\n  }\n\n  return variableTypeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, derived, context) {\n  let termTypeAssertionVerified = false;\n\n  const types = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n  if (termVerifiedAgainstConstructors) {\n    const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n    context.trace(`Verifying the '${typeAssertionString}' term type assertion...`, typeAssertionNode);\n\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = context.findTypeByTypeName(assertedTypeName);\n\n    if (assertedType === null) {\n      context.info(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);\n    } else {\n      const firstType = first(types),\n            termType = firstType; ///\n\n      if (derived) {\n        const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);\n\n        if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {\n          const termString = context.nodeAsString(termNode),\n                termTypeName = termType.getName(),\n                assertedTypeName = assertedType.getName();\n\n          context.info(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);\n        } else {\n          termTypeAssertionVerified = true;\n        }\n      } else {\n        const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);\n\n        if (!assertedTypeIsEqualToOrSubTypeOfTermType) {\n          const termString = context.nodeAsString(termNode),\n                termTypeName = termType.getName(),\n                assertedTypeName = assertedType.getName();\n\n          context.info(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);\n        } else {\n          termTypeAssertionVerified = true;\n        }\n      }\n    }\n\n    if (termTypeAssertionVerified) {\n      context.debug(`...verified the '${typeAssertionString}' term type assertion.`, typeAssertionNode);\n    }\n  }\n\n  return termTypeAssertionVerified;\n}\n\n"],"names":["verifyTypeAssertion","verifyVariableTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNode","assignments","derived","context","typeAssertionVerified","typeAssertionString","nodeAsString","trace","typeNode","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","info","variableTypeAssertionVerified","termTypeAssertionVerified","verifyTermTypeAssertion","debug","variables","termNode","termVerifiedAsVariable","verifyTermAsVariable","assertedTypeName","assertedType","findTypeByTypeName","firstVariable","first","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSuperTypeOfVariableType","isEqualToOrSuperTypeOf","variableTypeName","assertedTypeEqualToOrSubTypeOfVariableType","isEqualToOrSubTypeOf","name","type","Variable","fromNameAndType","assignment","Assignment","fromVariable","push","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","firstType","termType","assertedTypeIsEqualToOrSuperTypeOfTermType","termString","termTypeName","assertedTypeIsEqualToOrSubTypeOfTermType"],"mappings":"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"}

package/lib/verify/axiom.js

@@ -24,7 +24,7 @@ var labelNodesQuery = (0, _query.nodesQuery)("/axiom/labels/label"), consequentN
 function verifyAxiom(axiomNode, fileContext) {
     var axiomVerified = false;
     var labelNodes = labelNodesQuery(axiomNode), labelsString = fileContext.nodesAsString(labelNodes), proofContext = _proof.default.fromFileContext(fileContext);
-    fileContext.debug("Verifying the '".concat(labelsString, "' axiom..."), axiomNode);
+    fileContext.trace("Verifying the '".concat(labelsString, "' axiom..."), axiomNode);
     var labels = [], labelsVerified = (0, _labels.default)(labelNodes, labels, fileContext);
     if (labelsVerified) {
         var suppositions = [], suppositionNodes = suppositionsNodeQuery(axiomNode), suppositionsVerified = suppositionNodes.every(function(suppositionNode) {
@@ -43,9 +43,9 @@ function verifyAxiom(axiomNode, fileContext) {
         }
     }
     if (axiomVerified) {
-        fileContext.info("Verified the '".concat(labelsString, "' axiom."), axiomNode);
+        fileContext.debug("...verified the '".concat(labelsString, "' axiom."), axiomNode);
     }
     return axiomVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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