occam-verify-cli 0.0.535 → 0.0.536

package/src/verifier/statementForMetavariable.js

@@ -12,7 +12,7 @@ const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
 
 export default class StatementForMetavariableVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeVerifies = false;
+    let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
           nonTerminalNodeBRuleNameMetaArgumentRuleName = (nonTerminalNodeBRuleName === META_ARGUMENT_RULE_NAME);
@@ -23,7 +23,7 @@ export default class StatementForMetavariableVerifier extends Verifier {
 
       nonTerminalNodeB = metaArgumentChildNodeB;  ///
 
-      nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
     } else {
       const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
             nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
@@ -33,10 +33,10 @@ export default class StatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               statementNodeB = nonTerminalNodeB,  ///
-              statementNodeVerifies = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions);
+              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions);
 
-        if (statementNodeVerifies) {
-          nonTerminalNodeVerifies = true;  ///
+        if (statementNodeVerified) {
+          nonTerminalNodeVerified = true;  ///
         } else {
           const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
@@ -44,32 +44,32 @@ export default class StatementForMetavariableVerifier extends Verifier {
                 nodesB = nonTerminalNodeBChildNodes, ///
                 nodesMatch = this.verifyNodes(nodesA, nodesB, substitutions);
 
-          nonTerminalNodeVerifies = nodesMatch;  ///
+          nonTerminalNodeVerified = nodesMatch;  ///
         }
       } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-        nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
     }
 
-    return nonTerminalNodeVerifies;
+    return nonTerminalNodeVerified;
   }
 
   verifyStatementNode(metastatementNodeA, statementNodeB, substitutions) {
-    let statementNodeVerifies = false;
+    let statementNodeVerified = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metavariableNodeVerifies = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
+      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
 
-      statementNodeVerifies = metavariableNodeVerifies; ///
+      statementNodeVerified = metavariableNodeVerified; ///
     }
 
-    return statementNodeVerifies;
+    return statementNodeVerified;
   }
 
   verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
-    let metavariableNodeVerifies;
+    let metavariableNodeVerified;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
           substitution = substitutions.find((substitution) => {
@@ -84,7 +84,7 @@ export default class StatementForMetavariableVerifier extends Verifier {
       const statementNode = statementNodeB, ///
             statementNodeMatches = substitution.matchStatementNode(statementNode);
 
-      metavariableNodeVerifies = statementNodeMatches;  ///
+      metavariableNodeVerified = statementNodeMatches;  ///
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -97,9 +97,9 @@ export default class StatementForMetavariableVerifier extends Verifier {
         substitutions.push(substitution);
       }
 
-      metavariableNodeVerifies = true;
+      metavariableNodeVerified = true;
     }
 
-    return metavariableNodeVerifies;
+    return metavariableNodeVerified;
   }
 }

package/src/verifier/termForVariable.js

@@ -11,7 +11,7 @@ const variableNodeQuery = nodeQuery('/term/variable!');
 
 export default class TermForVariableVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeVerifies = false;
+    let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -23,37 +23,37 @@ export default class TermForVariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeVerifies = this.verifyTermNode(termNodeA, termNodeB, substitutions);
+              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions);
 
-        if (termNodeVerifies) {
-          nonTerminalNodeVerifies = true;  ///
+        if (termNodeVerified) {
+          nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
         }
       } else {
-        nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
     }
 
-    return nonTerminalNodeVerifies;
+    return nonTerminalNodeVerified;
   }
 
   verifyTermNode(termNodeA, termNodeB, substitutions) {
-    let termNodeVerifies = false;
+    let termNodeVerified = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerifies = this.verifyVariableNode(variableNodeA, termNodeB, substitutions);
+      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions);
 
-      termNodeVerifies = variableVerifies; ///
+      termNodeVerified = variableVerified; ///
     }
 
