occam-verify-cli 1.0.172 → 1.0.175

package/src/dom/declaration/constructor.js

@@ -32,41 +32,15 @@ export default domAssigned(class ConstructorDeclaration {
 
     this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    const constructorVerified = this.verifyConstructor();
+    const constructorTypeVerified = this.verifyConstructorType();
 
-    if (constructorVerified) {
-      const typeVerified = this.verifyType();
-
-      if (typeVerified) {
-        let type;
-
-        type = this.constructor.getType();
-
-        const typeName = type.getName();
-
-        type = this.fileContext.findTypeByTypeName(typeName);
-
-        const typeProvisional = type.isProvisional(),
-              constructorProvisional = this.constructor.isProvisional();
+    if (constructorTypeVerified) {
+      const constructorVerified = this.verifyConstructor();
 
-        if (typeProvisional !== constructorProvisional) {
-          const typeString = type.getString(),
-                constructorString = this.constructor.getString();
+      if (constructorVerified) {
+        this.fileContext.addConstructor(this.constructor);
 
-          if (typeProvisional) {
-            this.fileContext.debug(`The '${typeString}' type is provisional whilst the '${constructorString}' constructor's type is not.`);
-          }
-
-          if (constructorProvisional) {
-            this.fileContext.debug(`The '${typeString}' type is not provisional whilst the '${constructorString}' constructor's type is.`);
-          }
-        } else {
-          this.constructor.setType(type);
-
-          this.fileContext.addConstructor(this.constructor);
-
-          verified = true;
-        }
+        verified = true;
       }
     }
 
@@ -77,31 +51,6 @@ export default domAssigned(class ConstructorDeclaration {
     return verified;
   }
 
-  verifyType() {
-    let typeVerified;
-
-    const type = this.constructor.getType();
-
-    const typeName = type.getName(),
-          typeString = type.getString();
-
-    this.fileContext.trace(`Verifying the '${typeString}' type...`);
-
-    const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
-
-    if (!typePresent) {
-      this.fileContext.debug(`The '${typeString}' type is not present.`);
-    } else {
-      typeVerified = true;
-    }
-
-    if (typeVerified) {
-      this.fileContext.debug(`...verified the '${typeString}' type.`);
-    }
-
-    return typeVerified;
-  }
-
   verifyConstructor() {
     let constructorVerified;
 
@@ -121,6 +70,49 @@ export default domAssigned(class ConstructorDeclaration {
     return constructorVerified;
   }
 
+  verifyConstructorType() {
+    let constructorTypeVerified = false;
+
+    let type;
+
+    type = this.constructor.getType();
+
+    const typeName = type.getName(),
+          typeString = type.getString(),
+          constructorString = this.constructor.getString();
+
+    this.fileContext.trace(`Verifying the '${constructorString}' constructor's '${typeString}' type...`);
+
+    const includeSupertypes = false,
+          provisional = type.isProvisional(includeSupertypes);
+
+    type = this.fileContext.findTypeByTypeName(typeName);
+
+    const typePresent = (type !== null)
+
+    if (!typePresent) {
+      this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is not present.`);
+    } else {
+      const provisionalMatches = type.matchProvisional(provisional);
+
+      if (!provisionalMatches) {
+        provisional ?
+          this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is present but it should be provisional.`) :
+            this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is present but it should not be provisional.`);
+      } else {
+        this.constructor.setType(type);
+
+        constructorTypeVerified = true;
+      }
+    }
+
+    if (constructorTypeVerified) {
+      this.fileContext.debug(`...verified the '${constructorString}' constructor's '${typeString}' type.`);
+    }
+
+    return constructorTypeVerified;
+  }
+
   static name = "ConstructorDeclaration";
 
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {

package/src/dom/declaration/type.js

@@ -37,20 +37,6 @@ export default domAssigned(class TypeDeclaration {
       const superTypesVerified = this.verifySuperTypes();
 
       if (superTypesVerified) {
-        let superTypes;
-
-        superTypes = this.type.getSuperTypes();
-
-        superTypes = superTypes.map((superType) => {
-          const superTypeName = superType.getName();
-
-          superType = this.fileContext.findTypeByTypeName(superTypeName);
-
-          return superType;
-        });
-
-        this.type.setSuperTypes(superTypes);
-
         this.fileContext.addType(this.type);
 
         verified = true;
@@ -87,6 +73,25 @@ export default domAssigned(class TypeDeclaration {
     return typeVerified;
   }
 
+  verifySuperType(superType) {
+    let superTypeVerified;
+
+    const superTypeString = superType.getString();
+
+    this.fileContext.trace(`Verifying the '${superTypeString}' super-type...`);
+
+    const superTypeName = superType.getName(),
+          superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
+
+    superTypeVerified = superTypePresent; ///
+
+    if (superTypeVerified) {
+      this.fileContext.debug(`...verified the '${superTypeString}' super-type.`);
+    }
+
+    return superTypeVerified;
+  }
+
   verifySuperTypes() {
     let superTypesVerified;
 
@@ -95,11 +100,13 @@ export default domAssigned(class TypeDeclaration {
     if (typeBasic) {
       superTypesVerified = true;
     } else {
-      const typeString = this.type.getString(),
-            superTypes = this.type.getSuperTypes(),
-            superTypesString = superTypesStringFromSuperTypes(superTypes);
+      let superTypes;
+
+      superTypes = this.type.getSuperTypes();
+
+      const superTypesString = superTypesStringFromSuperTypes(superTypes);
 
-      this.fileContext.trace(`Verifying the '${typeString}' type's ${superTypesString} super-types...`);
+      this.fileContext.trace(`Verifying the ${superTypesString} super-types...`);
 
       superTypesVerified = superTypes.every((superType) => {
         const superTypeVerified = this.verifySuperType(superType);
@@ -110,31 +117,21 @@ export default domAssigned(class TypeDeclaration {
       });
 
       if (superTypesVerified) {
-        this.fileContext.debug(`...verified the '${typeString}' type's ${superTypesString} super-types.`);
-      }
-    }
-
-    return superTypesVerified;
-  }
-
-  verifySuperType(superType) {
-    let superTypeVerified;
-
-    const typeString = this.type.getString(),
-          superTypeString = superType.getString();
+        superTypes = superTypes.map((superType) => {
+          const superTypeName = superType.getName();
 
-    this.fileContext.trace(`Verifying the '${typeString}' type's '${superTypeString}' super-type...`);
+          superType = this.fileContext.findTypeByTypeName(superTypeName);
 
-    const superTypeName = superType.getName(),
-          superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
+          return superType;
+        });
 
-    superTypeVerified = superTypePresent; ///
+        this.type.setSuperTypes(superTypes);
 
-    if (superTypeVerified) {
-      this.fileContext.debug(`...verified the '${typeString}' type's '${superTypeString}' super-type.`);
+        this.fileContext.debug(`...verified the ${superTypesString} super-types.`);
+      }
     }
 
-    return superTypeVerified;
+    return superTypesVerified;
   }
 
   static name = "TypeDeclaration";

package/src/dom/declaration/variable.js

@@ -30,51 +30,50 @@ export default domAssigned(class VariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
-    const variableVerified = this.verifyVariable();
+    const variableTypeVerified = this.verifyVariableType();
 
-    if (variableVerified) {
-      const variableTypeVerified = this.verifyVariableType();
+    if (variableTypeVerified) {
+      const variableVerified = this.verifyVariable();
 
-      if (variableTypeVerified) {
-        let type;
+      if (variableVerified) {
+        this.fileContext.addVariable(this.variable);
 
-        type = this.variable.getType();
+        verified = true;
+      }
+    }
 
-        const typeName = type.getName();
+    if (verified) {
+      this.fileContext.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
+    }
 
-        type = this.fileContext.findTypeByTypeName(typeName);
+    return verified;
+  }
 
-        const typeProvisional = type.isProvisional(),
-              variableProvisional = this.variable.isProvisional();
+  verifyVariable() {
+    let  variableVerified = false;
 
-        if (typeProvisional !== variableProvisional) {
-          const typeString = type.getString(),
-                variableString = this.variable.getString();
+    const variableString = this.variable.getString();
 
-          if (typeProvisional) {
-            this.fileContext.debug(`The '${typeString}' type is provisional whilst the '${variableString}' variable's type is not.`);
-          }
+    this.fileContext.trace(`Verifying the '${variableString}' variable...`);
 
-          if (variableProvisional) {
-            this.fileContext.debug(`The '${typeString}' type is not provisional whilst the '${variableString}' variable's type is.`);
-          }
-        } else {
-          this.fileContext.addVariable(this.variable);
+    const variableName = this.variable.getName(),
+          variablePresent = this.fileContext.isVariablePresentByVariableName(variableName);
 
-          verified = true;
-        }
-      }
+    if (variablePresent) {
+      this.fileContext.debug(`The '${variableName}' variable is already present.`);
+    } else {
+      variableVerified = true;
     }
 
-    if (verified) {
-      this.fileContext.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
+    if ( variableVerified) {
+      this.fileContext.debug(`...verified the '${variableString}' variable.`);
     }
 
-    return verified;
+    return  variableVerified;
   }
 
   verifyVariableType() {
-    let typeVerified = false;
+    let variableTypeVerified = false;
 
     let type;
 
@@ -105,38 +104,15 @@ export default domAssigned(class VariableDeclaration {
       } else {
         this.variable.setType(type);
 
-        typeVerified = true;
+        variableTypeVerified = true;
       }
     }
 
-    if (typeVerified) {
+    if (variableTypeVerified) {
       this.fileContext.debug(`...verified the '${variableString}' variable's '${typeString}' type.`);
     }
 
-    return typeVerified;
-  }
-
-  verifyVariable() {
-    let  variableVerified = false;
-
-    const variableString = this.variable.getString();
-
-    this.fileContext.trace(`Verifying the '${variableString}' variable...`);
-
-    const variableName = this.variable.getName(),
-          variablePresent = this.fileContext.isVariablePresentByVariableName(variableName);
-
-    if (variablePresent) {
-      this.fileContext.debug(`The '${variableName}' variable is already present.`);
-    } else {
-      variableVerified = true;
-    }
-
-    if ( variableVerified) {
-      this.fileContext.debug(`...verified the '${variableString}' variable.`);
-    }
-
-    return  variableVerified;
+    return variableTypeVerified;
   }
 
   static name = "VariableDeclaration";

package/src/dom/metaType.js

@@ -4,7 +4,6 @@ import LocalContext from "../context/local";
 
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
-import { metaTypeNameFromMetaTypeNode } from "../utilities/name";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metavariableDeclarationMetaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
@@ -73,7 +72,7 @@ class MetaType {
 }
 
 function metaTypeFromMetaTypeNode(metaTypeNode, context) {
-  const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+  const metaTypeName = metaTypeNode.getMetaTypeName(),
         metaType = metaTypeFromMetaTypeName(metaTypeName);
 
   return metaType;

package/src/dom/metavariable.js

@@ -14,7 +14,6 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { metavariableFromFrame, metavariableFromStatement } from "../utilities/context";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
-import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       labelMetavariableNodeQuery = nodeQuery("/label/metavariable"),
@@ -458,7 +457,7 @@ export default domAssigned(class Metavariable {
           metavariablePartialContext = MetavariablePartialContext.fromStringLexerAndParser(string, lexer, parser),
           metavariableTokens = metavariablePartialContext.getMetavariableTokens(),
           metavariableNode = metavariablePartialContext.getMetavariableNode(),
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          metavariableName = metavariableNode.getMetavariableName(),
           name = metavariableName,  ///
           node = metavariableNode,  ///
           tokens = metavariableTokens, ///
@@ -543,7 +542,7 @@ export default domAssigned(class Metavariable {
 
 function metavariableFromMetavariableNode(metavariableNode, context) {
   const { Metavariable } = dom,
-        metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariableName = metavariableNode.getMetavariableName(),
         type = null,
         name = metavariableName,  ///
         node = metavariableNode,  ///
@@ -562,7 +561,7 @@ function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileCo
 
   if (metavariableDeclarationMetavariableTypeNode !== null) {
     const typeNode = metavariableDeclarationMetavariableTypeNode, ///
-          typeName = typeNameFromTypeNode(typeNode);
+          typeName = typeNode.getTypeName();
 
     type = fileContext.findTypeByTypeName(typeName);
   }

package/src/dom/property.js

@@ -12,8 +12,7 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 const { match } = arrayUtilities;
 
 const nameTerminalNodesQuery = nodesQuery("/property/@name"),
-      propertyRelationPropertyNodeQuery = nodeQuery("/propertyRelation/property"),
-      propertyDeclarationPropertyNodeQuery = nodeQuery("/propertyDeclaration/property");
+      propertyRelationPropertyNodeQuery = nodeQuery("/propertyRelation/property");
 
 export default domAssigned(class Property {
   constructor(string, names, type) {
@@ -88,11 +87,10 @@ export default domAssigned(class Property {
   static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
     const { Type } = dom,
           type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
-          propertyDeclarationPropertyNode = propertyDeclarationPropertyNodeQuery(propertyDeclarationNode),
-          propertyNode = propertyDeclarationPropertyNode,  ///
-          property = propertyFromPropertyNode(propertyNode, fileContext);
-
-    property.setType(type);
+          propertyNames = propertyDeclarationNode.getPropertyNames(),
+          names = propertyNames,  ///
+          string = stringFromNamesAndType(names, type),
+          property = new Property(string, names, type);
 
     return property;
   }

package/src/dom/statement.js

@@ -2,7 +2,6 @@
 
 import { arrayUtilities } from "necessary";
 
-import dom from "../dom";
 import LocalContext from "../context/local";
 import verifyMixins from "../mixins/statement/verify";
 import StatementPartialContext from "../context/partial/statement";
@@ -11,6 +10,7 @@ import { domAssigned } from "../dom";
 import { unifyStatement } from "../utilities/unification";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+import { statementFromStatementNode } from "../utilities/node";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
 import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/context";
 
@@ -24,8 +24,7 @@ const stepStatementNodeQuery = nodeQuery("/step/statement"),
       conclusionStatementNodeQuery = nodeQuery("/conclusion/statement"),
       suppositionStatementNodeQuery = nodeQuery("/supposition/statement"),
       declarationStatementNodeQuery = nodeQuery("/declaration/statement"),
-      containedAssertionStatementNodeQuery = nodeQuery("/containedAssertion/statement"),
-      combinatorDeclarationStatementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
+      containedAssertionStatementNodeQuery = nodeQuery("/containedAssertion/statement");
 
 export default domAssigned(class Statement {
   constructor(string, node, tokens) {
@@ -391,28 +390,11 @@ export default domAssigned(class Statement {
   }
 
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
-    let statement = null;
-
-    const combinatorDeclarationStatementNode = combinatorDeclarationStatementNodeQuery(combinatorDeclarationNode);
-
-    if (combinatorDeclarationStatementNode !== null) {
-      const statementNode = combinatorDeclarationStatementNode, ///
-            localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
-      statement = statementFromStatementNode(statementNode, context);
-    }
+    const statementNode = combinatorDeclarationNode.getStatementNode(),
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
+          statement = statementFromStatementNode(statementNode, context);
 
     return statement;
   }
 });
-
-function statementFromStatementNode(statementNode, context) {
-  const { Statement } = dom,
-        node = statementNode, ///
-        tokens = context.nodeAsTokens(node),
-        string = context.tokensAsString(tokens),
-        statement = new Statement(string, node, tokens);
-
-  return statement;
-}

package/src/dom/term.js

@@ -7,6 +7,7 @@ import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 
 import { domAssigned } from "../dom";
+import { termFromTermNode } from "../utilities/node";
 import { nodeQuery, nodesQuery } from "../utilities/query"
 import { termNodeFromTermString } from "../context/partial/term";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
@@ -19,8 +20,7 @@ const variableNodesQuery = nodesQuery("//variable"),
       definedAssertionTermNodeQuery = nodeQuery("/definedAssertion/term"),
       propertyRelationTermNodeQuery = nodeQuery("/propertyRelation/term"),
       propertyAssertionTermNodeQuery = nodeQuery("/propertyAssertion/term"),
-      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term"),
-      constructorDeclarationTermNodeQuery = nodeQuery("/constructorDeclaration/term");
+      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
 
 export default domAssigned(class Term {
   constructor(string, node, type) {
@@ -79,6 +79,8 @@ export default domAssigned(class Term {
     return termNodeMatches;
   }
 
+  isProvisional() { return this.type.isProvisional(); }
+
   isEqualTo(term) {
     const termString = term.getString(),
           equalTo = (termString === this.string);
@@ -282,10 +284,11 @@ export default domAssigned(class Term {
     return term;
   }
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
     const { Type } = dom,
-          constructorDeclarationTermNode = constructorDeclarationTermNodeQuery(constructorDeclarationNode),
-          termNode = constructorDeclarationTermNode,  ///
+          termNode = constructorDeclarationNode.getTermNode(),
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
           term = termFromTermNode(termNode, context),
           type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
 
@@ -295,12 +298,3 @@ export default domAssigned(class Term {
   }
 });
 
-function termFromTermNode(termNode, context) {
-  const { Term } = dom,
-        node = termNode,  ///
-        string = context.nodeAsString(node),
-        type = null,
-        term = new Term(string, node, type);
-
-  return term;
-}