occam-verify-cli 1.0.890 → 1.0.895

package/src/element/declaration/complexType.js

@@ -2,14 +2,21 @@
 
 import Declaration from "../declaration";
 
+import { asynchronousUtilities } from "occam-languages";
+
 import { define } from "../../elements";
+import { baseTypeFromNothing } from "../../utilities/type";
+
+const { asyncEvery } = asynchronousUtilities;
 
 export default define(class ComplexTypeDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, superTypes) {
+  constructor(context, string, node, lineIndex, type, superTypes, provisional, propertyDeclarations) {
     super(context, string, node, lineIndex);
 
     this.type = type;
     this.superTypes = superTypes;
+    this.provisional = provisional;
+    this.propertyDeclarations = propertyDeclarations;
   }
 
   getType() {
@@ -20,44 +27,59 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return this.superTypes;
   }
 
+  isProvisional() {
+    return this.provisional;
+  }
+
+  getPropertyDeclarations() {
+    return this.propertyDeclarations;
+  }
+
   getComplexTypeDeclarationNode() {
     const node = this.getNode(),
-          complexTypeDeclarationNode = node;  ///
+          complexTypeDeclarationNode = node; ///
 
     return complexTypeDeclarationNode;
   }
 
+  getProperties() {
+    const properties = this.propertyDeclarations.reduce((properties, propertyDeclaration) => {
+      const property = propertyDeclaration.getProperty();
+
+      if (property !== null) {
+        properties.push(property);
+      }
+
+      return properties;
+    }, []);
+
+    return properties;
+  }
+
   async verify(context) {
     let verifies = false;
 
     await this.break(context);
 
-    const complexTypeDeclarationString = this.getString(); ///
+    const complexTypeDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
 
-    if (this.prefixed) {
-      const typeString = this.type.getString();
-
-      context.trace(`The '${typeString}' type is prefixed.`);
-    } else {
-      const typeVerifies = this.verifyType(context);
+    const typeVerifies = this.verifyType(context);
 
-      if (typeVerifies) {
-        const superTypesVerify = this.verifySuperTypes(context);
+    if (typeVerifies) {
+      const superTypesVerify = this.verifySuperTypes(context);
 
-        if (superTypesVerify) {
-          const propertiesVerify = this.verifyProperties(context);
+      if (superTypesVerify) {
+        const typePrefixVerifies = this.verifyTypePrefix(context);
 
-          if (propertiesVerify) {
-            const typePrefix = context.getTypePrefix();
+        if (typePrefixVerifies) {
+          const propertyDeclarationsVerify = await this.verifyPropertyDeclaratisons(context);
 
-            if (typePrefix !== null) {
-              const typePrefixName = typePrefix.getName(),
-                    prefixName = typePrefixName;  ///
+          if (propertyDeclarationsVerify) {
+            const properties = this.getProperties();
 
-              this.type.setPrefixName(prefixName);
-            }
+            this.type.setProperties(properties);
 
             context.addType(this.type);
 
@@ -77,65 +99,64 @@ export default define(class ComplexTypeDeclaration extends Declaration {
   verifyType(context) {
     let typeVerifies = false;
 
-    const typeString = this.type.getString();
+    const typeString = this.type.getString(),
+          complexTypeDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${typeString}' complex type...`);
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type...`);
 
     const typeName = this.type.getName(),
-          includeRelease = true,
-          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);
+          typePresent = context.isTypePresentByTypeName(typeName);
 
-    if (typePresent) {
-      context.debug(`The '${typeString}' type is already present.`);
-    } else {
+    if (!typePresent) {
       const prefixedTypeName = typeName, ///
             typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
 
-      if (typePresent) {
-        context.debug(`The '${typeString}' type is already present.`);
-      } else {
+      if (!typePresent) {
+        this.type.setProvisional(this.provisional);
+
         typeVerifies = true;
+      } else {
+        context.debug(`The '${typeString}' type is already present.`);
       }
+    } else {
+      context.debug(`The '${typeString}' type is already present.`);
     }
 
     if (typeVerifies) {
-      context.debug(`...verified the '${typeString}' complex type.`);
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type`);
     }
 
     return typeVerifies;
   }
 
-  verifySuperType(context, superType) {
+  verifySuperType(context, superType, superTypes) {
     let superTypeVerifies = false;
 
-    const superTypeString = superType.getString();
+    const superTypeString = superType.getString(),
+          complexTypeDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${superTypeString}' super-type...`);
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${superTypeString}' super-type...`);
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
           typeComparesToTypeName = this.type.compareTypeName(typeName);
 
-    if (typeComparesToTypeName) {
-      context.trace(`The super-type's name compares to the ${typeName}' complex type's name.`);
-    } else {
-      const oldSuperType = superType;
-
+    if (!typeComparesToTypeName) {
       superType = context.findTypeByNominalTypeName(nominalTypeName);
 
-      const superTypePresent = (superType !== null);
-
-      if (superTypePresent) {
-        const newSuperType = superType; ///
-
-        this.type.replaceSuperType(oldSuperType, newSuperType);
+      if (superType !== null) {
+        superTypes.push(superType);
 
         superTypeVerifies = true;
+      } else {
+        context.debug(`The '${superTypeString}' super-type is not present.`);
       }
+    } else {
+      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);
     }
 
     if (superTypeVerifies) {
-      context.debug(`...verified the '${superTypeString}' super-type.`);
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's '${superTypeString}' super-type.`);
     }
 
     return superTypeVerifies;
@@ -144,162 +165,83 @@ export default define(class ComplexTypeDeclaration extends Declaration {
   verifySuperTypes(context) {
     let superTypesVerify;
 
-    const typeString = this.type.getString();
-
-    context.trace(`Verifying the '${typeString}' complex type's super-types...`);
+    const superTypes = [],
+          complexTypeDeclarationString = this.getString(); ///
 
-    const typeBasic = this.type.isBasic();
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's super-types...`);
 
-    if (typeBasic) {
-      superTypesVerify = true;
+    superTypesVerify = this.superTypes.every((superType) => {
+      const superTypeVerifies = this.verifySuperType(context, superType, superTypes);
 
-      context.trace(`The '${typeString}' complex type is basic.`)
-    } else  {
-      const superTypes = this.type.getSuperTypes();
-
-      superTypesVerify = superTypes.every((superType) => {
-        const superTypeVerifies = this.verifySuperType(context, superType);
-
-        if (superTypeVerifies) {
-          return true;
-        }
-      });
-    }
+      if (superTypeVerifies) {
+        return true;
+      }
+    });
 
     if (superTypesVerify) {
-      context.debug(`...verified the '${typeString}' complex type's super-types.`);
-    }
-
-    return superTypesVerify;
-  }
-
-  verifyProperty(context, property, properties) {
-    let propertyVerifies = false;
-
-    const propertyString = property.getString();
+      const superTypesLength = superTypes.length;
 
-    context.trace(`Verifying the '${propertyString}' property...`);
+      if (superTypesLength === 0) {
+        const baseType = baseTypeFromNothing(),
+              superTyupe = baseType;  ///
 
-    const propertyNameVerifies = this.verifyPropertyName(context, property, properties);
-
-    if (propertyNameVerifies) {
-      const propertyNominalTypeNameVerifies = this.verifyPropertyNominalTypeName(context, property, properties);
-
-      if (propertyNominalTypeNameVerifies) {
-        propertyVerifies = true;
+        superTypes.push(superTyupe);
       }
-    }
-
-    if (propertyVerifies) {
-      context.debug(`...verified the '${propertyString}' property.`);
-    }
-
-    return propertyVerifies;
-  }
-
-  verifyProperties(context) {
-    let propertiesVerify;
-
-    const typeString = this.type.getString();
 
-    context.trace(`Verifying the '${typeString}' complex type's properties...`);
+      this.type.setSuperTypes(superTypes);
 
-    const includeSuperTypes = false,
-          properties = this.type.getProperties(includeSuperTypes);
-
-    propertiesVerify = properties.every((property) => {
-      const propertyVerifies = this.verifyProperty(context, property, properties);
-
-      if (propertyVerifies) {
-        return true;
-      }
-    });
-
-    if (propertiesVerify) {
-      context.debug(`...verified the '${typeString}' complex type's properties.`);
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's super-types.`);
     }
 
-    return propertiesVerify;
+    return superTypesVerify;
   }
 
-  verifyPropertyName(context, property, properties) {
-    let propertyNameVerifies = false;
-
-    const propertyString = property.getString();
-
-    context.trace(`Verifying the '${propertyString}' property's name...`);
+  verifyTypePrefix(context) {
+    let typePrefixVerifies = false;
 
-    const propertyName = property.getName(),
-          count = properties.reduce((count, property) => {
-            const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
+    const typeString = this.type.getString(),
+          complexTypeDeclarationString = this.getString(); ///
 
-            if (propertyComparesToPropertyName) {
-              count++;
-            }
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's prefix...`);
 
-            return count;
-          }, 0);
+    const typePrefixed = this.type.isPrefixed();
 
-    if (count > 1) {
-      context.debug(`The '${propertyString}' property appears more than once.`);
+    if (!typePrefixed) {
+      typePrefixVerifies = true;
     } else {
-      const superTypes = this.type.getSuperTypes(),
-            superType = superTypes.find((superType) => {
-              const superTypeProperties = superType.getProperties(),
-                    superTypePropertyComparesToPropertyName = superTypeProperties.some((superTypeProperty) => {
-                      const superTypePropertyComparesToPropertyName = superTypeProperty.comparePropertyName(propertyName);
-
-                      if (superTypePropertyComparesToPropertyName) {
-                        return true;
-                      }
-                    });
-
-              if (superTypePropertyComparesToPropertyName) {
-                return true;
-              }
-            }) || null;
-
-      if (superType !== null) {
-        const superTypeString = superType.getString();
-
-        context.debug(`The '${superTypeString}' super-type has the same property.`);
-      } else {
-        propertyNameVerifies = true;
-      }
+      context.debug(`The '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type is prefixed.`);
     }
 
-    if (propertyNameVerifies) {
-      context.debug(`...verified the '${propertyString}' property's name.`);
+    if (typePrefixVerifies) {
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's prefix.`);
     }
 
-    return propertyNameVerifies;
+    return typePrefixVerifies;
   }
 
-  verifyPropertyNominalTypeName(context, property) {
-    let propertyNominalTypeNameVerifies = false;
+  async verifyPropertyDeclaratisons(context) {
+    let propertyDeclarationsVerify;
 
-    const propertyString = property.getString(),
-          nominalTypeName = property.getNominalTypeName();
+    const typeString = this.type.getString(),
+          complexTypeDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyString}' property's nominal type name...`);
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's property declarations...`);
 
-    const typeComparesToNominalTypeName = this.type.compareNominalTypeName(nominalTypeName);
+    const properties = this.getProperties();
 
-    if (typeComparesToNominalTypeName) {
-      propertyNominalTypeNameVerifies = true;
-    } else {
-      const typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+    propertyDeclarationsVerify = await asyncEvery(this.propertyDeclarations, async (propertyDeclaration) => {
+      const propertyVerifes = await propertyDeclaration.verify(properties, context);
 
-      if (typePresent) {
-        propertyNominalTypeNameVerifies = true;
+      if (propertyVerifes) {
+        return true;
       }
-    }
+    });
 
-    if (propertyNominalTypeNameVerifies) {
-      context.debug(`...verifies the '${propertyString}' property's nominal type name.`);
+    if (propertyDeclarationsVerify) {
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's property declarations.`);
     }
 
-    return propertyNominalTypeNameVerifies;
+    return propertyDeclarationsVerify;
   }
 
   static name = "ComplexTypeDeclaration";

package/src/element/declaration/property.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Declaration from "../declaration";
+
+import { define } from "../../elements";
+
+export default define(class PropertyDeclaration extends Declaration {
+  constructor(context, string, node, lineIndex, property, type) {
+    super(context, string, node, lineIndex);
+
+    this.property = property;
+    this.type = type;
+  }
+
+  getProperty() {
+    return this.property;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  async verify(properties, context) {
+    let verifies = false;
+
+    await this.break(context);
+
+    const propertyDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${propertyDeclarationString}' property declaration...`);
+
+    if (this.property !== null) {
+      const typeVerifies = this.verifyType(context);
+
+      if (typeVerifies) {
+        const propertyVerifies = this.verifyProperty(properties, context);
+
+        if (propertyVerifies) {
+          this.property.setType(this.type);
+
+          verifies = true;
+        }
+      }
+    } else {
+      context.debug(`Unable to verify the '${propertyDeclarationString}' property declaration because it is nonsense.`);
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${propertyDeclarationString}' property declaration.`);
+    }
+
+    return verifies;
+  }
+
+  verifyType(context) {
+    let typeVerifies = false;
+
+    const typeString = this.type.getString(),
+          propertyDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${propertyDeclarationString}' property declaration's '${typeString}' type...`);
+
+    const typeName = this.type.getName(),
+          type = context.findTypeByTypeName(typeName);
+
+    if (type !== null) {
+      this.type = type;
+
+      typeVerifies = true;
+    } else {
+      context.debug(`The '${typeString}' type is not present.`);
+    }
+
+    if (typeVerifies) {
+      context.debug(`...verified the '${propertyDeclarationString}' property declaration's '${typeString}' type`);
+    }
+
+    return typeVerifies;
+  }
+
+  verifyProperty(properties, context) {
+    let propertyVerifies;
+
+    const propertyString = this.property.getString(),
+          propertyDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${propertyDeclarationString}' property declaration's '${propertyString}' property...`);
+
+    propertyVerifies = this.property.verify(properties, context);
+
+    if (propertyVerifies) {
+      context.debug(`...verified the '${propertyDeclarationString}' property declaration's '${propertyString}' type`);
+    }
+
+    return propertyVerifies;
+  }
+
+  static name = "PropertyDeclaration";
+});

package/src/element/declaration/simpleType.js

@@ -3,8 +3,7 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { superTypesStringFromSuperTypes } from "../../utilities/string";
-import {baseTypeFromNothing} from "../../utilities/type";
+import { baseTypeFromNothing } from "../../utilities/type";
 
 export default define(class SimpleTypeDeclaration extends Declaration {
   constructor(context, string, node, lineIndex, type, superTypes, provisional) {
@@ -79,8 +78,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type...`);
 
     const typeName = this.type.getName(),
-          includeRelease = true,
-          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);
+          typePresent = context.isTypePresentByTypeName(typeName);
 
     if (!typePresent) {
       const prefixedTypeName = typeName, ///
@@ -108,7 +106,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     let superTypeVerifies = false;
 
     const superTypeString = superType.getString(),
-          simpleTypeDeclarationString = this.getString(); ///;
+          simpleTypeDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-type...`);
 
@@ -141,12 +139,9 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     let superTypesVerify;
 
     const superTypes = [],
-          superTypesString = superTypesStringFromSuperTypes(this.superTypes),
-          simpleTypeDeclarationString = this.getString(); ///;
+          simpleTypeDeclarationString = this.getString(); ///
 
-    (superTypesString !== null) ?
-      context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types...`) :
-        context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's super-types...`);
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's super-types...`);
 
     superTypesVerify = this.superTypes.every((superType) => {
       const superTypeVerifies = this.verifySuperType(context, superType, superTypes);
@@ -168,9 +163,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
 
       this.type.setSuperTypes(superTypes);
 
-      (superTypesString !== null) ?
-        context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types.`) :
-          context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's super-types.`);
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's super-types.`);
     }
 
     return superTypesVerify;
@@ -180,7 +173,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     let typePrefixVerifies = false;
 
     const typeString = this.type.getString(),
-          simpleTypeDeclarationString = this.getString(); ///;
+          simpleTypeDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix...`);
 
@@ -203,7 +196,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     let propertiesVerify = true;  ///
 
     const typeString = this.type.getString(),
-          simpleTypeDeclarationString = this.getString(); ///;
+          simpleTypeDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's properties...`);
 

package/src/element/declaration/typePrefix.js

@@ -35,7 +35,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
           typesLength = types.length;
 
     if (typesLength === 0) {
-      const typePrefixVerifies = this.verifyTypePrefix(context);
+      const typePrefixVerifies = this.typePrefix.verify(context);
 
       if (typePrefixVerifies) {
         context.addTypePrefix(this.typePrefix);
@@ -53,42 +53,5 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyTypePrefix(context) {
-    let typePrefixVerifies = false;
-
-    const typePrefixString = this.typePrefix.getString();
-
-    context.trace(`Verifying the '${typePrefixString}' type prefix...`);
-
-    const typePrefix = context.getTypePrefix();
-
-    if (typePrefix !== null) {
-      context.trace(`The package already has a '${typePrefixString}' type prefix.`);
-    } else {
-
-      const typePrefixName = this.typePrefix.getName(),
-            typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
-
-      if (typePrefixPresent) {
-        context.debug(`The '${typePrefixString}' type prefix is already present.`);
-      } else {
-        const nominalTypeName = typePrefixName,  ///
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          context.debug(`The '${typePrefixString}' type is already present.`);
-        } else {
-          typePrefixVerifies = true;
-        }
-      }
-    }
-
-    if (typePrefixVerifies) {
-      context.debug(`...verified the '${typePrefixString}' type prefix.`);
-    }
-
-    return typePrefixVerifies;
-  }
-
   static name = "TypePrefixDeclaration";
 });

package/src/element/metavariable.js

@@ -108,7 +108,7 @@ export default define(class Metavariable extends Element {
   verify(context) {
     let verifies = false;
 
-    const metavariableString = this.getString();
+    const metavariableString = this.getString();  ///
 
     context.trace(`Verifying the '${metavariableString}' metavariable...`);
 
@@ -148,7 +148,7 @@ export default define(class Metavariable extends Element {
     let typeVerifies = true;  ///
 
     if (this.type !== null) {
-      const metavariableString = this.getString();
+      const metavariableString = this.getString();  ///
 
       context.trace(`Verifying the '${metavariableString}' metavariable's type...`);
 
@@ -258,7 +258,7 @@ export default define(class Metavariable extends Element {
     if (this.term === null) {
       termValidates = true;
     } else {
-      const metavariableString = this.getString();
+      const metavariableString = this.getString();  ///
 
       context.trace(`Validating the '${metavariableString}' metavariable's term...`);