occam-verify-cli 0.0.965 → 0.0.968

package/src/verify/statement/qualified.js

@@ -7,12 +7,6 @@ import { nodeQuery } from "../../utilities/query";
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
-
 const unifyDerivedQualifiedStatementFunctions = [
   unifyDerivedQualifiedStatementAWithRule,
   unifyDerivedQualifiedStatementAWithAxiom,
@@ -33,13 +27,9 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
         statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
   if (statementVerified) {
-    if (derived) {
-      const derivedQualifiedStatementVerified = verifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
+    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
 
-      qualifiedStatementVerified = derivedQualifiedStatementVerified; ///
-    } else {
-      qualifiedStatementVerified = true;
-    }
+    qualifiedStatementVerified = derivedQualifiedStatementUnified; ///
   }
 
   if (qualifiedStatementVerified) {
@@ -49,56 +39,24 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function verifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementVerified = false;
+function unifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnified;
 
   const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-  localContext.trace(`Verifying the '${qualifiedStatementString}' derived qualified statement...`, qualifiedStatementNode);
-
-  if (!derivedQualifiedStatementVerified) {
-    const derivedQualifiedStatementVerifiedTrivially = verifyDerivedQualifiedStatementATrivially(qualifiedStatementNode, substitutions, localContext);
-
-    derivedQualifiedStatementVerified = derivedQualifiedStatementVerifiedTrivially; ///
-  }
-
-  if (!derivedQualifiedStatementVerified) {
-    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunctions.some((unifyDerivedQualifiedStatementFunction) => {
-      const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
+  localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement...`, qualifiedStatementNode);
 
-      return derivedQualifiedStatementUnified;
-    });
+  derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunctions.some((unifyDerivedQualifiedStatementFunction) => {
+    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
 
-    derivedQualifiedStatementVerified = derivedQualifiedStatementUnified; ///
-  }
-
-  if (derivedQualifiedStatementVerified) {
-    localContext.debug(`...verified the '${qualifiedStatementString}' derived qualified statement.`, qualifiedStatementNode);
-  }
-
-  return derivedQualifiedStatementVerified;
-}
+    return derivedQualifiedStatementUnified;
+  });
 
-function verifyDerivedQualifiedStatementATrivially(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementVerifiedTrivially = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode);
-
-  if (metavariableNode === null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement trivially...`, qualifiedStatementNode);
-
-    debugger
-
-
-    if (derivedQualifiedStatementVerifiedTrivially) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement trivially.`, qualifiedStatementNode);
-    }
+  if (derivedQualifiedStatementUnified) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement.`, qualifiedStatementNode);
   }
 
-  return derivedQualifiedStatementVerifiedTrivially;
+  return derivedQualifiedStatementUnified;
 }
 
 function unifyDerivedQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {

package/src/verify/statement/unqualified.js

@@ -3,6 +3,7 @@
 import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
+import { verifyStatementTrivially } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -18,9 +19,15 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
   if (statementVerified) {
     if (derived) {
-      const derivedUnqualifiedStatementVerified = verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext);
+      const statementVerifiedTrivially = verifyStatementTrivially(statementNode, localContext);
 
-      unqualifiedStatementVerified = derivedUnqualifiedStatementVerified; ///
+      if (statementVerifiedTrivially) {
+        unqualifiedStatementVerified = true;
+      } else {
+        const derivedUnqualifiedStatementUnified = unifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext);
+
+        unqualifiedStatementVerified = derivedUnqualifiedStatementUnified; ///
+      }
     } else {
       unqualifiedStatementVerified = true;
     }
@@ -33,21 +40,21 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   return unqualifiedStatementVerified;
 }
 
-function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext) {
-  let derivedUnqualifiedStatementVerified;
+function unifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext) {
+  let derivedUnqualifiedStatementUnified;
 
   const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
-  localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
+  localContext.trace(`Unifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
 
   const statementNode = statementNodeQuery(unqualifiedStatementNode),
         statementUnified = localContext.unifyStatement(statementNode, localContext);
 
-  derivedUnqualifiedStatementVerified = statementUnified;  ///
+  derivedUnqualifiedStatementUnified = statementUnified;  ///
 
-  if (derivedUnqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
+  if (derivedUnqualifiedStatementUnified) {
+    localContext.debug(`...unified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
   }
 
-  return derivedUnqualifiedStatementVerified;
+  return derivedUnqualifiedStatementUnified;
 }

package/src/verify/statement.js

@@ -89,6 +89,30 @@ Object.assign(shim, {
 
 export default verifyStatement;
 
+export function verifyStatementTrivially(statementNode, localContext) {
+  let statementVerifiedTrivially = false;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Verifying the '${statementString}' statement trivially...`, statementNode);
+
+  const equalityNode = equalityNodeQuery(statementNode),
+        judgementNode = judgementNodeQuery(statementNode),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if ((equalityNode !== null) || (judgementNode !== null) || (typeAssertionNode !== null) || (definedAssertionNode !== null) || (containedAssertionNode !== null)) {
+    statementVerifiedTrivially = true;
+  }
+
+  if (statementVerifiedTrivially) {
+    localContext.debug(`...verified the '${statementString}' statement trivially.`, statementNode);
+  }
+
+  return statementVerifiedTrivially;
+}
+
 function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsMetavariable = false;
 

package/src/verify/statementGivenMetaType.js

@@ -2,7 +2,10 @@
 
 import shim from "../shim";
 
-import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+import { nodeQuery } from "../utilities/query";
+import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+
+const metavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 export default function verifyStatementGivenMetaType(statementNode, metaType, assignments, derived, localContext) {
   let statementVerifiedGivenMetaType;
@@ -10,9 +13,23 @@ export default function verifyStatementGivenMetaType(statementNode, metaType, as
   const metaTypeName = metaType.getName();
 
   switch (metaTypeName) {
-    case FRAME_META_TYPE_NAME: {
+    case FRAME_META_TYPE_NAME:
+    case REFERENCE_META_TYPE_NAME: {
+      statementVerifiedGivenMetaType = false;
+
+      const metavariableNode = metavariableNodeQuery(statementNode);
+
+      if (metavariableNode !== null) {
+        const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+
+        if (metavariable !== null) {
+          const metavariableMetaType = metavariable.getMetaType();
 
-      debugger
+          if (metavariableMetaType === metaType) {
+            statementVerifiedGivenMetaType = true;
+          }
+        }
+      }
 
       break;
     }
@@ -21,16 +38,10 @@ export default function verifyStatementGivenMetaType(statementNode, metaType, as
       const { verifyStatement } = shim,
             statementVerified = verifyStatement(statementNode, assignments, derived, localContext)
 
-      statementVerifiedGivenMetaType = statementVerified;
+      statementVerifiedGivenMetaType = statementVerified; ///
 
       break;
     }
-
-    default: {
-
-      debugger
-
-    }
   }
 
   return statementVerifiedGivenMetaType;