occam-verify-cli 1.0.890 → 1.0.895

package/src/element/property.js

@@ -6,22 +6,22 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateProperty } from "../process/instantiate";
 import { nameFromPropertyNode } from "../utilities/element";
-import { nominalTypeNameFromJSON, nominalTypeNameToNominalTypeNameJSON } from "../utilities/json";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Property extends Element {
-  constructor(context, string, node, lineIndex, name, nominalTypeName) {
+  constructor(context, string, node, lineIndex, name, type) {
     super(context, string, node, lineIndex);
 
     this.name = name;
-    this.nominalTypeName = nominalTypeName;
+    this.type = type;
   }
 
   getName() {
     return this.name;
   }
 
-  getNominalTypeName() {
-    return this.nominalTypeName;
+  getType() {
+    return this.type;
   }
 
   getPropertyNode() {
@@ -31,27 +31,136 @@ export default define(class Property extends Element {
     return properetyNode;
   }
 
+  setName(name) {
+    this.name = name;
+  }
+
+  setType(type) {
+    this.type = type;
+  }
+
+  isEqualTo(property) {
+    const propertyNode = property.getNode(),
+          propertyNodeMatches = this.matchPropertyNode(propertyNode),
+          equalTo = propertyNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchPropertyNode(propertyNode) {
+    const node = propertyNode, ///
+          nodeMatches = this.matchNode(node),
+          propertyNodeMatches = nodeMatches; ///
+
+    return propertyNodeMatches;
+  }
+
   comparePropertyName(propertyName) {
     const comparesToPropertyName = (this.name === propertyName);
 
     return comparesToPropertyName;
   }
 
-  compareNominalTypeName(nominalTypeName) {
-    const comparesToNominalTypeName = (this.nominalTypeName === nominalTypeName);
+  verify(properties, context) {
+    let verifies = false;
+
+    const propertyString = this.getString();  ///
+
+    context.trace(`Verifying the '${propertyString}' property...`);
+
+    const naemVerifies = this.verifyName(properties, context);
+
+    if (naemVerifies) {
+      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) => {
+            if (property !== this) {
+              const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
+
+              if (propertyComparesToPropertyName) {
+                count++;
+              }
+            }
+
+            return count;
+          }, 0);
+
+    if (count === 0) {
+      naemVerifies = true;
+    } else {
+      context.debug(`The '${propertyString}' property appears more than once.`);
+    }
+
+    if (naemVerifies) {
+      context.debug(`...verified the '${propertyString}' property's name.`);
+    }
+
+    return naemVerifies;
+  }
+
+  findValidProperty(context) {
+    const propertyNode = this.getPropertyNode(),
+          property = context.findPropertyByPropertyNode(propertyNode),
+          validProperty = property; ///
+
+    return validProperty;
+  }
+
+  validate(context) {
+    let property = null;
+
+    const propertyString = this.getString(); ///
+
+    context.trace(`Validating the '${propertyString}' property...`);
+
+    const validProperty = this.findValidProperty(context);
+
+    if (validProperty) {
+      property = validProperty; ///
+
+      context.debug(`...the '${propertyString}' property is already valid.`);
+    } else {
+      let validates = false;
+
+      debugger
+
+      if (validates) {
+        const property = this; ///
+
+        context.addProperty(property);
+
+        context.debug(`...validated the '${propertyString}' property.`);
+      }
+    }
 
-    return comparesToNominalTypeName;
+    return property;
   }
 
   toJSON() {
-    const nominalTypeNameJSON = nominalTypeNameToNominalTypeNameJSON(this.nominalTypeName),
-          nominalTypeName = nominalTypeNameJSON,  ///
+    const typeJSON = typeToTypeJSON(this.type),
           string = this.getString(),
           lineIndex = this.getLineIndex(),
+          type = typeJSON,  ///
           json = {
             string,
             lineIndex,
-            nominalTypeName
+            type
           };
 
     return json;
@@ -65,11 +174,11 @@ export default define(class Property extends Element {
             propertyNode = instantiateProperty(string, context),
             node = propertyNode,  ///
             name = nameFromPropertyNode(propertyNode, context),
-            nominalTypeName = nominalTypeNameFromJSON(json);
+            type = typeFromJSON(json, context);
 
       context = null;
 
-      const property = new Property(context, string, node, lineIndex, name, nominalTypeName);
+      const property = new Property(context, string, node, lineIndex, name, type);
 
       return property;
     }, context);

package/src/element/propertyRelation.js

@@ -30,34 +30,74 @@ export default define(class PropertyRelation extends Element {
     return propertyRelationNode;
   }
 
-  verify(context) {
-    let verifies = false;
+  isEqualTo(propertyRelation) {
+    const propertyRelationNode = propertyRelation.getNode(),
+          propertyRelationNodeMatches = this.matchPropertyRelationNode(propertyRelationNode),
+          equalTo = propertyRelationNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchPropertyRelationNode(propertyRelationNode) {
+    const node = propertyRelationNode, ///
+          nodeMatches = this.matchNode(node),
+          propertyRelationNodeMatches = nodeMatches; ///
+
+    return propertyRelationNodeMatches;
+  }
+
+  findValidPropertyRelation(context) {
+    const propertyRelationNode = this.getPropertyRelationNode(),
+          propertyRelation = context.findPropertyRelationByPropertyRelationNode(propertyRelationNode),
+          validPropertyRelation = propertyRelation; ///
+
+    return validPropertyRelation;
+  }
+
+  validate(context) {
+    let propertyRelation = null;
 
     const propertyRelationString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation...`);
+    context.trace(`Validating the '${propertyRelationString}' property relation...`);
 
-    const termValidates = this.validateTerm(context);
+    const validPropertyRelation = this.findValidPropertyRelation(context);
 
-    if (termValidates) {
-      const propertyVerifies = this.verifyProperty(context);
+    if (validPropertyRelation) {
+      propertyRelation = validPropertyRelation; ///
 
-      verifies = propertyVerifies;
-    }
+      context.debug(`...the '${propertyRelationString}' property relation is already valid.`);
+    } else {
+      let validates = false;
+
+      const termValidates = this.validateTerm(context);
+
+      if (termValidates) {
+        const propertyVerifies = this.verifyProperty(context);
+
+        validates = propertyVerifies;
+      }
 
-    if (verifies) {
-      context.debug(`...verified the '${propertyRelationString}' property relation.`);
+      if (validates) {
+        const propertyRelation = this; ///
+
+        this.assign(context);
+
+        context.addPropertyRelation(propertyRelation);
+
+        context.debug(`...validated the '${propertyRelationString}' property relation.`);
+      }
     }
 
-    return verifies;
+    return propertyRelation;
   }
 
   validateTerm(context) {
     let termValidates = false;
 
-    const termString = this.term.getString();
+    const propertyRelationString = this.getString(); ///
 
-    context.trace(`Validating the '${termString}' term...`);
+    context.trace(`Validating the '${propertyRelationString}' property relation's term...`);
 
     const term = this.term.validate(context, (term) => {
       const validatesForwards = true;
@@ -72,7 +112,7 @@ export default define(class PropertyRelation extends Element {
     }
 
     if (termValidates) {
-      context.debug(`...validated the '${termString}' term.`);
+      context.debug(`...validated the '${propertyRelationString}' property relation's term.`);
     }
 
     return termValidates;

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";