occam-verify-cli 0.0.535 → 0.0.536

package/src/verify/statement.js

@@ -1,22 +1,27 @@
 "use strict";
 
-import Equality from "../equality";
+import Verifier from "../verifier";
 import Variable from "../variable";
-import Assignment from "../assignment";
+import Equality from "../equality";
 import verifyTerm from "../verify/term";
-import statementVerifier from "../verifier/statement";
 import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
-import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
+import { objectType } from "../type";
+import { first, second } from "../utilities/array";
+import { OBJECT_TYPE_NAME } from "../typeNames";
+import { STATEMENT_META_TYPE } from "../metaTypes";
 import { verifyTermAsVariable } from "../verify/term";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
-const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
-      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!"),
+      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
+      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export default function verifyStatement(statementNode, assignments, derived, context) {
   let statementVerified = false;
@@ -34,7 +39,7 @@ export default function verifyStatement(statementNode, assignments, derived, con
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assignments, derived, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
@@ -42,6 +47,121 @@ export default function verifyStatement(statementNode, assignments, derived, con
   return statementVerified;
 }
 
+class StatementVerifier extends Verifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNode = nonTerminalNodeA, ///
+          combinatorNonTerminalNode = nonTerminalNodeB; ///
+
+    const ruleName = nonTerminalNode.getRuleName(), ///
+      combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === combinatorRuleName) {
+      switch (ruleName) {
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                combinatorArgumentNode = combinatorNonTerminalNode, ///
+                argumentNodeVerified = this.verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
+        case META_ARGUMENT_RULE_NAME: {
+          const metaArgumentNode = nonTerminalNode, ///
+                combinatorMetaargumentNode = combinatorNonTerminalNode, ///
+                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context);
+
+          nonTerminalNodeVerified = metaArgumentNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          const childNodes = nonTerminalNode.getChildNodes(),
+                combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
+                nodesA = childNodes, ///
+                nodesB = combinatorChildNodes, ///
+                nodesVerified = this.verifyNodes(nodesA, nodesB, context);
+
+          nonTerminalNodeVerified = nodesVerified; ///
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
+    let argumentNodeVerified = false;
+
+    const termNode = termNodeQuery(argumentNode);
+
+    if (termNode === null) {
+      const argumentString = context.nodeAsString(argumentNode);
+
+      context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
+    } else {
+      const types = [],
+            termVerified = verifyTerm(termNode, types, context);
+
+      if (termVerified) {
+        const firstType = first(types),
+              termType = firstType, ///
+              typeNode = typeNodeQuery(combinatorArgumentNode),
+              typeName = typeNameFromTypeNode(typeNode),
+              type = (typeName === OBJECT_TYPE_NAME) ?
+                       objectType :  ///
+                         context.findTypeByTypeName(typeName),
+              statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+        if (statementTypeEqualToOrSubTypeOfType) {
+          argumentNodeVerified = true;
+        }
+      }
+    }
+
+    return argumentNodeVerified;
+  }
+
+  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
+    let metaArgumentNodeVerified = false;
+
+    const statementNode = statementNodeQuery(metaArgumentNode),
+          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
+
+    if (statementNode === null) {
+      const metaArgumentString = context.nodeAsString(metaArgumentNode);
+
+      context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
+    } else {
+      if (combinatorMetaTYpeNode === null) {
+        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
+
+        context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+      } else {
+        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
+              content = combinatorMetaTypeTerminalNode.getContent(),
+              contentStatementMetaType = (content === STATEMENT_META_TYPE);
+
+        if (!contentStatementMetaType) {
+          context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
+        } else {
+          metaArgumentNodeVerified = true;
+        }
+      }
+    }
+
+    return metaArgumentNodeVerified;
+  }
+}
+
+const statementVerifier = new StatementVerifier();
+
 function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
 
@@ -71,8 +191,7 @@ function verifyStatementAgainstCombinator(statementNode, combinator, context) {
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode,  ///
         nonTerminalNodeB = combinatorStatementNode, ///
-        substitutions = null,
-        nodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context),
+        nodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context),
         statementVerifiedAgainstCombinator = nodeVerified;  ///
 
   return statementVerifiedAgainstCombinator;
