occam-verify-cli 0.0.869 → 0.0.871

package/src/verify/typeAssertion.js

@@ -1,12 +1,11 @@
 "use strict";
 
 import Variable from "../variable";
+import verifyTerm from "../verify/term";
 import VariableAssignment from "../assignment/variable";
-import verifyTermAndGivenType from "../verify/termAndGivenType";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
-import { verifyTermAsGivenVariable } from "./term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),
@@ -21,7 +20,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
 
   const verifyTypeAssertionFunctions = [
     verifyDerivedTypeAssertion,
-    verifyGivenTypeAssertion
+    verifyStatedTypeAssertion
   ];
 
   typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
@@ -48,38 +47,39 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
     localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);
 
     const terms = [],
-          types = [],
           termNode = termNodeQuery(typeAssertionNode),
-          typeNode = typeNodeQuery(typeAssertionNode),
-          termAndGivenTypeVerified = verifyTermAndGivenType(termNode, typeNode, terms, types, localContext, () => {
+          termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const firstTerm = first(terms),
-                  firstType = first(types),
-                  term = firstTerm, ///
-                  type = firstType, ///
-                  termType = localContext.getTermType(term),
-                  typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
+            const typeNode = typeNodeQuery(typeAssertionNode),
+                  type = localContext.findTypeByTypeNode(typeNode);
 
-            if (typeEqualToOrSuperTypeOfTermType) {
-              const variableNode = variableNodeQuery(termNode);
+            if (type !== null) {
+              const firstTerm = first(terms),
+                    term = firstTerm, ///
+                    termType = localContext.getTermType(term),
+                    typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
 
-              if (variableNode === null) {
-                verifiedAhead = verifyAhead();
-              } else {
-                let variable = localContext.findVariableByVariableNode(variableNode);
+              if (typeEqualToOrSuperTypeOfTermType) {
+                const variableNode = variableNodeQuery(termNode);
 
-                variable = Variable.fromVariableAndType(variable, type);
+                if (variableNode === null) {
+                  verifiedAhead = verifyAhead();
+                } else {
+                  let variable = localContext.findVariableByVariableNode(variableNode);
 
-                const variableAssignment = VariableAssignment.fromVariable(variable),
-                      assignment = variableAssignment;  ///
+                  variable = Variable.fromVariableAndType(variable, type);
 
-                assignments.push(assignment);
+                  const variableAssignment = VariableAssignment.fromVariable(variable),
+                        assignment = variableAssignment;  ///
 
-                verifiedAhead = verifyAhead();
+                  assignments.push(assignment);
 
-                if (!verifiedAhead) {
-                  assignments.pop();
+                  verifiedAhead = verifyAhead();
+
+                  if (!verifiedAhead) {
+                    assignments.pop();
+                  }
                 }
               }
             }
@@ -87,7 +87,7 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
             return verifiedAhead;
           });
 
-    derivedTypeAssertionVerified = termAndGivenTypeVerified; ///
+    derivedTypeAssertionVerified = termVerified; ///
 
     if (derivedTypeAssertionVerified) {
       localContext.trace(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);
@@ -97,47 +97,48 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
   return derivedTypeAssertionVerified;
 }
 
-function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
-  let givenTypeAssertionVerified = false;
+function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
+  let statedTypeAssertionVerified = false;
 
   if (!derived) {
     const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
-    localContext.trace(`Verifying the '${typeAssertionString}' given type assertion...`, typeAssertionNode);
+    localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`, typeAssertionNode);
 
     const terms = [],
-          types = [],
           termNode = termNodeQuery(typeAssertionNode),
-          typeNode = typeNodeQuery(typeAssertionNode),
-          termAndGivenTypeVerified = verifyTermAndGivenType(termNode, typeNode, terms, types, localContext, () => {
+          termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const firstTerm = first(terms),
-                  firstType = first(types),
-                  term = firstTerm, ///
-                  type = firstType, ///
-                  termType = term.getType(),
-                  typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
+            const typeNode = typeNodeQuery(typeAssertionNode),
+                  type = localContext.findTypeByTypeNode(typeNode);
+
+            if (type !== null) {
+              const firstTerm = first(terms),
+                    term = firstTerm, ///
+                    termType = term.getType(),
+                    typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
 
-            if (typeEqualToOrSubTypeOfTermType) {
-              const variableNode = variableNodeQuery(termNode);
+              if (typeEqualToOrSubTypeOfTermType) {
+                const variableNode = variableNodeQuery(termNode);
 
-              if (variableNode === null) {
-                verifiedAhead = verifyAhead();
-              } else {
-                let variable = localContext.findVariableByVariableNode(variableNode);
+                if (variableNode === null) {
+                  verifiedAhead = verifyAhead();
+                } else {
+                  let variable = localContext.findVariableByVariableNode(variableNode);
 
-                variable = Variable.fromVariableAndType(variable, type);
+                  variable = Variable.fromVariableAndType(variable, type);
 
-                const variableAssignment = VariableAssignment.fromVariable(variable),
-                      assignment = variableAssignment;  ///
+                  const variableAssignment = VariableAssignment.fromVariable(variable),
+                        assignment = variableAssignment;  ///
 
-                assignments.push(assignment);
+                  assignments.push(assignment);
 
-                verifiedAhead = verifyAhead();
+                  verifiedAhead = verifyAhead();
 
-                if (!verifiedAhead) {
-                  assignments.pop();
+                  if (!verifiedAhead) {
+                    assignments.pop();
+                  }
                 }
               }
             }
@@ -145,12 +146,12 @@ function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, local
             return verifiedAhead;
           });
 
-    givenTypeAssertionVerified = termAndGivenTypeVerified; ///
+    statedTypeAssertionVerified = termVerified; ///
 
-    if (givenTypeAssertionVerified) {
-      localContext.trace(`...verified the '${typeAssertionString}' given type assertion.`, typeAssertionNode);
+    if (statedTypeAssertionVerified) {
+      localContext.trace(`...verified the '${typeAssertionString}' stated type assertion.`, typeAssertionNode);
     }
   }
 
-  return givenTypeAssertionVerified;
+  return statedTypeAssertionVerified;
 }

package/src/verify/variable.js

@@ -2,7 +2,6 @@
 
 import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
-import verifyGivenVariable from "../verify/givenVariable";
 
 import { objectType } from "../type";
 
@@ -54,16 +53,19 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
 }
 
 export function verifyStandaloneVariable(variableNode, localContext, verifyAhead) {
-  let standaloneVariableVerified;
+  let standaloneVariableVerified = false;
 
   const variableString = localContext.nodeAsString(variableNode);
 
   localContext.trace(`Verifying the '${variableString}' standalone variable...`, variableNode);
 
-  const variables = [],
-        givenVariableVerified = verifyGivenVariable(variableNode, variables, localContext, verifyAhead);
+  const variablePresent = localContext.isVariablePresentByVariableNode(variableNode);
 
-  standaloneVariableVerified = givenVariableVerified; ///
+  if (variablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneVariableVerified = verifiedAhead; ///
+  }
 
   if (standaloneVariableVerified) {
     localContext.debug(`...verified the '${variableString}' standalone variable.`, variableNode);

package/src/verify/variableAgainstTerm.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import verifyTerm from "../verify/term";
+import TermForVariableSubstitution from "../substitution/termForVariable";
+
+import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable");
+
+export default function verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead) {
+  let variableVerifiedAgainstTerm = false;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNode);
+
+    if (substitutionMatchesVariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const termNodeMatches = substitution.matchTermNode(termNode);
+
+    if (termNodeMatches) {
+      const verifiedAhead = verifyAhead();
+
+      variableVerifiedAgainstTerm = verifiedAhead;  ///
+    }
+  } else {
+    const variableA = localContextA.findVariableByVariableNode(variableNode);
+
+    if (variableA !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContextB, () => {
+              let verifiedAhead = false;
+
+              const firstTerm = first(terms),
+                    termB = firstTerm, ///
+                    variableB = variableFromTerm(termB, localContextB);
+
+              if (variableA === variableB) {
+                verifiedAhead = verifyAhead();
+              } else {
+                const term = termB, ///
+                      variable = variableA, ///
+                      termType = term.getType(),
+                      variableType = variable.getType(),
+                      variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+
+                if (variableTypeEqualToOrSuperTypeOfTermType) {
+                  const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+                        substitution = termForVariableSubstitution;  ///
+
+                  substitutions.push(substitution);
+
+                  verifiedAhead = verifyAhead();
+
+                  if (!verifiedAhead) {
+                    substitutions.pop();
+                  }
+                }
+              }
+
+              return verifiedAhead;
+            });
+
+      variableVerifiedAgainstTerm = termVerified;  ///
+    }
+  }
+
+  return variableVerifiedAgainstTerm;
+}
+
+function variableFromTerm(term, localContext) {
+  let variable = null;
+
+  const termNode = term.getNode(),
+        variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    variable = localContext.findVariableByVariableNode(variableNode);
+  }
+
+  return variable;
+}