-    return termNodeVerifies;
+    return termNodeVerified;
   }
 
   verifyVariableNode(variableNodeB, termNodeB, substitutions) {
-    let variableVerifies;
+    let variableVerified;
 
     const variableNameA = variableNameFromVariableNode(variableNodeB),
           substitution = substitutions.find((substitution) => {
@@ -66,9 +66,9 @@ export default class TermForVariableVerifier extends Verifier {
 
     if (substitution !== null) {
       const termNode = termNodeB, ///
-            substitutionNodesVerifies = substitution.matchTermNode(termNode);
+            substitutionNodesVerified = substitution.matchTermNode(termNode);
 
-      variableVerifies = substitutionNodesVerifies;  ///
+      variableVerified = substitutionNodesVerified;  ///
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -81,9 +81,9 @@ export default class TermForVariableVerifier extends Verifier {
         substitutions.push(substitution);
       }
 
-      variableVerifies = true;
+      variableVerified = true;
     }
 
-    return variableVerifies;
+    return variableVerified;
   }
 }

package/src/verifier.js

@@ -1,8 +1,8 @@
 "use strict";
 
 export default class Verifier {
-  verifyNode(nodeA, nodeB, substitutions, context) {
-    let nodeVerifies = false;
+  verifyNode(nodeA, nodeB, ...remainingArguments) {
+    let nodeVerified = false;
 
     const nodeATerminalNode = nodeA.isTerminalNode(),
           nodeBTerminalNode = nodeB.isTerminalNode();
@@ -11,22 +11,22 @@ export default class Verifier {
       if (nodeATerminalNode) {
         const terminalNodeA = nodeA,  ///
               terminalNodeB = nodeB,  ///
-              terminalNodeVerifies = this.verifyTerminalNode(terminalNodeA, terminalNodeB);
+              terminalNodeVerified = this.verifyTerminalNode(terminalNodeA, terminalNodeB);
 
-        nodeVerifies = terminalNodeVerifies;  ///
+        nodeVerified = terminalNodeVerified;  ///
       } else {
         const nonTerminalNodeA = nodeA,  ///
               nonTerminalNodeB = nodeB, ///
-              nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context);
+              nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
 
-        nodeVerifies = nonTerminalNodeVerifies; ///
+        nodeVerified = nonTerminalNodeVerified; ///
       }
     }
 
-    return nodeVerifies;
+    return nodeVerified;
   }
 
-  verifyNodes(nodesA, nodesB, substitutions, context) {
+  verifyNodes(nodesA, nodesB, ...remainingArguments) {
     let nodesVerify = false;
 
     const nodesALength = nodesA.length,
@@ -35,9 +35,9 @@ export default class Verifier {
     if (nodesALength === nodesBLength) {
       nodesVerify = nodesA.every((nodeA, index) => {
         const nodeB = nodesB[index],
-              nodeVerifies = this.verifyNode(nodeA, nodeB, substitutions, context);
+              nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments);
 
-        if (nodeVerifies) {
+        if (nodeVerified) {
           return true;
         }
       })
@@ -46,15 +46,15 @@ export default class Verifier {
     return nodesVerify;
   }
 
-  verifyTerminalNode(terminalNodeA, terminalNodeB, substitutions, context) {
+  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
     const matches = terminalNodeA.match(terminalNodeB),
-          terminalNodeVerifies = matches;  ///
+          terminalNodeVerified = matches;  ///
 
-    return terminalNodeVerifies;
+    return terminalNodeVerified;
   }
 
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context = null) {
-    let nonTerminalNodeVerifies = false;
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
@@ -64,11 +64,11 @@ export default class Verifier {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             nodesA = nonTerminalNodeAChildNodes, ///
             nodesB = nonTerminalNodeBChildNodes, ///
-            nodesVerify = this.verifyNodes(nodesA, nodesB, substitutions, context);
+            nodesVerify = this.verifyNodes(nodesA, nodesB, ...remainingArguments);
 
-      nonTerminalNodeVerifies = nodesVerify; ///
+      nonTerminalNodeVerified = nodesVerify; ///
     }
 
-    return nonTerminalNodeVerifies;
+    return nonTerminalNodeVerified;
   }
 }

package/src/verify/assertion/type.js

@@ -31,7 +31,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
     }
 
     if (!typeAssertionVerified) {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, context);
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, derived, context);
 
       typeAssertionVerified = termTypeAssertionVerified;  ///
     }
@@ -66,13 +66,13 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
             variableType = variable.getType();
 
       if (derived) {
-        const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+        const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);
 
-        if (!variableTypeEqualToOrSubTypeOfAssertedType) {
+        if (!assertedTypeEqualToOrSuperTypeOfVariableType) {
           const assertedTypeName = assertedType.getName(),
                 variableTypeName = variableType.getName();
 
-          context.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
+          context.error(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
         } else {
           variableTypeAssertionVerified = true;
         }
@@ -101,7 +101,7 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
   return variableTypeAssertionVerified;
 }
 
-function verifyTermTypeAssertion(typeAssertionNode, context) {
+function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
   let termTypeAssertionVerified = false;
 
   const types = [],
@@ -118,17 +118,32 @@ function verifyTermTypeAssertion(typeAssertionNode, context) {
       context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
     } else {
       const firstType = first(types),
-            termType = firstType, ///
-            termTypeIsEqualToAssertedType = termType.isEqualTo(assertedType);
+            termType = firstType; ///
 
-      if (!termTypeIsEqualToAssertedType) {
-        const termString = context.nodeAsString(termNode),
-              termTypeName = termType.getName(),
-              assertedTypeName = assertedType.getName();
+      if (derived) {
+        const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);
+
+        if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {
+          const termString = context.nodeAsString(termNode),
+                termTypeName = termType.getName(),
+                assertedTypeName = assertedType.getName();
 
-        context.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+          context.error(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+        } else {
+          termTypeAssertionVerified = true;
+        }
       } else {
-        termTypeAssertionVerified = true;
+        const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+
+        if (!assertedTypeIsEqualToOrSubTypeOfTermType) {
+          const termString = context.nodeAsString(termNode),
+                termTypeName = termType.getName(),
+                assertedTypeName = assertedType.getName();
+
+          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+        } else {
+          termTypeAssertionVerified = true;
+        }
       }
     }
   }