occam-verify-cli 1.0.320 → 1.0.325

package/src/dom/declaration/complexType.js

@@ -2,7 +2,6 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../../utilities/type";
 
@@ -58,9 +57,22 @@ export default domAssigned(class ComplexTypeDeclaration {
           const propertiesVerify = this.verifyProperties();
 
           if (propertiesVerify) {
-            this.context.addType(this.type);
+            const propertyTypesVerify = this.verifyPropertyTypes();
 
-            verifies = true;
+            if (propertyTypesVerify) {
+              const typePrefix = this.context.getTypePrefix();
+
+              if (typePrefix !== null) {
+                const typePrefixName = typePrefix.getName(),
+                      prefixName = typePrefixName;  ///
+
+                this.type.setPrefixName(prefixName);
+              }
+
+              this.context.addType(this.type);
+
+              verifies = true;
+            }
           }
         }
       }
@@ -81,16 +93,25 @@ export default domAssigned(class ComplexTypeDeclaration {
     this.context.trace(`Verifying the '${typeString}' complex 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 in the package.`, 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}' complex type.`, this.node);
+      this.context.trace(`...verified the '${typeString}' complex type.`, this.node);
     }
 
     return typeVerifies;
@@ -103,11 +124,26 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     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}' complex type's name.`, this.node);
+    } else {
+      const oldSuperType = superType;
+
+      superType = this.context.findTypeByNominalTypeName(nominalTypeName);
+
+      const superTypePresent = (superType !== null);
+
+      if (superTypePresent) {
+        const newSuperType = superType; ///
+
+        this.type.replaceSuperType(oldSuperType, newSuperType);
 
-    if (superTypePresent) {
-      superTypeVerifies = true;
+        superTypeVerifies = true;
+      }
     }
 
     if (superTypeVerifies) {
@@ -118,71 +154,38 @@ export default domAssigned(class ComplexTypeDeclaration {
   }
 
   verifySuperTypes() {
-    let superTypesVerify = false;
-
-    this.context.trace(`Verifying the super-types...`, this.node);
-
-    let superTypes;
-
-    superTypes = this.type.getSuperTypes();
-
-    const superTypesLength = superTypes.length;
+    let superTypesVerify;
 
-    if (superTypesLength === 0) {
-      const superType = objectType; ///
+    const typeString = this.type.getString();
 
-      superTypes.push(superType);
-    }
+    this.context.trace(`Verifying the '${typeString}' complex 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}' complex 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}' complex type cannot be a super-type `, this.node);
-      } else {
-        superTypesVerify = superTypes.every((superType) => {
-          const superTypeVerifies = this.verifySuperType(superType);
-
-          if (superTypeVerifies) {
-            return true;
-          }
-        });
-
-        if (superTypesVerify) {
-          superTypes = superTypes.map((superType) => {
-            const superTypeName = superType.getName();
+      const superTypes = this.type.getSuperTypes();
 
-            superType = this.context.findTypeByTypeName(superTypeName);
+      superTypesVerify = superTypes.every((superType) => {
+        const superTypeVerifies = this.verifySuperType(superType);
 
-            return superType;
-          });
-
-          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}' complex type's super-types.`, this.node);
     }
 
     return superTypesVerify;
   }
 
-  verifyProperty(property, properties, superTypeProperties) {
+  verifyProperty(property, properties) {
     let propertyVerifies = false;
 
     const propertyString = property.getString();
@@ -203,49 +206,30 @@ export default domAssigned(class ComplexTypeDeclaration {
     if (count > 1) {
       this.context.debug(`The '${propertyString}' property appears more than once.`, this.node);
     } else {
-      const superTypeProperty = superTypeProperties.find((superTypeProperty) => {
-        const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
-
-        if (propertyNameMatches) {
-          return true;
-        }
-      }) || null;
-
-      if (superTypeProperty !== null) {
-        const superTypePropertyString = superTypeProperty.getString();
-
-        this.context.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`, this.node);
-      } else {
-        let propertyType;
-
-        propertyType = property.getType();
+      const superTypes = this.type.getSuperTypes();
 
-        const propertyTypeVerifies = this.verifyPropertyType(propertyType);
+      propertyVerifies = superTypes.every((superType) => {
+        const superTypeProperties = superType.getProperties(),
+              superTypeProperty = superTypeProperties.find((superTypeProperty) => {
+                const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
 
-        if (propertyTypeVerifies) {
-          const propertyTypeName = propertyType.getName();
+                if (propertyNameMatches) {
+                  return true;
+                }
+              }) || null;
 
-          propertyType = this.context.findTypeByTypeName(propertyTypeName);
+        if (superTypeProperty !== null) {
+          const superTypePropertyString = superTypeProperty.getString();
 
-          const type = propertyType;  ///
-
-          property.setType(type);
-
-          propertyVerifies = true;
+          this.context.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`, this.node);
+        } else {
+          return true;
         }
-      }
+      });
     }
 
     if (propertyVerifies) {
-      const typeName = this.type.getName(),
-            prefixed = true,
-            typeNameMatches = property.matchTypeName(typeName, prefixed, this.context);
-
-      if (typeNameMatches) {
-        property.setType(this.type);
-      }
-
-      this.context.debug(`verifies the '${propertyString}' property.`, this.node);
+      this.context.debug(`...verified the '${propertyString}' property.`, this.node);
     }
 
     return propertyVerifies;
