occam-verify-cli 1.0.984 → 1.0.985

package/src/element/declaration/simpleType.js

@@ -1,208 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-import { baseTypeFromNothing } from "../../utilities/type";
-
-export default define(class SimpleTypeDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, type, superTypes, provisional) {
-    super(context, string, node, breakPoint);
-
-    this.type = type;
-    this.superTypes = superTypes;
-    this.provisional = provisional;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getSuperTypes() {
-    return this.superTypes;
-  }
-
-  isProvisional() {
-    return this.provisional;
-  }
-
-  getSimpleTypeDeclarationNode() {
-    const node = this.getNode(),
-          simpleTypeDeclarationNode = node; ///
-
-    return simpleTypeDeclarationNode;
-  }
-
-  getProperties() {
-    const properties = [];
-
-    return properties;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const simpleTypeDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
-
-    const typeVerifies = this.verifyType(context);
-
-    if (typeVerifies) {
-      const superTypesVerify = this.verifySuperTypes(context);
-
-      if (superTypesVerify) {
-        const typePrefixVerifies = this.verifyTypePrefix(context);
-
-        if (typePrefixVerifies) {
-          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 '${simpleTypeDeclarationString}' simple type declaration.`);
-    }
-
-    return verifies;
-  }
-
-  verifyType(context) {
-    let typeVerifies = false;
-
-    const typeString = this.type.getString(),
-          simpleTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type...`);
-
-    const typeName = this.type.getName(),
-          typePresent = context.isTypePresentByTypeName(typeName);
-
-    if (!typePresent) {
-      const prefixedTypeName = typeName, ///
-            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
-
-      if (!typePresent) {
-        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 '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type`);
-    }
-
-    return typeVerifies;
-  }
-
-  verifySuperType(superType, superTypes, context) {
-    let superTypeVerifies = false;
-
-    const superTypeString = superType.getString(),
-          simpleTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple 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 '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-type.`);
-    }
-
-    return superTypeVerifies;
-  }
-
-  verifySuperTypes(context) {
-    let superTypesVerify;
-
-    const superTypes = [],
-          simpleTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple 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 '${simpleTypeDeclarationString}' simple type declaration's super-types.`);
-    }
-
-    return superTypesVerify;
-  }
-
-  verifyTypePrefix(context) {
-    let typePrefixVerifies = false;
-
-    const typeString = this.type.getString(),
-          simpleTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix...`);
-
-    const typePrefixed = this.type.isPrefixed();
-
-    if (!typePrefixed) {
-      typePrefixVerifies = true;
-    } else {
-      context.debug(`The '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type is prefixed.`);
-    }
-
-    if (typePrefixVerifies) {
-      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix.`);
-    }
-
-    return typePrefixVerifies;
-  }
-
-  static name = "SimpleTypeDeclaration";
-});

package/src/element/declaration/typePrefix.js

@@ -1,58 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-
-export default define(class TypePrefixDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, typePrefix) {
-    super(context, string, node, breakPoint);
-
-    this.typePrefix = typePrefix;
-  }
-
-  getTypePrefix() {
-    return this.typePrefix;
-  }
-
-  getTypePrefixDeclarationNode() {
-    const node = this.getNode(),
-          typePrefixDeclarationNode = node; ///
-
-    return typePrefixDeclarationNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const typePrefixDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`);
-
-    const includeRelease = false,
-          types = context.getTypes(includeRelease),
-          typesLength = types.length;
-
-    if (typesLength === 0) {
-      const typePrefixVerifies = this.typePrefix.verify(context);
-
-      if (typePrefixVerifies) {
-        context.addTypePrefix(this.typePrefix);
-
-        verifies = true;
-      }
-    } else {
-      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`);
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`);
-    }
-
-    return verifies;
-  }
-
-  static name = "TypePrefixDeclaration";
-});

package/src/element/declaration/variable.js

