occam-verify-cli 1.0.318 → 1.0.325

package/src/dom/declaration/simpleType.js

@@ -2,16 +2,16 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
-import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
+import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class SimpleTypeDeclaration {
-  constructor(context, node, string, type) {
+  constructor(context, node, string, type, prefixed) {
     this.context = context;
     this.node = node;
     this.string = string;
     this.type = type;
+    this.prefixed = prefixed;
   }
 
   getContext() {
@@ -30,6 +30,10 @@ export default domAssigned(class SimpleTypeDeclaration {
     return this.type;
   }
 
+  isPrefixed() {
+    return this.prefixed;
+  }
+
   verify() {
     let verifies = false;
 
@@ -37,15 +41,30 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     this.context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`, this.node);
 
-    const typeVerifies = this.verifyType();
+    if (this.prefixed) {
+      const typeString = this.type.getString();
 
-    if (typeVerifies) {
-      const superTypesVerify = this.verifySuperTypes();
+      this.context.trace(`The '${typeString}' type is prefixed.`);
+    } else {
+      const typeVerifies = this.verifyType();
+
+      if (typeVerifies) {
+        const superTypesVerify = this.verifySuperTypes();
+
+        if (superTypesVerify) {
+          const typePrefix = this.context.getTypePrefix();
+
+          if (typePrefix !== null) {
+            const typePrefixName = typePrefix.getName(),
+                  prefixName = typePrefixName;  ///
+
+            this.type.setPrefixName(prefixName);
+          }
 
-      if (superTypesVerify) {
-        this.context.addType(this.type);
+          this.context.addType(this.type);
 
-        verifies = true;
+          verifies = true;
+        }
       }
     }
 
@@ -64,16 +83,25 @@ export default domAssigned(class SimpleTypeDeclaration {
     this.context.trace(`Verifying the '${typeString}' simple type...`, this.node);
 
     const typeName = this.type.getName(),
-          typePresent = this.context.isTypePresentByTypeName(typeName);
+          includeRelease = true,
+          includeDependencies = false,
+          typePresent = this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
 
     if (typePresent) {
-      this.context.debug(`The '${typeString}' type is already present.`, this.node);
+      this.context.trace(`The '${typeString}' type is already present.`, this.node);
     } else {
-      typeVerifies = true;
+      const prefixedTypeName = typeName, ///
+            typePresent = this.context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+
+      if (typePresent) {
+        this.context.trace(`The '${typeString}' type is already present.`, this.node);
+      } else {
+        typeVerifies = true;
+      }
     }
 
     if (typeVerifies) {
-      this.context.debug(`...verified the '${typeString}' simple type.`, this.node);
+      this.context.trace(`...verified the '${typeString}' simple type.`, this.node);
     }
 
     return typeVerifies;
@@ -86,11 +114,24 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     this.context.trace(`Verifying the '${superTypeString}' super-type...`, this.node);
 
-    const superTypeName = superType.getName(),
-          superTypePresent = this.context.isTypePresentByTypeName(superTypeName);
+    const nominalTypeName = superType.getNominalTypeName(),
+          typeName = nominalTypeName, ///
+          typeNameMatches = this.type.matchTypeName(typeName);
+
+    if (typeNameMatches) {
+      this.context.trace(`The super-type's name matches the ${typeName}' simple type's name.`, this.node);
+    } else {
+      const oldSuperType = superType;
+
+      superType = this.context.findTypeByNominalTypeName(nominalTypeName);
+
+      const superTypePresent = (superType !== null);
 
-    if (superTypePresent) {
-      superTypeVerifies = true;
+      if (superTypePresent) {
+        this.type.replaceSuperType(oldSuperType, newSuperType);
+
+        superTypeVerifies = true;
+      }
     }
 
     if (superTypeVerifies) {
@@ -101,69 +142,32 @@ export default domAssigned(class SimpleTypeDeclaration {
   }
 
   verifySuperTypes() {
-    let superTypesVerify = false;
+    let superTypesVerify;
 
-    this.context.trace(`Verifying the super-types...`, this.node);
-
-    let superTypes;
-
-    superTypes = this.type.getSuperTypes();
-
-    const superTypesLength = superTypes.length;
-
-    if (superTypesLength === 0) {
-      const superType = objectType; ///
+    const typeString = this.type.getString();
 
-      superTypes.push(superType);
-    }
+    this.context.trace(`Verifying the '${typeString}' simple type's super-types...`, this.node);
 
-    const typeName = this.type.getName(),
-          typeBasic = this.type.isBasic(),
-          typeString = this.type.getString();
+    const typeBasic = this.type.isBasic();
 
     if (typeBasic) {
       superTypesVerify = true;
 
       this.context.trace(`The '${typeString}' simple type is basic.`, this.node)
     } else  {
-      const superTypeNames = superTypes.map((superType) => {
-              const superTypeName = superType.getName();
-
-              return superTypeName;
-            }),
-            superTypeNamesIncludesTypeName = superTypeNames.includes(typeName);
-
-      if (superTypeNamesIncludesTypeName) {
-        this.context.trace(`The '${typeName}' simple type cannot be a super-type `, this.node);
-      } else {
-        superTypesVerify = superTypes.every((superType) => {
-          const superTypeVerifies = this.verifySuperType(superType);
+      const superTypes = this.type.getSuperTypes();
 
-          if (superTypeVerifies) {
-            return true;
-          }
-        });
-
-        if (superTypesVerify) {
-          superTypes = superTypes.map((superType) => {
-            const superTypeName = superType.getName();
-
-            superType = this.context.findTypeByTypeName(superTypeName);
-
-            return superType;
-          });
+      superTypesVerify = superTypes.every((superType) => {
+        const superTypeVerifies = this.verifySuperType(superType);
 
-          const string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes);
-
-          this.type.setString(string);
-
-          this.type.setSuperTypes(superTypes);
+        if (superTypeVerifies) {
+          return true;
         }
-      }
+      });
     }
 
     if (superTypesVerify) {
-      this.context.debug(`...verified the super-types.`, this.node);
+      this.context.debug(`...verified the '${typeString}' simple type's super-types.`, this.node);
     }
 
     return superTypesVerify;
@@ -173,12 +177,14 @@ export default domAssigned(class SimpleTypeDeclaration {
 
   static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
     const { Type } = dom,
-          node = simpleTypeDeclarationNode, ///
           type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
+          node = simpleTypeDeclarationNode, ///
+          prefixed = simpleTypeDeclarationNode.isPrefixed(),
+          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
           typeName = type.getName(),
           superTypes = type.getSuperTypes(),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          simpleTypeDeclaration = new SimpleTypeDeclaration(context, node, string, type);
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          simpleTypeDeclaration = new SimpleTypeDeclaration(context, node, string, type, prefixed);
 
     return simpleTypeDeclaration;
   }

package/src/dom/declaration/typePrefix.js

@@ -35,10 +35,21 @@ export default domAssigned(class TypePrefixDeclaration {
 
     this.context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`, this.node);
 
-    const typePrefixVerifies = this.verifyTypePrefix();
+    const includeRelease = true,
+          includeDependencies = false,
+          types = this.context.getTypes(includeRelease, includeDependencies),
+          typesLength = types.length;
 
-    if (typePrefixVerifies) {
-      verifies = true;
+    if (typesLength > 0) {
+      this.context.debug(`Cannot verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, this.node);
+    } else {
+      const typePrefixVerifies = this.verifyTypePrefix();
+
+      if (typePrefixVerifies) {
+        this.context.addTypePrefix(this.typePrefix);
+
+        verifies = true;
+      }
     }
 
     if (verifies) {
@@ -58,16 +69,23 @@ export default domAssigned(class TypePrefixDeclaration {
     const typePrefix = this.context.getTypePrefix();
 
     if (typePrefix !== null) {
-      this.context.debug(`The package already has a '${typePrefixString}' type prefix.`, this.node);
+      this.context.trace(`The package already has a '${typePrefixString}' type prefix.`, this.node);
     } else {
 
       const typePrefixName = this.typePrefix.getName(),
             typePrefixPresent = this.context.isTypePrefixPresentByTypePrefixName(typePrefixName);
 
       if (typePrefixPresent) {
-        this.context.debug(`The '${typePrefixString}' type prefix is already present.`, this.node);
+        this.context.trace(`The '${typePrefixString}' type prefix is already present.`, this.node);
       } else {
-        debugger
+        const nominalTypeName = typePrefixName,  ///
+              typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          this.context.trace(`The '${typePrefixString}' type is already present.`, this.node);
+        } else {
+          typePrefixVerifies = true;
+        }
       }
     }
 

package/src/dom/declaration/variable.js

@@ -84,22 +84,22 @@ export default domAssigned(class VariableDeclaration {
 
     type = this.variable.getType();
 
-    const typeName = type.getName(),
-          typeString = type.getString();
+    const typeString = type.getString();
 
     this.context.trace(`Verifying the '${typeString}' type...`, this.node);
 
-    const includeSupertypes = false,
-          provisional = type.isProvisional(includeSupertypes);
+    const nominalTypeName = type.getNominalTypeName();
 
-    type = this.context.findTypeByTypeName(typeName);
+    type = this.context.findTypeByNominalTypeName(nominalTypeName);
 
     const typePresent = (type !== null)
 
     if (!typePresent) {
       this.context.debug(`The '${typeString}' type is not present.`, this.node);
     } else {
-      const provisionalMatches = type.matchProvisional(provisional);
+      const includeSupertypes = false,
+            provisional = type.isProvisional(includeSupertypes),
+            provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?

package/src/dom/metavariable.js

@@ -529,9 +529,9 @@ function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, contex
   const typeNode = metavariableDeclarationNode.getTypeNode();
 
   if (typeNode !== null) {
-    const typeName = typeNode.getTypeName();
+    const nominalTypeName = typeNode.getNominalTypeName();
 
-    type = context.findTypeByTypeName(typeName);
+    type = context.findTypeByNominalTypeName(nominalTypeName);
   }
 
   return type;

package/src/dom/property.js

@@ -28,7 +28,7 @@ export default domAssigned(class Property {
     this.type = type;
   }
 
-  matchTypeName(typeName) { return this.type.matchTypeName(typeName); }
+  matchNominalTypeName(nominalTypeName) { return this.type.matchNominalTypeName(nominalTypeName); }
 
   matchPropertyName(propertyName) {
     const propertyNameMatches = (this.name === propertyName);

package/src/dom/topLevelAssertion.js

@@ -68,21 +68,9 @@ export default class TopLevelAssertion {
     return this.hypotheses;
   }
 
-  setContext(context) { this.context = context; }
-
-  setString(string) { this.string = string; }
-
-  setLabels(labels) { this.labels = labels; }
-
-  setSuppositions(suppositions) { this.suppositions = suppositions; }
-
-  setDeduction(deduction) { this.deduction = deduction; }
-
-  setProof(proof) { this.proof = proof; }
-
-  setSignature(signature) { this.signature = signature; }
-
-  setHypotheses(hypotheses) { this.hypotheses = hypotheses; }
+  setHypotheses(hypotheses) {
+    this.hypotheses = hypotheses;
+  }
 
   getStatement() { return this.deduction.getStatement(); }
 

package/src/dom/type.js

@@ -7,15 +7,16 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../constants";
 import { typeFromTypeNode } from "../utilities/node";
-import { stringFromTypeNameNameAndSuperTypes } from "../utilities/type";
+import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/type";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
 class Type {
-  constructor(string, name, superTypes, properties, provisional) {
+  constructor(string, name, prefixName, superTypes, properties, provisional) {
     this.string = string;
     this.name = name;
+    this.prefixName = prefixName;
     this.superTypes = superTypes;
     this.properties = properties;
     this.provisional = provisional;
@@ -29,6 +30,10 @@ class Type {
     return this.name;
   }
 
+  getPrefixName() {
+    return this.prefixName;
+  }
+
   getSuperTypes() {
     return this.superTypes;
   }
@@ -67,14 +72,14 @@ class Type {
     return provisional;
   }
 
-  setString(string) {
-    this.string = string;
-  }
-
   setName(name) {
     this.name = name;
   }
 
+  setPrefixName(prefixName) {
+    this.prefixName = prefixName;
+  }
+
   setSuperTypes(superTypes) {
     this.superTypes = superTypes;
   }
@@ -87,6 +92,41 @@ class Type {
     this.provisional = provisional;
   }
 
+  replaceSuperType(oldSuperType, newSuperType) {
+    const index = this.superTypes.indexOf(oldSuperType),
+          start = index,
+          deleteCount = 1;
+
+    this.superTypes.splice(start, deleteCount, newSuperType);
+  }
+
+  isPrefixed() {
+    const prefixed = (this.prefixName !== null);
+
+    return prefixed;
+  }
+
+  getPrefixedName() {
+    let prefixedName = null;
+
+    const prefixed = this.isPrefixed();
+
+    if (prefixed) {
+      prefixedName = `${this.prefixName}${this.name}`;
+    }
+
+    return prefixedName;
+  }
+
+  getNominalTypeName() {
+    const prefixed = this.isPrefixed(),
+          nominalTypeName = prefixed ?
+                             `${this.prefixName}${this.name}` :
+                                this.name;
+
+    return nominalTypeName;
+  }
+
   isBasic() {
     let basic = false;
 
@@ -183,7 +223,8 @@ class Type {
   }
 
   matchTypeName(typeName) {
-    const typeNameMatches = (this.name === typeName);
+    const name = this.getName(),
+          typeNameMatches = (name === typeName);
 
     return typeNameMatches;
   }
@@ -202,6 +243,42 @@ class Type {
     return provisionalMatches;
   }
 
+  matchPrefixedTypeName(prefixedTypeName) {
+    let prefixedTypeNameMatches = false;
+
+    const prefixed = this.isPrefixed();
+
+    if (prefixed) {
+      const prefixedName = this.getPrefixedName();
+
+      prefixedTypeNameMatches = (prefixedTypeName === prefixedName);
+    }
+
+    return prefixedTypeNameMatches;
+  }
+
+  matchNominalTypeName(nominalTypeName) {
+    let nominalTypeNameMatches = false;
+
+    if (!nominalTypeNameMatches) {
+      const name = this.getName();
+
+      nominalTypeNameMatches = (nominalTypeName === name);
+    }
+
+    if (!nominalTypeNameMatches) {
+      const prefixed = this.isPrefixed();
+
+      if (prefixed) {
+        const prefixedName = this.getPrefixedName();
+
+        nominalTypeNameMatches = (nominalTypeName === prefixedName);
+      }
+    }
+
+    return nominalTypeNameMatches;
+  }
+
   toJSON() {
     const propertiesJSON = propertiesToPropertiesJSON(this.properties),
           superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
@@ -209,8 +286,10 @@ class Type {
           properties = propertiesJSON,  ///
           superTypes = superTypesJSON,  ///
           name = this.name,
+          prefixName = this.prefixName,
           json = {
             name,
+            prefixName,
             superTypes,
             properties,
             provisional
@@ -222,12 +301,13 @@ class Type {
   static name = "Type";
 
   static fromJSON(json, context) {
-    const { name, provisional } = json,
+    const { name, prefixName, provisional } = json,
           properties = propertiesFromJSON(json, context),
           superTypes = superTypesFromJSON(json, context),
           typeName = name,  ///
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
+          typePrefixName = null,
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -238,6 +318,15 @@ class Type {
     return type;
   }
 
+  static fromSuperTypeNode(superTypeNode, context) {
+    context = null; ///
+
+    const typeNode = superTypeNode, ///
+          type = typeFromTypeNode(typeNode, context);
+
+    return type;
+  }
+
   static fromTypeAssertionNode(typeAssertionNode, context) {
     const typeNode = typeAssertionNode.getTypeNode(),
           type = typeFromTypeNode(typeNode, context);
@@ -247,15 +336,17 @@ class Type {
 
   static fromTypeAndProvisional(type, provisional) {
     const name = type.getName(),
+          prefixName = type.getPrefixName(),
           superType = type, ///
           typeName = name,  ///
+          typePrefixName = prefixName,  ///
           superTypes = [
             superType
           ],
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
           properties = type.getProperties();
 
-    type = new Type(string, name, superTypes, properties, provisional);  ///
+    type = new Type(string, name, prefixName, superTypes, properties, provisional);  ///
 
     return type;
   }
@@ -271,10 +362,12 @@ class Type {
     const properties = [],
           provisional = simpleTypeDeclarationNode.isProvisional(),
           typeName = simpleTypeDeclarationNode.getTypeName(),
+          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
           name = typeName,  ///
+          prefixName = typePrefixName,  ///
           superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -282,11 +375,13 @@ class Type {
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
     const provisional = complexTypeDeclarationNode.isProvisional(),
           typeName = complexTypeDeclarationNode.getTypeName(),
-          name = typeName,
+          typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),
+          name = typeName,  ///
+          prefixName = typePrefixName,  ///
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -315,10 +410,17 @@ export default domAssigned(Type);
 function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromTypeNode(superTypeNode, context);
+          const superType = Type.fromSuperTypeNode(superTypeNode, context);
 
           return superType;
-        });
+        }),
+        superTypesLength = superTypes.length;
+
+  if (superTypesLength === 0) {
+    const superType = objectType; ///
+
+    superTypes.push(superType);
+  }
 
   return superTypes;
 }
@@ -326,10 +428,17 @@ function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, cont
 function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromTypeNode(superTypeNode, context);
+          const superType = Type.fromSuperTypeNode(superTypeNode, context);
 
           return superType;
-        });
+        }),
+        superTypesLength = superTypes.length;
+
+  if (superTypesLength === 0) {
+    const superType = objectType; ///
+
+    superTypes.push(superType);
+  }
 
   return superTypes;
 }
@@ -350,10 +459,11 @@ class ObjectType extends Type {
   static fromNothing() {
     const name = OBJECT_TYPE_NAME,
           string = name,  ///
+          prefixName = null,
           superTypes = [],
           properties = [],
           provisional = false,
-          objectType = new ObjectType(string, name, superTypes, properties, provisional);
+          objectType = new ObjectType(string, name, prefixName, superTypes, properties, provisional);
 
     return objectType;
   }

package/src/dom/variable.js

@@ -92,12 +92,12 @@ export default domAssigned(class Variable {
   verifyType(context) {
     let typeVerifies = false;
 
-    const typeName = this.tyupe.getName(),
-          typeString = this.type.getString();
+    const typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' type...`);
 
-    const type = context.findTypeByTypeName(typeName);
+    const prefixedTypeName = this.type.getPrefixedName(),
+          type = context.findTypeByPrefixedTypeName(prefixedTypeName);
 
     if (type === null) {
       context.debug(`The '${typeString}' type is not present.`);
@@ -217,7 +217,7 @@ export default domAssigned(class Variable {
     const { Variable } = dom,
           provisional = variableDeclarationNode.isProvisional(),
           typeNode = variableDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode);
+          type = typeFromTypeNode(typeNode, context);
 
     type.setProvisional(provisional);