occam-verify-cli 0.0.696 → 0.0.698

package/src/variable.js

@@ -2,14 +2,17 @@
 
 import Type from "./type";
 
+import { nodeAsString } from "./utilities/string";
+import { variableNodeFromVariableString } from "./utilities/node";
+
 export default class Variable {
-  constructor(name, type) {
-    this.name = name;
+  constructor(node, type) {
+    this.node = node;
     this.type = type;
   }
 
-  getName() {
-    return this.name;
+  getNode() {
+    return this.node;
   }
 
   getType() {
@@ -17,19 +20,19 @@ export default class Variable {
   }
 
   match(variable) {
-    const name = variable.getName(),
-          type = variable.getType(),
-          nameMatches = this.matchName(name),
+    const type = variable.getType(),
+          node = variable.getNode(),
           typeMatches = this.matchType(type),
-          matches = (nameMatches && typeMatches);
+          nodeMatches = this.matchNode(node),
+          matches = nodeMatches && typeMatches;
 
     return matches;
   }
 
-  matchName(name) {
-    const nameMatches = (this.name === name);
+  matchNode(node) {
+    const nodeMatches = this.node.match(node);
 
-    return nameMatches;
+    return nodeMatches;
   }
 
   matchType(type) {
@@ -38,41 +41,46 @@ export default class Variable {
     return typeMatches;
   }
 
-  matchNameAndType(name, type) {
-    const nameMatches = this.matchName(name),
+  matchNodeAndType(node, type) {
+    const nodeMatches = this.matchNode(node),
           typeMatches = this.matchType(type),
-          nameAndTypeMatch = (nameMatches && typeMatches);
+          nodeAndTypeMatch = nodeMatches && typeMatches;
 
-    return nameAndTypeMatch;
+    return nodeAndTypeMatch;
   }
 
   asString(tokens) {
-    const typeName = this.type.getName(),
-          string = `${this.name}:${typeName}`;
+    const typeName = this.type.getName();
+
+    let string = nodeAsString(this.node, tokens);
+
+    string = `${string}:${typeName}`; ///
 
     return string;
   }
 
   toJSON(tokens) {
     const typeJSON = this.type.toJSON(tokens),
-          name = this.name, ///
+          string = nodeAsString(this.node, tokens),
+          node = string,  //
           type = typeJSON,  ///
           json = {
-            name,
+            node,
             type
           };
 
     return json;
   }
 
-  static fromNameAndType(name, type) {
-    const variable = new Variable(name, type);
+  static fromJSONAndFileContext(json, fileContext) {
+    let { node } = json;
 
-    return variable;
-  }
+    const lexer  = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          variableString = node,  ///
+          variableNode = variableNodeFromVariableString(variableString, lexer, parser);
 
-  static fromJSONAndFileContext(json, fileContext) {
-    const { name } = json;
+    node = variableNode;  ///
 
     let { type } = json;
 
@@ -84,7 +92,14 @@ export default class Variable {
 
     type = fileContext.findTypeByTypeName(typeName); ///
 
-    const variable = new Variable(name, type);
+    const variable = new Variable(node, type);
+
+    return variable;
+  }
+
+  static fromVariableNodeAndType(variableNode, type) {
+    const node = variableNode,  ///
+          variable = new Variable(node, type);
 
     return variable;
   }

package/src/verifier/node/metastatement.js

@@ -3,7 +3,6 @@
 import NodeVerifier from "../../verifier/node";
 
 import { METAVARIABLE_RULE_NAME } from "../../ruleNames";
-import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 class MetastatementNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
@@ -44,8 +43,7 @@ function verifyMetavariable(metavariableNode, localMetaContext, verifyAhead) {
 
   localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableName(metavariableName);
+  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();

package/src/verifier/nodes/metastatementForMetavariable.js

@@ -5,7 +5,6 @@ import MetastatementForMetavariableSubstitution from "../../substitution/metasta
 
 import { nodeQuery } from "../../utilities/query";
 import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
-import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
@@ -55,11 +54,10 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
   verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
     let metavariableNodeVerified;
 
-    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const metavariableName = substitution.getMetavariableName();
+    const substitution = substitutions.find((substitution) => {
+            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
-            if (metavariableName === metavariableNameA) {
+            if (substitutionMatchesMetavariableNodeA) {
               return true;
             }
           }) || null;
@@ -73,9 +71,9 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
       const { createSubstitutions } = this.constructor;
 
       if (createSubstitutions) {
-        const metavariableName = metavariableNameA, ///
+        const metavariableNode = metavariableNodeA, ///
               metastatementNode = metastatementNodeB, ///
-              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode),
+              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
               substitution = metastatementForMetavariableSubstitution;  ///
 
         substitutions.push(substitution);

package/src/verifier/nodes/statementForMetavariable.js

@@ -4,7 +4,6 @@ import NodesVerifier from "../../verifier/nodes";
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
@@ -71,11 +70,10 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
   verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext) {
     let metavariableNodeVerified;
 
-    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const metavariableName = substitution.getMetavariableName();
+    const substitution = substitutions.find((substitution) => {
+            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
-            if (metavariableName === metavariableNameA) {
+            if (substitutionMatchesMetavariableNodeA) {
               return true;
             }
           }) || null;
@@ -89,9 +87,9 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
       const { createSubstitutions } = this.constructor;
 
       if (createSubstitutions) {
-        const metavariableName = metavariableNameA, ///
+        const metavariableNode = metavariableNodeA, ///
               statementNode = statementNodeB, ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode),
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
               substitution = statementForMetavariableSubstitution;  ///
 
         substitutions.push(substitution);

package/src/verifier/nodes/termForVariable.js

@@ -7,7 +7,6 @@ import TermForVariableSubstitution from "../../substitution/termForVariable";
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
 import { TERM_RULE_NAME } from "../../ruleNames";
-import { variableNameFromVariableNode } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
@@ -57,11 +56,10 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
   verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let variableVerified = false;
 
-    const variableNameA = variableNameFromVariableNode(variableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const variableName = substitution.getVariableName();
+    const substitution = substitutions.find((substitution) => {
+            const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
 
-            if (variableName === variableNameA) {
+            if (substitutionMatchesVariableNodeA) {
               return true;
             }
           }) || null;
@@ -79,9 +77,9 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
       const { createSubstitutions } = this.constructor;
 
       if (createSubstitutions) {
-        const variableName = variableNameA, ///
+        const variableNode = variableNodeA, ///
               localContext = localContextA, ///
-              variable = localContext.findVariableByVariableName(variableName);
+              variable = localContext.findVariableByVariableNode(variableNode);
 
         if (variable !== null) {
           const terms = [],
@@ -97,7 +95,7 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
                         variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
                   if (variableTypeEqualToOrSuperTypeOfTermType) {
-                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
                           substitution = termForVariableSubstitution;  ///
 
                     substitutions.push(substitution);

package/src/verify/derivation.js

@@ -2,7 +2,7 @@
 
 import ProofStep from "../step/proof";
 import LocalContext from "../context/local";
-import verifySupposition from "./supposition";
+import verifySupposition from "../verify/supposition";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 

package/src/verify/equality.js

@@ -59,7 +59,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
 
             if (equality !== null) {
               const equalityEqual = context.isEqualityEqual(equality);
@@ -104,7 +104,7 @@ function verifyStandaloneEquality(equalityNode, assignments, derived, context, v
                   secondTerm = second(terms),
                   leftTerm = firstTerm, ///
                   rightTerm = secondTerm, ///
-                  equality = Equality.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+                  equality = Equality.fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm);
 
             if (equality !== null) {
               const equalityAssignment = EqualityAssignment.fromEquality(equality),

package/src/verify/file.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import FileContext from "../context/file";
-import verifyTopLevelDeclaration from "./declaration/topLevel";
+import verifyTopLevelDeclaration from "../verify/declaration/topLevel";
 
 import { nodesQuery } from "../utilities/query";
 

package/src/verify/metavariable.js

@@ -1,8 +1,9 @@
 "use strict";
 
 import Metavariable from "../metavariable";
+import MetavariableAssignment from "../assignment/metavariable";
 
-import { metaTypeNameFromMetaTypeNode, metavariableNameFromMetavariableNode } from "../utilities/query";
+import { metaTypeNameFromMetaTypeNode } from "../utilities/query";
 
 export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
   let metavariableVerified = false;
@@ -11,20 +12,20 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 
   fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+  const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
-    fileContext.debug(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+    fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
   } else {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
           metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
-          name = metavariableName,  ///
-          metavariable = Metavariable.fromNameAndMetaType(name, metaType);
+          metavariable = Metavariable.fromMetavariableNodeAndMetaType(metavariableNode, metaType),
+          metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
+          metavariableAssigned = metavariableAssignment.assign(fileContext);
 
-    fileContext.addMetavariable(metavariable);
-
-    metavariableVerified = true;
+    if (metavariableAssigned) {
+      metavariableVerified = true;
+    }
   }
 
   if (metavariableVerified) {

package/src/verify/standaloneType.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { typeNameFromTypeNode } from "../utilities/query";
+
+export default function verifyStandaloneType(typeNode, types, context, verifyAhead) {
+  let standaloneTypeVerified = false;
+
+  const typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the standalone '${typeString}' type...`, typeNode);
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        type = context.findTypeByTypeName(typeName);
+
+  if (type !== null) {
+    let verifiedAhead;
+
+    types.push(type)
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      types.pop();
+    }
+
+    standaloneTypeVerified = verifiedAhead; ///
+  }
+
+  if (standaloneTypeVerified) {
+    context.debug(`...verified the standalone '${typeString}' type.`, typeNode);
+  }
+
+  return standaloneTypeVerified;
+}

package/src/verify/statement/unqualified.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import verifyStatement from "../statement";
+import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
 

package/src/verify/supposition.js

@@ -2,7 +2,7 @@
 
 import ProofStep from "../step/proof";
 import Supposition from "../supposition";
-import verifyUnqualifiedStatement from "./statement/unqualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -30,8 +30,12 @@ export default function verifySupposition(suppositionNode, suppositions, localCo
 
     localContext.addProofStep(proofStep);
 
-    assignments.forEach((assignment) => {
-      assignment.assign(localContext);
+    assignments.every((assignment) => {
+      const assigned = assignment.assign(localContext);
+
+      if (assigned) {
+        return true;
+      }
     });
 
     suppositionVerified = true;

package/src/verify/term.js

@@ -4,7 +4,7 @@ import Term from "../term";
 import termNodesVerifier from "../verifier/nodes/term";
 
 import { first } from "../utilities/array";
-import { nodeQuery, variableNameFromVariableNode } from "../utilities/query";
+import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
@@ -67,13 +67,12 @@ export function verifyTermAsVariable(termNode, variables, context, verifyAhead)
 
     context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variableName = variableNameFromVariableNode(variableNode),
-          variablePresent = context.isVariablePresentByVariableName(variableName);
+    const variablePresent = context.isVariablePresentByVariableNode(variableNode);
 
     if (variablePresent) {
       let verifiedAhead;
 
-      const variable = context.findVariableByVariableName(variableName);
+      const variable = context.findVariableByVariableNode(variableNode);
 
       variables.push(variable);
 

package/src/verify/termAndStandaloneType.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import verifyTerm from "../verify/term";
+import verifyStandaloneType from "../verify/standaloneType";
+
+export default function verifyTermAndStandaloneType(termNode, typeNode, terms, types, context, verifyAhead) {
+  let termAndStandaloneTypeVerified;
+
+  const termString = context.nodeAsString(termNode),
+        typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the '${termString}' term and the standalone '${typeString}' type...`, termNode);
+
+  const termVerified = verifyTerm(termNode, terms, context, () => {
+          let verifiedAhead;
+
+          const standaloneTypeVerified = verifyStandaloneType(typeNode, types, context, () => {
+            let verifiedAhead;
+
+            verifiedAhead = verifyAhead();
+
+            return verifiedAhead;
+          });
+
+          verifiedAhead = standaloneTypeVerified;  ///
+
+          return verifiedAhead;
+        });
+
+  termAndStandaloneTypeVerified = termVerified; ///
+
+  if (termAndStandaloneTypeVerified) {
+    context.debug(`...verified the '${termString}' term and the standalone '${typeString}' type.`, termNode);
+  }
+
+  return termAndStandaloneTypeVerified
+}

package/src/verify/termAsVariableAndStandaloneType.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import verifyStandaloneType from "../verify/standaloneType";
+
+import { verifyTermAsVariable } from "../verify/term";
+
+export default function verifyTermAsVariableAndStandaloneType(termNode, typeNode, variables, types, context, verifyAhead) {
+  let termAsVariableAndStandaloneTypeVerified;
+
+  const termString = context.nodeAsString(termNode),
+        typeString = context.nodeAsString(typeNode);
+
+  context.trace(`Verifying the '${termString}' term as a variable and the standalone '${typeString}' type...`, termNode);
+
+  const termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+          let verifiedAhead;
+
+          const standaloneTypeVerified = verifyStandaloneType(typeNode, types, context, () => {
+            let verifiedAhead;
+
+            verifiedAhead = verifyAhead();
+
+            return verifiedAhead;
+          });
+
+          verifiedAhead = standaloneTypeVerified;  ///
+
+          return verifiedAhead;
+        });
+
+  termAsVariableAndStandaloneTypeVerified = termVerifiedAsVariable; ///
+
+  if (termAsVariableAndStandaloneTypeVerified) {
+    context.debug(`...verified the '${termString}' term as a variable and the standalone '${typeString}' type.`, termNode);
+  }
+
+  return termAsVariableAndStandaloneTypeVerified
+}

package/src/verify/theorem.js

@@ -4,8 +4,8 @@ import Theorem from "../theorem";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySupposition from "../verify/supposition";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";

package/src/verify/type.js

@@ -9,7 +9,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 
   const typeString = fileContext.nodeAsString(typeNode);
 
-  fileContext.trace(`Verifying the '${typeString}' type.`, typeNode);
+  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
 
   const typeName = typeNameFromTypeNode(typeNode),
         typePresent = fileContext.isTypePresentByTypeName(typeName);