occam-verify-cli 0.0.946 → 0.0.948

package/src/verify/assertion/type.js

@@ -6,6 +6,7 @@ import VariableAssignment from "../../assignment/variable";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
+import local from "../../context/local";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),
@@ -46,39 +47,43 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
 
     localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);
 
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          type = localContext.findTypeByTypeNode(typeNode);
+
+    if (type === null) {
+      const typeString = localContext.nodeAsString(typeNode);
+
+      localContext.debug(`The '${typeString}' type is not present.`, typeNode);
+    }
+
     const terms = [],
           termNode = termNodeQuery(typeAssertionNode),
           termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const typeNode = typeNodeQuery(typeAssertionNode),
-                  type = localContext.findTypeByTypeNode(typeNode);
-
-            if (type !== null) {
-              const firstTerm = first(terms),
-                    term = firstTerm, ///
-                    termType = localContext.getTermType(term),
-                    typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
+            const firstTerm = first(terms),
+                  term = firstTerm, ///
+                  termType = localContext.getTermType(term),
+                  typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
 
-              if (typeEqualToOrSuperTypeOfTermType) {
-                const variableNode = variableNodeQuery(termNode);
+            if (typeEqualToOrSuperTypeOfTermType) {
+              const variableNode = variableNodeQuery(termNode);
 
-                if (variableNode === null) {
-                  verifiedAhead = true;
-                } else {
-                  let variable = localContext.findVariableByVariableNode(variableNode);
+              if (variableNode === null) {
+                verifiedAhead = true;
+              } else {
+                let variable;
 
-                  variable = Variable.fromVariableAndType(variable, type);
+                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 = true;
+                assignments.push(assignment);
 
-                  assignments.pop();
-                }
+                verifiedAhead = true;
               }
             }
 
@@ -103,39 +108,43 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
 
     localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`, typeAssertionNode);
 
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          type = localContext.findTypeByTypeNode(typeNode);
+
+    if (type === null) {
+      const typeString = localContext.nodeAsString(typeNode);
+
+      localContext.debug(`The '${typeString}' type is not present.`, typeNode);
+    }
+
     const terms = [],
           termNode = termNodeQuery(typeAssertionNode),
           termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const typeNode = typeNodeQuery(typeAssertionNode),
-                  type = localContext.findTypeByTypeNode(typeNode);
-
-            if (type !== null) {
-              const firstTerm = first(terms),
-                    term = firstTerm, ///
-                    termType = term.getType(),
-                    typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
+            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 = true;
-                } else {
-                  let variable = localContext.findVariableByVariableNode(variableNode);
+              if (variableNode === null) {
+                verifiedAhead = true;
+              } else {
+                let variable;
 
-                  variable = Variable.fromVariableAndType(variable, type);
+                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 = true;
+                assignments.push(assignment);
 
-                  assignments.pop();
-                }
+                verifiedAhead = true;
               }
             }
 

package/src/verify/term.js

@@ -5,7 +5,6 @@ import Term from "../term";
 import bracketedConstructor from "../constructor/bracketed";
 import termAgainstConstructorUnifier from "../unifier/termAgainstConstructor";
 
-import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term/argument/term"),
@@ -69,7 +68,7 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
 
       terms.pop();
 
-      termVerifiedAsVariable = verifiedAhead;  ///
+      termVerifiedAsVariable = verifiedAhead; ///
     }
 
     if (termVerifiedAsVariable) {
@@ -104,90 +103,58 @@ function unifyTermAgainstBracketedConstructor(termNode, terms, localContext, ver
   let termUnifiedAgainstBracketedConstructor;
 
   const termString = localContext.nodeAsString(termNode),
-        bracketedConstructorString = bracketedConstructor.getString();
+        bracketedTerms = [];
 
-  localContext.trace(`Unifying the '${termString}' term against the '${bracketedConstructorString}' bracketed constructor...`, termNode);
+  localContext.trace(`Unifying the '${termString}' term against the bracketed constructor...`, termNode);
 
-  const bracketedConstructorTermNode = bracketedConstructor.getTermNode(),
-        termNodeA = termNode,  ///
-        constructorTermNodeB = bracketedConstructorTermNode,  ///
-        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext, () => {
-          let verifiedAhead;
+  termUnifiedAgainstBracketedConstructor = unifyTermAgainstConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
+    let verifiedAhead;
 
-          const bracketedTermNode = termNode; ///
+    const bracketedTermNode = termNode; ///
 
-          termNode = termNodeQuery(termNode); ///
+    termNode = termNodeQuery(bracketedTermNode); ///
 
-          if (termNode === null) {
-            verifiedAhead = false;
-          } else {
-            let type;
+    const termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
 
-            verifyTerm(termNode, terms, localContext, () => {
-              let verifiedAhead;
+    verifiedAhead = termVVerified;  ///
 
-              const firstTerm = first(terms),
-                    term = firstTerm; ///
-
-              type = term.getType();
-
-              verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-            terms.pop();
-
-            termNode = bracketedTermNode; ///
-
-            const term = Term.fromTermNodeAndType(termNode, type);
-
-            terms.push(term);
-
-            verifiedAhead = verifyAhead();
-
-            terms.pop();
-          }
-
-          return verifiedAhead;
-        });
-
-  termUnifiedAgainstBracketedConstructor = unified;  ///
+    return verifiedAhead;
+  });
 
   if (termUnifiedAgainstBracketedConstructor) {
-    localContext.debug(`...unified the '${termString}' term against the '${bracketedConstructorString}' constructor.`, termNode);
+    localContext.debug(`...unified the '${termString}' term against the bracketed constructor.`, termNode);
   }
 
   return termUnifiedAgainstBracketedConstructor;
 }
 
 function unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termUnifiedAgainstConstructor;
+  let termUnifiedAgainstConstructor = false;
 
   const termString = localContext.nodeAsString(termNode),
-        constructorString = constructor.getString();
+        constructorString = constructor.getString(),
+        constructorTermNode = constructor.getTermNode();
 
   localContext.trace(`Unifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
-  const constructorTermNode = constructor.getTermNode(),
-        termNodeA = termNode,  ///
+  const termNodeA = termNode,  ///
         constructorTermNodeB = constructorTermNode,  ///
-        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext, () => {
-          let verifiedAhead;
+        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
 
-          const type = constructor.getType(),
-                term = Term.fromTermNodeAndType(termNode, type);
+  if (unified) {
+    let verifiedAhead;
 
-          terms.push(term);
+    const type = constructor.getType(),
+          term = Term.fromTermNodeAndType(termNode, type);
 
-          verifiedAhead = verifyAhead();
+    terms.push(term);
 
-          terms.pop();
+    verifiedAhead = verifyAhead();
 
-          return verifiedAhead;
-        });
+    terms.pop();
 
-  termUnifiedAgainstConstructor = unified;  ///
+    termUnifiedAgainstConstructor = verifiedAhead;  ///
+  }
 
   if (termUnifiedAgainstConstructor) {
     localContext.debug(`...unified the '${termString}' term against the '${constructorString}' constructor.`, termNode);