@@ -1,130 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-
-export default define(class VariableDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, type, variable, provisional) {
-    super(context, string, node, breakPoint);
-
-    this.type = type;
-    this.variable = variable;
-    this.provisional = provisional;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getVariable() {
-    return this.variable;
-  }
-
-  isProvisional() {
-    return this.provisional;
-  }
-
-  getVariableDeclarationNode() {
-    const node = this.getNode(),
-          variableDeclarationNode = node; ///
-
-    return variableDeclarationNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const variableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
-
-    const typeVerifies = this.verifyType(context);
-
-    if (typeVerifies) {
-      const variableVerifies = this.verifyVariable(context);
-
-      if (variableVerifies) {
-        const declaredVariable = this.variable;
-
-        context.addDeclaredVariable(declaredVariable);
-
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
-    }
-
-    return verifies;
-  }
-
-  verifyType(context) {
-    let typeVerifies = false;
-
-    const variableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${variableDeclarationString}' variable declaration's type...`);
-
-    const nominalTypeName = this.type.getNominalTypeName(),
-          type = context.findTypeByNominalTypeName(nominalTypeName),
-          typePresent = (type !== null)
-
-    if (!typePresent) {
-      const typeString = this.type.getString();
-
-      context.debug(`The '${typeString}' type is not present.`);
-    } else {
-      const typeComparesToProvisional = type.compareProvisional(this.provisional);
-
-      if (!typeComparesToProvisional) {
-        const typeString = this.type.getString();
-
-        this.provisional ?
-          context.debug(`The '${variableDeclarationString}' variable declaration's '${typeString}' type is present but not provisional.`) :
-            context.debug(`The '${variableDeclarationString}' variable declaration's '${typeString}' type is present but provisional.`);
-      } else {
-        this.variable.setType(type);
-
-        this.variable.setProvisional(this.provisional);
-
-        typeVerifies = true;
-      }
-    }
-
-    if (typeVerifies) {
-      context.debug(`...verified the '${variableDeclarationString}' variable declaration's type.`);
-    }
-
-    return typeVerifies;
-  }
-
-  verifyVariable(context) {
-    let  variableVerifies = false;
-
-    const variableString = this.variable.getString(),
-          variableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${variableString}' variable...`);
-
-    const variableIdentifier = this.variable.getIdentifier(),
-          declaredVariablePresent = context.isDeclaredVariablePresentByVariableIdentifier(variableIdentifier);
-
-    if (declaredVariablePresent) {
-      context.debug(`The '${variableString}' declared variable is already present.`);
-    } else {
-      variableVerifies = true;
-    }
-
-    if (variableVerifies) {
-      context.debug(`...verified the '${variableDeclarationString}' variable declaration's '${variableString}' variable.`);
-    }
-
-    return variableVerifies;
-  }
-
-  static name = "VariableDeclaration";
-});

package/src/element/declaration.js

@@ -1,7 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-export default class Declaration extends Element {
-  ///
-}

package/src/element/deduction.js

