occam-verify-cli 1.0.184 → 1.0.192

package/src/dom/metavariable.js

@@ -7,7 +7,6 @@ import ReferenceSubstitution from "../substitution/reference";
 import StatementSubstitution from "../substitution/statement";
 import MetavariablePartialContext from "../context/partial/metavariable";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
@@ -15,13 +14,6 @@ import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { metavariableFromFrame, metavariableFromStatement } from "../utilities/context";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
 
-const frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      labelMetavariableNodeQuery = nodeQuery("/label/metavariable"),
-      referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable"),
-      metavariableDeclarationMetavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
-      metavariableDeclarationMetavariableTypeNodeQuery = nodeQuery("/metavariableDeclaration/metavariable/type");
-
 export default domAssigned(class Metavariable {
   constructor(string, node, tokens, name, type, metaType) {
     this.string = string;
@@ -469,8 +461,7 @@ export default domAssigned(class Metavariable {
   }
 
   static fromLabelNode(labelNode, context) {
-    const labelMetavariableNode = labelMetavariableNodeQuery(labelNode),
-          metavariableNode = labelMetavariableNode, ///
+    const metavariableNode = labelNode.getMetavariableNode(),
           metavariable = metavariableFromMetavariableNode(metavariableNode, context);
 
     return metavariable;
@@ -479,10 +470,10 @@ export default domAssigned(class Metavariable {
   static fromFrameNode(frameNode, context) {
     let metavariable = null;
 
-    const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
+    const singularMetavariableNode = frameNode.getSingularMetavariableNode();
 
-    if (frameMetavariableNode !== null) {
-      const metavariableNode = frameMetavariableNode; ///
+    if (singularMetavariableNode !== null) {
+      const metavariableNode = singularMetavariableNode;  ///
 
       metavariable = metavariableFromMetavariableNode(metavariableNode, context);
     }
@@ -491,8 +482,7 @@ export default domAssigned(class Metavariable {
   }
 
   static fromReferenceNode(referenceNode, context) {
-    const referenceMetavariableNode = referenceMetavariableNodeQuery(referenceNode),
-          metavariableNode = referenceMetavariableNode, ///
+    const metavariableNode = referenceNode.getMetavariableNode(),
           metavariable = metavariableFromMetavariableNode(metavariableNode, context);
 
     return metavariable;
@@ -501,11 +491,9 @@ export default domAssigned(class Metavariable {
   static fromStatementNode(statementNode, context) {
     let metavariable = null;
 
-    const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
-
-    if (statementMetavariableNode !== null) {
-      const metavariableNode = statementMetavariableNode; ///
+    const metavariableNode = statementNode.getMetavariableNode();
 
+    if (metavariableNode !== null) {
       metavariable = metavariableFromMetavariableNode(metavariableNode, context);
     }
 
@@ -524,8 +512,7 @@ export default domAssigned(class Metavariable {
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
     const { MetaType } = dom,
-          metavariableDeclarationMetavariableNode = metavariableDeclarationMetavariableNodeQuery(metavariableDeclarationNode),
-          metavariableNode = metavariableDeclarationMetavariableNode, ///
+          metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
           type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
@@ -557,11 +544,10 @@ function metavariableFromMetavariableNode(metavariableNode, context) {
 function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
   let type = null;
 
-  const metavariableDeclarationMetavariableTypeNode = metavariableDeclarationMetavariableTypeNodeQuery(metavariableDeclarationNode);
+  const typeNode = metavariableDeclarationNode.getTypeNode();
 
-  if (metavariableDeclarationMetavariableTypeNode !== null) {
-    const typeNode = metavariableDeclarationMetavariableTypeNode, ///
-          typeName = typeNode.getTypeName();
+  if (typeNode !== null) {
+    const typeName = typeNode.getTypeName();
 
     type = fileContext.findTypeByTypeName(typeName);
   }

package/src/dom/parameter.js

@@ -1,10 +1,7 @@
 "use strict";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const nameTerminalNodeQuery = nodeQuery("/parameter/@name");
-
 export default domAssigned(class Parameter {
   constructor(name) {
     this.name = name;
@@ -57,9 +54,8 @@ export default domAssigned(class Parameter {
   }
 
   static fromParameterNode(parameterNode, context) {
-    const nameTerminalNode = nameTerminalNodeQuery(parameterNode),
-          nameTerminalNodeContent = nameTerminalNode.getContent(),
-          name = nameTerminalNodeContent, ///
+    const parameterName = parameterNode.getParameterName(),
+          name = parameterName, ///
           parameter = new Parameter(name);
 
     return parameter;

package/src/dom/procedureCall.js

@@ -5,13 +5,8 @@ import { Expressions } from "occam-furtle";
 import dom from "../dom";
 
 import { domAssigned } from "../dom";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 import { referenceFromJSON, parametersFromJSON, parametersToParametersJSON } from "../utilities/json";
 
-const parameterNodesQuery = nodesQuery("/procedureCall/parameter"),
-      premiseProcedureCallNodeQuery = nodeQuery("/premise/procedureCall"),
-      suppositionProcedureCallNodeQuery = nodeQuery("/supposition/procedureCall");
-
 export default domAssigned(class ProcedureCall {
   constructor(string, reference, parameters) {
     this.string = string;
@@ -126,11 +121,9 @@ export default domAssigned(class ProcedureCall {
   static fromPremiseNode(premiseNode, context) {
     let procedureCall = null;
 
-    const premiseProcedureCallNode = premiseProcedureCallNodeQuery(premiseNode);
-
-    if (premiseProcedureCallNode !== null) {
-      const procedureCallNode = premiseProcedureCallNode; ///
+    const procedureCallNode = premiseNode.getProcedureCallNode();
 
+    if (procedureCallNode !== null) {
       procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
     }
 
@@ -140,11 +133,9 @@ export default domAssigned(class ProcedureCall {
   static fromSuppositionNode(suppositionNode, context) {
     let procedureCall = null;
 
-    const suppositionProcedureCallNode = suppositionProcedureCallNodeQuery(suppositionNode);
-
-    if (suppositionProcedureCallNode !== null) {
-      const procedureCallNode = suppositionProcedureCallNode; ///
+    const procedureCallNode = suppositionNode.getProcedureCallNode();
 
+    if (procedureCallNode !== null) {
       procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
     }
 
@@ -164,7 +155,7 @@ function procedureCallFromProcedureCallNode(procedureCallNode, context) {
 
 function parametersFromProcedureCallNode(procedureCallNode, context) {
   const { Parameter } = dom,
-        parameterNodes = parameterNodesQuery(procedureCallNode),
+        parameterNodes = procedureCallNode.getParameterNodes(),
         parameters = parameterNodes.map((parameterNode) => {
           const parameter = Parameter.fromParameterNode(parameterNode, context);
 

package/src/dom/proof.js

@@ -3,11 +3,8 @@
 import dom from "../dom";
 import LocalContext from "../context/local";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const derivationNodeQuery = nodeQuery("/proof/derivation");
-
 export default domAssigned(class Proof {
   constructor(derivation) {
     this.derivation = derivation;
@@ -60,7 +57,7 @@ export default domAssigned(class Proof {
 
     if (proofNode !== null) {
       const { Derivation } = dom,
-            derivationNode = derivationNodeQuery(proofNode),
+            derivationNode = proofNode.getDerivationNode(),
             derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
 
       proof = new Proof(derivation);

package/src/dom/property.js

@@ -1,23 +1,14 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import dom from "../dom";
 
-import { objectType } from "./type";
 import { domAssigned } from "../dom";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
-const { match } = arrayUtilities;
-
-const nameTerminalNodesQuery = nodesQuery("/property/@name"),
-      propertyRelationPropertyNodeQuery = nodeQuery("/propertyRelation/property");
-
 export default domAssigned(class Property {
-  constructor(string, names, type) {
+  constructor(string, name, type) {
     this.string = string;
-    this.names = names;
+    this.name = name;
     this.type = type;
   }
 
@@ -25,8 +16,8 @@ export default domAssigned(class Property {
     return this.string;
   }
 
-  getNames() {
-    return this.names;
+  getName() {
+    return this.name;
   }
 
   getType() {
@@ -37,23 +28,19 @@ export default domAssigned(class Property {
     this.type = type;
   }
 
-  matchPropertyNames(propertyNames) {
-    const propertyNamesMatch = match(propertyNames, this.names, (propertyName, name) => {
-      if (propertyName === name) {
-        return true;
-      }
-    });
+  matchPropertyName(propertyName) {
+    const propertyNameMatches = (this.name === propertyName);
 
-    return propertyNamesMatch;
+    return propertyNameMatches;
   }
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          names = this.names, ///
+          name = this.name, ///
           type = typeJSON,  ///
           json = {
             type,
-            names
+            name
           };
 
     return json;
@@ -62,10 +49,10 @@ export default domAssigned(class Property {
   static name = "Property";
 
   static fromJSON(json, fileContext) {
-    const { names } = json,
+    const { name } = json,
           type = typeFromJSON(json, fileContext),
-          string = stringFromNamesAndType(names, type),
-          property = new Property(string, names, type);
+          string = name, ///
+          property = new Property(string, name, type);
 
     return property;
   }
@@ -77,8 +64,7 @@ export default domAssigned(class Property {
   }
 
   static fromPropertyRelationNode(propertyRelationNode, fileContext) {
-    const propertyRelationPropertyNode = propertyRelationPropertyNodeQuery(propertyRelationNode),
-          propertyNode = propertyRelationPropertyNode,  ///
+    const propertyNode = propertyRelationNode.getPropertyNode(),
           property = propertyFromPropertyNode(propertyNode, fileContext);
 
     return property;
@@ -87,10 +73,10 @@ export default domAssigned(class Property {
   static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
     const { Type } = dom,
           type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
-          propertyNames = propertyDeclarationNode.getPropertyNames(),
-          names = propertyNames,  ///
-          string = stringFromNamesAndType(names, type),
-          property = new Property(string, names, type);
+          propertyName = propertyDeclarationNode.getPropertyName(),
+          name = propertyName,  ///
+          string = name,  ///
+          property = new Property(string, name, type);
 
     return property;
   }
@@ -98,54 +84,11 @@ export default domAssigned(class Property {
 
 function propertyFromPropertyNode(propertyNode, fileContext) {
   const { Property } = dom,
-        node = propertyNode,  ///
-        names = namesFromPropertyNode(propertyNode),
+        propertyName = propertyNode.getPropertyName(),
+        name = propertyName,  ///
         type = null,
-        string = fileContext.nodeAsString(node),
-        property = new Property(string, names, type);
+        string = name,  ///
+        property = new Property(string, name, type);
 
   return property;
 }
-
-function stringFromNamesAndType(names, type) {
-  let string;
-
-  const namesString = namesStringFromNames(names);
-
-  if (type === objectType) {
-    string = namesString;  ///
-  } else {
-    const typeString = type.getString();
-
-    string = `${namesString}:${typeString}`;
-  }
-
-  return string;
-}
-
-function namesFromPropertyNode(propertyNode, fileContext) {
-  const nameTerminalNodes = nameTerminalNodesQuery(propertyNode),
-        names = nameTerminalNodes.map((nameTerminalNode) => {
-          const nameTerminalNodeContent = nameTerminalNode.getContent(),
-                name = nameTerminalNodeContent; ///
-
-          return name;
-        });
-
-  return names;
-}
-
-function namesStringFromNames(names) {
-  const namesString = names.reduce((namesString, name) => {
-    const nameString = name;  ///
-
-    namesString = (namesString === null) ?
-                    nameString :  ///
-                     `${namesString} ${nameString}`;
-
-    return namesString;
-  }, null);
-
-  return namesString;
-}
-

package/src/dom/propertyRelation.js

@@ -2,11 +2,8 @@
 
 import dom from "../dom";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const propertyAssertionPropertyRelationNodeQuery = nodeQuery("/propertyAssertion/propertyRelation");
-
 export default domAssigned(class PropertyRelation {
   constructor(string, node, tokens, property, term) {
     this.string = string;
@@ -96,24 +93,24 @@ export default domAssigned(class PropertyRelation {
 
     context.trace(`Verifying the '${propertyRelationString}' property relation's '${propertyString}' property...`);
 
-    const variableType = this.term.getType(),
-          propertyNames = this.property.getNames(),
-          variableTypeProperties = variableType.getProperties(),
-          variableTypeProperty = variableTypeProperties.find((variableTypeProperty) => {
-            const propertyNamesMatch = variableTypeProperty.matchPropertyNames(propertyNames);
+    const termType = this.term.getType(),
+          propertyName = this.property.getName(),
+          termTypeProperties = termType.getProperties(),
+          variableTypeProperty = termTypeProperties.find((termTypeProperty) => {
+            const propertyNameMatches = termTypeProperty.matchPropertyName(propertyName);
 
-            if (propertyNamesMatch) {
+            if (propertyNameMatches) {
               return true;
             }
           }) || null;
 
     if (variableTypeProperty === null) {
       const variableString = this.term.getString(),
-            variableTypeString = variableType.getString();
+            variableTypeString = termType.getString();
 
-      context.debug(`The '${propertyNames}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
+      context.debug(`The '${propertyName}' property is not a property of the '${variableString}' variable's '${variableTypeString}' type.`);
     } else {
-      const type = variableType;
+      const type = termType;
 
       this.property.setType(type);
 
@@ -131,8 +128,7 @@ export default domAssigned(class PropertyRelation {
 
   static fromPropertyAssertionNode(propertyAssertionNode, context) {
     const { Term, Property } = dom,
-          propertyAssertionPropertyRelationNode = propertyAssertionPropertyRelationNodeQuery(propertyAssertionNode),
-          propertyRelationNode = propertyAssertionPropertyRelationNode, ///
+          propertyRelationNode = propertyAssertionNode.getPropertyRelationNode(),
           node = propertyRelationNode,  ///
           string = context.nodeAsString(node),
           tokens = context.nodeAsTokens(node),

package/src/dom/reference.js

@@ -4,17 +4,11 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { referenceMetaType } from "../dom/metaType";
 import { unifyMetavariableIntrinsically } from "../utilities/unification";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-const stepReferenceNodeQuery = nodeQuery("/step/reference"),
-      procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference"),
-      declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable"),
-      satisfiesAssertionMetavariableNodeQuery = nodeQuery("/satisfiesAssertion/metavariable");
-
 export default domAssigned(class Reference {
   constructor(metavariable) {
     this.metavariable = metavariable;
@@ -183,11 +177,9 @@ export default domAssigned(class Reference {
   static fromStepNode(stepNode, fileContext) {
     let reference = null;
 
-    const stepReferenceNode = stepReferenceNodeQuery(stepNode);
-
-    if (stepReferenceNode !== null) {
-      const referenceNode = stepReferenceNode; ///
+    const referenceNode = stepNode.getReferenceNode();
 
+    if (referenceNode !== null) {
       reference = referenceFromReferenceNode(referenceNode, fileContext);
     }
 
@@ -201,8 +193,7 @@ export default domAssigned(class Reference {
   }
 
   static fromDeclarationNode(declarationNode, fileContext) {
-    const declarationMetavariableNode = declarationMetavariableNodeQuery(declarationNode),
-          metavariableNode = declarationMetavariableNode, ///
+    const metavariableNode = declarationNode.getMetavariableNode(),
           reference = referenceFromMetavariableNode(metavariableNode, fileContext);
 
     return reference;
@@ -217,11 +208,9 @@ export default domAssigned(class Reference {
   static fromProcedureCallNode(procedureCallNode, fileContext) {
     let reference = null;
 
-    const procedureCallReferenceNode = procedureCallReferenceNodeQuery(procedureCallNode);
-
-    if (procedureCallReferenceNode !== null) {
-      const referenceNode = procedureCallReferenceNode; ///
+    const referenceNode = procedureCallNode.getReferenceNode();
 
+    if (referenceNode !== null) {
       reference = referenceFromReferenceNode(referenceNode, fileContext);
     }
 
@@ -229,8 +218,7 @@ export default domAssigned(class Reference {
   }
 
   static fromSatisfiesAssertionNode(satisfiesAssertionNode, fileContext) {
-    const satisfiesAssertionMetavariableNode = satisfiesAssertionMetavariableNodeQuery(satisfiesAssertionNode),
-          metavariableNode = satisfiesAssertionMetavariableNode, ///
+    const metavariableNode = satisfiesAssertionNode.getMetavariableNode(),
           reference = referenceFromMetavariableNode(metavariableNode, fileContext);
 
     return reference;

package/src/dom/rule.js

@@ -7,7 +7,6 @@ import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 import { labelsStringFromLabels } from "./topLevelAssertion";
 import { labelsFromJSON,
          premisesFromJSON,
@@ -18,11 +17,6 @@ import { labelsFromJSON,
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
-const proofNodeQuery = nodeQuery("/rule/proof"),
-      labelNodesQuery = nodesQuery("/rule/parenthesisedLabels/labels/label"),
-      premiseNodesQuery = nodesQuery("/rule/premise"),
-      conclusionNodeQuery = nodeQuery("/rule/conclusion");
-
 export default domAssigned(class Rule {
   constructor(fileContext, string, labels, premises, conclusion, proof) {
     this.fileContext = fileContext;
@@ -236,10 +230,10 @@ export default domAssigned(class Rule {
   }
 
   static fromRuleNode(ruleNode, fileContext) {
-    const labels = labelsFromRuleNode(ruleNode, fileContext),
+    const proof = proofFromRuleNode(ruleNode, fileContext),
+          labels = labelsFromRuleNode(ruleNode, fileContext),
           premises = premisesFromRuleNode(ruleNode, fileContext),
           conclusion = conclusionFromRuleNode(ruleNode, fileContext),
-          proof = proofFromRuleNode(ruleNode, fileContext),
           string = stringFromLabelsAndConclusion(labels, conclusion),
           rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
@@ -249,7 +243,7 @@ export default domAssigned(class Rule {
 
 function proofFromRuleNode(ruleNode, fileContext) {
   const { Proof } = dom,
-        proofNode = proofNodeQuery(ruleNode),
+        proofNode = ruleNode.getProofNode(),
         proof = Proof.fromProofNode(proofNode, fileContext);
 
   return proof;
@@ -257,7 +251,7 @@ function proofFromRuleNode(ruleNode, fileContext) {
 
 function labelsFromRuleNode(ruleNode, fileContext) {
   const { Label } = dom,
-        labelNodes = labelNodesQuery(ruleNode),
+        labelNodes = ruleNode.getLabelNodes(),
         labels = labelNodes.map((labelNode) => {
           const label = Label.fromLabelNode(labelNode, fileContext);
 
@@ -269,7 +263,7 @@ function labelsFromRuleNode(ruleNode, fileContext) {
 
 function premisesFromRuleNode(ruleNode, fileContext) {
   const { Premise } = dom,
-        premiseNodes = premiseNodesQuery(ruleNode),
+        premiseNodes = ruleNode.getPremiseNodes(),
         premises = premiseNodes.map((premiseNode) => {
           const premise = Premise.fromPremiseNode(premiseNode, fileContext);
 
@@ -281,7 +275,7 @@ function premisesFromRuleNode(ruleNode, fileContext) {
 
 function conclusionFromRuleNode(ruleNode, fileContext) {
   const { Conclusion } = dom,
-        conclusionNode = conclusionNodeQuery(ruleNode),
+        conclusionNode = ruleNode.getConclusionNode(),
         conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext);
 
   return conclusion;