occam-verify-cli 1.0.166 → 1.0.168

package/src/dom/declaration/complexType.js

@@ -2,9 +2,8 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
-import { superTypeStringFromSuperType, superTypesStringFromSuperTypes } from "../declaration/type";
+import { superTypesStringFromSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
   constructor(fileContext, string, type) {
@@ -74,26 +73,21 @@ export default domAssigned(class ComplexTypeDeclaration {
   verifyType() {
     let typeVerified = false;
 
-    const typeName = this.type.getName();
+    const typeName = this.type.getName(),
+          typeString = this.type.getString();
 
-    this.fileContext.trace(`Verifying the '${typeName}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
     const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
 
     if (typePresent) {
-      const typeRefined = this.type.isRefined();
-
-      if (typeRefined) {
-        typeVerified = true;
-      } else {
-        this.fileContext.debug(`The type '${typeName}' is already present.`);
-      }
+      this.fileContext.debug(`The type '${typeString}' is already present.`);
     } else {
       typeVerified = true;
     }
 
     if (typeVerified) {
-      this.fileContext.debug(`...verified the '${typeName}' type.`);
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return typeVerified;
@@ -102,58 +96,57 @@ export default domAssigned(class ComplexTypeDeclaration {
   verifySuperTypes() {
     let superTypesVerified;
 
-    const typeBasic = this.type.isBasic(),
-          typeRefined = this.type.isRefined();
+    const typeBasic = this.type.isBasic();
 
-    if (typeBasic || typeRefined) {
+    if (typeBasic) {
       superTypesVerified = true;
     } else {
-      const typeName = this.type.getName(),
+      const typeString = this.type.getString(),
             superTypes = this.type.getSuperTypes(),
             superTypesString = superTypesStringFromSuperTypes(superTypes);
 
-      this.fileContext.trace(`Verifying the '${typeName}' type's ${superTypesString} super-types...`);
+      this.fileContext.trace(`Verifying the '${typeString}' type's ${superTypesString} super-types...`);
 
       superTypesVerified = superTypes.every((superType) => {
-        const superTypeVerified = this.verifySuperType(superType);
+        const superTypesVerified = this.verifySuperTypes(superType);
 
-        if (superTypeVerified) {
+        if (superTypesVerified) {
           return true;
         }
       });
 
       if (superTypesVerified) {
-        this.fileContext.debug(`...verified the '${typeName}' type's ${superTypesString} super-types.`);
+        this.fileContext.debug(`...verified the '${typeString}' type's ${superTypesString} super-types.`);
       }
     }
 
     return superTypesVerified;
   }
 
-  verifySuperType(superType) {
-    let superTypeVerified;
+  verifySuperTypes(superType) {
+    let superTypesVerified;
 
-    const superTypeObjectType = (superType === objectType);
+    const typeBasic = this.type.isBasic();
 
-    if (superTypeObjectType) {
-      superTypeVerified = true;
+    if (typeBasic) {
+      superTypesVerified = true;
     } else {
-      const typeName = this.type.getString(),
-            superTypeString = superTypeStringFromSuperType(superType);
+      const typeString = this.type.getString(),
+            superTypeString = superType.getString();
 
-      this.fileContext.trace(`Verifying the '${typeName}' type's '${superTypeString}' super-type...`);
+      this.fileContext.trace(`Verifying the '${typeString}' type's '${superTypeString}' super-type...`);
 
       const superTypeName = superType.getName(),
             superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
 
-      superTypeVerified = superTypePresent; ///
+      superTypesVerified = superTypePresent; ///
 
-      if (superTypeVerified) {
-        this.fileContext.debug(`...verified the '${typeName}' type's '${superTypeString}' super-type.`);
+      if (superTypesVerified) {
+        this.fileContext.debug(`...verified the '${typeString}' type's '${superTypeString}' super-type.`);
       }
     }
 
-    return superTypeVerified;
+    return superTypesVerified;
   }
 
   verifyProperty(property, properties, superTypeProperties) {
@@ -243,32 +236,28 @@ export default domAssigned(class ComplexTypeDeclaration {
   verifyPropertyType(propertyType) {
     let propertyTypeVerified = false;
 
-    if (propertyType === objectType) {
-      propertyTypeVerified = true;
-    } else {
-      const typeName = this.type.getName(),
-            propertyTypeName = propertyType.getName();
+    const typeEqualToPropertyType = this.type.isEqualTo(propertyType);
 
-      if (typeName === propertyTypeName) {
-        propertyTypeVerified = true;
-      } else  {
-        const propertyTypeString = propertyType.getString(); ///
+    if (typeEqualToPropertyType) {
+      propertyTypeVerified = true;
+    } else  {
+      const propertyTypeString = propertyType.getString(); ///
 
-        this.fileContext.trace(`Verifying the '${propertyTypeString}' property type...`);
+      this.fileContext.trace(`Verifying the '${propertyTypeString}' property type...`);
 
-        const propertyTypePresent = this.fileContext.isTypePresentByTypeName(propertyTypeName);
+      const propertyTypeName = propertyType.getName(),
+            propertyTypePresent = this.fileContext.isTypePresentByTypeName(propertyTypeName);
 
-        if (!propertyTypePresent) {
-          const propertyTypeString = propertyType.getString();
+      if (!propertyTypePresent) {
+        const propertyTypeString = propertyType.getString();
 
-          this.fileContext.debug(`The '${propertyTypeString}' property type is not present.`);
-        } else {
-          propertyTypeVerified = true;
-        }
+        this.fileContext.debug(`The '${propertyTypeString}' property type is not present.`);
+      } else {
+        propertyTypeVerified = true;
+      }
 
-        if (propertyTypeVerified) {
-          this.fileContext.debug(`...verified the '${propertyTypeString}' property type.`);
-        }
+      if (propertyTypeVerified) {
+        this.fileContext.debug(`...verified the '${propertyTypeString}' property type.`);
       }
     }
 

package/src/dom/declaration/constructor.js

@@ -4,7 +4,6 @@ import dom from "../../dom";
 
 import constructorVerifier from "../../verifier/constructor";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class ConstructorDeclaration {
@@ -83,24 +82,21 @@ export default domAssigned(class ConstructorDeclaration {
 
     const type = this.constructor.getType();
 
-    if (type === objectType) {
-      typeVerified = true;
-    } else {
-      const typeName = type.getName();
+    const typeName = type.getName(),
+          typeString = type.getString();
 
-      this.fileContext.trace(`Verifying the '${typeName}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
-      const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+    const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
 
-      if (!typePresent) {
-        this.fileContext.debug(`The '${typeName}' type is not present.`);
-      } else {
-        typeVerified = true;
-      }
+    if (!typePresent) {
+      this.fileContext.debug(`The '${typeString}' type is not present.`);
+    } else {
+      typeVerified = true;
+    }
 
-      if (typeVerified) {
-        this.fileContext.debug(`...verified the '${typeName}' type.`);
-      }
+    if (typeVerified) {
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return typeVerified;

package/src/dom/declaration/metavariable.js

@@ -2,7 +2,6 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
@@ -56,24 +55,21 @@ export default domAssigned(class MetavariableDeclaration {
     if (type === null) {
       typeVerified = true;
     } else {
-      if (type === objectType) {
-        typeVerified = true;
-      } else {
-        const typeName = type.getName();
+      const typeName = type.getName(),
+            typeString = type.getString();
 
-        this.fileContext.trace(`Verifying the '${typeName}' type...`);
+      this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
-        const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+      const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
 
-        if (!typePresent) {
-          this.fileContext.debug(`The '${typeName}' type is not present.`);
-        } else {
-          typeVerified = true;
-        }
+      if (!typePresent) {
+        this.fileContext.debug(`The '${typeString}' type is not present.`);
+      } else {
+        typeVerified = true;
+      }
 
-        if (typeVerified) {
-          this.fileContext.debug(`...verified the '${typeName}' type.`);
-        }
+      if (typeVerified) {
+        this.fileContext.debug(`...verified the '${typeString}' type.`);
       }
     }
 

package/src/dom/declaration/type.js

@@ -2,8 +2,8 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
+import { superTypesStringFromSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class TypeDeclaration {
   constructor(fileContext, string, type) {
@@ -67,18 +67,21 @@ export default domAssigned(class TypeDeclaration {
   verifyType() {
     let typeVerified = false;
 
-    const typeName = this.type.getName();
+    const typeName = this.type.getName(),
+          typeString = this.type.getString();
 
-    this.fileContext.trace(`Verifying the '${typeName}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
     const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
 
-    if (!typePresent) {
+    if (typePresent) {
+      this.fileContext.debug(`The type '${typeString}' is already present.`);
+    } else {
       typeVerified = true;
     }
 
     if (typeVerified) {
-      this.fileContext.debug(`...verified the '${typeName}' type.`);
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return typeVerified;
@@ -92,11 +95,11 @@ export default domAssigned(class TypeDeclaration {
     if (typeBasic) {
       superTypesVerified = true;
     } else {
-      const typeName = this.type.getName(),
+      const typeString = this.type.getString(),
             superTypes = this.type.getSuperTypes(),
             superTypesString = superTypesStringFromSuperTypes(superTypes);
 
-      this.fileContext.trace(`Verifying the '${typeName}' type's ${superTypesString} super-types...`);
+      this.fileContext.trace(`Verifying the '${typeString}' type's ${superTypesString} super-types...`);
 
       superTypesVerified = superTypes.every((superType) => {
         const superTypeVerified = this.verifySuperType(superType);
@@ -107,7 +110,7 @@ export default domAssigned(class TypeDeclaration {
       });
 
       if (superTypesVerified) {
-        this.fileContext.debug(`...verified the '${typeName}' type's ${superTypesString} super-types.`);
+        this.fileContext.debug(`...verified the '${typeString}' type's ${superTypesString} super-types.`);
       }
     }
 
@@ -117,24 +120,18 @@ export default domAssigned(class TypeDeclaration {
   verifySuperType(superType) {
     let superTypeVerified;
 
-    const superTypeObjectType = (superType === objectType);
-
-    if (superTypeObjectType) {
-      superTypeVerified = true;
-    } else {
-      const typeName = this.type.getString(),
-            superTypeString = superTypeStringFromSuperType(superType);
+    const typeString = this.type.getString(),
+          superTypeString = superType.getString();
 
-      this.fileContext.trace(`Verifying the '${typeName}' type's '${superTypeString}' super-type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type's '${superTypeString}' super-type...`);
 
-      const superTypeName = superType.getName(),
-            superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
+    const superTypeName = superType.getName(),
+          superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
 
-      superTypeVerified = superTypePresent; ///
+    superTypeVerified = superTypePresent; ///
 
-      if (superTypeVerified) {
-        this.fileContext.debug(`...verified the '${typeName}' type's '${superTypeString}' super-type.`);
-      }
+    if (superTypeVerified) {
+      this.fileContext.debug(`...verified the '${typeString}' type's '${superTypeString}' super-type.`);
     }
 
     return superTypeVerified;
@@ -152,25 +149,3 @@ export default domAssigned(class TypeDeclaration {
     return typeDeclaration;
   }
 });
-
-export function superTypeStringFromSuperType(superType) {
-  const superTypeName = superType.getName(),
-        superTypeString = superTypeName;  ///
-
-  return superTypeString;
-}
-
-export function superTypesStringFromSuperTypes(superTypes) {
-  const superTypesString = superTypes.reduce((superTypesString, superType) => {
-    const superTypeString = superTypeStringFromSuperType(superType);
-
-    superTypesString = (superTypesString === null) ?
-                        `'${superTypeString}'` :
-                          `${superTypesString}, '${superTypeString}'`;
-
-    return superTypesString;
-  }, null);
-
-  return superTypesString;
-}
-

package/src/dom/declaration/variable.js

@@ -2,7 +2,6 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class VariableDeclaration {
@@ -41,13 +40,9 @@ export default domAssigned(class VariableDeclaration {
 
         type = this.variable.getType();
 
-        const typeObjectType = (type === objectType);
+        const typeName = type.getName();
 
-        if (!typeObjectType) {
-          const typeName = type.getName();
-
-          type = this.fileContext.findTypeByTypeName(typeName);
-        }
+        type = this.fileContext.findTypeByTypeName(typeName);
 
         const typeProvisional = type.isProvisional(),
               variableProvisional = this.variable.isProvisional();
@@ -64,8 +59,6 @@ export default domAssigned(class VariableDeclaration {
             this.fileContext.debug(`The '${typeString}' type is not provisional whilst the '${variableString}' variable's type is.`);
           }
         } else {
-          this.variable.setType(type);
-
           this.fileContext.addVariable(this.variable);
 
           verified = true;
@@ -83,26 +76,41 @@ export default domAssigned(class VariableDeclaration {
   verifyVariableType() {
     let typeVerified = false;
 
-    const type = this.variable.getType();
+    let type;
 
-    if (type === objectType) {
-      typeVerified = true;
-    } else {
-      const typeName = type.getName();
+    type = this.variable.getType();
+
+    const typeName = type.getName(),
+          typeString = type.getString(),
+          variableString = this.variable.getString();
+
+    this.fileContext.trace(`Verifying the '${variableString}' variable's '${typeString}' type...`);
 
-      this.fileContext.trace(`Verifying the '${typeName}' type...`);
+    const includeSupertypes = false,
+          provisional = type.isProvisional(includeSupertypes);
 
-      const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+    type = this.fileContext.findTypeByTypeName(typeName);
 
-      if (!typePresent) {
-        this.fileContext.debug(`The '${typeName}' type is not present.`);
+    const typePresent = (type !== null)
+
+    if (!typePresent) {
+      this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is not present.`);
+    } else {
+      const provisionalMatches = type.matchProvisional(provisional);
+
+      if (!provisionalMatches) {
+        provisional ?
+          this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is present but it should be provisional.`) :
+            this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is present but it should not be provisional.`);
       } else {
+        this.variable.setType(type);
+
         typeVerified = true;
       }
+    }
 
-      if (typeVerified) {
-        this.fileContext.debug(`...verified the '${typeName}' type.`);
-      }
+    if (typeVerified) {
+      this.fileContext.debug(`...verified the '${variableString}' variable's '${typeString}' type.`);
     }
 
     return typeVerified;

package/src/dom/property.js

@@ -117,9 +117,9 @@ function stringFromNamesAndType(names, type) {
   if (type === objectType) {
     string = namesString;  ///
   } else {
-    const typeName = type.getName();
+    const typeString = type.getString();
 
-    string = `${namesString}:${typeName}`;
+    string = `${namesString}:${typeString}`;
   }
 
   return string;

package/src/dom/propertyRelation.js

@@ -109,9 +109,9 @@ export default domAssigned(class PropertyRelation {
 
     if (variableTypeProperty === null) {
       const variableString = this.term.getString(),
-            variableTypeName = variableType.getName();
+            variableTypeString = variableType.getString();
 
-      context.debug(`The '${propertyNames}' property is not a property of the '${variableString}' variable's '${variableTypeName}' type.`);
+      context.debug(`The '${propertyNames}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
     } else {
       const type = variableType;
 

package/src/dom/term.js

@@ -152,10 +152,10 @@ export default domAssigned(class Term {
   verifyGivenType(type, generalContext, specificContext) {
     let verifiedGivenType;
 
-    const typeName = type.getName(),
+    const typeString = type.getString(),
           termString = this.getString();  ///
 
-    specificContext.trace(`Verifying the '${termString}' term given the '${typeName}' type...`);
+    specificContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);
 
     const context = specificContext, ///
           verified = this.verify(context, () => {
@@ -173,7 +173,7 @@ export default domAssigned(class Term {
     verifiedGivenType = verified; ///
 
     if (verifiedGivenType) {
-      specificContext.debug(`...verified the '${termString}' term given the '${typeName}' type.`);
+      specificContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);
     }
 
     return verifiedGivenType;