occam-verify-cli 0.0.613 → 0.0.615

package/lib/verify/term.js

@@ -9,22 +9,194 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    termVerifier: function() {
+        return termVerifier;
+    },
     default: function() {
         return verifyTerm;
     },
-    verifyTermAsVariable: function() {
-        return verifyTermAsVariable;
-    },
     verifyTermAgainstConstructors: function() {
         return verifyTermAgainstConstructors;
+    },
+    verifyTermAgainstConstructor: function() {
+        return verifyTermAgainstConstructor;
+    },
+    verifyTermAsVariable: function() {
+        return verifyTermAsVariable;
     }
 });
+var _verifier = /*#__PURE__*/ _interop_require_default(require("../verifier"));
 var _array = require("../utilities/array");
 var _type = require("../type");
 var _typeNames = require("../typeNames");
 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_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 _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 termNodeQuery = (0, _query.nodeQuery)("/argument/term!"), typeNodeQuery = (0, _query.nodeQuery)("/argument/type!"), variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
+var TermVerifier = /*#__PURE__*/ function(Verifier) {
+    _inherits(TermVerifier, Verifier);
+    var _super = _create_super(TermVerifier);
+    function TermVerifier() {
+        _class_call_check(this, TermVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(TermVerifier, [
+        {
+            key: "verifyTerminalNode",
+            value: function verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
+                var terminalNodeVerified = false;
+                var matches = terminalNode.match(constructorTerminalNode);
+                if (matches) {
+                    terminalNodeVerified = true;
+                }
+                return terminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
+                var nonTerminalNodeVerified = false;
+                var ruleName = nonTerminalNode.getRuleName(), constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
+                if (ruleName === constructorRuleName) {
+                    switch(ruleName){
+                        case _ruleNames.ARGUMENT_RULE_NAME:
+                            {
+                                var argumentNode = nonTerminalNode, constructorArgumentNode = constructorNonTerminalNode, argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context);
+                                nonTerminalNodeVerified = argumentNodeVerified; ///
+                                break;
+                            }
+                        default:
+                            {
+                                var childNodes = nonTerminalNode.getChildNodes(), constructorChildNodes = constructorNonTerminalNode.getChildNodes(), nodes = childNodes, constructorNodes = constructorChildNodes, nodesVerified = this.verifyNodes(nodes, constructorNodes, context);
+                                nonTerminalNodeVerified = nodesVerified; ///
+                                break;
+                            }
+                    }
+                }
+                return nonTerminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyArgumentNode",
+            value: function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
+                var argumentNodeVerified = false;
+                var typeNode = typeNodeQuery(argumentNode);
+                if (typeNode !== null) {
+                    var argumentString = context.nodeAsString(argumentNode);
+                    context.error("The ".concat(argumentString, " argument should be a term, not a type"), argumentNode);
+                } else {
+                    var termNode = termNodeQuery(argumentNode), constructorTermNode = termNodeQuery(constructorArgumentNode), constructorTypeNode = typeNodeQuery(constructorArgumentNode);
+                    if (false) {
+                    ///
+                    } else if (constructorTermNode !== null) {
+                        var node = termNode, constructorNode = constructorTermNode, nodeVerified = this.verifyNode(node, constructorNode, context);
+                        argumentNodeVerified = nodeVerified; ///
+                    } else if (constructorTypeNode !== null) {
+                        var types = [], termVerified = verifyTerm(termNode, types, context);
+                        if (termVerified) {
+                            var constructorTypeName = (0, _query.typeNameFromTypeNode)(constructorTypeNode), constructorType = constructorTypeName === _typeNames.OBJECT_TYPE_NAME ? _type.objectType : context.findTypeByTypeName(constructorTypeName), firstType = (0, _array.first)(types), termType = firstType, type = constructorType, termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+                            if (termTypeEqualToOrSubTypeOfType) {
+                                argumentNodeVerified = true;
+                            }
+                        }
+                    }
+                }
+                return argumentNodeVerified;
+            }
+        }
+    ]);
+    return TermVerifier;
+}(_verifier.default);
+var termVerifier = new TermVerifier();
 function verifyTerm(termNode, types, context) {
     var termVerified = false;
     var termString = context.nodeAsString(termNode);
@@ -48,19 +220,6 @@ function verifyTerm(termNode, types, context) {
     }
     return termVerified;
 }
