occam-verify-cli 0.0.986 → 0.0.988

package/src/substitution/termForVariable.js

@@ -90,9 +90,8 @@ export default class TermForVariableSubstitution extends Substitution {
     const termNodeB = this.termNode,  ///
           termStringB = localContextB.nodeAsString(termNodeB),
           variableNodeA = this.variableNode,  ///
-          variableStringA = localContextA.nodeAsString(variableNodeA);
-
-    const string = `[${termStringB} for ${variableStringA}]`;
+          variableStringA = localContextA.nodeAsString(variableNodeA),
+          string = `[${termStringB} for ${variableStringA}]`;
 
     return string;
   }

package/src/unifier/statementWithCombinator.js

@@ -2,12 +2,14 @@
 
 import Unifier from "../unifier";
 import unifyTermWithType from "../unify/termWithType";
+import unifyFrameWithMetaType from "../unify/frameWithMetaType";
 import unifyStatementWithMetaType from "../unify/statementWithMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
+      frameNodeQuery = nodeQuery("/frame!"),
       metaTypeNodeQuery = nodeQuery("/metaType!"),
       statementNodeQuery = nodeQuery("/statement!");
 
@@ -36,6 +38,17 @@ class StatementWithCombinatorUnifier extends Unifier {
         return statementUnifiedWithMetaType;
       }
     },
+    {
+      nodeQueryA: frameNodeQuery,
+      nodeQueryB: metaTypeNodeQuery,
+      unify: (frameNodeA, metaTypeNodeB, assignments, stated, localContext) => {
+        const metaTypeNode = metaTypeNodeB, ///
+              frameNode = frameNodeA, ///
+              frameUnifiedWithMetaType = unifyFrameWithMetaType(frameNode, metaTypeNode, assignments, stated, localContext);
+
+        return frameUnifiedWithMetaType;
+      }
+    },
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,

package/src/unify/complexSubstitutionStatementWithSimpleSubstitutionStatement.js

@@ -5,6 +5,11 @@ import metaLevelUnifier from "../unifier/metaLevel";
 export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB) {
   let complexSubstitutionStatementWithSimpleSubstitutionStatement;
 
+  const complexSubstitutionStatementString = localContextB.nodeAsString(complexSubstitutionStatementNode),
+        simpleSubstitutionStatementString = localContextB.nodeAsString(simpleSubstitutionStatementNode);
+
+  localContextB.trace(`Unifying the complex substitution's '${complexSubstitutionStatementString}' statement with the simple substitution's '${simpleSubstitutionStatementString}' statement...`, simpleSubstitutionStatementNode);
+
   const nodeA = complexSubstitutionStatementNode,  ///
         nodeB = simpleSubstitutionStatementNode;  ///
 
@@ -14,5 +19,9 @@ export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionS
 
   complexSubstitutionStatementWithSimpleSubstitutionStatement = unified;  ///
 
+  if (complexSubstitutionStatementWithSimpleSubstitutionStatement) {
+    localContextB.trace(`...unified the complex substitution's '${complexSubstitutionStatementString}' statement with the simple substitution's '${simpleSubstitutionStatementString}' statement.`, simpleSubstitutionStatementNode);
+  }
+
   return complexSubstitutionStatementWithSimpleSubstitutionStatement;
 }

package/src/unify/frameWithMetaType.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import verifyFrameGivenMetaType from "../verify/frameGivenMetaType";
+
+export default function unifyFrameWithMetaType(frameNode, metaTypeNode, assignments, stated, localContext) {
+  let frameUnifiedWithMetaType;
+
+  const metaType = localContext.findMetaTypeByMetaTypeNode(metaTypeNode),
+        frameVerifiedGivenMetaType = verifyFrameGivenMetaType(frameNode, metaType, assignments, stated, localContext);
+
+  frameUnifiedWithMetaType = frameVerifiedGivenMetaType;  ///
+
+  return frameUnifiedWithMetaType;
+}

package/src/verify/assertion/contained.js

@@ -5,8 +5,8 @@ import metaLevelVerifier from "../../verifier/metaLevel";
 import { isAssertionNegated } from "../../utilities/assertion";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
-const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
-      metavariableNodeQuery = nodeQuery("/containedAssertion/frame/metavariable!"),
+const termVariableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
+      frameMetavariableNodeQuery = nodeQuery("/containedAssertion/frame/metavariable!"),
       statementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable"),
       statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement//metavariable");
 
