occam-verify-cli 1.0.890 → 1.0.892

package/src/element/declaration/property.js

@@ -0,0 +1,96 @@
+"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) {
+          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(),
+          includeRelease = true,
+          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);
+
+    if (typePresent) {
+      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) {
@@ -108,7 +107,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 +140,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 +164,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 +174,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 +197,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...`);
 

package/src/element/property.js

@@ -43,6 +43,109 @@ export default define(class Property extends Element {
     return comparesToNominalTypeName;
   }
 
+  verify(properties, context) {
+    let verifies = false;
+
+    const propertyString = this.getString();  ///
+
+    context.trace(`Verifying the '${propertyString}' property...`);
+
+    const naemVerifies = this.verifyName(properties, context);
+
+    if (naemVerifies) {
+      const nominalTypeNameVerifies = this.verifyNominalTypeName(context);
+
+      if (nominalTypeNameVerifies) {
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${propertyString}' property.`);
+    }
+
+    return verifies;
+  }
+
+  verifyName(properties, context) {
+    let naemVerifies = false;
+
+    const propertyString = this.getString();
+
+    context.trace(`Verifying the '${propertyString}' property's name...`);
+
+    const propertyName = this.name, ///
+          count = properties.reduce((count, property) => {
+            const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
+
+            if (propertyComparesToPropertyName) {
+              count++;
+            }
+
+            return count;
+          }, 0);
+
+    if (count > 1) {
+      context.debug(`The '${propertyString}' property appears more than once.`);
+    } 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 {
+        naemVerifies = true;
+      }
+    }
+
+    if (naemVerifies) {
+      context.debug(`...verified the '${propertyString}' property's name.`);
+    }
+
+    return naemVerifies;
+  }
+
+  verifyNominalTypeName(context) {
+    let nominalTypeNameVerifies = false;
+
+    const propertyString = this.getString();  ///
+
+    context.trace(`Verifying the '${propertyString}' property's nominal type name...`);
+
+    const typeComparesToNominalTypeName = this.type.compareNominalTypeName(this.nominalTypeName);
+
+    if (typeComparesToNominalTypeName) {
+      nominalTypeNameVerifies = true;
+    } else {
+      const typePresent = context.isTypePresentByNominalTypeName(this.nominalTypeName);
+
+      if (typePresent) {
+        nominalTypeNameVerifies = true;
+      }
+    }
+
+    if (nominalTypeNameVerifies) {
+      context.debug(`...verifies the '${propertyString}' property's nominal type name.`);
+    }
+
+    return nominalTypeNameVerifies;
+  }
+
   toJSON() {
     const nominalTypeNameJSON = nominalTypeNameToNominalTypeNameJSON(this.nominalTypeName),
           nominalTypeName = nominalTypeNameJSON,  ///

package/src/element/statement.js

@@ -229,7 +229,7 @@ export default define(class Statement extends Element {
     if (subproofAssertionNode !== null) {
       const context = generalContext, ///
             subproofString = subproof.getString(),
-            statementString = this.getString();
+            statementString = this.getString(); ///
 
       context.trace(`Unifying the '${subproofString}' subproof with the '${statementString}' statement...`);
 

package/src/element/substitution/statement.js

@@ -141,7 +141,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (substitution !== null) {
       const context = generalContext,  ///
-            statementSubstitutionString = this.getString();
+            statementSubstitutionString = this.getString(); ///
 
       context.trace(`Validating the '${statementSubstitutionString}' statement substitution's substitution...`);
 

package/src/element/typePrefix.js

@@ -31,6 +31,42 @@ export default define(class TypePrefix extends Element {
     return comparesToTypePrefixName;
   }
 
+  verify(context) {
+    let verifies = false;
+
+    const typePrefixString = this.getString();  ///
+
+    context.trace(`Verifying the '${typePrefixString}' type prefix...`);
+
+    const typePrefix = context.getTypePrefix();
+
+    if (typePrefix === null) {
+      const typePrefixName = this.name, ///
+            typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
+
+      if (!typePrefixPresent) {
+        const nominalTypeName = typePrefixName,  ///
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (!typePresent) {
+          verifies = true;
+        } else {
+          context.debug(`The '${typePrefixString}' type is already present.`);
+        }
+      } else {
+        context.debug(`The '${typePrefixString}' type prefix is already present.`);
+      }
+    } else {
+      context.trace(`The package already has a '${typePrefixString}' type prefix.`);
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${typePrefixString}' type prefix.`);
+    }
+
+    return verifies;
+  }
+
   static name = "TypePrefix";
 
   toJSON() {

package/src/preamble.js

@@ -50,6 +50,7 @@ import ProcedureReference from "./element/procedureReference";
 import ContainedAssertion from "./element/assertion/contained";
 import SatisfiesAssertion from "./element/assertion/satisfies";
 import MetaLevelAssumption from "./element/assumption/metaLevel";
+import PropertyDeclaration from "./element/declaration/property";
 import VariableDeclaration from "./element/declaration/variable";
 import BracketedCombinator from "./element/combinator/bracketed";
 import BracketedConstructor from "./element/constructor/bracketed";

package/src/utilities/element.js

@@ -10,7 +10,8 @@ import { equivalenceStringFromTerms,
          subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
-         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction,
+         complexTypeDeclarationStringFromTypeSuperTypesAndProvisional } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -233,17 +234,21 @@ export function theoremFromTheoremNode(theoremNode, context) {
 }
 
 export function propertyFromPropertyNode(propertyNode, context) {
-  const { Property } = elements,
-        node = propertyNode, ///
-        string = context.nodeAsString(node),
-        lineIndex = null,
-        propertyName = propertyNode.getPropertyName(),
-        nominalTypeName = null,
-        name = propertyName;  ///
+  let property = null;
 
-  context = null;
+  if (propertyNode != null) {
+    const { Property } = elements,
+          node = propertyNode, ///
+          string = context.nodeAsString(node),
+          lineIndex = null,
+          propertyName = propertyNode.getPropertyName(),
+          nominalTypeName = null,
+          name = propertyName;  ///
 
-  const property = new Property(context, string, node, lineIndex, name, nominalTypeName);
+    context = null;
+
+    property = new Property(context, string, node, lineIndex, name, nominalTypeName);
+  }
 
   return property;
 }
@@ -488,12 +493,11 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
         node = typePrefixNode, ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        term = termFromTypePrefixNode(typePrefixNode, context),
-        type = typeFromTypePrefixNode(typePrefixNode, context);
+        name = nameFromTypePrefixNode(typePrefixNode, context);
 
   context = null;
 
-  const typePrefix = new TypePrefix(context, string, node, lineIndex, term, type);
+  const typePrefix = new TypePrefix(context, string, node, lineIndex, name);
 
   return typePrefix;
 }
@@ -783,6 +787,23 @@ export function procedureReferenceFromProcedureReferenceNode(procedureReferenceN
   return procedureRefereence;
 }
 
+export function propertyDeclarationFromPropertyDeclarationNode(propertyDeclarationNode, context) {
+  const { PropertyDeclaration } = elements,
+        node = propertyDeclarationNode,  ///
+        string = context.nodeAsString(node),
+        lineIndex = null,
+        typeNode = propertyDeclarationNode.getTypeNode(),
+        propertyNode = propertyDeclarationNode.getPropertyNode(),
+        type = typeFromTypeNode(typeNode, context),
+        property = propertyFromPropertyNode(propertyNode, context);
+
+  context = null;
+
+  const propertyDeclaration = new PropertyDeclaration(context, string, node, lineIndex, property, type);
+
+  return propertyDeclaration;
+}
+
 export function variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context) {
   const { VariableDeclaration } = elements,
         node = variableDeclarationNode,  ///
@@ -938,15 +959,17 @@ export function constructorDeclarationFromConstructorDeclarationNode(constructor
 export function complexTypeDeclarationFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const { ComplexTypeDeclaration } = elements,
         node = complexTypeDeclarationNode,  ///
-        string = context.nodeAsString(node),
         lineIndex = null,
         type = typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
         superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-        provisional = provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context);
+        provisional = provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        propertyDeclarations = propertyDeclarationsFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        complexTypeDeclarationString = complexTypeDeclarationStringFromTypeSuperTypesAndProvisional(type, superTypes, provisional),
+        string = complexTypeDeclarationString;  ///
 
   context = null;
 
-  const complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, lineIndex, type, superTypes, provisional);
+  const complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, lineIndex, type, superTypes, provisional, propertyDeclarations);
 
   return complexTypeDeclaration;
 }
@@ -2090,6 +2113,13 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
+export function propertyDeclarationsFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  const propertyDeclarationnNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
+        propertyDeclarations = propertyDeclarationsFromPropertyDeclarationNodes(propertyDeclarationnNodes, context);
+
+  return propertyDeclarations;
+}
+
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);
@@ -2204,3 +2234,13 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
 
   return stepsOrSubproofs;
 }
