occam-verify-cli 1.0.318 → 1.0.325

package/src/dom/declaration/complexType.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 ComplexTypeDeclaration {
-  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 ComplexTypeDeclaration {
     return this.type;
   }
 
+  isPrefixed() {
+    return this.prefixed;
+  }
+
   getReleaseContext() { return this.context.getReleaseContext(); }
 
   verify() {
@@ -39,18 +43,37 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     this.context.trace(`Verifying the '${complexTypeDeclarationString}' complex 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 propertiesVerify = this.verifyProperties();
+
+          if (propertiesVerify) {
+            const propertyTypesVerify = this.verifyPropertyTypes();
+
+            if (propertyTypesVerify) {
+              const typePrefix = this.context.getTypePrefix();
 
-      if (superTypesVerify) {
-        const propertiesVerify = this.verifyProperties();
+              if (typePrefix !== null) {
+                const typePrefixName = typePrefix.getName(),
+                      prefixName = typePrefixName;  ///
 
-        if (propertiesVerify) {
-          this.context.addType(this.type);
+                this.type.setPrefixName(prefixName);
+              }
+
+              this.context.addType(this.type);
 
-          verifies = true;
+              verifies = true;
+            }
+          }
         }
       }
     }
@@ -70,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;
@@ -92,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;
 
-    if (superTypePresent) {
-      superTypeVerifies = true;
+      superType = this.context.findTypeByNominalTypeName(nominalTypeName);
+
+      const superTypePresent = (superType !== null);
+
+      if (superTypePresent) {
+        const newSuperType = superType; ///
+
+        this.type.replaceSuperType(oldSuperType, newSuperType);
+
+        superTypeVerifies = true;
+      }
     }
 
     if (superTypeVerifies) {
@@ -107,75 +154,38 @@ export default domAssigned(class ComplexTypeDeclaration {
   }
 
   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}' 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);
+      const superTypes = this.type.getSuperTypes();
 
-          if (superTypeVerifies) {
-            return true;
-          }
-        });
+      superTypesVerify = superTypes.every((superType) => {
+        const superTypeVerifies = this.verifySuperType(superType);
 
-        if (superTypesVerify) {
-          superTypes = superTypes.map((superType) => {
-            const superTypeName = superType.getName();
-
-            superType = this.context.findTypeByTypeName(superTypeName);
-
-            return 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}' complex type's super-types.`, this.node);
     }
 
     return superTypesVerify;
   }
 
-  verifyProperty(property, properties, superTypeProperties) {
+  verifyProperty(property, properties) {
     let propertyVerifies = false;
 
     const propertyString = property.getString();
@@ -196,48 +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);
+      const superTypes = this.type.getSuperTypes();
 
-        if (propertyNameMatches) {
-          return true;
-        }
-      }) || null;
+      propertyVerifies = superTypes.every((superType) => {
+        const superTypeProperties = superType.getProperties(),
+              superTypeProperty = superTypeProperties.find((superTypeProperty) => {
+                const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
 
-      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;
+                if (propertyNameMatches) {
+                  return true;
+                }
+              }) || null;
 
-        propertyType = property.getType();
+        if (superTypeProperty !== null) {
+          const superTypePropertyString = superTypeProperty.getString();
 
-        const propertyTypeVerifies = this.verifyPropertyType(propertyType);
-
-        if (propertyTypeVerifies) {
-          const propertyTypeName = propertyType.getName();
-
-          propertyType = this.context.findTypeByTypeName(propertyTypeName);
-
-          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(),
-            typeNameMatches = property.matchTypeName(typeName);
-
-      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;
@@ -246,69 +238,104 @@ 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();
 
-      const propertyTypeName = propertyType.getName(),
-            propertyTypePresent = this.context.isTypePresentByTypeName(propertyTypeName);
+      propertyType = this.context.findTypeByNominalTypeName(nominalTypeName);
 
-      if (!propertyTypePresent) {
-        const propertyTypeString = propertyType.getString();
+      const propertyTypePresent = (propertyType !== null);
+
+      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) {
     const { Type } = dom,
-          node = complexTypeDeclarationNode,  ///
           type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+          node = complexTypeDeclarationNode,  ///
+          prefixed = complexTypeDeclarationNode.isPrefixed(),
+          typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),
           typeName = type.getName(),
           superTypes = type.getSuperTypes(),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          complexTypeDeclaration = new ComplexTypeDeclaration(context, node, string, type);
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          complexTypeDeclaration = new ComplexTypeDeclaration(context, node, string, type, prefixed);
 
     return complexTypeDeclaration;
   }

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);