occam-verify-cli 0.0.1272 → 0.0.1273

package/lib/utilities/verification.js

@@ -27,6 +27,9 @@ _export(exports, {
     metavariableFromStatement: function() {
         return metavariableFromStatement;
     },
+    propertyAssertionFromStatement: function() {
+        return propertyAssertionFromStatement;
+    },
     subproofAssertionFromStatement: function() {
         return subproofAssertionFromStatement;
     },
@@ -71,6 +74,11 @@ function definedAssertionFromStatement(statement, context) {
     var DefinedAssertion = _dom.default.DefinedAssertion, statementNode = statement.getNode(), definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);
     return definedAssertion;
 }
+function propertyAssertionFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var PropertyAssertion = _dom.default.PropertyAssertion, statementNode = statement.getNode(), propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);
+    return propertyAssertion;
+}
 function containedAssertionFromStatement(statement, context) {
     context = contextFromStatement(statement, context); ///
     var ContainedAssertion = _dom.default.ContainedAssertion, statementNode = statement.getNode(), containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);
@@ -92,4 +100,4 @@ function contextFromStatement(statement, context) {
     return context;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/verification.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport LocalContext from \"../context/local\";\n\nexport function metavariableFromFrame(frame, context) {\n  context = contextFromFrame(frame, context); ///\n\n  const { Metavariable } = dom,\n        frameNode = frame.getNode(),\n        metavariable = Metavariable.fromFrameNode(frameNode, context);\n\n  return metavariable;\n}\n\nexport function equalityFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Equality } = dom,\n        statementNode = statement.getNode(),\n        equality = Equality.fromStatementNode(statementNode, context);\n\n  return equality;\n}\n\nexport function judgementFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Judgement } = dom,\n        statementNode = statement.getNode(),\n        judgement = Judgement.fromStatementNode(statementNode, context);\n\n  return judgement;\n}\n\nexport function metavariableFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Metavariable } = dom,\n        statementNode = statement.getNode(),\n        metavariable = Metavariable.fromStatementNode(statementNode, context);\n\n  return metavariable;\n}\n\nexport function typeAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { TypeAssertion } = dom,\n        statementNode = statement.getNode(),\n        typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);\n\n  return typeAssertion;\n}\n\nexport function definedAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { DefinedAssertion } = dom,\n        statementNode = statement.getNode(),\n        definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);\n\n  return definedAssertion;\n}\n\nexport function containedAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { ContainedAssertion } = dom,\n        statementNode = statement.getNode(),\n        containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);\n\n  return containedAssertion;\n}\n\nexport function subproofAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { SubproofAssertion } = dom,\n        statementNode = statement.getNode(),\n        subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);\n\n  return subproofAssertion;\n}\n\nfunction contextFromFrame(frame, context) {\n  const frameTokens = frame.getTokens(),\n        tokens = frameTokens, ///\n        localContext = LocalContext.fromContextAndTokens(context, tokens);\n\n  context = localContext; ///\n\n  return context;\n}\n\nfunction contextFromStatement(statement, context) {\n  const statementTokens = statement.getTokens(),\n        tokens = statementTokens, ///\n        localContext = LocalContext.fromContextAndTokens(context, tokens);\n\n  context = localContext; ///\n\n  return context;\n}\n"],"names":["containedAssertionFromStatement","definedAssertionFromStatement","equalityFromStatement","judgementFromStatement","metavariableFromFrame","metavariableFromStatement","subproofAssertionFromStatement","typeAssertionFromStatement","frame","context","contextFromFrame","Metavariable","dom","frameNode","getNode","metavariable","fromFrameNode","statement","contextFromStatement","Equality","statementNode","equality","fromStatementNode","Judgement","judgement","TypeAssertion","typeAssertion","DefinedAssertion","definedAssertion","ContainedAssertion","containedAssertion","SubproofAssertion","subproofAssertion","frameTokens","getTokens","tokens","localContext","LocalContext","fromContextAndTokens","statementTokens"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/verification.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport LocalContext from \"../context/local\";\n\nexport function metavariableFromFrame(frame, context) {\n  context = contextFromFrame(frame, context); ///\n\n  const { Metavariable } = dom,\n        frameNode = frame.getNode(),\n        metavariable = Metavariable.fromFrameNode(frameNode, context);\n\n  return metavariable;\n}\n\nexport function equalityFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Equality } = dom,\n        statementNode = statement.getNode(),\n        equality = Equality.fromStatementNode(statementNode, context);\n\n  return equality;\n}\n\nexport function judgementFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Judgement } = dom,\n        statementNode = statement.getNode(),\n        judgement = Judgement.fromStatementNode(statementNode, context);\n\n  return judgement;\n}\n\nexport function metavariableFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Metavariable } = dom,\n        statementNode = statement.getNode(),\n        metavariable = Metavariable.fromStatementNode(statementNode, context);\n\n  return metavariable;\n}\n\nexport function typeAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { TypeAssertion } = dom,\n        statementNode = statement.getNode(),\n        typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);\n\n  return typeAssertion;\n}\n\nexport function definedAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { DefinedAssertion } = dom,\n        statementNode = statement.getNode(),\n        definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);\n\n  return definedAssertion;\n}\n\nexport function propertyAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { PropertyAssertion } = dom,\n        statementNode = statement.getNode(),\n        propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);\n\n  return propertyAssertion;\n}\n\nexport function containedAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { ContainedAssertion } = dom,\n        statementNode = statement.getNode(),\n        containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);\n\n  return containedAssertion;\n}\n\nexport function subproofAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { SubproofAssertion } = dom,\n        statementNode = statement.getNode(),\n        subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);\n\n  return subproofAssertion;\n}\n\nfunction contextFromFrame(frame, context) {\n  const frameTokens = frame.getTokens(),\n        tokens = frameTokens, ///\n        localContext = LocalContext.fromContextAndTokens(context, tokens);\n\n  context = localContext; ///\n\n  return context;\n}\n\nfunction contextFromStatement(statement, context) {\n  const statementTokens = statement.getTokens(),\n        tokens = statementTokens, ///\n        localContext = LocalContext.fromContextAndTokens(context, tokens);\n\n  context = localContext; ///\n\n  return context;\n}\n"],"names":["containedAssertionFromStatement","definedAssertionFromStatement","equalityFromStatement","judgementFromStatement","metavariableFromFrame","metavariableFromStatement","propertyAssertionFromStatement","subproofAssertionFromStatement","typeAssertionFromStatement","frame","context","contextFromFrame","Metavariable","dom","frameNode","getNode","metavariable","fromFrameNode","statement","contextFromStatement","Equality","statementNode","equality","fromStatementNode","Judgement","judgement","TypeAssertion","typeAssertion","DefinedAssertion","definedAssertion","PropertyAssertion","propertyAssertion","ContainedAssertion","containedAssertion","SubproofAssertion","subproofAssertion","frameTokens","getTokens","tokens","localContext","LocalContext","fromContextAndTokens","statementTokens"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1272",
+  "version": "0.0.1273",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/dom/assertion/contained.js

@@ -99,7 +99,7 @@ export default domAssigned(class ContainedAssertion {
       });
 
       if (termVerified) {
-        context.trace(`...verified the '${containedAssertionString}' contained assertion's '${termString}' term.`);
+        context.debug(`...verified the '${containedAssertionString}' contained assertion's '${termString}' term.`);
       }
     }
 
