occam-verify-cli 0.0.834 → 0.0.836

package/src/verifier/nodes/equality.js

@@ -15,17 +15,11 @@ class EqualityNodesVerifier extends NodesVerifier {
     if (ruleNameA === ruleNameB) {
       switch (ruleNameA) {
         case TERM_RULE_NAME: {
-          const leftTermNode = nonTerminalNodeA, ///
-                rightTermNode = nonTerminalNodeB, ///
-                termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+          const termNodeA = nonTerminalNodeA, ///
+                termNodeB = nonTerminalNodeB, ///
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, collections, localContext, verifyAhead);
 
-          if (termNodesEqual) {
-            const verifiedAhead = verifyAhead();
-
-            nonTerminalNodeVerified = verifiedAhead;  ///
-          } else {
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
-          }
+          nonTerminalNodeVerified = termNodeVerified;  ///
 
           break;
         }
@@ -40,6 +34,27 @@ class EqualityNodesVerifier extends NodesVerifier {
 
     return nonTerminalNodeVerified;
   }
+
+  verifyTermNode(termNodeA, termNodeB, collections, localContext, verifyAhead) {
+    let termNodeVerified;
+
+    const leftTermNode = termNodeA, ///
+          rightTermNode = termNodeB, ///
+          termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+
+    if (termNodesEqual) {
+      const verifiedAhead = verifyAhead();
+
+      termNodeVerified = verifiedAhead;  ///
+    } else {
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB; ///
+
+      termNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+    }
+
+    return termNodeVerified;
+  }
 }
 
 const equalityNodesVerifier = new EqualityNodesVerifier();

package/src/verifier/nodes/intrinsicLevel.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
+
+import { nodeQuery } from "../../utilities/query";
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+const variableNodeQuery = nodeQuery("/term/variable!");
+
+class IntrinsicLevelNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const ruleName = nonTerminalNodeARuleName;  ///
+
+      switch (ruleName) {
+        case TERM_RULE_NAME: {
+          const termNodeA = nonTerminalNodeA,  ///
+                termNodeB = nonTerminalNodeB,  ///
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = termNodeVerified;  ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let termNodeVerified;
+
+    const variableNodeA = variableNodeQuery(termNodeA);
+
+    if (variableNodeA !== null) {
+      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+      termNodeVerified = variableNodeVerified; ///
+    } else {
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB, ///
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+      termNodeVerified = nonTerminalNodeVerified; ///
+    }
+
+    return termNodeVerified;
+  }
+}
+
+Object.assign(IntrinsicLevelNodesVerifier.prototype, intrinsicLevelNodesVerifierMixins);
+
+const intrinsicLevelNodesVerifier = new IntrinsicLevelNodesVerifier();
+
+export default intrinsicLevelNodesVerifier;

package/src/verifier/nodes/metaLevel.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+import metaLevelNodesVerifierMixins from "../../mixins/nodesVerifier/metaLevel";
+
+import { nodeQuery } from "../../utilities/query";
+import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
+
+const metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+
+class MetaLevelNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const ruleName = nonTerminalNodeARuleName;  ///
+
+      switch (ruleName) {
+        case METASTATEMENT_RULE_NAME: {
+          const metastatementNodeA = nonTerminalNodeA,  ///
+                metastatementNodeB = nonTerminalNodeB,  ///
+                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementNodeVerified;  ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+    let metastatementNodeVerified;
+
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if (metavariableNodeA !== null) {
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+
+      metastatementNodeVerified = metaVariableNodeVerified; ///
+    } else {
+      const nonTerminalNodeA = metastatementNodeA,  ///
+            nonTerminalNodeB = metastatementNodeB, ///
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+
+      metastatementNodeVerified = nonTerminalNodeVerified;  ///
+    }
+
+    return metastatementNodeVerified;
+  }
+}
+
+Object.assign(MetaLevelNodesVerifier.prototype, metaLevelNodesVerifierMixins);
+
+const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
+
+export default metaLevelNodesVerifier;

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -0,0 +1,170 @@
+"use strict";
+
+import LocalContext from "../../context/local";
+import NodesVerifier from "../../verifier/nodes";
+import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
+import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
+
+import { nodeQuery } from "../../utilities/query";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
+
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      statementNodeQuery = nodeQuery("/metaArgument/statement"),
+      metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+
+class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName();
+
+    switch (nonTerminalNodeARuleName) {
+      case METASTATEMENT_RULE_NAME: {
+        const metastatementNodeA = nonTerminalNodeA, ///
+              metaArgumentNodeVerified = this.verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+        nonTerminalNodeVerified = metaArgumentNodeVerified; ///
+
+        break;
+      }
+
+      case TERM_RULE_NAME: {
+        const termNodeA = nonTerminalNodeA, ///
+              termNodeVerified = this.verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+        nonTerminalNodeVerified = termNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let metastatementNodeVerified;
+
+    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    switch (nonTerminalNodeBRuleName) {
+      case META_ARGUMENT_RULE_NAME: {
+        const metaArgumentNodeB = nonTerminalNodeB, ///
+              metaArgumentNodeVerified = this.verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+        metastatementNodeVerified = metaArgumentNodeVerified; ///
+
+        break;
+      }
+
+      case STATEMENT_RULE_NAME: {
+        const statementNodeB = nonTerminalNodeB,  ///
+              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+        metastatementNodeVerified = statementNodeVerified;  ///
+
+        break;
+      }
+    }
+
+    return metastatementNodeVerified;
+  }
+
+  verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let metaArgumentNodeVerified = false;
+
+    const statementNodeB = statementNodeQuery(metaArgumentNodeB),
+          metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if ((metavariableNodeA !== null) && (statementNodeB !== null)) {
+      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+      metaArgumentNodeVerified = metavariableNodeVerified;  ///
+    }
+
+    return metaArgumentNodeVerified;
+  }
+
+  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let metavariableNodeVerified;
+
+    const substitution = substitutions.find((substitution) => {
+      const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
+
+      if (substitutionMatchesMetavariableNodeA) {
+        return true;
+      }
+    }) || null;
+
+    if (substitution !== null) {
+      const statementNode = statementNodeB, ///
+            statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+      metavariableNodeVerified = statementNodeMatches;  ///
+    } else {
+      const metavariableNode = metavariableNodeA, ///
+            statementNode = statementNodeB, ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
+            substitution = statementForMetavariableSubstitution;  ///
+
+      substitutions.push(substitution);
+
+      metavariableNodeVerified = true;
+    }
+
+    return metavariableNodeVerified;
+  }
+
+  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let statementNodeVerified;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeB = statementNodeB,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+          childNodesA = nonTerminalNodeAChildNodes, ///
+          childNodesB = nonTerminalNodeBChildNodes, ///
+          childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContextB, verifyAhead);
+
+    statementNodeVerified = childNodesVerified;  ///
+
+    return statementNodeVerified;
+  }
+
+  verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let termNodeVerified = false;
+
+    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    switch (nonTerminalNodeBRuleName) {
+      case TERM_RULE_NAME: {
+        const variableNodeA = variableNodeQuery(termNodeA);
+
+        if (variableNodeA !== null) {
+          const termNodeB = nonTerminalNodeB, ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
+                variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          termNodeVerified = variableNodeVerified; ///
+        } else {
+          const nonTerminalNodeA = termNodeA, ///
+                nonTerminalNodeB = termNodeB, ///
+                nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+          termNodeVerified = nonTerminalNodeVerified; ///
+        }
+      }
+    }
+
+    return termNodeVerified;
+  }
+}
+
+Object.assign(MetaLevelToIntrinsicLevelNodesVerifier.prototype, intrinsicLevelNodesVerifierMixins);
+
+const metaLevelToIntrinsicLevelNodesVerifier = new MetaLevelToIntrinsicLevelNodesVerifier();
+
+export default metaLevelToIntrinsicLevelNodesVerifier;

