occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/declaration/metavariable.js

@@ -24,32 +24,32 @@ export default domAssigned(class MetavariableDeclaration {
   }
 
   verify() {
-    let verified;
+    let verifies;
 
     const metavariableDeclarationString = this.string; ///
 
     this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerified = this.verifyMetavariable(this.metavariable);
+    const metavariableVerifies = this.verifyMetavariable(this.metavariable);
 
-    if (metavariableVerified) {
+    if (metavariableVerifies) {
       this.fileContext.addMetavariable(this.metavariable);
 
-      verified = true;
+      verifies = true;
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyType(type) {
-    let typeVerified;
+    let typeVerifies;
 
     if (type === null) {
-      typeVerified = true;
+      typeVerifies = true;
     } else {
       const typeName = type.getName(),
             typeString = type.getString();
@@ -61,19 +61,19 @@ export default domAssigned(class MetavariableDeclaration {
       if (!typePresent) {
         this.fileContext.debug(`The '${typeString}' type is not present.`);
       } else {
-        typeVerified = true;
+        typeVerifies = true;
       }
 
-      if (typeVerified) {
+      if (typeVerifies) {
         this.fileContext.debug(`...verified the '${typeString}' type.`);
       }
     }
 
-    return typeVerified;
+    return typeVerifies;
   }
 
   verifyMetavariable(metavariable) {
-    let metavariableVerified = false;
+    let metavariableVerifies = false;
 
     const metavariableString = metavariable.getString();
 
@@ -92,17 +92,17 @@ export default domAssigned(class MetavariableDeclaration {
         this.fileContext.debug(`The '${metavariableName}' metavariable is already present.`);
       } else {
         const type = metavariable.getType(),
-              typeVerified = this.verifyType(type);
+              typeVerifies = this.verifyType(type);
 
-        metavariableVerified = typeVerified;  ///
+        metavariableVerifies = typeVerifies;  ///
       }
     }
 
-    if (metavariableVerified) {
+    if (metavariableVerifies) {
       this.fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
     }
 
-    return metavariableVerified;
+    return metavariableVerifies;
   }
 
   static name = "MetavariableDeclaration";

package/src/dom/declaration/simpleType.js

@@ -0,0 +1,179 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { objectType } from "../type";
+import { domAssigned } from "../../dom";
+import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
+
+export default domAssigned(class SimpleTypeDeclaration {
+  constructor(fileContext, string, type) {
+    this.fileContext = fileContext;
+    this.string = string;
+    this.type = type;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  verify() {
+    let verifies = false;
+
+    const typeDeclarationString = this.getString(); ///
+
+    this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
+
+    const typeVerifies = this.verifyType();
+
+    if (typeVerifies) {
+      const superTypesVerify = this.verifySuperTypes();
+
+      if (superTypesVerify) {
+        this.fileContext.addType(this.type);
+
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      this.fileContext.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+    }
+
+    return verifies;
+  }
+
+  verifyType() {
+    let typeVerifies = false;
+
+    const typeString = this.type.getString();
+
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
+
+    const typeName = this.type.getName(),
+          typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+    if (typePresent) {
+      this.fileContext.debug(`The type '${typeString}' is already present.`);
+    } else {
+      typeVerifies = true;
+    }
+
+    if (typeVerifies) {
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
+    }
+
+    return typeVerifies;
+  }
+
+  verifySuperType(superType) {
+    let superTypeVerifies = false;
+
+    const superTypeString = superType.getString();
+
+    this.fileContext.trace(`Verifying the '${superTypeString}' super-type...`);
+
+    const superTypeName = superType.getName(),
+          superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
+
+    if (superTypePresent) {
+      superTypeVerifies = true;
+    }
+
+    if (superTypeVerifies) {
+      this.fileContext.debug(`...verified the '${superTypeString}' super-type.`);
+    }
+
+    return superTypeVerifies;
+  }
+
+  verifySuperTypes() {
+    let superTypesVerify = false;
+
+    this.fileContext.trace(`Verifying the super-types...`);
+
+    let superTypes;
+
+    superTypes = this.type.getSuperTypes();
+
+    const superTypesLength = superTypes.length;
+
+    if (superTypesLength === 0) {
+      const superType = objectType; ///
+
+      superTypes.push(superType);
+    }
+
+    const typeName = this.type.getName(),
+          typeBasic = this.type.isBasic(),
+          typeString = this.type.getString();
+
+    if (typeBasic) {
+      superTypesVerify = true;
+
+      this.fileContext.trace(`The '${typeString}' type is basic.`)
+    } else  {
+      const superTypeNames = superTypes.map((superType) => {
+              const superTypeName = superType.getName();
+
+              return superTypeName;
+            }),
+            superTypeNamesIncludesTypeName = superTypeNames.includes(typeName);
+
+      if (superTypeNamesIncludesTypeName) {
+        this.fileContext.trace(`The '${typeName}' type cannot be a super-type `);
+      } else {
+        superTypesVerify = superTypes.every((superType) => {
+          const superTypeVerifies = this.verifySuperType(superType);
+
+          if (superTypeVerifies) {
+            return true;
+          }
+        });
+
+        if (superTypesVerify) {
+          superTypes = superTypes.map((superType) => {
+            const superTypeName = superType.getName();
+
+            superType = this.fileContext.findTypeByTypeName(superTypeName);
+
+            return superType;
+          });
+
+          const string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes);
+
+          this.type.setString(string);
+
+          this.type.setSuperTypes(superTypes);
+        }
+      }
+    }
+
+    if (superTypesVerify) {
+      this.fileContext.debug(`...verified the super-types.`);
+    }
+
+    return superTypesVerify;
+  }
+
+  static name = "SimpleTypeDeclaration";
+
+  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext) {
+    const { Type } = dom,
+          type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext),
+          typeName = type.getName(),
+          superTypes = type.getSuperTypes(),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
+          simpleTypeDeclaration = new SimpleTypeDeclaration(fileContext, string, type);
+
+    return simpleTypeDeclaration;
+  }
+});

package/src/dom/declaration/variable.js

@@ -24,33 +24,33 @@ export default domAssigned(class VariableDeclaration {
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
     const variableDeclarationString = this.getString();
 
     this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
-    const variableTypeVerified = this.verifyVariableType();
+    const variableTypeVerifies = this.verifyVariableType();
 
-    if (variableTypeVerified) {
-      const variableVerified = this.verifyVariable();
+    if (variableTypeVerifies) {
+      const variableVerifies = this.verifyVariable();
 
-      if (variableVerified) {
+      if (variableVerifies) {
         this.fileContext.addVariable(this.variable);
 
-        verified = true;
+        verifies = true;
       }
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyVariable() {
-    let  variableVerified = false;
+    let  variableVerifies = false;
 
     const variableString = this.variable.getString();
 
@@ -62,18 +62,18 @@ export default domAssigned(class VariableDeclaration {
     if (variablePresent) {
       this.fileContext.debug(`The '${variableName}' variable is already present.`);
     } else {
-      variableVerified = true;
+      variableVerifies = true;
     }
 
-    if ( variableVerified) {
+    if ( variableVerifies) {
       this.fileContext.debug(`...verified the '${variableString}' variable.`);
     }
 
-    return  variableVerified;
+    return  variableVerifies;
   }
 
   verifyVariableType() {
-    let variableTypeVerified = false;
+    let variableTypeVerifies = false;
 
     let type;
 
@@ -103,15 +103,15 @@ export default domAssigned(class VariableDeclaration {
       } else {
         this.variable.setType(type);
 
-        variableTypeVerified = true;
+        variableTypeVerifies = true;
       }
     }
 
-    if (variableTypeVerified) {
+    if (variableTypeVerifies) {
       this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
-    return variableTypeVerified;
+    return variableTypeVerifies;
   }
 
   static name = "VariableDeclaration";

package/src/dom/declaration.js

@@ -48,58 +48,58 @@ export default domAssigned(class Declaration {
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const declarationString = this.string;  ///
 
     context.trace(`Verifying the '${declarationString}' declaration...`);
 
-    const referenceVerified = this.verifyReference(assignments, stated, context);
+    const referenceVerifies = this.verifyReference(assignments, stated, context);
 
-    if (referenceVerified) {
-      const statementVerified = this.verifyStatement(assignments, stated, context);
+    if (referenceVerifies) {
+      const statementVerifies = this.verifyStatement(assignments, stated, context);
 
-      if (statementVerified) {
-        let verifiedWhenStated = false,
-            verifiedWhenDerived = false;
+      if (statementVerifies) {
+        let verifiesWhenStated = false,
+            verifiesWhenDerived = false;
 
         if (stated) {
-          verifiedWhenStated = this.verifyWhenStated(assignments, context);
+          verifiesWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(context);
+          verifiesWhenDerived = this.verifyWhenDerived(context);
         }
 
-        if (verifiedWhenStated || verifiedWhenDerived) {
-          verified = true;
+        if (verifiesWhenStated || verifiesWhenDerived) {
+          verifies = true;
         }
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${declarationString}' declaration.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyReference(assignments, stated, context) {
-    let referenceVerified;
+    let referenceVerifies;
 
     const referenceString = this.reference.getString();
 
     context.trace(`Verifying the '${referenceString}' reference...`);
 
-    referenceVerified = this.reference.verify(context);
+    referenceVerifies = this.reference.verify(context);
 
-    if (referenceVerified) {
+    if (referenceVerifies) {
       context.debug(`...verified the '${referenceString}' reference.`);
     }
 
-    return referenceVerified;
+    return referenceVerifies;
   }
 
   verifyStatement(assignments, stated, context) {
-    let statementVerified;
+    let statementVerifies;
 
     const statementString = this.statement.getString();
 
@@ -109,17 +109,17 @@ export default domAssigned(class Declaration {
 
     assignments = null; ///
 
-    statementVerified = this.statement.verify(assignments, stated, context);
+    statementVerifies = this.statement.verify(assignments, stated, context);
 
-    if (statementVerified) {
+    if (statementVerifies) {
       context.debug(`...verified the '${statementString}' statement.`);
     }
 
-    return statementVerified;
+    return statementVerifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated;
+    let verifiesWhenStated;
 
     const declarationString = this.string;  ///
 
@@ -128,29 +128,29 @@ export default domAssigned(class Declaration {
     const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
 
     if (metavariablePresent) {
-      verifiedWhenStated = true;
+      verifiesWhenStated = true;
     } else {
       const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(this.reference),
-            metaLemmaMetatheoremsUnified = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
-              const metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+            metaLemmaMetatheoremsUnify = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
+              const metaLemmaMetatheoremUnifies = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
 
-              if (metaLemmaMetatheoremUnified) {
+              if (metaLemmaMetatheoremUnifies) {
                 return true;
               }
             });
 
-      verifiedWhenStated = metaLemmaMetatheoremsUnified; ///
+      verifiesWhenStated = metaLemmaMetatheoremsUnify; ///
     }
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${declarationString}' stated declaration.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const declarationString = this.string;  ///
 
@@ -158,17 +158,17 @@ export default domAssigned(class Declaration {
 
     const metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(this.reference);
 
-    verifiedWhenDerived = metaLemmaMetatheoremPresent; ///
+    verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${declarationString}' derived declaration.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
+    let statementUnifies;
 
     const context = generalContext,  ///
           statementString = statement.getString(),
@@ -178,19 +178,19 @@ export default domAssigned(class Declaration {
 
     const generalStatement = this.statement,
           specificStatement = statement,  ///
-          statementUUnifiedIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+          statementUUnifiesIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
-    statementUnified = statementUUnifiedIntrinsically;  ///
+    statementUnifies = statementUUnifiesIntrinsically;  ///
 
-    if (statementUnified) {
+    if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   unifyLabelWithReference(label, substitutions, generalContext, specificContext) {
-    let labelUnifiedWithReference;
+    let labelUnifiesWithReference;
 
     const context = generalContext, ///
           labelString = label.getString(),
@@ -198,19 +198,19 @@ export default domAssigned(class Declaration {
 
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const labelUnified = this.reference.unifyLabel(label, substitutions, context);
+    const labelUnifies = this.reference.unifyLabel(label, substitutions, context);
 
-    labelUnifiedWithReference = labelUnified; ///
+    labelUnifiesWithReference = labelUnifies; ///
 
-    if (labelUnifiedWithReference) {
+    if (labelUnifiesWithReference) {
       context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
     }
 
-    return labelUnifiedWithReference;
+    return labelUnifiesWithReference;
   }
 
   unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnified;
+    let metaLemmaMetatheoremUnifies = false;
 
     const declarationString = this.string,  ///
           metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
@@ -223,26 +223,28 @@ export default domAssigned(class Declaration {
           labelSubstitutions = Substitutions.fromNothing(),
           label = metaLemmaMetatheorem.getLabel(),
           substitutions = labelSubstitutions, ///
-          labelUnifiedWithReference = this.unifyLabelWithReference(label, substitutions, generalContext, specificContext);
+          labelUnifiesWithReference = this.unifyLabelWithReference(label, substitutions, generalContext, specificContext);
 
-    if (labelUnifiedWithReference) {
+    if (labelUnifiesWithReference) {
       const statementSubstitutions = Substitutions.fromNothing(),
             statement = metaLemmaMetatheorem.getStatement(),
             substitutions = statementSubstitutions, ///
-            statementUUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+            statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-      if (statementUUnified) {
-        const labelSubstitutionsMatchStatementSubstitutions = labelSubstitutions.matchSubstitutions(statementSubstitutions);
+      if (statementUUnifies) {
+        const labelSubstitutionsCorrelateStatementSubstitutions = labelSubstitutions.correlateSubstitutions(statementSubstitutions);
 
-        metaLemmaMetatheoremUnified = labelSubstitutionsMatchStatementSubstitutions;  ///
+        if (labelSubstitutionsCorrelateStatementSubstitutions) {
+          metaLemmaMetatheoremUnifies = true; ///
+        }
       }
     }
 
-    if (metaLemmaMetatheoremUnified) {
+    if (metaLemmaMetatheoremUnifies) {
       context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
     }
 
-    return metaLemmaMetatheoremUnified;
+    return metaLemmaMetatheoremUnifies;
   }
 
   static name = "Declaration";

package/src/dom/deduction.js

@@ -20,7 +20,7 @@ export default domAssigned(class Deduction {
   }
 
   verify(context) {
-    let verified = false;
+    let verifies = false;
 
     const deductionString = this.string;  ///
 
@@ -29,22 +29,22 @@ export default domAssigned(class Deduction {
     if (this.statement !== null) {
       const stated = true,
             assignments = null,
-            statementVerified = this.statement.verify(assignments, stated, context);
+            statementVerifies = this.statement.verify(assignments, stated, context);
 
-      verified = statementVerified; ///
+      verifies = statementVerifies; ///
     } else {
       context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${deductionString}' deduction.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
+    let statementUnifies;
 
     const deduction = this,  ///
           statementString = statement.getString(),
@@ -52,17 +52,17 @@ export default domAssigned(class Deduction {
 
     specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
 
-    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+    statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    if (statementUnified) {
+    if (statementUnifies) {
       specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   unifyDeduction(deduction, substitutions, generalContext, specificContext) {
-    let deductionUnified;
+    let deductionUnifies;
 
     const context = specificContext,  ///
           specificDeduction = deduction,  ///
@@ -72,15 +72,15 @@ export default domAssigned(class Deduction {
     context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`);
 
     const statement = specificDeduction.getStatement(),
-          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    deductionUnified = statementUnified;  ///
+    deductionUnifies = statementUnifies;  ///
 
-    if (deductionUnified) {
+    if (deductionUnifies) {
       context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`);
     }
 
-    return deductionUnified;
+    return deductionUnifies;
   }
 
   toJSON() {