@@ -122,7 +122,7 @@ export default domAssigned(class ContainedAssertion {
       frameVerified = this.frame.verify(assignments, stated, context);
 
       if (frameVerified) {
-        context.trace(`...verified the '${containedAssertionString}' contained assertion's '${frameString}' frame.`);
+        context.debug(`...verified the '${containedAssertionString}' contained assertion's '${frameString}' frame.`);
       }
     }
 
@@ -145,7 +145,7 @@ export default domAssigned(class ContainedAssertion {
       statementVerified = this.statement.verify(assignments, stated, context);
 
       if (statementVerified) {
-        context.trace(`...verified the '${containedAssertionString}' contained assertion's '${statementString}' statement.`);
+        context.debug(`...verified the '${containedAssertionString}' contained assertion's '${statementString}' statement.`);
       }
     }
 

package/src/dom/assertion/property.js

@@ -0,0 +1,179 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+
+const propertyNodeQuery = nodeQuery("/propertyAssertion/property"),
+      leftTermNodeQuery = nodeQuery("/propertyAssertion/term[0]"),
+      rightTermNodeQuery = nodeQuery("/propertyAssertion/term[1]"),
+      propertyAssertionNodeQuery = nodeQuery("/statement/propertyAssertion");
+
+export default domAssigned(class PropertyAssertion {
+  constructor(string, node, tokens, property, leftTerm, rightTerm) {
+    this.string = string;
+    this.node = node;
+    this.tokens = tokens;
+    this.property = property;
+    this.leftTerm = leftTerm;
+    this.rightTerm = rightTerm;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getProperty() {
+    return this.property;
+  }
+
+  getLeftTerm() {
+    return this.leftTerm;
+  }
+
+  getRightTerm() {
+    return this.rightTerm;
+  }
+
+  verify(assignments, stated, context) {
+    let verified = false;
+
+    const propertyAssertionString = this.string; ///
+
+    context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);
+
+    const rightTermVerified = this.verifyRightTerm(assignments, stated, context);
+
+    if (rightTermVerified) {
+      const leftTermVerified = this.verifyLeftTerm(assignments, stated, context);
+
+      if (leftTermVerified) {
+        const propertyVerified = this.verifyProperty(assignments, stated, context);
+
+        if (propertyVerified) {
+          verified = true;
+        }
+      }
+    }
+
+    if (verified) {
+      context.debug(`...verified the '${propertyAssertionString}' property assertion.`);
+    }
+
+    return verified;
+  }
+
+  verifyProperty(assignments, stated, context) {
+    let propertyVerified;
+
+    const propertyString = this.property.getString(),
+          propertyAssertionString = this.string; ///
+
+    context.trace(`Verifying the '${propertyAssertionString}' property assertion's '${propertyString}' property...`);
+
+    const rightTermType = this.rightTerm.getType(),
+          propertyName = this.property.getName(),
+          property = rightTermType.findPropertyByPropertyName(propertyName);
+
+    if (property === null) {
+      const rightTermTypeName = rightTermType.getName();
+
+      context.debug(`The '${propertyName}' property is not a property of the right term's '${rightTermTypeName}' type.`);
+    } else {
+      const leftTermType = this.leftTerm.getType(),
+            propertyType = property.getType(),
+            leftTermTypeEqualToOrSubTypeOfPropertyType = leftTermType.isEqualToOrSubTypeOf(propertyType);
+
+      if (!leftTermTypeEqualToOrSubTypeOfPropertyType) {
+        const leftTermTypeName = leftTermType.getName(),
+              propertyTypeName = propertyType.getName();
+
+        context.debug(`The left term's '${leftTermTypeName}' type is not equal to or a sub-type of the '${propertyName}' property's '${propertyTypeName}' type.`);
+      } else {
+        propertyVerified = true;
+      }
+    }
+
+    if (propertyVerified) {
+      context.debug(`...verified the '${propertyAssertionString}' property assertion's '${propertyString}' property.`);
+    }
+
+    return propertyVerified;
+  }
+
+  verifyLeftTerm(assignments, stated, context) {
+    let leftTermVerified;
+
+    const leftTermString = this.leftTerm.getString(),
+          propertyAssertionString = this.string; ///
+
+    context.trace(`Verifying the '${propertyAssertionString}' property assertion's '${leftTermString}' left term...`);
+
+    leftTermVerified = this.leftTerm.verify(context, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    if (leftTermVerified) {
+      context.debug(`...verified the '${propertyAssertionString}' property assertion's '${leftTermString}' left term.`);
+    }
+
+    return leftTermVerified;
+  }
+
+  verifyRightTerm(assignments, stated, context) {
+    let rightTermVerified;
+
+    const rightTermString = this.rightTerm.getString(),
+          propertyAssertionString = this.string; ///
+
+    context.trace(`Verifying the '${propertyAssertionString}' property assertion's '${rightTermString}' right term...`);
+
+    rightTermVerified = this.rightTerm.verify(context, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    if (rightTermVerified) {
+      context.debug(`...verified the '${propertyAssertionString}' property assertion's '${rightTermString}' right term.`);
+    }
+
+    return rightTermVerified;
+  }
+
+  static name = "PropertyAssertion";
+
+  static fromStatementNode(statementNode, context) {
+    let propertyAssertion = null;
+
+    const propertyAssertionNode = propertyAssertionNodeQuery(statementNode);
+
+    if (propertyAssertionNode !== null) {
+      const { Term, Property } = dom,
+            node = propertyAssertionNode,  ///
+            string = context.nodeAsString(node),
+            tokens = context.nodeAsTokens(node),
+            propertyNode = propertyNodeQuery(propertyAssertionNode),
+            leftTermNode = leftTermNodeQuery(propertyAssertionNode),
+            rightTermNode = rightTermNodeQuery(propertyAssertionNode),
+            property = Property.fromPropertyNode(propertyNode, context),
+            leftTerm = Term.fromTermNode(leftTermNode, context),
+            rightTerm = Term.fromTermNode(rightTermNode, context);
+
+      propertyAssertion = new PropertyAssertion(string, node, tokens, property, leftTerm, rightTerm);
+    }
+
+    return propertyAssertion;
+  }
+});

package/src/dom/declaration/complexType.js

@@ -110,10 +110,21 @@ export default domAssigned(class ComplexTypeDeclaration {
     if (count > 1) {
       this.fileContext.debug(`The '${propertyString}' property appears more than once.`);
     } else {
-      const propertyType = property.getType(),
-            propertyTypeVerified = this.verifyPropertyType(propertyType);
+      let propertyType;
+
+      propertyType = property.getType();
+
+      const propertyTypeVerified = this.verifyPropertyType(propertyType);
 
       if (propertyTypeVerified) {
+        const propertyTypeName = propertyType.getName();
+
+        propertyType = this.fileContext.findTypeByTypeName(propertyTypeName);
+
+        const type = propertyType;  ///
+
+        property.setType(type);
+
         propertyVerified = true;
       }
     }

package/src/dom/declaration/variable.js

@@ -6,7 +6,7 @@ import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class VariableDeclaration {
-  constructor(fileContext, string, variable) {
+  constructor(fileContext, variable) {
     this.fileContext = fileContext;
     this.variable = variable;
   }

package/src/dom/declaration.js

@@ -149,7 +149,7 @@ export default domAssigned(class Declaration {
     }
 
     if (verifiedWhenStated) {
-      context.trace(`...verified the '${declarationString}' stated declaration.`);
+      context.debug(`...verified the '${declarationString}' stated declaration.`);
     }
 
     return verifiedWhenStated;
@@ -172,7 +172,7 @@ export default domAssigned(class Declaration {
     }
 
     if (verifiedWhenDerived) {
-      context.trace(`...verified the '${declarationString}' derived declaration.`);
+      context.debug(`...verified the '${declarationString}' derived declaration.`);
     }
 
     return verifiedWhenDerived;

package/src/dom/property.js

@@ -6,8 +6,7 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
-const typeNodeQuery = nodeQuery("/property/type"),
-      propertyNodeQuery = nodeQuery("/propertyDeclaration/property"),
+const propertyNodeQuery = nodeQuery("/propertyDeclaration/property"),
       nameTerminalNodeQuery = nodeQuery("/property/@name");
 
 export default domAssigned(class Property {
@@ -29,28 +28,16 @@ export default domAssigned(class Property {
     return this.type;
   }
 
+  setType(type) {
+    this.type = type;
+  }
+
   matchPropertyName(propertyName) {
     const propertyNameMatches = (propertyName === this.name);
 
     return propertyNameMatches;
   }
 
-  verify(context) {
-    let verified;
-
-    const propertyString = this.string; ///
-
-    context.trace(`Verifying the '${propertyString}' property...`);
-
-    debugger
-
-    if (verified) {
-      context.debug(`...verified the '${propertyString}' property.`);
-    }
-
-    return verified;
-  }
-
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           name = this.name, ///
@@ -74,11 +61,22 @@ export default domAssigned(class Property {
     return property;
   }
 
+  static fromPropertyNode(propertyNode, fileContext) {
+    const node = propertyNode,  ///
+          name = nameFromPropertyNode(propertyNode),
+          type = null,
+          string = fileContext.nodeAsString(node),
+          property = new Property(string, name, type);
+
+    return property;
+  }
+
   static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
-    const propertyNode = propertyNodeQuery(propertyDeclarationNode),
+    const { Type } = dom,
+          propertyNode = propertyNodeQuery(propertyDeclarationNode),
           node = propertyNode,  ///
           name = nameFromPropertyNode(propertyNode),
-          type = typeFromPropertyNode(propertyNode),
+          type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
           string = fileContext.nodeAsString(node),
           property = new Property(string, name, type);
 
@@ -93,11 +91,3 @@ function nameFromPropertyNode(propertyNode, fileContext) {
 
   return name;
 }
-
-function typeFromPropertyNode(propertyNode, fileContext) {
-  const { Type } = dom,
-        typeNode = typeNodeQuery(propertyNode),
-        type = Type.fromTypeNode(typeNode);
-
-  return type;
-}

package/src/dom/type.js

@@ -10,6 +10,7 @@ import { superTypeFromJSON, propertiesFromJSON, superTypeToSuperTypeJSON, proper
 
 const typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type[0]"),
       propertyDeclarationNodesQuery = nodesQuery("/complexTypeDeclaration/propertyDeclaration"),
+      propertyDeclarationTypeNodeQuery = nodeQuery("/propertyDeclaration/type"),
       typeDeclarationSuperTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type[1]");
 
 class Type {
@@ -118,12 +119,16 @@ class Type {
     return typeNameMatches;
   }
 
-  matchTypeNode(typeNode) {
-    const typeName = typeNameFromTypeNode(typeNode),
-          typeNameMatches = this.matchTypeName(typeName),
-          typeNodeMatches = typeNameMatches;  ///
+  findPropertyByPropertyName(propertyName) {
+    const property = this.properties.find((property) => {
+      const propertyNameMatches = property.matchPropertyName(propertyName);
 
-    return typeNodeMatches;
+      if (propertyNameMatches) {
+        return true;
+      }
+    }) || null;
+
+    return property;
   }
 
   toJSON() {
@@ -183,6 +188,27 @@ class Type {
     return type;
   }
 
+  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+    let type;
+
+    const propertyDeclarationTypeNode = propertyDeclarationTypeNodeQuery(propertyDeclarationNode);
+
+    if (propertyDeclarationTypeNode === null) {
+      type = objectType;
+    } else {
+      const typeNode = propertyDeclarationTypeNode, ///
+            typeName = typeNameFromTypeNode(typeNode),
+            name = typeName,  ///
+            string = name,  ///
+            superType = null,
+            properties = null;
+
+      type = new Type(string, name, superType, properties);
+    }
+
+    return type;
+  }
+
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
     const properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
           superType = superTypeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),

package/src/index.js

@@ -38,6 +38,7 @@ import TypeAssertion from "./dom/assertion/type";
 import TypeDeclaration from "./dom/declaration/type";
 import DefinedAssertion from "./dom/assertion/defined";
 import SubproofAssertion from "./dom/assertion/subproof";
+import PropertyAssertion from "./dom/assertion/property";
 import ContainedAssertion from "./dom/assertion/contained";
 import VariableDeclaration from "./dom/declaration/variable";
 import BracketedCombinator from "./dom/combinator/bracketed";

package/src/mixins/statement/verify.js

@@ -7,9 +7,39 @@ import { equalityFromStatement,
          metavariableFromStatement,
          typeAssertionFromStatement,
          definedAssertionFromStatement,
+         propertyAssertionFromStatement,
          containedAssertionFromStatement,
          subproofAssertionFromStatement } from "../../utilities/verification";
 
+function unifyWithBracketedCombinator(statement, assignments, stated, context) {
+  stated = true;  ///
+
+  assignments = null; ///
+
+  const { BracketedCombinator } = dom,
+        bracketedCombinator = BracketedCombinator.fromNothing(),
+        unifiedWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
+
+  return unifiedWithBracketedCombinator;
+}
+
+function unifyWithCombinators(statement, assignments, stated, context) {
+  stated = true;  ///
+
+  assignments = null; ///
+
+  const combinators = context.getCombinators(),
+        unifiedWithCombinators = combinators.some((combinator) => {
+          const unifiedWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
+
+          if (unifiedWithCombinator) {
+            return true;
+          }
+        });
+
+  return unifiedWithCombinators;
+}
+
 function verifyAsMetavariable(statement, assignments, stated, context) {
   let verifiedAsMetavariable = false;
 
@@ -120,6 +150,28 @@ function verifyAsDefinedAssertion(statement, assignments, stated, context) {
   return verifiedAsDefinedAssertion;
 }
 
+function verifyAsPropertyAssertion(statement, assignments, stated, context) {
+  let verifiedAsPropertyAssertion = false;
+
+  const propertyAssertion = propertyAssertionFromStatement(statement, context);
+
+  if (propertyAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Verifying the '${statementString}' statement as a property assertion...`);
+
+    const propertyAssertionVerified = propertyAssertion.verify(assignments, stated, context);
+
+    verifiedAsPropertyAssertion = propertyAssertionVerified; ///
+
+    if (verifiedAsPropertyAssertion) {
+      context.debug(`...verified the '${statementString}' statement as a property assertion.`);
+    }
+  }
+
+  return verifiedAsPropertyAssertion;
+}
+
 function verifyAsContainedAssertion(statement, assignments, stated, context) {
   let verifiedAsContainedAssertion = false;
 
@@ -164,45 +216,17 @@ function verifyAsSubproofAssertion(statement, assignments, stated, context) {
   return verifiedAsSubproofAssertion;
 }
 
-function unifyWithBracketedCombinator(statement, assignments, stated, context) {
-  stated = true;  ///
-
-  assignments = null; ///
-
-  const { BracketedCombinator } = dom,
-        bracketedCombinator = BracketedCombinator.fromNothing(),
-        unifiedWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
-
-  return unifiedWithBracketedCombinator;
-}
-
-function unifyWithCombinators(statement, assignments, stated, context) {
-  stated = true;  ///
-
-  assignments = null; ///
-
-  const combinators = context.getCombinators(),
-        unifiedWithCombinators = combinators.some((combinator) => {
-          const unifiedWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
-
-          if (unifiedWithCombinator) {
-            return true;
-          }
-        });
-
-  return unifiedWithCombinators;
-}
-
 const verifyMixins = [
+  unifyWithBracketedCombinator,
+  unifyWithCombinators,
   verifyAsMetavariable,
   verifyAsEquality,
   verifyAsJudgement,
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
   verifyAsContainedAssertion,
-  verifyAsSubproofAssertion,
-  unifyWithBracketedCombinator,
-  unifyWithCombinators
+  verifyAsPropertyAssertion,
+  verifyAsSubproofAssertion
 ];
 
 export default verifyMixins;

package/src/utilities/verification.js

@@ -63,6 +63,16 @@ export function definedAssertionFromStatement(statement, context) {
   return definedAssertion;
 }
 
+export function propertyAssertionFromStatement(statement, context) {
+  context = contextFromStatement(statement, context); ///
+
+  const { PropertyAssertion } = dom,
+        statementNode = statement.getNode(),
+        propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);
+
+  return propertyAssertion;
+}
+
 export function containedAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///