-function verifyTermAsVariable(termNode, variables, context) {
-    var termVerifiedAsVariable = false;
-    var variableNode = variableNodeQuery(termNode);
-    if (variableNode !== null) {
-        var variableName = (0, _query.variableNameFromVariableNode)(variableNode), variablePresent = context.isVariablePresentByVariableName(variableName);
-        if (variablePresent) {
-            var variable = context.findVariableByVariableName(variableName);
-            variables.push(variable);
-            termVerifiedAsVariable = true;
-        }
-    }
-    return termVerifiedAsVariable;
-}
 function verifyTermAgainstConstructors(termNode, types, context) {
     var termVerifiedAgainstConstructors = false;
     var constructors = context.getConstructors(), constructor = constructors.find(function(constructor) {
@@ -77,81 +236,21 @@ function verifyTermAgainstConstructors(termNode, types, context) {
     return termVerifiedAgainstConstructors;
 }
 function verifyTermAgainstConstructor(termNode, constructor, context) {
-    var constructorTermNode = constructor.getTermNode(), node = termNode, constructorNode = constructorTermNode, nodeVerified = verifyNode(node, constructorNode, context), termVerifiedAgainstConstructor = nodeVerified; ///
+    var constructorTermNode = constructor.getTermNode(), nonTerminalNNdeA = termNode, nonTerminalNodeB = constructorTermNode, nodeVerified = termVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context), termVerifiedAgainstConstructor = nodeVerified; ///
     return termVerifiedAgainstConstructor;
 }
-function verifyNode(node, constructorNode, context) {
-    var nodeVerified;
-    var nodeTerminalNode = node.isTerminalNode(), constructorNodeTerminalNode = constructorNode.isTerminalNode();
-    if (nodeTerminalNode === constructorNodeTerminalNode) {
-        if (nodeTerminalNode) {
-            var terminalNode = node, constructorTerminalNode = constructorNode, terminalNodeVerified = verifyTerminalNode(terminalNode, constructorTerminalNode, context);
-            nodeVerified = terminalNodeVerified; ///
-        } else {
-            var nonTerminalNode = node, constructorNonTerminalNode = constructorNode, nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context);
-            nodeVerified = nonTerminalNodeVerified; ///
-        }
-    }
-    return nodeVerified;
-}
-function verifyNodes(nodes, constructorNodes, context) {
-    var nodesVerified = false;
-    var nodesLength = nodes.length, constructorNodesLength = constructorNodes.length;
-    if (nodesLength === constructorNodesLength) {
-        nodesVerified = nodes.every(function(node, index) {
-            var constructorNode = constructorNodes[index], nodeVerified = verifyNode(node, constructorNode, context);
-            if (nodeVerified) {
-                return true;
-            }
-        });
-    }
-    return nodesVerified;
-}
-function verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
-    var terminalNodeVerified = false;
-    var matches = terminalNode.match(constructorTerminalNode);
-    if (matches) {
-        terminalNodeVerified = true;
-    }
-    return terminalNodeVerified;
-}
-function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
-    var nonTerminalNodeVerified = false;
-    var ruleName = nonTerminalNode.getRuleName(), constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
-    if (ruleName === constructorRuleName) {
-        switch(ruleName){
-            case _ruleNames.ARGUMENT_RULE_NAME:
-                {
-                    var argumentNode = nonTerminalNode, constructorArgumentNode = constructorNonTerminalNode, argumentNodeVerified = verifyArgumentNode(argumentNode, constructorArgumentNode, context);
-                    nonTerminalNodeVerified = argumentNodeVerified; ///
-                    break;
-                }
-            default:
-                {
-                    var childNodes = nonTerminalNode.getChildNodes(), constructorChildNodes = constructorNonTerminalNode.getChildNodes(), nodes = childNodes, constructorNodes = constructorChildNodes, nodesVerified = verifyNodes(nodes, constructorNodes, context);
-                    nonTerminalNodeVerified = nodesVerified; ///
-                    break;
-                }
-        }
-    }
-    return nonTerminalNodeVerified;
-}
-function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
-    var argumentNodeVerified = false;
-    var termNode = termNodeQuery(argumentNode);
-    if (termNode === null) {
-        var argumentString = context.nodeAsString(argumentNode);
-        context.error("The ".concat(argumentString, " argument should be a term, not a type"), argumentNode);
-    } else {
-        var types = [], termVerified = verifyTerm(termNode, types, context);
-        if (termVerified) {
-            var firstType = (0, _array.first)(types), termType = firstType, typeNode = typeNodeQuery(constructorArgumentNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), type = typeName === _typeNames.OBJECT_TYPE_NAME ? _type.objectType : context.findTypeByTypeName(typeName), termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-            if (termTypeEqualToOrSubTypeOfType) {
-                argumentNodeVerified = true;
-            }
+function verifyTermAsVariable(termNode, variables, context) {
+    var termVerifiedAsVariable = false;
+    var variableNode = variableNodeQuery(termNode);
+    if (variableNode !== null) {
+        var variableName = (0, _query.variableNameFromVariableNode)(variableNode), variablePresent = context.isVariablePresentByVariableName(variableName);
+        if (variablePresent) {
+            var variable = context.findVariableByVariableName(variableName);
+            variables.push(variable);
+            termVerifiedAsVariable = true;
         }
     }
-    return argumentNodeVerified;
+    return termVerifiedAsVariable;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport { first } from \"../utilities/array\";\nimport { objectType } from \"../type\";\nimport { OBJECT_TYPE_NAME } from \"../typeNames\";\nimport { ARGUMENT_RULE_NAME } from \"../ruleNames\";\nimport { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nexport default function verifyTerm(termNode, types, context) {\n  let termVerified = false;\n\n  const termString = context.nodeAsString(termNode);\n\n  context.trace(`Verifying the '${termString}' term...`, termNode);\n\n  if (!termVerified) {\n    const variables = [],\n          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n    if (termVerifiedAsVariable) {\n      const firstVariable = first(variables),\n            variable = firstVariable, ///\n            type = variable.getType();\n\n      types.push(type);\n\n      termVerified = true;\n    }\n  }\n\n  if (!termVerified) {\n    const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n    if (termVerifiedAgainstConstructors) {\n      termVerified = true;\n    }\n  }\n\n  if (termVerified) {\n    context.debug(`Verified the '${termString}' term.`, termNode);\n  }\n\n  return termVerified;\n}\n\nexport function verifyTermAsVariable(termNode, variables, context) {\n  let termVerifiedAsVariable = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode !== null) {\n    const variableName = variableNameFromVariableNode(variableNode),\n          variablePresent = context.isVariablePresentByVariableName(variableName);\n\n    if (variablePresent) {\n      const variable = context.findVariableByVariableName(variableName);\n\n      variables.push(variable);\n\n      termVerifiedAsVariable = true;\n    }\n  }\n\n  return termVerifiedAsVariable;\n}\n\nexport function verifyTermAgainstConstructors(termNode, types, context) {\n  let termVerifiedAgainstConstructors = false;\n\n  const constructors = context.getConstructors(),\n        constructor = constructors.find((constructor) => {\n          const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);\n\n          if (termVerifiedAgainstConstructor) {\n            return true;\n          }\n        }) || null;\n\n  if (constructor !== null) {\n    const type = constructor.getType();\n\n    types.push(type);\n\n    termVerifiedAgainstConstructors = true;\n  }\n\n  return termVerifiedAgainstConstructors;\n}\n\nfunction verifyTermAgainstConstructor(termNode, constructor, context) {\n  const constructorTermNode = constructor.getTermNode(),\n        node = termNode,  ///\n        constructorNode = constructorTermNode, ///\n        nodeVerified = verifyNode(node, constructorNode, context),\n        termVerifiedAgainstConstructor = nodeVerified;  ///\n\n  return termVerifiedAgainstConstructor;\n}\n\nfunction verifyNode(node, constructorNode, context) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode(),\n        constructorNodeTerminalNode = constructorNode.isTerminalNode();\n\n  if (nodeTerminalNode === constructorNodeTerminalNode) {\n    if (nodeTerminalNode) {\n      const terminalNode = node,  ///\n            constructorTerminalNode = constructorNode,  ///\n            terminalNodeVerified = verifyTerminalNode(terminalNode, constructorTerminalNode, context);\n\n      nodeVerified = terminalNodeVerified;  ///\n    } else {\n      const nonTerminalNode = node, ///\n            constructorNonTerminalNode = constructorNode,  ///\n            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context);\n\n      nodeVerified = nonTerminalNodeVerified; ///\n    }\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyNodes(nodes, constructorNodes, context) {\n  let nodesVerified = false;\n\n  const nodesLength = nodes.length,\n        constructorNodesLength = constructorNodes.length;\n\n  if (nodesLength === constructorNodesLength) {\n    nodesVerified = nodes.every((node, index) => {\n      const constructorNode = constructorNodes[index],\n            nodeVerified = verifyNode(node, constructorNode, context);\n\n      if (nodeVerified) {\n        return true;\n      }\n    });\n  }\n\n  return nodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, constructorTerminalNode, context) {\n  let terminalNodeVerified = false;\n\n  const matches = terminalNode.match(constructorTerminalNode);\n\n  if (matches) {\n    terminalNodeVerified = true;\n  }\n\n  return terminalNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {\n  let nonTerminalNodeVerified = false;\n\n  const ruleName = nonTerminalNode.getRuleName(), ///\n        constructorRuleName = constructorNonTerminalNode.getRuleName(); ///\n\n  if (ruleName === constructorRuleName) {\n    switch (ruleName) {\n      case ARGUMENT_RULE_NAME: {\n        const argumentNode = nonTerminalNode, ///\n              constructorArgumentNode = constructorNonTerminalNode, ///\n              argumentNodeVerified = verifyArgumentNode(argumentNode, constructorArgumentNode, context);\n\n        nonTerminalNodeVerified = argumentNodeVerified; ///\n\n        break;\n      }\n\n      default: {\n        const childNodes = nonTerminalNode.getChildNodes(),\n              constructorChildNodes = constructorNonTerminalNode.getChildNodes(),\n              nodes = childNodes, ///\n              constructorNodes = constructorChildNodes, ///\n              nodesVerified = verifyNodes(nodes, constructorNodes, context);\n\n        nonTerminalNodeVerified = nodesVerified; ///\n\n        break;\n      }\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, constructorArgumentNode, context) {\n  let argumentNodeVerified = false;\n\n  const termNode = termNodeQuery(argumentNode);\n\n  if (termNode === null) {\n    const argumentString = context.nodeAsString(argumentNode);\n\n    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);\n  } else {\n    const types = [],\n          termVerified = verifyTerm(termNode, types, context);\n\n    if (termVerified) {\n      const firstType = first(types),\n            termType = firstType, ///\n            typeNode = typeNodeQuery(constructorArgumentNode),\n            typeName = typeNameFromTypeNode(typeNode),\n            type = (typeName === OBJECT_TYPE_NAME) ?\n                     objectType :  ///\n                       context.findTypeByTypeName(typeName),\n            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);\n\n      if (termTypeEqualToOrSubTypeOfType) {\n        argumentNodeVerified = true;\n      }\n    }\n  }\n\n  return argumentNodeVerified;\n}\n"],"names":["verifyTerm","verifyTermAsVariable","verifyTermAgainstConstructors","termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","termNode","types","context","termVerified","termString","nodeAsString","trace","variables","termVerifiedAsVariable","firstVariable","first","variable","type","getType","push","termVerifiedAgainstConstructors","debug","variableNode","variableName","variableNameFromVariableNode","variablePresent","isVariablePresentByVariableName","findVariableByVariableName","constructors","getConstructors","constructor","find","termVerifiedAgainstConstructor","verifyTermAgainstConstructor","constructorTermNode","getTermNode","node","constructorNode","nodeVerified","verifyNode","nodeTerminalNode","isTerminalNode","constructorNodeTerminalNode","terminalNode","constructorTerminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNode","constructorNonTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","verifyNodes","nodes","constructorNodes","nodesVerified","nodesLength","length","constructorNodesLength","every","index","matches","match","ruleName","getRuleName","constructorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","verifyArgumentNode","childNodes","getChildNodes","constructorChildNodes","argumentString","error","firstType","termType","typeNode","typeName","typeNameFromTypeNode","OBJECT_TYPE_NAME","objectType","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport Verifier from \"../verifier\";\n\nimport { first } from \"../utilities/array\";\nimport { objectType } from \"../type\";\nimport { OBJECT_TYPE_NAME } from \"../typeNames\";\nimport { ARGUMENT_RULE_NAME } from \"../ruleNames\";\nimport { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nclass TermVerifier extends Verifier {\n  verifyTerminalNode(terminalNode, constructorTerminalNode, context) {\n    let terminalNodeVerified = false;\n\n    const matches = terminalNode.match(constructorTerminalNode);\n\n    if (matches) {\n      terminalNodeVerified = true;\n    }\n\n    return terminalNodeVerified;\n  }\n\n  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {\n    let nonTerminalNodeVerified = false;\n\n    const ruleName = nonTerminalNode.getRuleName(), ///\n          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///\n\n    if (ruleName === constructorRuleName) {\n      switch (ruleName) {\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                constructorArgumentNode = constructorNonTerminalNode, ///\n                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          const childNodes = nonTerminalNode.getChildNodes(),\n                constructorChildNodes = constructorNonTerminalNode.getChildNodes(),\n                nodes = childNodes, ///\n                constructorNodes = constructorChildNodes, ///\n                nodesVerified = this.verifyNodes(nodes, constructorNodes, context);\n\n          nonTerminalNodeVerified = nodesVerified; ///\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyArgumentNode(argumentNode, constructorArgumentNode, context) {\n    let argumentNodeVerified = false;\n\n    const typeNode = typeNodeQuery(argumentNode);\n\n    if (typeNode !== null) {\n      const argumentString = context.nodeAsString(argumentNode);\n\n      context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);\n    } else {\n      const termNode = termNodeQuery(argumentNode),\n            constructorTermNode = termNodeQuery(constructorArgumentNode),\n            constructorTypeNode = typeNodeQuery(constructorArgumentNode);\n\n      if (false) {\n        ///\n      } else if (constructorTermNode !== null) {\n        const node = termNode,  ///\n              constructorNode = constructorTermNode,  ///\n              nodeVerified = this.verifyNode(node, constructorNode, context);\n\n        argumentNodeVerified = nodeVerified;  ///\n      } else if (constructorTypeNode !== null) {\n        const types = [],\n              termVerified = verifyTerm(termNode, types, context);\n\n        if (termVerified) {\n          const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),\n                constructorType = (constructorTypeName === OBJECT_TYPE_NAME) ?\n                                    objectType :\n                                      context.findTypeByTypeName(constructorTypeName),\n                firstType = first(types),\n                termType = firstType, ///\n                type = constructorType, ///\n                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);\n\n          if (termTypeEqualToOrSubTypeOfType) {\n            argumentNodeVerified = true;\n          }\n        }\n      }\n    }\n\n    return argumentNodeVerified;\n  }\n}\n\nexport const termVerifier = new TermVerifier();\n\nexport default function verifyTerm(termNode, types, context) {\n  let termVerified = false;\n\n  const termString = context.nodeAsString(termNode);\n\n  context.trace(`Verifying the '${termString}' term...`, termNode);\n\n  if (!termVerified) {\n    const variables = [],\n          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n    if (termVerifiedAsVariable) {\n      const firstVariable = first(variables),\n            variable = firstVariable, ///\n            type = variable.getType();\n\n      types.push(type);\n\n      termVerified = true;\n    }\n  }\n\n  if (!termVerified) {\n    const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n    if (termVerifiedAgainstConstructors) {\n      termVerified = true;\n    }\n  }\n\n  if (termVerified) {\n    context.debug(`Verified the '${termString}' term.`, termNode);\n  }\n\n  return termVerified;\n}\n\nexport function verifyTermAgainstConstructors(termNode, types, context) {\n  let termVerifiedAgainstConstructors = false;\n\n  const constructors = context.getConstructors(),\n        constructor = constructors.find((constructor) => {\n          const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);\n\n          if (termVerifiedAgainstConstructor) {\n            return true;\n          }\n        }) || null;\n\n  if (constructor !== null) {\n    const type = constructor.getType();\n\n    types.push(type);\n\n    termVerifiedAgainstConstructors = true;\n  }\n\n  return termVerifiedAgainstConstructors;\n}\n\nexport function verifyTermAgainstConstructor(termNode, constructor, context) {\n  const constructorTermNode = constructor.getTermNode(),\n        nonTerminalNNdeA = termNode,  ///\n        nonTerminalNodeB = constructorTermNode,  ///\n        nodeVerified = termVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context),\n        termVerifiedAgainstConstructor = nodeVerified;  ///\n\n  return termVerifiedAgainstConstructor;\n}\n\nexport function verifyTermAsVariable(termNode, variables, context) {\n  let termVerifiedAsVariable = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode !== null) {\n    const variableName = variableNameFromVariableNode(variableNode),\n          variablePresent = context.isVariablePresentByVariableName(variableName);\n\n    if (variablePresent) {\n      const variable = context.findVariableByVariableName(variableName);\n\n      variables.push(variable);\n\n      termVerifiedAsVariable = true;\n    }\n  }\n\n  return termVerifiedAsVariable;\n}\n"],"names":["termVerifier","verifyTerm","verifyTermAgainstConstructors","verifyTermAgainstConstructor","verifyTermAsVariable","termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","TermVerifier","verifyTerminalNode","terminalNode","constructorTerminalNode","context","terminalNodeVerified","matches","match","verifyNonTerminalNode","nonTerminalNode","constructorNonTerminalNode","nonTerminalNodeVerified","ruleName","getRuleName","constructorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","verifyArgumentNode","childNodes","getChildNodes","constructorChildNodes","nodes","constructorNodes","nodesVerified","verifyNodes","typeNode","argumentString","nodeAsString","error","termNode","constructorTermNode","constructorTypeNode","node","constructorNode","nodeVerified","verifyNode","types","termVerified","constructorTypeName","typeNameFromTypeNode","constructorType","OBJECT_TYPE_NAME","objectType","findTypeByTypeName","firstType","first","termType","type","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf","Verifier","termString","trace","variables","termVerifiedAsVariable","firstVariable","variable","getType","push","termVerifiedAgainstConstructors","debug","constructors","getConstructors","constructor","find","termVerifiedAgainstConstructor","getTermNode","nonTerminalNNdeA","nonTerminalNodeB","variableNode","variableName","variableNameFromVariableNode","variablePresent","isVariablePresentByVariableName","findVariableByVariableName"],"mappings":"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"}

package/lib/verify/termAsConstructor.js

@@ -18,7 +18,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-var typeNodeQuery = (0, _query.nodeQuery)("/argument/type");
+var typeNodeQuery = (0, _query.nodeQuery)("/argument/type"), termNodeQuery = (0, _query.nodeQuery)("/argument/term");
 function verifyTermAsConstructor(termNode, typeNode, fileContext) {
     var termVerifiedAsConstructor = false;
     var type = null;
@@ -105,20 +105,21 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
     return nonTerminalNodeVerified;
 }
 function verifyArgumentNode(argumentNode, fileContext) {
-    var typeNodeVerified = false;
-    var typeNode = typeNodeQuery(argumentNode);
-    if (typeNode === null) {
-        var argumentString = fileContext.nodeAsString(argumentNode);
-        fileContext.error("The ".concat(argumentString, " argument should be a type."), argumentNode);
-    } else {
+    var argumentNodeVerified = false;
+    var typeNode = typeNodeQuery(argumentNode), termNode = termNodeQuery(argumentNode);
+    if (false) {
+    ///
+    } else if (typeNode !== null) {
         var typeName = (0, _query.typeNameFromTypeNode)(typeNode), typePresent = fileContext.isTypePresentByTypeName(typeName);
         if (!typePresent) {
             fileContext.error("The type '".concat(typeName, "' is not present."), argumentNode);
-        } else {
-            typeNodeVerified = true;
         }
+        argumentNodeVerified = typePresent; ///
+    } else if (termNode !== null) {
+        var node = termNode, nodeVerified = verifyNode(node, fileContext);
+        argumentNodeVerified = nodeVerified; ///
     }
-    return typeNodeVerified;
+    return argumentNodeVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/termAsConstructor.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../verify/term\";\nimport Constructor from \"../constructor\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from \"../ruleNames\";\n\nconst typeNodeQuery = nodeQuery(\"/argument/type\");\n\nexport default function verifyTermAsConstructor(termNode, typeNode, fileContext) {\n  let termVerifiedAsConstructor = false;\n\n  let type = null;\n\n  const nonTerminalNode = termNode,  ///\n        termString = fileContext.nodeAsString(termNode);\n\n  const childNodes = nonTerminalNode.getChildNodes(),\n        childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n  if (childNodesVerified) {\n    if (typeNode === null) {\n      termVerifiedAsConstructor = true;\n    } else {\n      const typeName = typeNameFromTypeNode(typeNode);\n\n      type = fileContext.findTypeByTypeName(typeName);\n\n      if (type !== null) {\n        termVerifiedAsConstructor = true;\n      } else {\n        fileContext.error(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);\n      }\n    }\n  }\n\n  if (termVerifiedAsConstructor) {\n    const constructor = Constructor.fromTermNodeAndType(termNode, type);\n\n    fileContext.addConstructor(constructor);\n  }\n\n  if (termVerifiedAsConstructor) {\n    fileContext.info(`Verified the '${termString}' constructor.`, termNode);\n  }\n\n  return termVerifiedAsConstructor;\n}\n\nfunction verifyNode(node, fileContext) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode();\n\n  if (nodeTerminalNode) {\n    const terminalNode = node,  ///\n          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);\n\n    nodeVerified = terminalNodeVerified;  ///\n  } else {\n    const nonTerminalNode = node, ///\n          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);\n\n    nodeVerified = nonTerminalNodeVerified; ///\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyChildNodes(childNodes, fileContext) {\n  const childNodesVerified = childNodes.every((childNode) => {\n    const node = childNode, ///\n          nodeVerified = verifyNode(node, fileContext);\n\n    if (nodeVerified) {\n      return true;\n    }\n  });\n\n  return childNodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, fileContext) {\n  const terminalNodeVerified = true;\n\n  return terminalNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, fileContext) {\n  let nonTerminalNodeVerified;\n\n  const ruleName = nonTerminalNode.getRuleName();\n\n  switch (ruleName) {\n    case ARGUMENT_RULE_NAME: {\n      const argumentNode = nonTerminalNode, ///\n            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);\n\n      nonTerminalNodeVerified = argumentNodeVerified; ///\n\n      break;\n    }\n\n    case TERM_RULE_NAME: {\n      const termNode = nonTerminalNode, ///\n            types = [],\n            context = fileContext,  ///\n            termVerified = verifyTerm(termNode, types, context);\n\n      if (termVerified) {\n        const firstType = first(types),\n              type = firstType; ///\n\n        if (type !== null) {\n          const termString = fileContext.nodeAsString(termNode);\n\n          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);\n        } else {\n          nonTerminalNodeVerified = true; ///\n        }\n      }\n\n      break;\n    }\n\n    default: {\n      const childNodes = nonTerminalNode.getChildNodes(),\n            childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n      nonTerminalNodeVerified = childNodesVerified; ///\n\n      break;\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, fileContext) {\n  let typeNodeVerified = false;\n\n  const typeNode = typeNodeQuery(argumentNode);\n\n  if (typeNode === null) {\n    const argumentString = fileContext.nodeAsString(argumentNode);\n\n    fileContext.error(`The ${argumentString} argument should be a type.`, argumentNode);\n  } else {\n    const typeName = typeNameFromTypeNode(typeNode),\n          typePresent = fileContext.isTypePresentByTypeName(typeName);\n\n    if (!typePresent) {\n      fileContext.error(`The type '${typeName}' is not present.`, argumentNode);\n    } else {\n      typeNodeVerified = true;\n    }\n  }\n\n  return typeNodeVerified;\n}\n"],"names":["verifyTermAsConstructor","typeNodeQuery","nodeQuery","termNode","typeNode","fileContext","termVerifiedAsConstructor","type","nonTerminalNode","termString","nodeAsString","childNodes","getChildNodes","childNodesVerified","verifyChildNodes","typeName","typeNameFromTypeNode","findTypeByTypeName","error","constructor","Constructor","fromTermNodeAndType","addConstructor","info","verifyNode","node","nodeVerified","nodeTerminalNode","isTerminalNode","terminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","every","childNode","ruleName","getRuleName","ARGUMENT_RULE_NAME","argumentNode","argumentNodeVerified","verifyArgumentNode","TERM_RULE_NAME","types","context","termVerified","verifyTerm","firstType","first","typeNodeVerified","argumentString","typePresent","isTypePresentByTypeName"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/termAsConstructor.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../verify/term\";\nimport Constructor from \"../constructor\";\n\nimport { first } from \"../utilities/array\";\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\nexport default function verifyTermAsConstructor(termNode, typeNode, fileContext) {\n  let termVerifiedAsConstructor = false;\n\n  let type = null;\n\n  const nonTerminalNode = termNode,  ///\n        termString = fileContext.nodeAsString(termNode);\n\n  const childNodes = nonTerminalNode.getChildNodes(),\n        childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n  if (childNodesVerified) {\n    if (typeNode === null) {\n      termVerifiedAsConstructor = true;\n    } else {\n      const typeName = typeNameFromTypeNode(typeNode);\n\n      type = fileContext.findTypeByTypeName(typeName);\n\n      if (type !== null) {\n        termVerifiedAsConstructor = true;\n      } else {\n        fileContext.error(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);\n      }\n    }\n  }\n\n  if (termVerifiedAsConstructor) {\n    const constructor = Constructor.fromTermNodeAndType(termNode, type);\n\n    fileContext.addConstructor(constructor);\n  }\n\n  if (termVerifiedAsConstructor) {\n    fileContext.info(`Verified the '${termString}' constructor.`, termNode);\n  }\n\n  return termVerifiedAsConstructor;\n}\n\nfunction verifyNode(node, fileContext) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode();\n\n  if (nodeTerminalNode) {\n    const terminalNode = node,  ///\n          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);\n\n    nodeVerified = terminalNodeVerified;  ///\n  } else {\n    const nonTerminalNode = node, ///\n          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);\n\n    nodeVerified = nonTerminalNodeVerified; ///\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyChildNodes(childNodes, fileContext) {\n  const childNodesVerified = childNodes.every((childNode) => {\n    const node = childNode, ///\n          nodeVerified = verifyNode(node, fileContext);\n\n    if (nodeVerified) {\n      return true;\n    }\n  });\n\n  return childNodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, fileContext) {\n  const terminalNodeVerified = true;\n\n  return terminalNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, fileContext) {\n  let nonTerminalNodeVerified;\n\n  const ruleName = nonTerminalNode.getRuleName();\n\n  switch (ruleName) {\n    case ARGUMENT_RULE_NAME: {\n      const argumentNode = nonTerminalNode, ///\n            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);\n\n      nonTerminalNodeVerified = argumentNodeVerified; ///\n\n      break;\n    }\n\n    case TERM_RULE_NAME: {\n      const termNode = nonTerminalNode, ///\n            types = [],\n            context = fileContext,  ///\n            termVerified = verifyTerm(termNode, types, context);\n\n      if (termVerified) {\n        const firstType = first(types),\n              type = firstType; ///\n\n        if (type !== null) {\n          const termString = fileContext.nodeAsString(termNode);\n\n          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);\n        } else {\n          nonTerminalNodeVerified = true; ///\n        }\n      }\n\n      break;\n    }\n\n    default: {\n      const childNodes = nonTerminalNode.getChildNodes(),\n            childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n      nonTerminalNodeVerified = childNodesVerified; ///\n\n      break;\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, fileContext) {\n  let argumentNodeVerified = false;\n\n  const typeNode = typeNodeQuery(argumentNode),\n        termNode = termNodeQuery(argumentNode);\n\n  if (false) {\n    ///\n  } else if (typeNode !== null) {\n    const typeName = typeNameFromTypeNode(typeNode),\n          typePresent = fileContext.isTypePresentByTypeName(typeName);\n\n    if (!typePresent) {\n      fileContext.error(`The type '${typeName}' is not present.`, argumentNode);\n    }\n\n    argumentNodeVerified = typePresent; ///\n  } else if (termNode !== null) {\n    const node = termNode,  ///\n          nodeVerified = verifyNode(node, fileContext);\n\n    argumentNodeVerified = nodeVerified;  ///\n  }\n\n  return argumentNodeVerified;\n}\n"],"names":["verifyTermAsConstructor","typeNodeQuery","nodeQuery","termNodeQuery","termNode","typeNode","fileContext","termVerifiedAsConstructor","type","nonTerminalNode","termString","nodeAsString","childNodes","getChildNodes","childNodesVerified","verifyChildNodes","typeName","typeNameFromTypeNode","findTypeByTypeName","error","constructor","Constructor","fromTermNodeAndType","addConstructor","info","verifyNode","node","nodeVerified","nodeTerminalNode","isTerminalNode","terminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","every","childNode","ruleName","getRuleName","ARGUMENT_RULE_NAME","argumentNode","argumentNodeVerified","verifyArgumentNode","TERM_RULE_NAME","types","context","termVerified","verifyTerm","firstType","first","typePresent","isTypePresentByTypeName"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.613",
+  "version": "0.0.615",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -14,7 +14,7 @@
     "necessary": "^11.2.1",
     "occam-custom-grammars": "^5.0.468",
     "occam-dom": "^3.1.31",
-    "occam-file-system": "^5.0.208",
+    "occam-file-system": "^5.0.209",
     "occam-grammar-utilities": "^7.0.116"
   },
   "devDependencies": {

package/src/log.js

@@ -110,9 +110,9 @@ function formatMessage(level, message, node = null, tokens = null, filePath = nu
     message = `${upperCaseLevel}: ${message}`;
   } else {
     const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
-          leastLineNumber = leastLineIndex + 1,
+          leastLineNumber = leastLineIndex, ///
           greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, tokens),
-          greatestLineNumber = greatestLineIndex + 1;
+          greatestLineNumber = greatestLineIndex; ///
 
     if (leastLineNumber === greatestLineNumber) {
       const lineNumber = leastLineNumber; ///

package/src/verify/metastatement.js

@@ -55,7 +55,7 @@ class MetastatementVerifier extends Verifier {
   }
 }
 
-const metastatementVerifier = new MetastatementVerifier();
+export const metastatementVerifier = new MetastatementVerifier();
 
 export default function verifyMetastatement(metastatementNode, derived, metaproofContext) {
   let metastatementVerified = false;

package/src/verify/statement.js

@@ -9,6 +9,7 @@ import verifyTypeInference from "../verify/typeInference";
 import verifyTypeAssertion from "../verify/assertion/type";
 
 import { objectType } from "../type";
+import { termVerifier } from "../verify/term";
 import { first, second } from "../utilities/array";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
@@ -24,36 +25,6 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
-export default function verifyStatement(statementNode, assignments, derived, context) {
-  let statementVerified = false;
-
-  if (!statementVerified) {
-    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
-
-    statementVerified = statementVerifiedAgainstCombinators;  ///
-  }
-
-  if (!statementVerified) {
-    const statementVerifiedAsTypeInference = verifyStatementAsTypeInference(statementNode, derived, context);
-
-    statementVerified = statementVerifiedAsTypeInference; ///
-  }
-
-  if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
-
-    statementVerified = statementVerifiedAsTypeAssertion; ///
-  }
-
-  if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
-
-    statementVerified = statementVerifiedAsEquality;  //
-  }
-
-  return statementVerified;
-}
-
 class StatementVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context) {
     let nonTerminalNodeVerified = false;
@@ -62,14 +33,14 @@ class StatementVerifier extends Verifier {
           combinatorNonTerminalNode = nonTerminalNodeB; ///
 
     const ruleName = nonTerminalNode.getRuleName(), ///
-      combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
+          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
 
     if (ruleName === combinatorRuleName) {
       switch (ruleName) {
         case ARGUMENT_RULE_NAME: {
           const argumentNode = nonTerminalNode, ///
-                combinatorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = this.verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
+                constructorArgumentNode = combinatorNonTerminalNode, ///
+                argumentNodeVerified = termVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context);
 
           nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -167,7 +138,37 @@ class StatementVerifier extends Verifier {
   }
 }
 
-const statementVerifier = new StatementVerifier();
+export const statementVerifier = new StatementVerifier();
+
+export default function verifyStatement(statementNode, assignments, derived, context) {
+  let statementVerified = false;
+
+  if (!statementVerified) {
+    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
+
+    statementVerified = statementVerifiedAgainstCombinators;  ///
+  }
+
+  if (!statementVerified) {
+    const statementVerifiedAsTypeInference = verifyStatementAsTypeInference(statementNode, derived, context);
+
+    statementVerified = statementVerifiedAsTypeInference; ///
+  }
+
+  if (!statementVerified) {
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
+
+    statementVerified = statementVerifiedAsTypeAssertion; ///
+  }
+
+  if (!statementVerified) {
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+
+    statementVerified = statementVerifiedAsEquality;  //
+  }
+
+  return statementVerified;
+}
 
 export function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
@@ -179,7 +180,7 @@ export function verifyStatementAgainstCombinators(statementNode, context) {
     ...combinators
   ];
 
-  const combinator = combinators.find((combinator) => {
+  const combinator = combinators.find((combinator, index) => {
     const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
     if (statementVerifiedAgainstCombinator) {
@@ -238,9 +239,15 @@ function verifyStatementAsTypeAssertion(statementNode, assignments, derived, con
   return statementVerifiedAsTypeAssertion;
 }
 
+let count = 0;
+
 function verifyStatementAsEquality(statementNode, derived, context) {
   let statementVerifiedAsEquality = false;
 
+  if (count++ === 8) {
+    debugger
+  }
+
   const combinator = equalityCombinator,  ///
         statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);