@@ -1,185 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateDeduction } from "../process/instantiate";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { elide, declare, attempt, serialise, unserialise, instantiate, reconcile } from "../utilities/context";
-
-export default define(class Deduction extends Element {
-  constructor(context, string, node, breakPoint, statement) {
-    super(context, string, node, breakPoint);
-
-    this.statement = statement;
-  }
-
-  getStatement() {
-    return this.statement;
-  }
-
-  getDeductionNode() {
-    const node = this.getNode(),
-          deductionNode = node; ///
-
-    return deductionNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const deductionString = this.getString();  ///
-
-    context.trace(`Verifying the '${deductionString}' deduction...`);
-
-    if (this.statement !== null) {
-      declare((context) => {
-        elide((context) => {
-          const validates = this.validate(context);
-
-          if (validates) {
-            verifies = true;
-          }
-        }, context);
-      }, context);
-    } else {
-      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${deductionString}' deduction.`);
-    }
-
-    return verifies;
-  }
-
-  validate(context) {
-    let validates = false;
-
-    const deductionString = this.getString();  ///
-
-    context.trace(`Validating the '${deductionString}' deduction...`);
-
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
-
-      if (statementValidates) {
-        validates = true;
-      }
-
-      if (validates) {
-        this.commit(context);
-      }
-    }, context);
-
-    if (validates) {
-      context.debug(`...validated the '${deductionString}' deduction.`);
-    }
-
-    return validates;
-  }
-
-  validateStatement(context) {
-    let statementValidates = false;
-
-    const deductionnString = this.getString();  ///
-
-    context.trace(`Validating the '${deductionnString}' deductionn's statement...`);
-
-    const statement = this.statement.validate(context);
-
-    if (statement !== null) {
-      statementValidates = true;
-    }
-
-    if (statementValidates) {
-      context.trace(`...validated the '${deductionnString}' deductionn's statement.`);
-    }
-
-    return statementValidates;
-  }
-
-  unifyStep(step, context) {
-    let stepUnifies = false;
-
-    const stepString = step.getString(),
-          deductionString = this.getString();  ///
-
-    context.trace(`Unifying the '${stepString}' step with the '${deductionString}' deduction...`);
-
-    const stepContext = step.getContext(),
-          deductionContext = this.getContext(),
-          generalContext = deductionContext, ///
-          specificContext = stepContext;  ///
-
-    reconcile((specificContext) => {
-      const statement = step.getStatement(),
-            statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
-
-      if (statementUnifies) {
-        specificContext.commit(context);
-
-        stepUnifies = true;
-      }
-    }, specificContext);
-
-    if (stepUnifies) {
-      context.debug(`...unified the '${stepString}' step with the '${deductionString}' deduction.`);
-    }
-
-    return stepUnifies;
-  }
-
-  toJSON() {
-    const context = this.getContext();
-
-    return serialise((context) => {
-      const string = this.getString();
-
-      let breakPoint;
-
-      breakPoint = this.getBreakPoint();
-
-      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-      breakPoint = breakPointJSON;  ///
-
-      const json = {
-        context,
-        string,
-        breakPoint
-      };
-
-      return json;
-    }, context);
-  }
-
-  static name = "Deduction";
-
-  static fromJSON(json, context) {
-    let deduction;
-
-    instantiate((context) => {
-      unserialise((json, context) => {
-        const { string } = json,
-              deductionNode = instantiateDeduction(string, context),
-              node = deductionNode,  ///
-              breakPoint = breakPointFromJSON(json),
-              statement = statementFromDeductionNode(deductionNode, context);
-
-        deduction = new Deduction(context, string, node, breakPoint, statement);
-      }, json, context);
-    }, context);
-
-    return deduction;
-  }
-});
-
-function statementFromDeductionNode(deductionNode, context) {
-  const statementNode = deductionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/derivation.js

@@ -1,57 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-import { Element, asynchronousUtilities } from "occam-languages";
-
-import { define } from "../elements";
-
-const { last } = arrayUtilities,
-      { asyncEvery } = asynchronousUtilities;
-
-export default define(class Derivation extends Element {
-  constructor(context, string, node, breakPoint, subproofOrProofAssertions) {
-    super(context, string, node, breakPoint);
-
-    this.subproofOrProofAssertions = subproofOrProofAssertions;
-  }
-
-  getSubproofOrProofAssertions() {
-    return this.subproofOrProofAssertions;
-  }
-
-  getDerivationNode() {
-    const node = this.getNode(),
-          derivationNode = node;  ///
-
-    return derivationNode;
-  }
-
-  getLastStep() {
-    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
-          lastProofAssertion = lastSubproofOrProofAssertion,  ///
-          lastStep = lastProofAssertion;  ///
-
-    return lastStep;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    verifies = await asyncEvery(this.subproofOrProofAssertions, async (subproofOrProofAssertion) => { ///
-      const subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(context);
-
-      if (subproofOrProofAssertionVerifies) {
-        context.assignAssignments();
-
-        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-
-        return true;
-      }
-    });
-
-    return verifies;
-  }
-
-  static name = "Derivation";
-});
-