occam-verify-cli 0.0.1265 → 0.0.1267

package/src/dom/declaration/constructor.js

@@ -2,8 +2,11 @@
 
 import dom from "../../dom";
 
+import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 
+import constructorVerifier from "../../verifier/constructor";
+
 export default domAssigned(class ConstructorDeclaration {
   constructor(fileContext, constructor) {
     this.fileContext = fileContext;
@@ -27,12 +30,25 @@ export default domAssigned(class ConstructorDeclaration {
 
     this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    const constructorVerifiedWhenDeclared = this.constructor.verifyWhenDeclared(this.fileContext);
+    const term = this.constructor.getTerm(),
+          termVerified = this.verifyTerm(term);
+
+    if (termVerified) {
+      let type = this.constructor.getType();
+
+      const typeVerified = this.verifyType(type);
+
+      if (typeVerified) {
+        const typeName = type.getName();
+
+        type = this.fileContext.findTypeByTypeName(typeName);
+
+        term.setType(type);
 
-    if (constructorVerifiedWhenDeclared) {
-      this.fileContext.addConstructor(this.constructor);
+        this.fileContext.addConstructor(this.constructor);
 
-      verified = true;
+        verified = true;
+      }
     }
 
     if (verified) {
@@ -42,6 +58,50 @@ export default domAssigned(class ConstructorDeclaration {
     return verified;
   }
 
+  verifyTerm(term) {
+    let termVerified;
+
+    const termString = term.getString(); ///
+
+    this.fileContext.trace(`Verifying the '${termString}' term...`);
+
+    const termNode = term.getNode();
+
+    termVerified = constructorVerifier.verifyTerm(termNode, this.fileContext);
+
+    if (termVerified) {
+      this.fileContext.debug(`...verified the '${termString}' term.`);
+    }
+
+    return termVerified;
+  }
+
+  verifyType(type) {
+    let typeVerified;
+
+    if (type === objectType) {
+      typeVerified = true;
+    } else {
+      const typeName = type.getName();
+
+      this.fileContext.trace(`Verifying the '${typeName}' type...`);
+
+      const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+      if (!typePresent) {
+        this.fileContext.debug(`The '${typeName}' type is not present.`);
+      } else {
+        typeVerified = true;
+      }
+
+      if (typeVerified) {
+        this.fileContext.debug(`...verified the '${typeName}' type.`);
+      }
+    }
+
+    return typeVerified;
+  }
+
   static name = "ConstructorDeclaration";
 
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {

package/src/dom/declaration/metavariable.js

@@ -4,8 +4,10 @@ import dom from "../../dom";
 
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
+import {objectType} from "../type";
 
-const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
+const termNodeQuery = nodeQuery("/metavariable/argument/term"),
+      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
 
 export default domAssigned(class MetavariableDeclaration {
   constructor(fileContext, string, metavariable) {
@@ -33,9 +35,9 @@ export default domAssigned(class MetavariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerifiedWhenDeclared = this.metavariable.verifyWhenDeclared(this.fileContext);
+    const metavariableVerified = this.verifyMetavariable(this.metavariable);
 
-    if (metavariableVerifiedWhenDeclared) {
+    if (metavariableVerified) {
       this.fileContext.addMetavariable(this.metavariable);
 
       verified = true;
@@ -48,6 +50,69 @@ export default domAssigned(class MetavariableDeclaration {
     return verified;
   }
 
+  verifyType(type) {
+    let typeVerified;
+
+    if (type === null) {
+      typeVerified = true;
+    } else {
+      if (type === objectType) {
+        typeVerified = true;
+      } else {
+        const typeName = type.getName();
+
+        this.fileContext.trace(`Verifying the '${typeName}' type...`);
+
+        const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+        if (!typePresent) {
+          this.fileContext.debug(`The '${typeName}' type is not present.`);
+        } else {
+          typeVerified = true;
+        }
+
+        if (typeVerified) {
+          this.fileContext.debug(`...verified the '${typeName}' type.`);
+        }
+      }
+    }
+
+    return typeVerified;
+  }
+
+  verifyMetavariable(metavariable) {
+    let metavariableVerified = false;
+
+    const metavariableString = metavariable.getString();
+
+    this.fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
+
+    const metavariableNode = metavariable.getNode(), ///
+          termNode = termNodeQuery(metavariableNode);
+
+    if (termNode !== null) {
+      this.fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
+    } else {
+      const metavariableName = metavariable.getName(),
+            metavariablePresent = this.fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+      if (metavariablePresent) {
+        this.fileContext.debug(`The '${metavariableName}' metavariable is already present.`);
+      } else {
+        const type = metavariable.getType(),
+              typeVerified = this.verifyType(type);
+
+        metavariableVerified = typeVerified;  ///
+      }
+    }
+
+    if (metavariableVerified) {
+      this.fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
+    }
+
+    return metavariableVerified;
+  }
+
   static name = "MetavariableDeclaration";
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {

package/src/dom/declaration/type.js

@@ -27,9 +27,9 @@ export default domAssigned(class TypeDeclaration {
 
     this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
 
-    const typeVerifiedWhenDeclared = this.type.verifyWhenDeclared(this.fileContext);
+    const typeVerified = this.verifyType(this.type);
 
-    if (typeVerifiedWhenDeclared) {
+    if (typeVerified) {
       this.fileContext.addType(this.type);
 
       verified = true;
@@ -42,6 +42,42 @@ export default domAssigned(class TypeDeclaration {
     return verified;
   }
 
+  verifyType(type) {
+    let typeVerified = false;
+
+    const typeName = type.getName();
+
+    this.fileContext.trace(`Verifying the '${typeName}' type...`);
+
+    const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+    if (typePresent) {
+      this.fileContext.debug(`The type '${typeName}' is not present.`);
+    } else {
+      let superType;
+
+      superType = type.getSuperType();
+
+      const superTypeName = superType.getName();
+
+      superType = this.fileContext.findTypeByTypeName(superTypeName);
+
+      if (superType === null) {
+        this.fileContext.debug(`The super-type '${superTypeName}' is not present.`);
+      } else {
+        type.setSuperType(superType);
+
+        typeVerified = true;
+      }
+    }
+
+    if (typeVerified) {
+      this.fileContext.debug(`...typeVerified the '${typeName}' type.`);
+    }
+
+    return typeVerified;
+  }
+
   static name = "TypeDeclaration";
 
   static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {

package/src/dom/declaration/variable.js

@@ -3,6 +3,7 @@
 import dom from "../../dom";
 
 import { nodeQuery } from "../../utilities/query";
+import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 import { typeNameFromTypeNode } from "../../utilities/name";
 
@@ -28,18 +29,32 @@ export default domAssigned(class VariableDeclaration {
   }
 
   verify() {
-    let verified;
+    let verified = false;
 
     const variableDeclarationString = this.string; ///
 
     this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
-    const variableVerifiedWhenDeclared = this.variable.verifyWhenDeclared(this.fileContext);
+    const variableVerified = this.verifyVariable(this.variable);
 
-    if (variableVerifiedWhenDeclared) {
-      this.fileContext.addVariable(this.variable);
+    if (variableVerified) {
+      let type;
 
-      verified = true;
+      type = this.variable.getType();
+
+      const typeVerified = this.verifyType(type);
+
+      if (typeVerified) {
+        const typeName = type.getName();
+
+        type = this.fileContext.findTypeByTypeName(typeName);
+
+        this.variable.setType(type);
+
+        this.fileContext.addVariable(this.variable);
+
+        verified = true;
+      }
     }
 
     if (verified) {
@@ -49,6 +64,55 @@ export default domAssigned(class VariableDeclaration {
     return verified;
   }
 
+  verifyType(type) {
+    let typeVerified = false;
+
+    if (type === objectType) {
+      typeVerified = true;
+    } else {
+      const typeName = type.getName();
+
+      this.fileContext.trace(`Verifying the '${typeName}' type...`);
+
+      const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+      if (!typePresent) {
+        this.fileContext.debug(`The '${typeName}' type is not present.`);
+      } else {
+        typeVerified = true;
+      }
+
+      if (typeVerified) {
+        this.fileContext.debug(`...verified the '${typeName}' type.`);
+      }
+    }
+
+    return typeVerified;
+  }
+
+  verifyVariable(variable) {
+    let  variableVerified = false;
+
+    const variableString = variable.getString();
+
+    this.fileContext.trace(`Verifying the '${variableString}' variable...`);
+
+    const variableName = 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;
+  }
+
   static name = "VariableDeclaration";
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {

package/src/dom/metavariable.js

@@ -17,8 +17,7 @@ import { metavariableFromFrame, metavariableFromStatement } from "../utilities/v
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/metavariable/argument/term"),
-      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
+const metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       labelMetavariableNodeQuery = nodeQuery("/label/metavariable"),
       referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable"),
@@ -127,77 +126,6 @@ export default domAssigned(class Metavariable {
     return verified;
   }
 
-  verifyType(fileContext) {
-    let typeVerified;
-
-    if (this.type === null) {
-      typeVerified = true;
-    } else {
-      if (this.type === objectType) {
-        typeVerified = true;
-      } else {
-        const typeName = this.type.getName();
-
-        fileContext.trace(`Verifying the '${typeName}' type...`);
-
-        const type = fileContext.findTypeByTypeName(typeName);
-
-        if (type === null) {
-          fileContext.debug(`The '${typeName}' type is missing.`);
-        } else {
-          this.type = type; ///
-
-          typeVerified = true;
-        }
-
-        if (typeVerified) {
-          fileContext.debug(`...verified the '${typeName}' type.`);
-        }
-      }
-    }
-
-    return typeVerified;
-  }
-
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared = false;
-
-    const metavariableString = this.string; ///
-
-    fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
-
-    const metavariableNode = this.node, ///
-          termNode = termNodeQuery(metavariableNode);
-
-    if (termNode !== null) {
-      fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
-    } else {
-      const metavariableName = this.name, ///
-        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
-
-      if (metavariablePresent) {
-        fileContext.debug(`The '${metavariableName}' metavariable has already been declared.`);
-      } else {
-        const variableName = this.name, ///
-          variablePresent = fileContext.isVariablePresentByVariableName(variableName);
-
-        if (variablePresent) {
-          fileContext.debug(`A '${metavariableName}' variable has already been declared.`);
-        } else {
-          const typeVerified = this.verifyType(fileContext);
-
-          verifiedWhenDeclared = typeVerified;
-        }
-      }
-    }
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
   verifyGivenMetaType(metaType, context) {
     let verifiedGivenMetaType = false;
 

package/src/dom/property.js

@@ -1,14 +1,14 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
-import { propertyNameFromPropertyNode } from "../utilities/name";
 
-const propertyDeclarationTypeNodeQuery = nodeQuery("/propertyDeclaration/type");
+const typeNodeQuery = nodeQuery("/property/type"),
+      propertyNodeQuery = nodeQuery("/propertyDeclaration/property"),
+      nameTerminalNodeQuery = nodeQuery("/property/@name");
 
 export default domAssigned(class Property {
   constructor(string, name, type) {
@@ -68,31 +68,30 @@ export default domAssigned(class Property {
     return property;
   }
 
-  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
-    let property = null;
-
-    const propertyNode = propertyNodeQuery(propertyDeclarationNode);
-
-    if (propertyNode !== null) {
-      const node = propertyNode,  ///
-            propertyName = propertyNameFromPropertyNode(propertyDeclarationNode),
-            string = context.nodeAsString(node),
-            name = propertyName,  ///
-            type = null;
-
-      property = new Property(string, node, name, type);
-    }
+  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+    const propertyNode = propertyNodeQuery(propertyDeclarationNode),
+          node = propertyNode,  ///
+          name = nameFromPropertyNode(propertyNode),
+          type = typeFromPropertyNode(propertyNode),
+          string = fileContext.nodeAsString(node),
+          property = new Property(string, name, type);
 
     return property;
   }
 });
 
-function typeFromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+function nameFromPropertyNode(propertyNode, fileContext) {
+  const nameTerminalNode = nameTerminalNodeQuery(propertyNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        name = nameTerminalNodeContent; ///
+
+  return name;
+}
+
+function typeFromPropertyNode(propertyNode, fileContext) {
   const { Type } = dom,
-        propertyDeclarationTypeNode = propertyDeclarationTypeNodeQuery(propertyDeclarationNode),
-        typeNode = propertyDeclarationTypeNode, ///
-        context = LocalContext.fromFileContext(fileContext),
-        type = Type.fromTypeNode(typeNode, context);
+        typeNode = typeNodeQuery(propertyNode),
+        type = Type.fromTypeNode(typeNode);
 
   return type;
 }

package/src/dom/statement.js

@@ -5,7 +5,6 @@ import { arrayUtilities } from "necessary";
 import dom from "../dom";
 import LocalContext from "../context/local";
 import verifyMixins from "../mixins/statement/verify";
-import combinatorVerifier from "../verifier/combinator";
 import StatementPartialContext from "../context/partial/statement";
 
 import { domAssigned } from "../dom";
@@ -128,23 +127,6 @@ export default domAssigned(class Statement {
     return verified;
   }
 
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared;
-
-    const statementNode = this.node,  ///
-          statementString = this.string;  ///
-
-    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);
-
-    verifiedWhenDeclared = combinatorVerifier.verifyStatement(statementNode, fileContext);
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${statementString}' statement when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
   verifyGivenMetaType(metaType, assignments, stated, context) {
     let verifiedGivenMetaType = false;
 

package/src/dom/term.js

@@ -5,9 +5,7 @@ import { arrayUtilities } from "necessary";
 import dom from "../dom";
 import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
-import constructorVerifier from "../verifier/constructor";
 
-import { objectType } from "./type";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query"
 import { termNodeFromTermString } from "../context/partial/term";
@@ -149,34 +147,6 @@ export default domAssigned(class Term {
     return verified;
   }
 
-  verifyType(fileContext) {
-    let typeVerified;
-
-    if (this.type === objectType) {
-      typeVerified = true;
-    } else {
-      const typeName = this.type.getName();
-
-      fileContext.trace(`Verifying the '${typeName}' type...`);
-
-      const type = fileContext.findTypeByTypeName(typeName);
-
-      if (type === null) {
-        fileContext.debug(`The '${typeName}' type is missing.`);
-      } else {
-        this.type = type; ///
-
-        typeVerified = true;
-      }
-
-      if (typeVerified) {
-        fileContext.debug(`...verified the '${typeName}' type.`);
-      }
-    }
-
-    return typeVerified;
-  }
-
   verifyGivenType(type, generalContext, specificContext) {
     let verifiedGivenType;
 
@@ -207,29 +177,6 @@ export default domAssigned(class Term {
     return verifiedGivenType;
   }
 
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared;
-
-    const termString = this.string;  ///
-
-    fileContext.trace(`Verifying the '${termString}' term when declared...`);
-
-    const termNode = this.node, ///
-          termVerifiedAsConstructor = constructorVerifier.verifyTerm(termNode, fileContext);
-
-    if (termVerifiedAsConstructor) {
-      const typeVerified = this.verifyType(fileContext);
-
-      verifiedWhenDeclared = typeVerified;  ///
-    }
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${termString}' term when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           string = this.string,