occam-verify-cli 0.0.1051 → 0.0.1052

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1051",
+  "version": "0.0.1052",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/assertion/subproof.js

@@ -124,11 +124,10 @@ export default class SubproofAssertion {
     return subproofUnified;
   }
 
-  static fromStatement(statement, fileContext) {
+  static fromStatementNode(statementNode, fileContext) {
     let subproofAssertion = null;
 
-    const statementNode = statement.getNode(),
-          subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
 
     if (subproofAssertionNode !== null) {
       const { Statement } = shim,
@@ -150,16 +149,21 @@ export default class SubproofAssertion {
   }
 
   static fromSubproofAssertionNode(subproofAssertionNode, localContext) {
-    const { Statement } = shim,
-          statementNodes = statementNodesQuery(subproofAssertionNode),
-          statements = statementNodes.map((statementNode) => {
-            const statement = Statement.fromStatementNode(statementNode, localContext);
-
-            return statement;
-          }),
-          node = subproofAssertionNode, ///
-          string = stringFromStatements(statements),
-          subproofAssertion = new SubproofAssertion(string, node, statements);
+    let subproofAssertion = null;
+
+    if (subproofAssertionNode !== null) {
+      const { Statement } = shim,
+            statementNodes = statementNodesQuery(subproofAssertionNode),
+            statements = statementNodes.map((statementNode) => {
+              const statement = Statement.fromStatementNode(statementNode, localContext);
+
+              return statement;
+            }),
+            node = subproofAssertionNode, ///
+            string = stringFromStatements(statements);
+
+      subproofAssertion = new SubproofAssertion(string, node, statements);
+    }
 
     return subproofAssertion;
   }

package/src/assertion/type.js

@@ -153,15 +153,20 @@ export default class TypeAssertion {
   }
 
   static fromTypeAssertionNode(typeAssertionNode, localContext) {
-    const { Term, Type } = shim,
-          termNode = termNodeQuery(typeAssertionNode),
-          typeNode = typeNodeQuery(typeAssertionNode),
-          variableNode = variableNodeQuery(termNode),
-          term = Term.fromTermNode(termNode, localContext),
-          type = Type.fromTypeNode(typeNode, localContext),
-          variable = Variable.fromVariableNode(variableNode, localContext),
-          string = stringFromTermAndType(term, type),
-          typeAssertion = new TypeAssertion(string, term, type, variable);
+    let typeAssertion = null;
+
+    if (typeAssertionNode !== null) {
+      const { Term, Type } = shim,
+            termNode = termNodeQuery(typeAssertionNode),
+            typeNode = typeNodeQuery(typeAssertionNode),
+            variableNode = variableNodeQuery(termNode),
+            term = Term.fromTermNode(termNode, localContext),
+            type = Type.fromTypeNode(typeNode, localContext),
+            variable = Variable.fromVariableNode(variableNode, localContext),
+            string = stringFromTermAndType(term, type);
+
+      typeAssertion = new TypeAssertion(string, term, type, variable);
+    }
 
     return typeAssertion;
   }

package/src/conjecture.js

@@ -46,11 +46,11 @@ export default class Conjecture extends TopLevelAssertion {
         const consequentVerified = this.consequent.verify(localContext);
 
         if (consequentVerified) {
-          if (this.proof !== null) {
+          // if (this.proof !== null) {
             const substitutions = Substitutions.fromNothing();
 
             this.proof.verify(substitutions, this.consequent, localContext);
-          }
+          // }
 
           const conjecture = this;  ///
 

package/src/constructor.js

@@ -4,7 +4,6 @@ import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
-import { objectType } from "./type";
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
@@ -77,9 +76,7 @@ export default class Constructor {
     const { Term, Type } = shim,
           termNode = termNodeQuery(constructorDeclarationNode),
           typeNode = typeNodeQuery(constructorDeclarationNode),
-          type = (typeNode === null) ?
-                   objectType :
-                     Type.fromTypeNode(typeNode),
+          type = Type.fromTypeNode(typeNode),
           localContext = LocalContext.fromFileContext(fileContext),
           term = Term.fromTermNodeAndType(termNode, type, localContext),
           string = stringFromTermAndType(term, type),

package/src/equality.js

@@ -157,14 +157,19 @@ export default class Equality {
   }
 
   static fromEqualityNode(equalityNode, localContext) {
-    const { Term } = shim,
-          leftTermNode = leftTermNodeQuery(equalityNode),
-          rightTermNode = rightTermNodeQuery(equalityNode),
-          leftTerm = Term.fromTermNode(leftTermNode, localContext),
-          rightTerm = Term.fromTermNode(rightTermNode, localContext),
-          node = equalityNode,  ///
-          string = localContext.nodeAsString(node),
-          equality = new Equality(string, leftTerm, rightTerm);
+    let equality = null;
+
+    if (equalityNode !== null) {
+      const { Term } = shim,
+            leftTermNode = leftTermNodeQuery(equalityNode),
+            rightTermNode = rightTermNodeQuery(equalityNode),
+            leftTerm = Term.fromTermNode(leftTermNode, localContext),
+            rightTerm = Term.fromTermNode(rightTermNode, localContext),
+            node = equalityNode,  ///
+            string = localContext.nodeAsString(node);
+
+      equality = new Equality(string, leftTerm, rightTerm);
+    }
 
     return equality;
   }

package/src/mixins/statement/verify.js

@@ -51,15 +51,15 @@ function verifyAsEquality(statement, assignments, stated, localContext) {
   let verifiedAsEquality = false;
 
   const statementNode = statement.getNode(),
-        equalityNode = equalityNodeQuery(statementNode);
+        equalityNode = equalityNodeQuery(statementNode),
+        equality = Equality.fromEqualityNode(equalityNode, localContext);
 
-  if (equalityNode !== null) {
+  if (equality !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as an equality...`);
 
-    const equality = Equality.fromEqualityNode(equalityNode, localContext),
-          equalityVerified = equality.verify(assignments, stated, localContext);
+    const equalityVerified = equality.verify(assignments, stated, localContext);
 
     verifiedAsEquality = equalityVerified; ///
 
@@ -144,15 +144,15 @@ function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
   let verifiedAsTypeAssertion = false;
 
   const statementNode = statement.getNode(),
-        typeAssertionNode = typeAssertionNodeQuery(statementNode);
+        typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        typeAssertion = TypeAssertion.fromTypeAssertionNode(typeAssertionNode, localContext);
 
-  if (typeAssertionNode !== null) {
+  if (typeAssertion !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`);
 
-    const typeAssertion = TypeAssertion.fromTypeAssertionNode(typeAssertionNode, localContext),
-          typeAssertionVerified = typeAssertion.verify(assignments, stated, localContext);
+    const typeAssertionVerified = typeAssertion.verify(assignments, stated, localContext);
 
     verifiedAsTypeAssertion = typeAssertionVerified; ///
 
@@ -191,15 +191,15 @@ function verifyAsSubproofAssertion(statement, assignments, stated, localContext)
   let verifiedAsSubproofAssertion = false;
 
   const statementNode = statement.getNode(),
-        subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
+        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
 
   if (subproofAssertionNode !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext),
-          subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
+    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
 
     verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 

package/src/mixins/term/unify.js

@@ -20,15 +20,14 @@ function unifyTermWithBracketedConstructor(term, localContext, verifyAhead) {
   termUnifiedWithBracketedConstructor = unifyTermWithConstructor(term, bracketedConstructor, localContext, () => {
     let verifiedAhead = false;
 
-    const bracketedTerm = term, ///
+    const { Term } = shim,
+          bracketedTerm = term, ///
           bracketedTermNode = bracketedTerm.getNode(),
           termNode = termNodeQuery(bracketedTermNode); ///
 
-    if (termNode !== null) {
-      const { Term } = shim;
-
-      term = Term.fromTermNode(termNode, localContext);
+    term = Term.fromTermNode(termNode, localContext);
 
+    if (term !== null) {
       const termVVerified = term.verify(localContext, () => {
         let verifiedAhead;
 

package/src/mixins/term/verify.js

@@ -10,15 +10,15 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
   const termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
+        variableNode = variableNodeQuery(termNode),
+        variable = Variable.fromVariableNode(variableNode, localContext);
 
-  if (variableNode !== null) {
+  if (variable !== null) {
     const termString = localContext.nodeAsString(termNode);
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variable = Variable.fromVariableNode(variableNode, localContext),
-          variableVerified = variable.verify(localContext);
+    const variableVerified = variable.verify(localContext);
 
     if (variableVerified) {
       let verifiedAhead;

package/src/premise.js

@@ -40,7 +40,8 @@ export default class Premise {
     localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
     const statement = this.unqualifiedStatement.getStatement(),
-          subproofAssertion = SubproofAssertion.fromStatement(statement, this.fileContext);
+          statementNode = statement.getNode(),
+          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);

package/src/proofStep.js

@@ -90,23 +90,11 @@ class ProofStep {
   static fromProofStepNode(proofStepNode, fileContext) {
     const subproofNode = subproofNodeQuery(proofStepNode),
           qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
-          unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode);
-
-    let subproof = null,
-        qualifiedStatement = null,
-        unqualifiedStatement = null;
-
-    if (false) {
-      ///
-    } else if (subproofNode !== null) {
-      subproof = Subproof.fromSubproofNode(subproofNode, fileContext);
-    } else if (qualifiedStatementNode !== null) {
-      qualifiedStatement = QualifiedStatement.fromQualifiedStatementNode(qualifiedStatementNode, fileContext);
-    } else if (unqualifiedStatementNode !== null) {
-      unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext);
-    }
-
-    const proofStep = new ProofStep(subproof, qualifiedStatement, unqualifiedStatement);
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode),
+          subproof = Subproof.fromSubproofNode(subproofNode, fileContext),
+          qualifiedStatement = QualifiedStatement.fromQualifiedStatementNode(qualifiedStatementNode, fileContext),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          proofStep = new ProofStep(subproof, qualifiedStatement, unqualifiedStatement);
 
     return proofStep;
   }

package/src/statement/qualified.js

@@ -87,21 +87,25 @@ export default class QualifiedStatement {
   }
 
   static fromQualifiedStatementNode(qualifiedStatementNode, fileContext) {
-    let string;
+    let qualifiedStatement = null;
 
-    const { Statement } = shim,
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          referenceNode = referenceNodeQuery(qualifiedStatementNode),
-          localContext = LocalContext.fromFileContext(fileContext),
-          statement = Statement.fromStatementNode(statementNode, localContext),
-          reference = Reference.fromReferenceNode(referenceNode, fileContext),
-          node = qualifiedStatementNode;  ///
+    if (qualifiedStatementNode !== null) {
+      let string;
 
-    string = fileContext.nodeAsString(node);
+      const { Statement } = shim,
+            statementNode = statementNodeQuery(qualifiedStatementNode),
+            referenceNode = referenceNodeQuery(qualifiedStatementNode),
+            localContext = LocalContext.fromFileContext(fileContext),
+            statement = Statement.fromStatementNode(statementNode, localContext),
+            reference = Reference.fromReferenceNode(referenceNode, fileContext),
+            node = qualifiedStatementNode;  ///
 
-    string = trim(string);  ///
+      string = fileContext.nodeAsString(node);
 
-    const qualifiedStatement = new QualifiedStatement(string, statement, reference);
+      string = trim(string);  ///
+
+      qualifiedStatement = new QualifiedStatement(string, statement, reference);
+    }
 
     return qualifiedStatement;
   }

package/src/statement/unqualified.js

@@ -73,19 +73,23 @@ export default class UnqualifiedStatement {
   }
 
   static fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext) {
-    let string;
+    let unqualifiedStatement = null;
 
-    const { Statement } = shim,
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          localContext = LocalContext.fromFileContext(fileContext),
-          statement = Statement.fromStatementNode(statementNode, localContext),
-          node = unqualifiedStatementNode;  ///
+    if (unqualifiedStatementNode !== null) {
+      let string;
 
-    string = fileContext.nodeAsString(node);
+      const { Statement } = shim,
+            statementNode = statementNodeQuery(unqualifiedStatementNode),
+            localContext = LocalContext.fromFileContext(fileContext),
+            statement = Statement.fromStatementNode(statementNode, localContext),
+            node = unqualifiedStatementNode;  ///
 
-    string = trim(string);  ///
+      string = fileContext.nodeAsString(node);
 
-    const unqualifiedStatement = new UnqualifiedStatement(string, statement);
+      string = trim(string);  ///
+
+      unqualifiedStatement = new UnqualifiedStatement(string, statement);
+    }
 
     return unqualifiedStatement;
   }

package/src/statement.js

@@ -153,9 +153,9 @@ class Statement {
 
     if (statementNode !== null) {
       const node = statementNode, ///
-          string = localContext.nodeAsString(node),
-          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-          substitution = statementSubstitution; ///
+            string = localContext.nodeAsString(node),
+            statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
+            substitution = statementSubstitution; ///
 
       statement = new Statement(string, node, substitution);
     }

package/src/subproof.js

@@ -77,17 +77,22 @@ export default class Subproof {
   }
 
   static fromSubproofNode(subproofNode, fileContext) {
-    const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
-          suppositionNodes = suppositionNodesQuery(subproofNode),
-          subDerivationNode = subDerivationNodeQuery(subproofNode),
-          string = subproofString,  ///
-          suppositions = suppositionNodes.map((suppositionNode) => {
-            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
-
-            return supposition;
-          }),
-          subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext),
-          subproof = new Subproof(string, suppositions, subDerivation);
+    let subproof = null;
+
+    if (subproofNode !== null) {
+      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+            suppositionNodes = suppositionNodesQuery(subproofNode),
+            subDerivationNode = subDerivationNodeQuery(subproofNode),
+            string = subproofString,  ///
+            suppositions = suppositionNodes.map((suppositionNode) => {
+              const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+
+              return supposition;
+            }),
+            subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
+
+      subproof = new Subproof(string, suppositions, subDerivation);
+    }
 
     return subproof;
   }

package/src/supposition.js

@@ -71,7 +71,8 @@ export default class Supposition {
     localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
 
     const statement = this.unqualifiedStatement.getStatement(),
-          subproofAssertion = SubproofAssertion.fromStatement(statement, this.fileContext);
+          statementNode = statement.getNode(),
+          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);

package/src/term.js

@@ -240,10 +240,15 @@ class Term {
   }
 
   static fromTermNode(termNode, localContext) {
-    const node = termNode,  ///
-          string = localContext.nodeAsString(node),
-          type = null,
-          term = new Term(string, node, type);
+    let term = null;
+
+    if (termNode !== null) {
+      const node = termNode,  ///
+            string = localContext.nodeAsString(node),
+            type = null;
+
+      term = new Term(string, node, type);
+    }
 
     return term;
   }