package/src/verifier/nodes/statement.js

@@ -16,23 +16,12 @@ class StatementNodesVerifier extends NodesVerifier {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNode = nonTerminalNodeA, ///
-          combinatorNonTerminalNode = nonTerminalNodeB; ///
-
-    const ruleName = nonTerminalNode.getRuleName(), ///
+          combinatorNonTerminalNode = nonTerminalNodeB, ///
+          ruleName = nonTerminalNode.getRuleName(), ///
           combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
 
     if (ruleName === combinatorRuleName) {
       switch (ruleName) {
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
-
-          nonTerminalNodeVerified = argumentNodeVerified; ///
-
-          break;
-        }
-
         case META_ARGUMENT_RULE_NAME: {
           const metaArgumentNode = nonTerminalNode, ///
                 combinatorMetaargumentNode = combinatorNonTerminalNode, ///
@@ -43,6 +32,16 @@ class StatementNodesVerifier extends NodesVerifier {
           break;
         }
 
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                constructorArgumentNode = combinatorNonTerminalNode, ///
+                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
         default: {
           nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
 

package/src/verifier/nodes/term.js

@@ -10,10 +10,12 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!");
 
 class TermNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
-    const ruleName = nonTerminalNode.getRuleName(), ///
+    const nonTerminalNode = nonTerminalNodeA, ///
+          constructorNonTerminalNode = nonTerminalNodeB, ///
+          ruleName = nonTerminalNode.getRuleName(), ///
           constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
 
     if (ruleName === constructorRuleName) {

package/src/verify/containment.js

@@ -4,9 +4,8 @@ import { third } from "../utilities/array";
 import { CONTAINED } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const statementVariableNodesQuery = nodesQuery("/statement//variable");
-
-export const containmentVariableNodeQuery = nodeQuery("/containment/argument/term/variable!");
+const statementVariableNodesQuery = nodesQuery("/statement//variable"),
+      containmentVariableNodeQuery = nodeQuery("/containment/argument/term/variable!");
 
 export default function verifyContainment(containmentNode, statementNode) {
   let containmentVerified = false;

package/src/verify/statement.js

@@ -7,10 +7,9 @@ import verifyTypeAssertion from "../verify/typeAssertion";
 import statementNodesVerifier from "../verifier/nodes/statement";
 
 import { nodeQuery } from "../utilities/query";
-import { containmentVariableNodeQuery } from "../verify/containment";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      statementNodeQuery = nodeQuery("/statement/statement!"),
+      statementNodeQuery = nodeQuery("/statement/metaArgument/statement!"),
       containmentNodeQuery = nodeQuery("/statement/containment!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
@@ -120,37 +119,37 @@ function verifyStatementWithContainment(statementNode, assignments, derived, con
   const containmentNode = containmentNodeQuery(statementNode);
 
   if (containmentNode !== null) {
-    statementNode = statementNodeQuery(statementNode);  ///
+    const statementString = context.nodeAsString(statementNode);
 
-    const statementString = context.nodeAsString(statementNode),
-          containmentVariableNode = containmentVariableNodeQuery(containmentNode),
-          containmentVariableString = context.nodeAsString(containmentVariableNode);
+    statementNode = statementNodeQuery(statementNode);  ///
 
-    context.trace(`Verifying that the '${containmentVariableString}' is either contained in or omitted from the '${statementString}' statement...`, statementNode);
+    if (statementNode !== null) {
+      context.trace(`Verifying the '${statementString}' statement with containment...`, statementNode);
 
-    const containmentVerified = verifyContainment(containmentNode, statementNode);
+      const containmentVerified = verifyContainment(containmentNode, statementNode);
 
-    if (containmentVerified) {
-      const verifyStatementFunctions = [
-        verifyStatementAsEquality,
-        verifyStatementAgainstCombinators
-      ];
+      if (containmentVerified) {
+        const verifyStatementFunctions = [
+          verifyStatementAsEquality,
+          verifyStatementAgainstCombinators
+        ];
 
-      const statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
-        const derived = false,
-              assignments = [],
-              statementVerified = verifyStatementFunction(statementNode, assignments, derived, context, verifyAhead);
+        const statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
+          const derived = false,
+                assignments = [],
+                statementVerified = verifyStatementFunction(statementNode, assignments, derived, context, verifyAhead);
 
-        if (statementVerified) {
-          return true;
-        }
-      });
+          if (statementVerified) {
+            return true;
+          }
+        });
 
-      statementVerifiedWithContainment = statementVerified; ///
-    }
+        statementVerifiedWithContainment = statementVerified; ///
+      }
 
-    if (statementVerifiedWithContainment) {
-      context.debug(`...verified that '${containmentVariableString}' is either contained in or omitted from the '${statementString}' statement.`, statementNode);
+      if (statementVerifiedWithContainment) {
+        context.debug(`...verified the '${statementString}' statement with containment.`, statementNode);
+      }
     }
   }