occam-verify-cli 1.0.896 → 1.0.899

package/src/context.js

@@ -240,6 +240,13 @@ export default class Context extends ContextBase {
     return equality;
   }
 
+  findPropertyByPropertyNode(propertyNode) {
+    const context = this.getContext(),
+          property = context.findPropertyByPropertyNode(propertyNode);
+
+    return property;
+  }
+
   findJudgementByJudgementNode(judgementNode) {
     const context = this.getContext(),
           judgement = context.findJudgementByJudgementNode(judgementNode);
@@ -303,6 +310,13 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
+  findPropertyRelationByPropertyRelationNode(propertyRelationNode) {
+    const context = this.getContext(),
+          propertyRelation = context.findPropertyRelationByPropertyRelationNode(propertyRelationNode);
+
+    return propertyRelation;
+  }
+
   findDeclaredJudgementsByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
           declaredJudgements = context.findDeclaredJudgementsByMetavariableNode(metavariableNode);
@@ -586,6 +600,12 @@ export default class Context extends ContextBase {
     context.addEquality(equality);
   }
 
+  addProperty(property) {
+    const context = this.getContext();
+
+    context.addProperty(property);
+  }
+
   addJudgement(judgement) {
     const context = this.getContext();
 
@@ -634,6 +654,12 @@ export default class Context extends ContextBase {
     context.addSubstitution(substitution);
   }
 
+  addPropertyRelation(propertyRelation) {
+    const context = this.getContext();
+
+    context.addPropertyRelation(propertyRelation);
+  }
+
   addDeclaredVariable(declaredVariable) {
     const context = this.getContext();
 

package/src/element/assertion/property.js

@@ -31,6 +31,8 @@ export default define(class PropertyAssertion extends Assertion {
     return propertyAssertionNode;
   }
 
+  getType() { return this.propertyRelation.getType(); }
+
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
@@ -148,7 +150,13 @@ export default define(class PropertyAssertion extends Assertion {
     const propertyRelation = this.propertyRelation.validate(context);
 
     if (propertyRelation !== null) {
-      propertyRelationValidates = true;
+      const type = this.getType(),
+            termType = this.term.getType(),
+            termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(type);
+
+      if (termTypeEqualToOrSuperTypeOfType) {
+        propertyRelationValidates = true;
+      }
     }
 
     if (propertyRelationValidates) {

package/src/element/declaration/complexType.js

@@ -105,7 +105,8 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's '${typeString}' type...`);
 
     const typeName = this.type.getName(),
-          typePresent = context.isTypePresentByTypeName(typeName);
+          includeRelease = false,
+          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);
 
     if (!typePresent) {
       const prefixedTypeName = typeName, ///
@@ -129,7 +130,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifySuperType(context, superType, superTypes) {
+  verifySuperType(superType, superTypes, context) {
     let superTypeVerifies = false;
 
     const superTypeString = superType.getString(),
@@ -171,7 +172,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration's super-types...`);
 
     superTypesVerify = this.superTypes.every((superType) => {
-      const superTypeVerifies = this.verifySuperType(context, superType, superTypes);
+      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
 
       if (superTypeVerifies) {
         return true;

package/src/element/declaration/simpleType.js

@@ -54,6 +54,13 @@ export default define(class SimpleTypeDeclaration extends Declaration {
           const propertiesVerifies = this.verifyProperties(context);
 
           if (propertiesVerifies) {
+            const typePrefix = context.getTypePrefix(),
+                  prefixName = typePrefix.getPrefixName();
+
+            this.type.setProvisional(this.provisional);
+
+            this.type.setPrefixName(prefixName);
+
             context.addType(this.type);
 
             verifies = true;
@@ -85,8 +92,6 @@ export default define(class SimpleTypeDeclaration extends Declaration {
             typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
 
       if (!typePresent) {
-        this.type.setProvisional(this.provisional);
-
         typeVerifies = true;
       } else {
         context.debug(`The '${typeString}' type is already present.`);
@@ -102,7 +107,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifySuperType(context, superType, superTypes) {
+  verifySuperType(superType, superTypes, context) {
     let superTypeVerifies = false;
 
     const superTypeString = superType.getString(),
@@ -144,7 +149,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's super-types...`);
 
     superTypesVerify = this.superTypes.every((superType) => {
-      const superTypeVerifies = this.verifySuperType(context, superType, superTypes);
+      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
 
       if (superTypeVerifies) {
         return true;

package/src/element/declaration/typePrefix.js

@@ -31,7 +31,8 @@ export default define(class TypePrefixDeclaration extends Declaration {
 
     context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`);
 
-    const types = context.getTypes(),
+    const includeRelease = false,
+          types = context.getTypes(includeRelease),
           typesLength = types.length;
 
     if (typesLength === 0) {

package/src/element/property.js

@@ -122,7 +122,7 @@ export default define(class Property extends Element {
     return validProperty;
   }
 
-  validate(context) {
+  validate(context, validateForwards) {
     let property = null;
 
     const propertyString = this.getString(); ///
@@ -135,14 +135,24 @@ export default define(class Property extends Element {
       property = validProperty; ///
 
       context.debug(`...the '${propertyString}' property is already valid.`);
+
+      const validatesForward = validateForwards(property);
+
+      if (!validatesForward) {
+        property = null;
+      }
     } else {
       let validates = false;
 
-      debugger
+      property = this;  ///
 
-      if (validates) {
-        const property = this; ///
+      const validatesForward = validateForwards(property);
 
+      if (validatesForward) {
+        validates = true;
+      }
+
+      if (validates) {
         context.addProperty(property);
 
         context.debug(`...validated the '${propertyString}' property.`);
@@ -152,6 +162,51 @@ export default define(class Property extends Element {
     return property;
   }
 
+  validateGivenType(type, context) {
+    let property;
+
+    const typeString = type.getString(),
+          propertyString = this.getString();  ///
+
+    context.trace(`Validating the '${propertyString}' property given the '${typeString}' type...`);
+
+    let validatesGivenType = false;
+
+    property = this.validate(context, (property) => {
+      let validatesForwards = false;
+
+      const propertyName = this.name, ///
+            typeProperties = type.getProperties(),
+            typeProperty = typeProperties.find((typeProperty) => {
+              const typePropertyComparesToPropertyName = typeProperty.comparePropertyName(propertyName);
+
+              if (typePropertyComparesToPropertyName) {
+                return true;
+              }
+            }) || null;
+
+      if (typeProperty !== null) {
+        const type = typeProperty.getType();
+
+        property.setType(type);
+
+        validatesForwards = true;
+      }
+
+      return validatesForwards;
+    });
+
+    if (property !== null) {
+      validatesGivenType = true;
+    }
+
+    if (validatesGivenType) {
+      context.debug(`...validated the '${propertyString}' property given the '${typeString}' type.`);
+    }
+
+    return property;
+  }
+
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           string = this.getString(),

package/src/element/propertyRelation.js

@@ -30,6 +30,8 @@ export default define(class PropertyRelation extends Element {
     return propertyRelationNode;
   }
 
+  getType() { return this.property.getType(); }
+
   isEqualTo(propertyRelation) {
     const propertyRelationNode = propertyRelation.getNode(),
           propertyRelationNodeMatches = this.matchPropertyRelationNode(propertyRelationNode),
@@ -73,15 +75,13 @@ export default define(class PropertyRelation extends Element {
       const termValidates = this.validateTerm(context);
 
       if (termValidates) {
-        const propertyVerifies = this.verifyProperty(context);
+        const propertyValidates = this.validateProperty(context);
 
-        validates = propertyVerifies;
+        validates = propertyValidates;
       }
 
       if (validates) {
-        const propertyRelation = this; ///
-
-        this.assign(context);
+        propertyRelation = this; ///
 
         context.addPropertyRelation(propertyRelation);
 
@@ -118,38 +118,27 @@ export default define(class PropertyRelation extends Element {
     return termValidates;
   }
 
-  verifyProperty(context) {
-    let propertyVerifies;
-
-    const propertyString = this.property.getString();
+  validateProperty(context) {
+    let propertyValidates = false;
 
-    context.trace(`Verifying the '${propertyString}' property...`);
+    const propertyRelationString = this.getString(); ///
 
-    const termType = this.term.getType(),
-          propertyName = this.property.getName(),
-          termTypeProperties = termType.getProperties(),
-          variableTypeProperty = termTypeProperties.find((termTypeProperty) => {
-            const termTypePropertyComparesToPropertyName = termTypeProperty.comparePropertyName(propertyName);
+    context.trace(`Validating the '${propertyRelationString}' property relation's property...`);
 
-            if (termTypePropertyComparesToPropertyName) {
-              return true;
-            }
-          }) || null;
+    const type = this.term.getType(),
+          property = this.property.validateGivenType(type, context);
 
-    if (variableTypeProperty === null) {
-      const variableString = this.term.getString(),
-            variableTypeString = termType.getString();
+    if (property !== null) {
+      this.property = property;
 
-      context.debug(`The '${propertyName}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
-    } else {
-      propertyVerifies = true;
+      propertyValidates = true;
     }
 
-    if (propertyVerifies) {
-      context.debug(`...verified the '${propertyString}' property.`);
+    if (propertyValidates) {
+      context.trace(`...validated the '${propertyRelationString}' property relation's property.`);
     }
 
-    return propertyVerifies;
+    return propertyValidates;
   }
 
   static name = "PropertyRelation";

package/src/element/rule.js

@@ -95,7 +95,7 @@ export default define(class Rule extends Element {
     return verifies;
   }
 
-  verifyLabel(context, label) {
+  verifyLabel(label, context) {
     let labelVerifies;
 
     const ruleString = this.getString(),  ///
@@ -120,7 +120,7 @@ export default define(class Rule extends Element {
     context.trace(`Verifying the '${ruleString}' rule's labels...`);
 
     labelsVerify = this.labels.every((label) => {
-      const labelVerifies = this.verifyLabel(context, label);
+      const labelVerifies = this.verifyLabel(label, context);
 
       if (labelVerifies) {
         return true;

package/src/element/type.js

@@ -6,9 +6,16 @@ import { arrayUtilities } from "necessary";
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateType } from "../process/instantiate";
+import { nameFromTypeNode } from "../utilities/element";
 import { baseTypeFromNothing } from "../utilities/type";
-import { nameFromTypeNode, prefixNameFromTypeNode } from "../utilities/element";
-import { superTypesFromJSON, provisionalFromJSON, propertiesFromJSON, provisionalToProvisionalJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
+import { propertiesFromJSON,
+         prefixNameFromJSON,
+         superTypesFromJSON,
+         provisionalFromJSON,
+         prefixnameToPrevixNameJSON,
+         superTypesToSuperTypesJSON,
+         propertiesToPropertiesJSON,
+         provisionalToProvisionalJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
@@ -229,8 +236,7 @@ export default define(class Type extends Element {
   }
 
   compareTypeName(typeName) {
-    const name = this.getName(),
-          nameTypeName = (name === typeName),
+    const nameTypeName = (this.name === typeName),
           comparesToTypeName = nameTypeName;  ///
 
     return comparesToTypeName;
@@ -254,8 +260,7 @@ export default define(class Type extends Element {
     let comparesToNominalTypeName = false;
 
     if (!comparesToNominalTypeName) {
-      const name = this.getName(),
-            nominalTypeNameName = (nominalTypeName === name);
+      const nominalTypeNameName = (this.name === nominalTypeName);
 
       if (nominalTypeNameName) {
         comparesToNominalTypeName = true;
@@ -304,14 +309,17 @@ export default define(class Type extends Element {
           };
 
     if (!abridged) {
-      const superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
+      const prefixNameJSON = prefixnameToPrevixNameJSON(this.prefixName),
+            superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
             propertiesJSON = propertiesToPropertiesJSON(this.properties),
             provisinoalJSOM = provisionalToProvisionalJSON(this.provisional),
+            prefixName = prefixNameJSON,  ///
             superTypes = superTypesJSON,  ///
             properties = propertiesJSON,  ///
             provisional = provisinoalJSOM;  ///
 
       Object.assign(json, {
+        prefixName,
         superTypes,
         properties,
         provisional
@@ -329,7 +337,7 @@ export default define(class Type extends Element {
             typeNode = instantiateType(string, context),
             node = typeNode, ///
             name = nameFromTypeNode(typeNode, context),
-            prefixName = prefixNameFromTypeNode(typeNode, context),
+            prefixName = prefixNameFromJSON(json, context),
             superTypes = superTypesFromJSON(json, context),
             properties = propertiesFromJSON(json, context),
             provisional = provisionalFromJSON(json);

package/src/element/typePrefix.js

@@ -25,6 +25,12 @@ export default define(class TypePrefix extends Element {
     return typePrefixNode;
   }
 
+  getPrefixName() {
+    const prefixName = this.name;  ///
+
+    return prefixName;
+  }
+
   compareTypePrefixName(typePrefixName) {
     const comparesToTypePrefixName = (this.name === typePrefixName);
 

package/src/process/assign.js

@@ -45,23 +45,9 @@ export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
 }
 
 export function variableAssignmentFromPrepertyAssertion(propertyAssertion, context) {
+  const term = propertyAssertion.getTerm(),
+        type = propertyAssertion.getType(),
+        variableAssignment = variableAssignmentFromTermAndType(term, type, context);
 
-  debugger
-
-  // let variable;
-  //
-  // const { Variable } = elements,
-  //   termNode = this.term.getNode();
-  //
-  // variable = Variable.fromTermNode(termNode, context);
-  //
-  // if (variable !== null) {
-  //   const variableIdentifier = variable.getIdentifier();
-  //
-  //   variable = context.findVariableByVariableIdentifier(variableIdentifier);
-  //
-  //   variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
-  //
-  //   const variableAssignment = variableAssignmentFromVariable(variable),
-
-  }
+  return variableAssignment;
+}

package/src/process/instantiate.js

@@ -28,6 +28,7 @@ import { TERM_RULE_NAME,
          PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
+         PROPERTY_ASSERTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
          PROCEDURE_REFERENCE_RULE_NAME,
@@ -65,6 +66,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       definedAssertionPlaceholderRule = ruleFromRuleName(DEFINED_ASSERTION_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
       subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
+      propertyAssertionPlaceholderRule = ruleFromRuleName(PROPERTY_ASSERTION_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
       procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
@@ -149,6 +151,8 @@ export function instantiateTermSubstitution(string, context) { return instantiat
 
 export function instantiateSubproofAssertion(string, context) { return instantiate(subproofAssertionlaceholderRule, string, context); }
 
+export function instantiatePropertyAssertion(string, context) { return instantiate(propertyAssertionPlaceholderRule, string, context); }
+
 export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateProcedureReference(string, context) { return instantiate(procedureReferencelaceholderRule, string, context); }

package/src/utilities/json.js

@@ -407,18 +407,24 @@ export function equalitiesFromJSON(json, context) {
   return equalities;
 }
 
+export function prefixNameFromJSON(json, context) {
+  const { prefixName } = json;
+
+  return prefixName;
+}
+
 export function superTypesFromJSON(json, context) {
   const { superTypes: superTypesJSON } = json;
 
   const superTypes = superTypesJSON.map((superTypeJSON) => {
-          const json = superTypeJSON,  ///
-                { string } = json,
-                name = string,  ///
-                type = findTypeByName(name, context),
-                superType = type; ///
+    const json = superTypeJSON,  ///
+      { string } = json,
+      name = string,  ///
+      type = findTypeByName(name, context),
+      superType = type; ///
 
-          return superType;
-        });
+    return superType;
+  });
 
   return superTypes;
 }
@@ -999,6 +1005,12 @@ export function hypothesesToHypothesesJSON(hypotheses) {
   return hypothesesJSON;
 }
 
+export function prefixnameToPrevixNameJSON(prefixname) {
+  const prefixNameJSON = prefixname;  ///
+
+  return prefixNameJSON;
+}
+
 export function superTypesToSuperTypesJSON(superTypes) {
   const superTypesJSON = superTypes.map((superType) => {
           const abridged = true,