occam-verify-cli 0.0.1016 → 0.0.1020

package/src/consequent.js

@@ -1,32 +1,107 @@
 "use strict";
 
+import LocalContext from "./context/local";
 import metaLevelUnifier from "./unifier/metaLevel";
+import UnqualifiedStatement from "./statement/unqualified";
+
+import { nodeQuery } from "./utilities/query";
+
+const unqualifiedStatementNodeQuery = nodeQuery("/consequent/unqualifiedStatement");
 
 export default class Consequent {
-  constructor(statementNode) {
-    this.statementNode = statementNode;
+  constructor(fileContext, unqualifiedStatement) {
+    this.fileContext = fileContext;
+    this.unqualifiedStatement = unqualifiedStatement;
+  }
+
+  getFileContext() {
+    return this.fileContext;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
   }
 
-  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-    let statementUnified = false;
+  getString() { return this.unqualifiedStatement.getString(); }
+
+  getStatement() { return this.unqualifiedStatement.getStatement(); }
+
+  unifyStatement(statement, substitutions, localContext) {
+    let statementUnified;
+
+    const consequent = this, ///
+          statementString = statement.getString(),
+          consequentStatement = consequent.getStatement(),
+          consequentStatementString = consequentStatement.getString();
+
+    localContext.trace(`Unifying the '${statementString}' statement with the consequent's '${consequentStatementString}' statement...`);
 
-    if (this.statementNode !== null) {
-      const nodeA = this.statementNode,  ///
-            nodeB = statementNodeB,  ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    const statementNode = statement.getNode(),
+          consequentStatementNode = consequentStatement.getNode(),
+          nodeA = consequentStatementNode,  ///
+          nodeB = statementNode,  ///
+          fileContextA = this.fileContext,  ///
+          localContextA = LocalContext.fromFileContext(fileContextA),
+          localContextB = localContext, ///
+          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-      statementUnified = unified; ///
+    statementUnified = unified; ///
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the consequent's '${consequentStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  static fromStatementNode(statementNode) {
-    const consequent = new Consequent(statementNode);
+  verify(localContext) {
+    let verified = false;
+
+    const consequentString = this.getString();  ///
+
+    localContext.trace(`Verifying the '${consequentString}' consequent...`);
+
+    const stated = true,
+          assignments = [],
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+    if (unqualifiedStatementVerified) {
+      verified = true;
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${consequentString}' consequent.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+          unqualifiedStatement = unqualifiedStatementJSON,  ///
+          json = {
+            unqualifiedStatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let { unqualifiedStatement } = json;
+
+    json = unqualifiedStatement;  ///
+
+    unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
+
+    const consequent = new Consequent(fileContext, unqualifiedStatement);
+
+    return consequent;
+  }
+
+  static fromConsequentNode(consequentNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          consequent = new Consequent(fileContext, unqualifiedStatement);
 
     return consequent;
   }

package/src/constructor/bracketed.js

@@ -4,6 +4,7 @@ import shim from "../shim";
 import Constructor from "../constructor";
 import bracketedConstructorTermNode from "../node/term/constructor/bracketed";
 
+import { stringFromTermAndType } from "../constructor";
 import { bracketedConstructorTermString } from "../node/term/constructor/bracketed";
 
 const localContext = {
@@ -19,7 +20,9 @@ export default class BracketedConstructor extends Constructor {
     const { Term } = shim,
           termNode = bracketedConstructorTermNode,  ///
           term = Term.fromTermNode(termNode, localContext),
-          bracketedConstructor = new BracketedConstructor(term);
+          type = null,
+          string = stringFromTermAndType(term, type),
+          bracketedConstructor = new BracketedConstructor(string, term);
 
     return bracketedConstructor;
   }

package/src/constructor.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Type from "./type";
-import Term from "./term";
+import shim from "./shim";
+import Type, {objectType} from "./type";
 
 import { nodeQuery } from "./utilities/query";
 
@@ -24,28 +24,28 @@ export default class Constructor {
 
   getType() { return this.term.getType(); }
 
-  verify(fileContext) {
-    let verified;
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel;
 
     const constructorString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${constructorString}' constructor...`);
+    fileContext.trace(`Verifying the '${constructorString}' constructor at top level...`);
 
     const termTypeVerified = this.term.verifyType(fileContext);
 
     if (termTypeVerified) {
-      const termVerifiedAsConstructor = this.term.verifyAsConstructor(fileContext);
+      const termVerifiedAtTopLevel = this.term.verifyAtTopLevel(fileContext);
 
-      if (termVerifiedAsConstructor) {
-        verified = true; ///
+      if (termVerifiedAtTopLevel) {
+        verifiedAtTopLevel = true; ///
       }
     }
 
-    if (verified) {
-      fileContext.debug(`...verified the '${constructorString}' constructor.`);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${constructorString}' constructor at top level.`);
     }
 
-    return verified;
+    return verifiedAtTopLevel;
   }
 
   toJSON() {
@@ -65,6 +65,8 @@ export default class Constructor {
 
     json = termJSON;  ///
 
+    const { Term } = shim;
+
     term = Term.fromJSON(json, fileContext);
 
     const type = term.getType(),
@@ -77,8 +79,10 @@ export default class Constructor {
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
     const termNode = termNodeQuery(constructorDeclarationNode),
           typeNode = typeNodeQuery(constructorDeclarationNode),
-          type = Type.fromTypeNode(typeNode),
-          term = Term.fromTermNodeAndType(termNode, type, fileContext),
+          type = (typeNode === null) ?
+                   objectType :
+                     Type.fromTypeNode(typeNode),
+          term = Term.fromTermNodeAndType(termNode, type),
           string = stringFromTermAndType(term, type),
           constructor = new Constructor(string, term);
 
@@ -86,7 +90,7 @@ export default class Constructor {
   }
 }
 
-function stringFromTermAndType(term, type) {
+export function stringFromTermAndType(term, type) {
   let string;
 
   const termString = term.getString();

package/src/context/file.js

@@ -364,40 +364,10 @@ export default class FileContext {
     return type;
   }
 
-  findTypeByTypeNode(typeNode) {
-    let types = this.getTypes();
-
-    types.push(objectType);
-
-    const type = types.find((type) => {
-      const nodeMatches = type.matchTypeNode(typeNode);
-
-      if (nodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return type;
-  }
-
-  findVariableByVariableNode(variableNode) {
-    const node = variableNode,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const nodeMatches = variable.matchNode(node);
-
-            if (nodeMatches) {
-              return true;
-            }
-          }) || null;
-
-    return variable;
-  }
-
-  findMetaTypeByMetaTypeNode(metaTypeNode) {
+  findMetaTypeByMetaTypeName(metaTypeName) {
     const metaTypes = this.getMetaTypes(),
           metaType = metaTypes.find((metaType) => {
-            const metaTypeNodeMatches = metaType.matchMetaTypeNode(metaTypeNode);
+            const metaTypeNodeMatches = metaType.matchMetaTypeName(metaTypeName);
 
             if (metaTypeNodeMatches) {
               return true;
@@ -420,6 +390,48 @@ export default class FileContext {
     return label;
   }
 
+  findMetavariableByMetavariableName(metavariableName) {
+    const name = metavariableName,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const nameMatches = metavariable.matchName(name);
+
+            if (nameMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  isTypePresentByTypeName(typeName) {
+    const type = this.findTypeByTypeName(typeName),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
+  isLabelPresentByMetavariableNode(metavariableNode) {
+    const label = this.findLabelByMetavariableNode(metavariableNode),
+          labelPresent = (label !== null);
+
+    return labelPresent;
+  }
+
+  isMetavariablePresentByMetavariableName(metavariableName) {
+    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+          metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
   findRuleByReference(reference) {
     const rules = this.getRules(),
           metavariableNode = reference.getMetavariableNode(),
@@ -518,73 +530,18 @@ export default class FileContext {
     return metatheorem;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode) {
-    const metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
-
-            if (metavariableNodeMatches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
-  findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
-          metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchName(name);
+  findVariableByVariableName(variableName) {
+    const name = variableName,  ///
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const nameMatches = variable.matchName(name);
 
             if (nameMatches) {
               return true;
             }
           }) || null;
 
-    return metavariable;
-  }
-
-  isTypePresentByTypeName(typeName) {
-    const type = this.findTypeByTypeName(typeName),
-          typePresent = (type !== null);
-
-    return typePresent;
-  }
-
-  isTypePresentByTypeNode(typeNode) {
-    const type = this.findTypeByTypeNode(typeNode),
-          typePresent = (type !== null);
-
-    return typePresent;
-  }
-
-  isVariablePresentByVariableNode(variableNode) {
-    const variable = this.findVariableByVariableNode(variableNode),
-          variablePresent = (variable !== null);
-
-    return variablePresent;
-  }
-
-  isLabelPresentByMetavariableNode(metavariableNode) {
-    const label = this.findLabelByMetavariableNode(metavariableNode),
-          labelPresent = (label !== null);
-
-    return labelPresent;
-  }
-
-  isMetavariablePresentByMetavariableName(metavariablename) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariablename),
-          metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
-  }
-
-  isMetavariablePresentByMetavariableNode(metavariableNode) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
-          metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
+    return variable;
   }
 
   nodeAsString(node) {

package/src/context/local.js

@@ -303,8 +303,14 @@ class LocalContext {
     return variableDefined;
   }
 
-  isVariablePresentByVariableNode(variableNode) {
-    const variable = this.findVariableByVariableNode(variableNode),
+  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+
+  isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
+
+  isMetavariablePresentByMetavariableName(metavariableName) { return this.context.isMetavariablePresentByMetavariableName(metavariableName); }
+
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
           variablePresent = (variable !== null);
 
     return variablePresent;
@@ -319,34 +325,18 @@ class LocalContext {
 
   isMetavariableDefinedByMetavariableName(metavariableName) {
     const judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName),
-      metavariableDefinedByMetavariableName = judgementPresent; ///
+          metavariableDefinedByMetavariableName = judgementPresent; ///
 
     return metavariableDefinedByMetavariableName
   }
 
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
-
-  isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
-
-  isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
-
-  isMetavariablePresentByMetavariableName(metavariableName) { return this.context.isMetavariablePresentByMetavariableName(metavariableName); }
-
-  isMetavariablePresentByMetavariableNode(metavariableNode) { return this.context.isMetavariablePresentByMetavariableNode(metavariableNode); }
+  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
 
-  findVariableByVariableNode(variableNode) {
-    const node = variableNode,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const nodeMatches = variable.matchNode(node);
+  findVariableByVariableName(variableName) { return this.context.findVariableByVariableName(variableName); }
 
-            if (nodeMatches) {
-              return true;
-            }
-          }) || null;
+  findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-    return variable;
-  }
+  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
 
   findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
@@ -375,16 +365,8 @@ class LocalContext {
     return metavariable;
   }
 
-  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
-
-  findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
-
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
-
   findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
-
   findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
 
   findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }

package/src/declaration/combinator.js

@@ -25,9 +25,9 @@ export default class CombinatorDeclaration {
 
     this.fileContext.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerified = this.combinator.verify(this.fileContext);
+    const combinatorVerifiedAtTopLevel = this.combinator.verifyAtTopLevel(this.fileContext);
 
-    if (combinatorVerified) {
+    if (combinatorVerifiedAtTopLevel) {
       this.fileContext.addCombinator(this.combinator);
 
       verified = true;

package/src/declaration/metavariable.js

@@ -33,9 +33,9 @@ export default class MetavariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerified = this.metavariable.verifyWhenDeclared(this.fileContext);
+    const metavariableVerifiedAtTopLevel = this.metavariable.verifyAtTopLevel(this.fileContext);
 
-    if (metavariableVerified) {
+    if (metavariableVerifiedAtTopLevel) {
       this.fileContext.addMetavariable(this.metavariable);
 
       verified = true;
@@ -52,11 +52,25 @@ export default class MetavariableDeclaration {
     const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
           metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext),
           metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
-          metavariableString = metavariable.getString(),
-          metaTypeString = metaType.getString(),
-          string = `${metavariableString}:${metaTypeString}`,
+          string = stringFromMetavariableAndMetaType(metavariable, metaType),
           metavariableDeclaration = new MetavariableDeclaration(fileContext, string, metavariable);
 
     return metavariableDeclaration;
   }
-}
+}
+
+function stringFromMetavariableAndMetaType(metavariable, metaType) {
+  let string;
+
+  const metavariableString = metavariable.getString();
+
+  if (metaType === null) {
+    string = metavariableString; ///
+  } else {
+    const metaTypeString = metaType.getString();
+
+    string = `${metavariableString}:${metaTypeString}`;
+  }
+
+  return string;
+}

package/src/declaration/type.js

@@ -25,9 +25,9 @@ export default class TypeDeclaration {
 
     this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
 
-    const typeVerified = this.type.verifyWhenDeclared(this.fileContext);
+    const typeVerifiedAtTopLevel = this.type.verifyAtTopLevel(this.fileContext);
 
-    if (typeVerified) {
+    if (typeVerifiedAtTopLevel) {
       this.fileContext.addType(this.type);
 
       verified = true;

package/src/declaration/variable.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import Type, {objectType} from "../type";
+import Variable from "../variable";
+
+import { nodeQuery } from "../utilities/query";
+
+const typeNodeQuery = nodeQuery("/variableDeclaration/type");
+
+export default class VariableDeclaration {
+  constructor(fileContext, string, variable) {
+    this.fileContext = fileContext;
+    this.string = string;
+    this.variable = variable;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  verify() {
+    let verified;
+
+    const variableDeclarationString = this.string; ///
+
+    this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
+
+    const variableVerifiedAtTopLevel = this.variable.verifyAtTopLevel(this.fileContext);
+
+    if (variableVerifiedAtTopLevel) {
+      this.fileContext.addVariable(this.variable);
+
+      verified = true;
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
+    const typeNode = typeNodeQuery(variableDeclarationNode),
+          type = (typeNode === null) ?
+                   objectType :
+                     Type.fromTypeNode(typeNode, fileContext),
+          variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
+          string = stringFromVariableAndType(variable, type),
+          variableDeclaration = new VariableDeclaration(fileContext, string, variable);
+
+    return variableDeclaration;
+  }
+}
+
+function stringFromVariableAndType(variable, type) {
+  let string;
+
+  const variableString = variable.getString();
+
+  if (type === null) {
+    string = variableString;  ///
+  } else {
+    const typeString = type.getString();
+
+    string = `${variableString}:${typeString}`;
+  }
+
+  return string;
+}