occam-verify-cli 1.0.984 → 1.0.985

package/src/element/declaration/complexType.js

@@ -1,257 +0,0 @@
-"use strict";
-
-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, breakPoint, type, superTypes, provisional, propertyDeclarations) {
-    super(context, string, node, breakPoint);
-
-    this.type = type;
-    this.superTypes = superTypes;
-    this.provisional = provisional;
-    this.propertyDeclarations = propertyDeclarations;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getSuperTypes() {
-    return this.superTypes;
-  }
-
-  isProvisional() {
-    return this.provisional;
-  }
-
-  getPropertyDeclarations() {
-    return this.propertyDeclarations;
-  }
-
-  getComplexTypeDeclarationNode() {
-    const node = this.getNode(),
-          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();  ///
-
-    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
-
-    const typeVerifies = this.verifyType(context);
-
-    if (typeVerifies) {
-      const superTypesVerify = this.verifySuperTypes(context);
-
-      if (superTypesVerify) {
-        const typePrefixVerifies = this.verifyTypePrefix(context);
-
-        if (typePrefixVerifies) {
-          const propertyDeclarationsVerify = await this.verifyPropertyDeclaratisons(context);
-
-          if (propertyDeclarationsVerify) {
-            const properties = this.getProperties(),
-                  typePrefix = context.getTypePrefix(),
-                  prefixName = (typePrefix !== null) ?
-                                 typePrefix.getPrefixName() :
-                                   null;
-
-            this.type.setProvisional(this.provisional);
-
-            this.type.setProperties(properties);
-
-            this.type.setPrefixName(prefixName);
-
-            context.addType(this.type);
-
-            verifies = true;
-          }
-        }
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
-    }
-
-    return verifies;
-  }
-
-  verifyType(context) {
-    let typeVerifies = false;
-
-    const typeString = this.type.getString(),
-          complexTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type...`);
-
-    const typeName = this.type.getName(),
-          includeRelease = false,
-          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);
-
-    if (!typePresent) {
-      const prefixedTypeName = typeName, ///
-            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
-
-      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 '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type`);
-    }
-
-    return typeVerifies;
-  }
-
-  verifySuperType(superType, superTypes, context) {
-    let superTypeVerifies = false;
-
-    const superTypeString = superType.getString(),
-          complexTypeDeclarationString = this.getString(); ///
-
-    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) {
-      superType = context.findTypeByNominalTypeName(nominalTypeName);
-
-      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 '${complexTypeDeclarationString}' complex type declaration's '${superTypeString}' super-type.`);
-    }
-
-    return superTypeVerifies;
-  }
-
-  verifySuperTypes(context) {
-    let superTypesVerify;
-
-    const superTypes = [],
-          complexTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's super-types...`);
-
-    superTypesVerify = this.superTypes.every((superType) => {
-      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
-
-      if (superTypeVerifies) {
-        return true;
-      }
-    });
-
-    if (superTypesVerify) {
-      const superTypesLength = superTypes.length;
-
-      if (superTypesLength === 0) {
-        const baseType = baseTypeFromNothing(),
-              superTyupe = baseType;  ///
-
-        superTypes.push(superTyupe);
-      }
-
-      this.type.setSuperTypes(superTypes);
-
-      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's super-types.`);
-    }
-
-    return superTypesVerify;
-  }
-
-  verifyTypePrefix(context) {
-    let typePrefixVerifies = false;
-
-    const typeString = this.type.getString(),
-          complexTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's prefix...`);
-
-    const typePrefixed = this.type.isPrefixed();
-
-    if (!typePrefixed) {
-      typePrefixVerifies = true;
-    } else {
-      context.debug(`The '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type is prefixed.`);
-    }
-
-    if (typePrefixVerifies) {
-      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's prefix.`);
-    }
-
-    return typePrefixVerifies;
-  }
-
-  async verifyPropertyDeclaratisons(context) {
-    let propertyDeclarationsVerify;
-
-    const typeString = this.type.getString(),
-          complexTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's property declarations...`);
-
-    const properties = this.getProperties();
-
-    propertyDeclarationsVerify = await asyncEvery(this.propertyDeclarations, async (propertyDeclaration) => {
-      const propertyVerifes = await propertyDeclaration.verify(properties, this.type, context);
-
-      if (propertyVerifes) {
-        return true;
-      }
-    });
-
-    if (propertyDeclarationsVerify) {
-      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type's property declarations.`);
-    }
-
-    return propertyDeclarationsVerify;
-  }
-
-  static name = "ComplexTypeDeclaration";
-});

package/src/element/declaration/constructor.js

