occam-verify-cli 0.0.1068 → 0.0.1069

package/src/metavariable.js

@@ -1,17 +1,18 @@
 "use strict";
 
 import shim from "./shim";
-import Argument from "./argument";
 import LocalContext from "./context/local";
 import metavariableUnifier from "./unifier/metavariable";
 import FrameForMetavariableSubstitution from "./substitution/frameForMetavariable";
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
-import { metavariableNameFromMetavariableNode } from "./utilities/name";
 import { metavariableNodeFromMetavariableString } from "./utilities/node";
+import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
+import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "./utilities/name";
 
-const argumentNodeQuery = nodeQuery("/metavariable/argument"),
+const termNodeQuery = nodeQuery("/metavariable/argument/term"),
+      typeNodeQuery = nodeQuery("/metavariable/argument/type"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
@@ -171,6 +172,30 @@ class Metavariable {
     return statementUnified;
   }
 
+  unifySubstitution(substitution, localContext) {
+    let substitutionUnified = false;
+
+    const metavariableString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    localContext.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
+
+    const metavariableName = this.name, ///
+          judgement = localContext.findJudgementByMetavariableName(metavariableName);
+
+    if (judgement !== null){
+      const declaration = judgement.getDeclaration();
+
+      substitutionUnified = declaration.unifySubstitution(substitution, localContext);
+    }
+
+    if (substitutionUnified) {
+      localContext.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
+    }
+
+    return substitutionUnified;
+  }
+
   verify(localContext) {
     let verified;
 
@@ -212,15 +237,25 @@ class Metavariable {
     if (metavariablePresent) {
       fileContext.debug(`The metavariable '${metavariableString}' is already present.`);
     } else {
-      const argumentNode = argumentNodeQuery(metavariableNode),
-            argument = Argument.fromArgumentNode(argumentNode, fileContext);
+      const termNode = termNodeQuery(this.node);
 
-      if (argument === null) {
-        verifiedAtTopLevel = true;
-      } else {
-        const argumentVerified = argument.verify(fileContext);
+      if (termNode !== null) {
+        const termString = this.fileContext.nodeAsString(termNode);
 
-        if (argumentVerified) {
+        this.fileContext.debug(`The '${termString}' term was found when a type should have been present.`);
+      } else {
+        const typeNode = typeNodeQuery(this.node);
+
+        if (typeNode !== null) {
+          const typeName = typeNameFromTypeNode(typeNode),
+                typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+          if (typePresent) {
+            verifiedAtTopLevel = true;
+          } else {
+            this.fileContext.debug(`The '${typeName}' type is not present.`);
+          }
+        } else {
           verifiedAtTopLevel = true;
         }
       }
@@ -259,11 +294,9 @@ class Metavariable {
   }
 
   toJSON() {
-    const metaTypeJSON = (this.metaType !== null) ?
-                            this.metaType.toJSON() :
-                              null,
-          string = this.string,
+    const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           metaType = metaTypeJSON,  ///
+          string = this.string,
           json = {
             string,
             metaType
@@ -287,17 +320,17 @@ class Metavariable {
     return metavariable;
   }
 
-  static fromMetavariableNode(metavariableNode, fileContext) {
+  static fromMetavariableNode(metavariableNode, localContext) {
     let metavariable = null;
 
     if (metavariableNode !== null) {
       const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
             node = metavariableNode,  ///
             name = metavariableName,  ///
-            string = fileContext.nodeAsString(node),
+            string = localContext.nodeAsString(node),
             metaType = null;
 
-      metavariable = new Metavariable(fileContext, string, node, name, metaType);
+      metavariable = new Metavariable(localContext, string, node, name, metaType);
     }
 
     return metavariable;
@@ -326,19 +359,6 @@ Object.assign(shim, {
 
 export default Metavariable;
 
-function metaTypeFromJSON(json, fileContext) {
-  let { metaType } = json;
-
-  if (metaType !== null) {
-    const { name } = metaType,
-          metaTypeName = name;  ///
-
-    metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName);
-  }
-
-  return metaType;
-}
-
 function metavariableFromMetavariableNode(metavariableNode, localContext) {
   const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
         metavariable = localContext.findMetavariableByMetavariableName(metavariableName);

package/src/mixins/statement/qualified/unify.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import metavariableUnifier from "../../../unifier/metavariable";
 import StatementForMetavariableSubstitution from "../../../substitution/statementForMetavariable";
 
 import { trim } from "../../../utilities/string";
@@ -137,33 +136,22 @@ function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
   const reference = qualifiedStatement.getReference(),
         metavariableNode = reference.getMetavariableNode(),
         metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableName(metavariableName);
 
-  if (metavariable !== null) {
+  if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),
           statementString = statement.getString(),
           referenceString = reference.getString();
 
     localContext.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
 
-    const metavariableNode = metavariable.getNode(),
-          referenceMetavariableNode = reference.getMetavariableNode(),
-          metavariableNodeA = referenceMetavariableNode, ///
-          metavariableNodeB = metavariableNode, ///
-          metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+    const metavariable = reference.getMetavariable(),
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+          substitution = statementForMetavariableSubstitution; ///
 
-    if (metavariableUnified) {
-      const statementNode = statement.getNode(),
-            metavariableNode = metavariableNodeA, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB),
-            substitution = statementForMetavariableSubstitution, ///
-            localContextA = localContext, ///
-            localContextB = localContext; ///
+    substitutions.addSubstitution(substitution, localContext);
 
-      substitutions.addSubstitution(substitution, localContextA, localContextB);
-
-      unifiedWithReference = true;
-    }
+    unifiedWithReference = true;
 
     if (unifiedWithReference) {
       localContext.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);

package/src/mixins/statement/unify.js

@@ -14,7 +14,7 @@ function unifyWithBracketedCombinator(statement, assignments, stated, localConte
 
   localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, localContext);
 
   if (unifiedWithBracketedCombinator) {
     localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
@@ -61,7 +61,7 @@ function unifyStatementWithCombinator(statement, combinator, assignments, stated
 
   localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
 
-  unifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+  unifiedWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, localContext);
 
   if (unifiedWithCombinator) {
     localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);

package/src/mixins/term/unify.js

@@ -87,7 +87,7 @@ function unifyTermWithConstructor(term, constructor, localContext, verifyAhead)
   const termNode = term.getNode(),
         constructorTerm = constructor.getTerm(),
         constructorTermNode = constructorTerm.getNode(),
-        unified = termWithConstructorUnifier.unify(termNode, constructorTermNode, localContext);
+        unified = termWithConstructorUnifier.unify(constructorTermNode, termNode, localContext);
 
   if (unified) {
     let verifiedAhead;

package/src/premise.js

@@ -7,10 +7,11 @@ import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
+import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
-export default class Premise {
+class Premise {
   constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
     this.unqualifiedStatement = unqualifiedStatement;
@@ -40,7 +41,13 @@ export default class Premise {
 
     const statement = this.unqualifiedStatement.getStatement(),
           statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
@@ -138,7 +145,7 @@ export default class Premise {
   }
 
   toJSON() {
-    const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+    const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
           unqualifiedStatement = unqualifiedStatementJSON,  ///
           json = {
             unqualifiedStatement
@@ -148,13 +155,8 @@ export default class Premise {
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
-
-    json = unqualifiedStatement;  ///
-
-    unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
-
-    const premise = new Premise(fileContext, unqualifiedStatement);
+    const unqualifiedStatement = unqualifiedStatementFromJSON(json, fileContext),
+          premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise;
   }
@@ -167,3 +169,9 @@ export default class Premise {
     return premise
   }
 }
+
+Object.assign(shim, {
+  Premise
+});
+
+export default Premise;

package/src/reference.js

@@ -1,9 +1,11 @@
 "use strict";
 
 import Metavariable from "./metavariable";
+import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
 import { referenceMetaType } from "./metaType";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
 
 const metavariableNodeQuery = nodeQuery("//reference/metavariable");
 
@@ -46,7 +48,7 @@ export default class Reference {
   }
 
   toJSON() {
-    const metavariableJSON = this.metavariable.toJSON(),
+    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           metavariable = metavariableJSON,  ///
           string = this.string,
           json = {
@@ -58,22 +60,16 @@ export default class Reference {
   }
 
   static fromJSON(json, fileContext) {
-    const { string } = json;
-
-    let { metavariable } = json;
-
-    json = metavariable;  ///
-
-    metavariable = Metavariable.fromJSON(json, fileContext);
-
-    const reference = new Reference(string, metavariable);
+    const metavariable = metavariableFromJSON(json, fileContext),
+          reference = new Reference(string, metavariable);
 
     return reference;
   }
 
   static fromReferenceNode(referenceNode, fileContext) {
     const metavariableNode = metavariableNodeQuery(referenceNode),
-          metavariable = Metavariable.fromMetavariableNode(metavariableNode, fileContext),
+          localContext = LocalContext.fromFileContext(fileContext),
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           reference = new Reference(metavariable);
 
     return reference;

package/src/rule.js

@@ -2,6 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
+import shim from "./shim";
 import Label from "./label";
 import Proof from "./proof";
 import Premise from "./premise";
@@ -9,7 +10,14 @@ import Conclusion from "./conclusion";
 import LocalContext from "./context/local";
 import Substitutions from "./substitutions";
 
+import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
+import { labelsFromJSON,
+         premisesFromJSON,
+         conclusionFromJSON,
+         labelsToLabelsJSON,
+         premisesToPremisesJSON,
+         conclusionToConclusionJSON } from "./utilities/json";
 
 const { reverse, correlate } = arrayUtilities;
 
@@ -18,9 +26,10 @@ const proofNodeQuery = nodeQuery("/rule/proof"),
       premiseNodesQuery = nodesQuery("/rule/premise"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion");
 
-export default class Rule {
-  constructor(fileContext, labels, premises, conclusion, proof) {
+class Rule {
+  constructor(fileContext, string, labels, premises, conclusion, proof) {
     this.fileContext = fileContext;
+    this.string = string;
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
@@ -31,6 +40,10 @@ export default class Rule {
     return this.fileContext;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getLabels() {
     return this.labels;
   }
@@ -108,9 +121,9 @@ export default class Rule {
   verify() {
     let verified = false;
 
-    const labelsString = labelsStringFromLabels(this.labels);
+    const ruleString = this.string; ///
 
-    this.fileContext.trace(`Verifying the '${labelsString}' rule...`);
+    this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
 
     const labelsVerifiedAtTopLevel = this.labels.every((label) => {
       const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
@@ -154,24 +167,16 @@ export default class Rule {
     }
 
     if (verified) {
-      this.fileContext.debug(`...verified the '${labelsString}' rule.`);
+      this.fileContext.debug(`...verified the '${ruleString}' rule.`);
     }
 
     return verified;
   }
 
   toJSON() {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
-
-            return labelJSON;
-          }),
-          premisesJSON = this.premises.map((premise) => {
-            const premiseJSON = premise.toJSON();
-
-            return premiseJSON;
-          }),
-          conclusionJSON = this.conclusion.toJSON(),
+    const labelsJSON = labelsToLabelsJSON(this.labels),
+          premisesJSON = premisesToPremisesJSON(this.premises),
+          conclusionJSON = conclusionToConclusionJSON(this.conclusion),
           labels = labelsJSON,  ///
           premises = premisesJSON,  ///
           conclusion = conclusionJSON,  ///
@@ -187,39 +192,13 @@ export default class Rule {
   static fromJSON(json, fileContext) {
     let rule;
 
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSON(json, fileContext);
-
-      return label;
-    });
-
-    let { premises } = json;
+    const proof = null,
+          labels = labelsFromJSON(json, fileContext),
+          premises = premisesFromJSON(json, fileContext),
+          conclusion = conclusionFromJSON(json, fileContext),
+          string = stringFromLabels(labels);
 
-    const premisesJSON = premises;  ///
-
-    premises = premisesJSON.map((premiseJSON) => {
-      const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, fileContext);
-
-      return premise;
-    });
-
-    let { conclusion } = json;
-
-    const conclusionJSON = conclusion;  ///
-
-    json = conclusionJSON;  ///
-
-    conclusion = Conclusion.fromJSON(json, fileContext);
-
-    const proof = null;
-
-    rule = new Rule(fileContext, labels, premises, conclusion, proof);
+    rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
   }
@@ -240,19 +219,16 @@ export default class Rule {
             return premise;
           }),
           conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext),
+          string = stringFromLabels(labels),
           proof = Proof.fromProofNode(proofNode, fileContext),
-          rule = new Rule(fileContext, labels, premises, conclusion, proof);
+          rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
   }
 }
 
-function labelsStringFromLabels(labels) {
-  const labelsString = labels.map((label) => {
-          const labelString = label.getString();
-
-          return labelString;
-        });
+Object.assign(shim, {
+  Rule
+});
 
-  return labelsString;
-}
+export default Rule;

package/src/ruleNames.js

@@ -2,6 +2,5 @@
 
 export const VARIABLE_RULE_NAME = "variable";
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const SUBSTITUTION_RULE_NAME = "substitution";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/statement/unqualified.js

@@ -7,12 +7,13 @@ import LocalContext from "../context/local";
 
 import { trim } from "../utilities/string";
 import { nodeQuery } from "../utilities/query";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 const { reverse } = arrayUtilities;
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
-export default class UnqualifiedStatement {
+class UnqualifiedStatement {
   constructor(string, statement) {
     this.string = string;
     this.statement = statement;
@@ -93,7 +94,7 @@ export default class UnqualifiedStatement {
   }
 
   toJSON() {
-    const statementJSON = this.statement.toJSON(),
+    const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///
           string = this.string, ///
           json = {
@@ -105,15 +106,8 @@ export default class UnqualifiedStatement {
   }
 
   static fromJSON(json, fileContext) {
-    const { Statement } = shim;
-
-    let { statement } = json;
-
-    json = statement; ///
-
-    statement = Statement.fromJSON(json, fileContext);
-
     const { string } = json,
+          statement = statementFromJSON(json, fileContext),
           unqualifiedStatement = new UnqualifiedStatement(string, statement);
 
     return unqualifiedStatement;
@@ -141,3 +135,9 @@ export default class UnqualifiedStatement {
     return unqualifiedStatement;
   }
 }
+
+Object.assign(shim, {
+  UnqualifiedStatement
+});
+
+export default UnqualifiedStatement;

package/src/statement.js

@@ -117,10 +117,11 @@ class Statement {
 
     const statementANode = statementA.getNode(),
           statementBNode = statementB.getNode(),
+          context = localContextA,  ///
           nodeA = statementANode, ///
           nodeB = statementBNode; ///
 
-    localContextA = LocalContext.fromLocalContextAndTokens(localContextA, this.tokens);
+    localContextA = LocalContext.fromContextAndTokens(context, this.tokens);
 
     const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
@@ -221,9 +222,9 @@ class Statement {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          statementString = string, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
+          statementString = string, ///
           unqualifiedStatementString = unqualifiedStatementStringFromStatementString(statementString),
           unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
           unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),