+
+export function propertyDeclarationsFromPropertyDeclarationNodes(propertyDeclarationnNodes, context) {
+  const propertyDeclrations = propertyDeclarationnNodes.map((propertyDeclarationNode) => {
+    const propertyDeclcaration = propertyDeclarationFromPropertyDeclarationNode(propertyDeclarationNode, context);
+
+    return propertyDeclcaration;
+  });
+
+  return propertyDeclrations;
+}

package/src/utilities/string.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { baseTypeFromNothing } from "../utilities/type";
+import { EMPTY_STRING, PROVISIONALLY } from "../constants";
 
 export function termsStringFromTerms(terms) {
   const termsString = terms.reduce((termsString, term) => {
@@ -59,18 +60,25 @@ export function hypothesesStringFromHypotheses(hypotheses) {
 }
 
 export function superTypesStringFromSuperTypes(superTypes) {
-  const baseType = baseTypeFromNothing(),
-        superTypesString = superTypes.reduce((superTypesString, superType) => {
-          if (superType !== baseType) {
-            const superTypeString = superType.getString();
+  let superTypesString;
 
-            superTypesString = (superTypesString === null) ?
-                                 `'${superTypeString}'` :
-                                   `${superTypesString}, '${superTypeString}'`;
-          }
+  const baseType = baseTypeFromNothing();
 
-          return superTypesString;
-        }, null);
+  superTypesString = superTypes.reduce((superTypesString, superType) => {
+    if (superType !== baseType) {
+      const superTypeString = superType.getString();
+
+      superTypesString = (superTypesString === null) ?
+                           `'${superTypeString}'` :
+                              `${superTypesString}, '${superTypeString}'`;
+    }
+
+    return superTypesString;
+  }, null);
+
+  superTypesString = (superTypesString !== null) ?
+                       `:${superTypesString}` :
+                          EMPTY_STRING;
 
   return superTypesString;
 }
@@ -89,13 +97,21 @@ export function parametersStringFromParameters(parameters) {
   return parametersString;
 }
 
+export function provisinalStringFromProvisional(provisional) {
+  const provisionString = provisional ?
+                            PROVISIONALLY :
+                              EMPTY_STRING;
+
+  return provisionString;
+}
+
 export function suppositionsStringFromSuppositions(suppositions) {
   const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
     const suppositionString = supposition.getString();
 
     suppositionsString = (suppositionsString === null) ?
-                            suppositionString: ///
-                             `${suppositionsString}, ${suppositionString}`;
+      suppositionString: ///
+      `${suppositionsString}, ${suppositionString}`;
 
     return suppositionsString;
   }, null);
@@ -230,6 +246,15 @@ export function topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels
   return topLevelAssertionString;
 }
 
+export function complexTypeDeclarationStringFromTypeSuperTypesAndProvisional(type, superTypes, provisional) {
+  const typeString = type.getString(),
+        superTypesString = superTypesStringFromSuperTypes(superTypes),
+        provisionalString = provisinalStringFromProvisional(provisional),
+        complexTypeDeclarationString = `${provisionalString}${typeString}${superTypesString}`;
+
+  return complexTypeDeclarationString;
+}
+
 export function topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
   const labelString = label.getString(),
         deductionString = deduction.getString(),