@@ -1,122 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-
-export default define(class ConstructorDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, type, provisional, constructor) {
-    super(context, string, node, breakPoint);
-
-    this.type = type;
-    this.provisional = provisional;
-    this.constructor = constructor;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  isProvisional() {
-    return this.provisional;
-  }
-
-  getConstructor() {
-    return this.constructor;
-  }
-
-  getConstructorDeclarationNode() {
-    const node = this.getNode(),
-          constructorDeclarationNode = node; ///
-
-    return constructorDeclarationNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const constructorDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const typeVerified = this.verifyType(context);
-
-    if (typeVerified) {
-      const constructorValidates = this.validateConstructor(context);
-
-      if (constructorValidates) {
-        this.constructor.setType(this.type);
-
-        context.addConstructor(this.constructor);
-
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-    }
-
-    return verifies;
-  }
-
-  verifyType(context) {
-    let typeVerifies = false;
-
-    const constructorDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's type...`);
-
-    const nominalTypeName = this.type.getNominalTypeName(),
-          type = context.findTypeByNominalTypeName(nominalTypeName);
-
-    if (type !== null) {
-      const provisional = this.isProvisional(),
-            typeComparesToProvisional = type.compareProvisional(provisional);
-
-      if (!typeComparesToProvisional) {
-        const typeString = this.type.getString();
-
-        provisional ?
-          context.debug(`The '${typeString}' type is present but not provisional.`) :
-            context.debug(`The '${typeString}' type is present but provisional.`);
-      } else {
-        this.type = type;
-
-        typeVerifies = true;
-      }
-    } else {
-      const typeString = this.type.getString();
-
-      context.debug(`The '${typeString}' type is not present.`);
-    }
-
-    if (typeVerifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's type.`);
-    }
-
-    return typeVerifies;
-  }
-
-  validateConstructor(context) {
-    let constructorValidates;
-
-    const includeType = false,
-          constructorString = this.constructor.getString(includeType),
-          constructorDeclarationString = this.getString();  ///
-
-    context.trace(`Validating the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
-
-    constructorValidates = this.constructor.validate(context);
-
-    if (constructorValidates) {
-      context.debug(`...validated the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
-    }
-
-    return constructorValidates;
-  }
-
-  static name = "ConstructorDeclaration";
-});

package/src/element/declaration/metavariable.js

@@ -1,93 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-
-export default define(class MetavariableDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, metaType, metavariable) {
-    super(context, string, node, breakPoint);
-
-    this.metaType = metaType;
-    this.metavariable = metavariable;
-  }
-
-  getMetaType() {
-    return this.metaType;
-  }
-
-  getMetavariable() {
-    return this.metavariable;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    await this.break(context);
-
-    const metavariableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
-
-    const metavariableVerifies = this.verifyMetavariable(context);
-
-    if (metavariableVerifies) {
-      const metaTypeVerifies = this.verifyMetaType(context);
-
-      if (metaTypeVerifies) {
-        const declaredMetavariable = this.metavariable; ///
-
-        context.addDeclaredMetavariable(declaredMetavariable);
-
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
-    }
-
-    return verifies;
-  }
-
-  verifyMetaType(context) {
-    let metaTypeVerifies = true;
-
-    const metaTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${metaTypeDeclarationString}' metavariable declaration's metaType...`);
-
-    this.metavariable.setMetaType(this.metaType);
-
-    if (metaTypeVerifies) {
-      context.debug(`...verified the '${metaTypeDeclarationString}' metavariable declaration's metaType.`);
-    }
-
-    return metaTypeVerifies;
-  }
-
-  verifyMetavariable(context) {
-    let metavariableVerifies = false;
-
-    const metavariableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration's metavariable...`);
-
-    const metavariableName = this.metavariable.getName(),
-          declaredMetavariablePresent = context.isDeclaredMetavariablePresentByMetavariableName(metavariableName);
-
-    if (!declaredMetavariablePresent) {
-      metavariableVerifies = this.metavariable.verify(context);
-    } else {
-      context.debug(`The '${metavariableName}' declared metavariable is already present.`);
-    }
-
-    if (metavariableVerifies) {
-      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration's metavariable.`);
-    }
-
-    return metavariableVerifies;
-  }
-
-  static name = "MetavariableDeclaration";
-});

package/src/element/declaration/property.js

@@ -1,108 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-
-export default define(class PropertyDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, property, type) {
-    super(context, string, node, breakPoint);
-
-    this.property = property;
-    this.type = type;
-  }
-
-  getProperty() {
-    return this.property;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  async verify(properties, type, 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(type, 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(type, context) {
-    let typeVerifies = false;
-
-    const propertyDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${propertyDeclarationString}' property declaration's type...`);
-
-    const nominalTypeName = this.type.getNominalTypeName(),
-          comparesToNominalTypeName = type.compareNominalTypeName(nominalTypeName);
-
-    if (comparesToNominalTypeName) {
-      this.type = type;
-
-      typeVerifies = true;
-    } else {
-      const type = context.findTypeByTypeName(nominalTypeName);
-
-      if (type !== null) {
-        this.type = type;
-
-        typeVerifies = true;
-      } else {
-        const typeString = this.type.getString();
-
-        context.debug(`The '${typeString}' type is not present.`);
-      }
-    }
-
-    if (typeVerifies) {
-      context.debug(`...verified the '${propertyDeclarationString}' property declaration's 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";
-});