@@ -56,56 +56,53 @@ function verifyDerivedContainedAssertion(containedAssertionNode, assignments, st
 
     localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`, containedAssertionNode);
 
-    const metavariableNode = metavariableNodeQuery(containedAssertionNode);
-
-    if (metavariableNode !== null) {
-      const assertionNegated = isAssertionNegated(containedAssertionNode),
-            variableNode = variableNodeQuery(containedAssertionNode),
-            negated = assertionNegated; ///
-
-      if (false) {
-        ///
-      } else if (metavariableNode !== null) {
-        const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
-              variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
-                const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
-
-                if (variableNodeMatchesStatementMetavariableNode) {
-                  return true;
-                }
-              });
-
-        if (!negated) {
-          if (variableNodeMatchesStatementMetavariableNode) {
-            derivedContainedAssertionVerified = true;
-          }
+    const assertionNegated = isAssertionNegated(containedAssertionNode),
+          frameMetavariableNode = frameMetavariableNodeQuery(containedAssertionNode),
+          termVariableNode = termVariableNodeQuery(containedAssertionNode),
+          negated = assertionNegated; ///
+
+    if (false) {
+      ///
+    } else if (frameMetavariableNode !== null) {
+      const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
+            frameMetavariableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
+              const frameMetavariableNodeMatchesStatementMetavariableNode = frameMetavariableNode.match(statementMetavariableNode);
+
+              if (frameMetavariableNodeMatchesStatementMetavariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (frameMetavariableNodeMatchesStatementMetavariableNode) {
+          derivedContainedAssertionVerified = true;
         }
+      }
 
-        if (negated) {
-          if (!variableNodeMatchesStatementMetavariableNode) {
-            derivedContainedAssertionVerified = true;
-          }
+      if (negated) {
+        if (!frameMetavariableNodeMatchesStatementMetavariableNode) {
+          derivedContainedAssertionVerified = true;
         }
-      } else if (variableNode !== null) {
-        const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
-              variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
-                const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
-
-                if (variableNodeMatchesStatementVariableNode) {
-                  return true;
-                }
-              });
-
-        if (!negated) {
-          if (variableNodeMatchesStatementVariableNode) {
-            derivedContainedAssertionVerified = true;
-          }
+      }
+    } else if (termVariableNode !== null) {
+      const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
+            termVariableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
+              const termVariableNodeMatchesStatementVariableNode = termVariableNode.match(statementVariableNode);
+
+              if (termVariableNodeMatchesStatementVariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (termVariableNodeMatchesStatementVariableNode) {
+          derivedContainedAssertionVerified = true;
         }
+      }
 
-        if (negated) {
-          if (!variableNodeMatchesStatementVariableNode) {
-            derivedContainedAssertionVerified = true;
-          }
+      if (negated) {
+        if (!termVariableNodeMatchesStatementVariableNode) {
+          derivedContainedAssertionVerified = true;
         }
       }
     }

package/src/verify/assertion/defined.js

@@ -55,43 +55,40 @@ function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated
 
     localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`, definedAssertionNode);
 
-    const metavariableNode = metavariableNodeQuery(definedAssertionNode);
-
-    if (metavariableNode !== null) {
-      const assertionNegated = isAssertionNegated(definedAssertionNode),
-        variableNode = variableNodeQuery(definedAssertionNode);
-
-      if (false) {
-        ///
-      } else if (metavariableNode !== null) {
-        const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);
-
-        if (!assertionNegated) {
-          if (metavariableDefinedByMetavariableName) {
-            derivedDefinedAssertionVerified = true;
-          }
+    const assertionNegated = isAssertionNegated(definedAssertionNode),
+          metavariableNode = metavariableNodeQuery(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode);
+
+    if (false) {
+      ///
+    } else if (metavariableNode !== null) {
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);
+
+      if (!assertionNegated) {
+        if (metavariableDefinedByMetavariableName) {
+          derivedDefinedAssertionVerified = true;
         }
+      }
 
-        if (assertionNegated) {
-          if (!metavariableDefinedByMetavariableName) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (assertionNegated) {
+        if (!metavariableDefinedByMetavariableName) {
+          derivedDefinedAssertionVerified = true;
         }
-      } else if (variableNode !== null) {
-        const variable = localContext.findVariableByVariableNode(variableNode),
-              variableDefined = localContext.isVariableDefined(variable);
-
-        if (!assertionNegated) {
-          if (variableDefined) {
-            derivedDefinedAssertionVerified = true;
-          }
+      }
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode),
+            variableDefined = localContext.isVariableDefined(variable);
+
+      if (!assertionNegated) {
+        if (variableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
+      }
 
-        if (assertionNegated) {
-          if (!variableDefined) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (assertionNegated) {
+        if (!variableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
       }
     }

package/src/verify/frame.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Frame from "../frame";
 import frameMetaType from "../metaType/frame";
 import verifyDeclaration from "../verify/declaration";
@@ -17,7 +18,7 @@ const verifyFrameFunctions = [
   verifyStatedFrame
 ];
 
-export default function verifyFrame(frameNode, frames, stated, localContext) {
+function verifyFrame(frameNode, frames, stated, localContext) {
   let frameVerified;
 
   const frameString = localContext.nodeAsString(frameNode);
@@ -39,6 +40,12 @@ export default function verifyFrame(frameNode, frames, stated, localContext) {
   return frameVerified;
 }
 
+Object.assign(shim, {
+  verifyFrame
+});
+
+export default verifyFrame;
+
 function verifyDerivedFrame(frameNode, frames, stated, localContext) {
   let derivedFrameVerified;
 

package/src/verify/frameGivenMetaType.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import shim from "../shim";
+
+import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+
+export default function verifyFrameGivenMetaType(frameNode, metaType, assignments, stated, localContext) {
+  let frameVerifiedGivenMetaType;
+
+  const metaTypeName = metaType.getName();
+
+  switch (metaTypeName) {
+    case FRAME_META_TYPE_NAME: {
+      const { verifyFrame } = shim,
+            frames = [],
+            frameVerified = verifyFrame(frameNode, frames, stated, localContext)
+
+      frameVerifiedGivenMetaType = frameVerified; ///
+
+      break;
+    }
+
+    default: {
+      debugger
+
+      break;
+    }
+  }
+
+  return frameVerifiedGivenMetaType;
+}

package/src/verify/statementGivenMetaType.js

@@ -16,6 +16,8 @@ export default function verifyStatementGivenMetaType(statementNode, metaType, as
   switch (metaTypeName) {
     case FRAME_META_TYPE_NAME:
     case REFERENCE_META_TYPE_NAME: {
+      debugger
+
       statementVerifiedGivenMetaType = false;
 
       const metavariableNode = metavariableNodeQuery(statementNode);