@@ -254,59 +238,92 @@ export default domAssigned(class ComplexTypeDeclaration {
   verifyProperties() {
     let propertiesVerify;
 
-    const includeSuperTypes = false,
-          properties = this.type.getProperties(includeSuperTypes),
-          superTypes = this.type.getSuperTypes()
+    const typeString = this.type.getString();
 
-    propertiesVerify = superTypes.every((superType) => {
-      const superTypeProperties = superType.getProperties(),
-            propertiesVerify = properties.every((property) => {
-              const propertyVerifies = this.verifyProperty(property, properties, superTypeProperties);
+    this.context.trace(`Verifying the '${typeString}' complex type's properties...`, this.node);
 
-              if (propertyVerifies) {
-                return true;
-              }
-            });
+    const includeSuperTypes = false,
+          properties = this.type.getProperties(includeSuperTypes);
+
+    propertiesVerify = properties.every((property) => {
+      const propertyVerifies = this.verifyProperty(property, properties);
 
-      if (propertiesVerify) {
+      if (propertyVerifies) {
         return true;
       }
     });
 
+    if (propertiesVerify) {
+      this.context.debug(`...verified the '${typeString}' complex type's properties.`, this.node);
+    }
+
     return propertiesVerify;
   }
 
-  verifyPropertyType(propertyType) {
+  verifyPropertyType(property) {
     let propertyTypeVerifies = false;
 
-    const typeEqualToPropertyType = this.type.isEqualTo(propertyType);
+    let propertyType = property.getType();
+
+    const propertyTypeString = propertyType.getString();
 
-    if (typeEqualToPropertyType) {
+    this.context.trace(`Verifying the '${propertyTypeString}' property type...`, this.node);
+
+    const typeName = this.type.getName(),
+          typeNameMatches = propertyType.matchTypeName(typeName);
+
+    if (typeNameMatches) {
       propertyTypeVerifies = true;
-    } else  {
-      const propertyTypeString = propertyType.getString(); ///
 
-      this.context.trace(`Verifying the '${propertyTypeString}' property type...`, this.node);
+      property.setType(this.type);
+    } else {
+      const nominalTypeName = propertyType.getNominalTypeName();
+
+      propertyType = this.context.findTypeByNominalTypeName(nominalTypeName);
 
-      const propertyTypeName = propertyType.getName(),
-            propertyTypePresent = this.context.isTypePresentByTypeName(propertyTypeName);
+      const propertyTypePresent = (propertyType !== null);
 
-      if (!propertyTypePresent) {
-        const propertyTypeString = propertyType.getString();
+      if (propertyTypePresent) {
+        const type = propertyType;  ///
+
+        property.setType(type);
 
-        this.context.debug(`The '${propertyTypeString}' property type is not present.`, this.node);
-      } else {
         propertyTypeVerifies = true;
       }
+    }
 
-      if (propertyTypeVerifies) {
-        this.context.debug(`...verified the '${propertyTypeString}' property type.`, this.node);
-      }
+    if (propertyTypeVerifies) {
+      this.context.debug(`...verified the '${propertyTypeString}' property type.`, this.node);
     }
 
     return propertyTypeVerifies;
   }
 
+  verifyPropertyTypes() {
+    let propertyTypesVerify;
+
+    const typeString = this.type.getString();
+
+    this.context.trace(`Verifying the '${typeString}' complex type's property types...`, this.node);
+
+    const includeSuperTypes = false,
+          properties = this.type.getProperties(includeSuperTypes);
+
+    propertyTypesVerify = properties.every((property) => {
+      const propertyVerifies = this.verifyPropertyType(property);
+
+      if (propertyVerifies) {
+        return true;
+      }
+    });
+
+    if (propertyTypesVerify) {
+      this.context.debug(`...verified the '${typeString}' complex type's property types.`, this.node);
+    }
+
+    return propertyTypesVerify;
+  }
+
   static name = "ComplexTypeDeclaration";
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {

package/src/dom/declaration/constructor.js

@@ -82,22 +82,22 @@ export default domAssigned(class ConstructorDeclaration {
 
     type = this.constructor.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/declaration/metavariable.js

@@ -56,12 +56,12 @@ export default domAssigned(class MetavariableDeclaration {
     if (type === null) {
       typeVerifies = true;
     } else {
-      const typeName = type.getName(),
-            typeString = type.getString();
+      const typeString = type.getString();
 
       this.context.trace(`Verifying the '${typeString}' type...`, this.node);
 
-      const typePresent = this.context.isTypePresentByTypeName(typeName);
+      const nominalTypeName = type.getNominalTypeName(),
+            typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
 
       if (!typePresent) {
         this.context.debug(`The '${typeString}' type is not present.`, this.node);

package/src/dom/declaration/simpleType.js

@@ -2,7 +2,6 @@
 
 import dom from "../../dom";
 
-import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../../utilities/type";
 
@@ -53,6 +52,15 @@ export default domAssigned(class SimpleTypeDeclaration {
         const superTypesVerify = this.verifySuperTypes();
 
         if (superTypesVerify) {
+          const typePrefix = this.context.getTypePrefix();
+
+          if (typePrefix !== null) {
+            const typePrefixName = typePrefix.getName(),
+                  prefixName = typePrefixName;  ///
+
+            this.type.setPrefixName(prefixName);
+          }
+
           this.context.addType(this.type);
 
           verifies = true;
@@ -75,12 +83,21 @@ 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.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) {
@@ -97,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 (superTypePresent) {
-      superTypeVerifies = true;
+    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) {
+        this.type.replaceSuperType(oldSuperType, newSuperType);
+
+        superTypeVerifies = true;
+      }
     }
 
     if (superTypeVerifies) {
@@ -112,65 +142,32 @@ export default domAssigned(class SimpleTypeDeclaration {
   }
 
   verifySuperTypes() {
-    let superTypesVerify = false;
-
-    this.context.trace(`Verifying the super-types...`, this.node);
-
-    let superTypes;
+    let superTypesVerify;
 
-    superTypes = this.type.getSuperTypes();
-
-    const superTypesLength = superTypes.length;
+    const typeString = this.type.getString();
 
-    if (superTypesLength === 0) {
-      const superType = objectType; ///
+    this.context.trace(`Verifying the '${typeString}' simple type's super-types...`, this.node);
 
-      superTypes.push(superType);
-    }
-
-    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);
-
-          if (superTypeVerifies) {
-            return true;
-          }
-        });
+      const superTypes = this.type.getSuperTypes();
 
-        if (superTypesVerify) {
-          superTypes = superTypes.map((superType) => {
-            const superTypeName = superType.getName();
+      superTypesVerify = superTypes.every((superType) => {
+        const superTypeVerifies = this.verifySuperType(superType);
 
-            superType = this.context.findTypeByTypeName(superTypeName);
-
-            return superType;
-          });
-
-          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;

package/src/dom/declaration/typePrefix.js

@@ -35,12 +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) {
-      this.context.addTypePrefix(this.typePrefix);
+    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();
 
-      verifies = true;
+      if (typePrefixVerifies) {
+        this.context.addTypePrefix(this.typePrefix);
+
+        verifies = true;
+      }
     }
 
     if (verifies) {
@@ -69,8 +78,8 @@ export default domAssigned(class TypePrefixDeclaration {
       if (typePrefixPresent) {
         this.context.trace(`The '${typePrefixString}' type prefix is already present.`, this.node);
       } else {
-        const typeName = typePrefixName,  ///
-              typePresent = this.context.isTypePresentByTypeName(typeName);
+        const nominalTypeName = typePrefixName,  ///
+              typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
           this.context.trace(`The '${typePrefixString}' type is already present.`, this.node);

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, prefixed, context) { return this.type.matchTypeName(typeName, prefixed, context); }
+  matchNominalTypeName(nominalTypeName) { return this.type.matchNominalTypeName(nominalTypeName); }
 
   matchPropertyName(propertyName) {
     const propertyNameMatches = (this.name === propertyName);