@@ -92,66 +211,129 @@ function verifyStatementAsTypeAssertion(statementNode, assignments, derived, con
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, assignments, derived, context) {
+function verifyStatementAsEquality(statementNode, derived, context) {
   let statementVerifiedAsEquality = false;
 
-  const statementString = context.nodeAsString(statementNode);
-
   const combinator = equalityCombinator,  ///
         statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
   if (statementVerifiedAgainstCombinator) {
-    const leftTermNode = leftTermNodeQuery(statementNode),
-          rightTermNode = rightTermNodeQuery(statementNode);
+    const equality = Equality.fromStatementNode(statementNode);
 
     if (derived) {
-      const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
-            equalityEquates = equality.equate(context);
+      const equalities = context.getEqualities(),
+            equalityVerified = equality.verify(equalities, context);
 
-      statementVerifiedAsEquality = equalityEquates;  ///
+      statementVerifiedAsEquality = equalityVerified;  ///
     } else {
-      const types = [],
-            variables = [],
-            leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context);
+      const variables = [],
+            leftTermNode = equality.getLeftTermNode(),
+            rightTermNode = equality.getRightTermNode(),
+            leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),
+            rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+
+      if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
+        const firstVariable = first(variables),
+              secondVariable = second(variables),
+              leftVariable = firstVariable, ///
+              rightVariable = secondVariable, ///
+              leftVariableName = leftVariable.getName(),
+              leftVariableType = leftVariable.getType(),
+              rightVariableName = rightVariable.getName(),
+              rightVariableType = rightVariable.getType(),
+              leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
+
+        if (!leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
+          const leftVariableTypeName = leftVariableType.getName(),
+                rightVariableTypeName = rightVariableType.getName();
+
+          context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to, a sub-type of or a super-type of the right '${rightVariableName}' variable's '${rightVariableTypeName}' type.`, statementNode);
+        } else {
+          const leftVariableTypeSuperTypeOfRightVariableType = leftVariableType.isSuperTypeOf(rightVariableType),
+                rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
+
+          if (leftVariableTypeSuperTypeOfRightVariableType) {
+            const type = rightVariableType,  ///
+                  name = leftVariableName, ///
+                  variable = Variable.fromTypeAndName(type, name);
+
+            context.addVariable(variable);
+          }
+
+          if (rightVariableTypeSuperTypeOfLeftVariableType) {
+            const type = leftVariableType,  ///
+                  name = rightVariableName, ///
+                  variable = Variable.fromTypeAndName(type, name);
+
+            context.addVariable(variable);
+          }
+
+          statementVerifiedAsEquality = true;
+        }
+      } else if (leftTermVerifiedAsVariable) {
+        const types = [];
 
-      if (leftTermVerifiedAsVariable) {
         verifyTerm(rightTermNode, types, context);
 
-        const firstVariable = first(variables),
+        const firstType = first(types),
+              firstVariable = first(variables),
               leftVariable = firstVariable, ///
-              firstType = first(types),
-              rightTermType = firstType, ///
+              rightTermType = firstType,  ///
               leftVariableType = leftVariable.getType(),
-              leftVariableName = leftVariable.getName(),
               leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
 
         if (!leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
-          const rightTermString = nodeAsString(rightTermNode),
+          const rightTermString = context.nodeAsString(rightTermNode),
+                leftVariableName = leftVariable.getName(),
                 rightTermTypeName = rightTermType.getName(),
                 leftVariableTypeName = leftVariableType.getName();
 
           context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
         } else {
-          const type = leftVariableType,  ///
-                name = leftVariableName,  ///
-                termNode = rightTermNode, ///
-                variable = Variable.fromTypeNameAndTermNode(type, name, termNode),
-                assignment = Assignment.fromVariable(variable);
+          statementVerifiedAsEquality = true;
+        }
+      } else if (rightTermVerifiedAsVariable) {
+        const types = [];
+
+        verifyTerm(leftTermNode, types, context);
+
+        const firstType = first(types),
+              firstVariable = first(variables),
+              leftTermType = firstType,  ///
+              rightVariable = firstVariable, ///
+              rightVariableType = rightVariable.getType(),
+              rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);
 
-          assignments.push(assignment);
+        if (!rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
+          const leftTermString = context.nodeAsString(leftTermNode),
+                rightVariableName = rightVariable.getName(),
+                leftTermTypeName = leftTermType.getName(),
+                rightVariableTypeName = rightVariableType.getName();
 
+          context.error(`The right '${rightVariableName}' variable's '${rightVariableTypeName}' type is not equal to or a super-type of the left '${leftTermString}' term's '${leftTermTypeName}' type.`, statementNode);
+        } else {
           statementVerifiedAsEquality = true;
         }
       } else {
-        const rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+        const types = [];
 
-        if (rightTermVerifiedAsVariable) {
-          const firstVariable = first(variables),
-                rightVariable = firstVariable,  ///
-                leftTermString = nodeAsString(leftTermNode),
-                rightVariableName = rightVariable.getName();
+        verifyTerm(leftTermNode, types, context);
 
-          context.error(`The left '${leftTermString}' term cannot be equated with the right '${rightVariableName}' variable.`, statementNode);
+        verifyTerm(rightTermNode, types, context);
+
+        const firstType = first(types),
+              secondType = second(types),
+              leftTermType = firstType, ///
+              rightTermType = secondType, ///
+              leftTermTypeEqualToOrSubTypeOfOfSuperTypeOf = leftTermType.isEqualToOrSubTypeOfOfSuperTypeOf(rightTermType);
+
+        if (!leftTermTypeEqualToOrSubTypeOfOfSuperTypeOf) {
+          const leftTermString = context.nodeAsString(leftTermNode),
+                rightTermString = context.nodeAsString(rightTermNode),
+                leftTermTypeName = leftTermType.getName(),
+                rightTermTypeName = rightTermType.getName();
+
+          context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to, a sub-type of or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
         } else {
           statementVerifiedAsEquality = true;
         }
@@ -160,6 +342,8 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
   }
 
   if (statementVerifiedAsEquality) {
+    const statementString = context.nodeAsString(statementNode);
+
     context.info(`Verified the '${statementString}' statement as an equality.`, statementNode);
   }
 

package/lib/verifier/statement.js

@@ -1,199 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _verifier = /*#__PURE__*/ _interopRequireDefault(require("../verifier"));
-var _term = /*#__PURE__*/ _interopRequireDefault(require("../verify/term"));
-var _array = require("../utilities/array");
-var _type = require("../type");
-var _typeNames = require("../typeNames");
-var _metaTypes = require("../metaTypes");
-var _query = require("../utilities/query");
-var _ruleNames = require("../ruleNames");
-function _assertThisInitialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(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) _setPrototypeOf(subClass, superClass);
-}
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _possibleConstructorReturn(self, call) {
-    if (call && (_typeof(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assertThisInitialized(self);
-}
-function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _setPrototypeOf(o, p);
-}
-var _typeof = function(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
-function _isNativeReflectConstruct() {
-    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 _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-    return function _createSuperInternal() {
-        var Super = _getPrototypeOf(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _getPrototypeOf(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possibleConstructorReturn(this, result);
-    };
-}
-var termNodeQuery = (0, _query.nodeQuery)("/argument/term!"), typeNodeQuery = (0, _query.nodeQuery)("/argument/type!"), metaTypeNodeQuery = (0, _query.nodeQuery)("/metaArgument/metaType!"), statementNodeQuery = (0, _query.nodeQuery)("/metaArgument/statement!"), metaTypeTerminalNodeQuery = (0, _query.nodeQuery)("/metaType/@meta-type");
-var StatementVerifier = /*#__PURE__*/ function(Verifier) {
-    _inherits(StatementVerifier, Verifier);
-    var _super = _createSuper(StatementVerifier);
-    function StatementVerifier() {
-        _classCallCheck(this, StatementVerifier);
-        return _super.apply(this, arguments);
-    }
-    _createClass(StatementVerifier, [
-        {
-            key: "verifyNonTerminalNode",
-            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context) {
-                var nonTerminalNodeVerified = false;
-                var nonTerminalNode = nonTerminalNodeA, combinatorNonTerminalNode = nonTerminalNodeB; ///
-                var ruleName = nonTerminalNode.getRuleName(), combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
-                if (ruleName === combinatorRuleName) {
-                    switch(ruleName){
-                        case _ruleNames.ARGUMENT_RULE_NAME:
-                            {
-                                var argumentNode = nonTerminalNode, combinatorArgumentNode = combinatorNonTerminalNode, argumentNodeVerified = this.verifyArgumentNode(argumentNode, combinatorArgumentNode, substitutions, context);
-                                nonTerminalNodeVerified = argumentNodeVerified; ///
-                                break;
-                            }
-                        case _ruleNames.META_ARGUMENT_RULE_NAME:
-                            {
-                                var metaArgumentNode = nonTerminalNode, combinatorMetaargumentNode = combinatorNonTerminalNode, metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, substitutions, context);
-                                nonTerminalNodeVerified = metaArgumentNodeVerified; ///
-                                break;
-                            }
-                        default:
-                            {
-                                var childNodes = nonTerminalNode.getChildNodes(), combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(), nodesA = childNodes, nodesB = combinatorChildNodes, nodesVerified = this.verifyNodes(nodesA, nodesB, substitutions, context);
-                                nonTerminalNodeVerified = nodesVerified; ///
-                                break;
-                            }
-                    }
-                }
-                return nonTerminalNodeVerified;
-            }
-        },
-        {
-            key: "verifyArgumentNode",
-            value: function verifyArgumentNode(argumentNode, combinatorArgumentNode, substitutions, 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 = (0, _term.default)(termNode, types, context);
-                    if (termVerified) {
-                        var firstType = (0, _array.first)(types), termType = firstType, typeNode = typeNodeQuery(combinatorArgumentNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), type = typeName === _typeNames.OBJECT_TYPE_NAME ? _type.objectType : context.findTypeByTypeName(typeName), statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-                        if (statementTypeEqualToOrSubTypeOfType) {
-                            argumentNodeVerified = true;
-                        }
-                    }
-                }
-                return argumentNodeVerified;
-            }
-        },
-        {
-            key: "verifyMetaargumentNode",
-            value: function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, substitutions, context) {
-                var metaArgumentNodeVerified = false;
-                var statementNode = statementNodeQuery(metaArgumentNode), combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
-                if (statementNode === null) {
-                    var metaArgumentString = context.nodeAsString(metaArgumentNode);
-                    context.error("Expected a statement but got a '".concat(metaArgumentString, "' meta-type."), metaArgumentNode);
-                } else {
-                    if (combinatorMetaTYpeNode === null) {
-                        var combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-                        context.error("Expected a meta-type but got a '".concat(combinatorMetaargumentString, "' statement."), metaArgumentNode);
-                    } else {
-                        var combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode), content = combinatorMetaTypeTerminalNode.getContent(), contentStatementMetaType = content === _metaTypes.STATEMENT_META_TYPE;
-                        if (!contentStatementMetaType) {
-                            context.error("Expected the meta-type to be 'Statement' but got '".concat(content, "'."), metaArgumentNode);
-                        } else {
-                            metaArgumentNodeVerified = true;
-                        }
-                    }
-                }
-                return metaArgumentNodeVerified;
-            }
-        }
-    ]);
-    return StatementVerifier;
-}(_verifier.default);
-var statementVerifier = new StatementVerifier();
-var _default = statementVerifier;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verifier/statement.js"],"sourcesContent":["\"use strict\";\n\nimport Verifier from \"../verifier\";\nimport verifyTerm from \"../verify/term\";\n\nimport { first } from \"../utilities/array\";\nimport { objectType } from \"../type\";\nimport { OBJECT_TYPE_NAME } from \"../typeNames\";\nimport { STATEMENT_META_TYPE } from \"../metaTypes\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from \"../ruleNames\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\"),\n      metaTypeNodeQuery = nodeQuery(\"/metaArgument/metaType!\"),\n      statementNodeQuery = nodeQuery(\"/metaArgument/statement!\"),\n      metaTypeTerminalNodeQuery = nodeQuery(\"/metaType/@meta-type\");\n\nclass StatementVerifier extends Verifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          combinatorNonTerminalNode = nonTerminalNodeB; ///\n\n    const ruleName = nonTerminalNode.getRuleName(), ///\n          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///\n\n    if (ruleName === combinatorRuleName) {\n      switch (ruleName) {\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                combinatorArgumentNode = combinatorNonTerminalNode, ///\n                argumentNodeVerified = this.verifyArgumentNode(argumentNode, combinatorArgumentNode, substitutions, context);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        case META_ARGUMENT_RULE_NAME: {\n          const metaArgumentNode = nonTerminalNode, ///\n                combinatorMetaargumentNode = combinatorNonTerminalNode, ///\n                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, substitutions, context);\n\n          nonTerminalNodeVerified = metaArgumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          const childNodes = nonTerminalNode.getChildNodes(),\n                combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),\n                nodesA = childNodes, ///\n                nodesB = combinatorChildNodes, ///\n                nodesVerified = this.verifyNodes(nodesA, nodesB, substitutions, context);\n\n          nonTerminalNodeVerified = nodesVerified; ///\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyArgumentNode(argumentNode, combinatorArgumentNode, substitutions, 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(combinatorArgumentNode),\n              typeName = typeNameFromTypeNode(typeNode),\n              type = (typeName === OBJECT_TYPE_NAME) ?\n                        objectType :  ///\n                          context.findTypeByTypeName(typeName),\n              statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);\n\n        if (statementTypeEqualToOrSubTypeOfType) {\n          argumentNodeVerified = true;\n        }\n      }\n    }\n\n    return argumentNodeVerified;\n  }\n\n  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, substitutions, context) {\n    let metaArgumentNodeVerified = false;\n\n    const statementNode = statementNodeQuery(metaArgumentNode),\n          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);\n\n    if (statementNode === null) {\n      const metaArgumentString = context.nodeAsString(metaArgumentNode);\n\n      context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);\n    } else {\n      if (combinatorMetaTYpeNode === null) {\n        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);\n\n        context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);\n      } else {\n        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),\n              content = combinatorMetaTypeTerminalNode.getContent(),\n              contentStatementMetaType = (content === STATEMENT_META_TYPE);\n\n        if (!contentStatementMetaType) {\n          context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);\n        } else {\n          metaArgumentNodeVerified = true;\n        }\n      }\n    }\n\n    return metaArgumentNodeVerified;\n  }\n}\n\nconst statementVerifier = new StatementVerifier();\n\nexport default statementVerifier;\n\n"],"names":["termNodeQuery","nodeQuery","typeNodeQuery","metaTypeNodeQuery","statementNodeQuery","metaTypeTerminalNodeQuery","StatementVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","substitutions","context","nonTerminalNodeVerified","nonTerminalNode","combinatorNonTerminalNode","ruleName","getRuleName","combinatorRuleName","ARGUMENT_RULE_NAME","argumentNode","combinatorArgumentNode","argumentNodeVerified","verifyArgumentNode","META_ARGUMENT_RULE_NAME","metaArgumentNode","combinatorMetaargumentNode","metaArgumentNodeVerified","verifyMetaargumentNode","childNodes","getChildNodes","combinatorChildNodes","nodesA","nodesB","nodesVerified","verifyNodes","termNode","argumentString","nodeAsString","error","types","termVerified","verifyTerm","firstType","first","termType","typeNode","typeName","typeNameFromTypeNode","type","OBJECT_TYPE_NAME","objectType","findTypeByTypeName","statementTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf","statementNode","combinatorMetaTYpeNode","metaArgumentString","combinatorMetaargumentString","combinatorMetaTypeTerminalNode","content","getContent","contentStatementMetaType","STATEMENT_META_TYPE","Verifier","statementVerifier"],"mappings":"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"}