occam-verify-cli 0.0.835 → 0.0.837

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -1,83 +1,103 @@
 "use strict";
 
+import LocalContext from "../../context/local";
 import NodesVerifier from "../../verifier/nodes";
-import TermForVariableSubstitution from "../../substitution/termForVariable";
+import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../../utilities/query";
-import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
-const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
-      metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      statementNodeQuery = nodeQuery("/metaArgument/statement"),
+      metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext) {
-    let nonTerminalNodeVerified = false;
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
-          nonTerminalNodeBRuleNameMetaArgumentRuleName = (nonTerminalNodeBRuleName === META_ARGUMENT_RULE_NAME);
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName();
 
-    if (nonTerminalNodeBRuleNameMetaArgumentRuleName) {
-      const metaArgumentNodeB = nonTerminalNodeB, ///
-            metaArgumentChildNodeB = metaArgumentChildNodeNodeQuery(metaArgumentNodeB);
+    switch (nonTerminalNodeARuleName) {
+      case METASTATEMENT_RULE_NAME: {
+        const metastatementNodeA = nonTerminalNodeA, ///
+              metaArgumentNodeVerified = this.verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
 
-      nonTerminalNodeB = metaArgumentChildNodeB;  ///
+        nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
-      nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext);
-    } else {
-      const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-            nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
-            nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
-            nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
-
-      if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
-        const metastatementNodeA = nonTerminalNodeA,  ///
-              statementNodeB = nonTerminalNodeB,  ///
-              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContext);
-
-        if (statementNodeVerified) {
-          nonTerminalNodeVerified = true;  ///
-        } else {
-          const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-                nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-                childNodesA = nonTerminalNodeAChildNodes, ///
-                childNodesB = nonTerminalNodeBChildNodes, ///
-                childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContext);
+        break;
+      }
 
-          nonTerminalNodeVerified = childNodesVerified;  ///
-        }
-      } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext);
+      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;
   }
 
-  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContext) {
-    let statementNodeVerified = false;
+  verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let metastatementNodeVerified;
+
+    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
 
-    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+    switch (nonTerminalNodeBRuleName) {
+      case META_ARGUMENT_RULE_NAME: {
+        const metaArgumentNodeB = nonTerminalNodeB, ///
+              metaArgumentNodeVerified = this.verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead);
 
-    if (metavariableNodeA !== null) {
-      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext);
+        metastatementNodeVerified = metaArgumentNodeVerified; ///
+
+        break;
+      }
 
-      statementNodeVerified = metavariableNodeVerified; ///
+      case STATEMENT_RULE_NAME: {
+        const statementNodeB = nonTerminalNodeB,  ///
+              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+        metastatementNodeVerified = statementNodeVerified;  ///
+
+        break;
+      }
     }
 
-    return statementNodeVerified;
+    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, localContext) {
+  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
     let metavariableNodeVerified;
 
     const substitution = substitutions.find((substitution) => {
-            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
+      const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
-            if (substitutionMatchesMetavariableNodeA) {
-              return true;
-            }
-          }) || null;
+      if (substitutionMatchesMetavariableNodeA) {
+        return true;
+      }
+    }) || null;
 
     if (substitution !== null) {
       const statementNode = statementNodeB, ///
@@ -97,8 +117,54 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
     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,9 +16,8 @@ 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) {

package/src/verifier/nodes/term.js

@@ -14,9 +14,8 @@ class TermNodesVerifier extends NodesVerifier {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNode = nonTerminalNodeA, ///
-          constructorNonTerminalNode = nonTerminalNodeB; ///
-
-    const ruleName = nonTerminalNode.getRuleName(), ///
+          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);
+      }
     }
   }