occam-verify-cli 1.0.185 → 1.0.198

package/src/dom/judgement.js

@@ -3,11 +3,8 @@
 import dom from "../dom";
 import JudgementAssignment from "../assignment/judgement";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const judgementNodeQuery = nodeQuery("/statement/judgement");
-
 export default domAssigned(class Judgement {
   constructor(string, frame, declaration) {
     this.string = string;
@@ -73,15 +70,14 @@ export default domAssigned(class Judgement {
   verifyFrame(assignments, stated, context) {
     let frameVerified;
 
-    const frameString = this.frame.getString(),
-          judgementString = this.string;  ///
+    const frameString = this.frame.getString();
 
-    context.trace(`Verifying the '${judgementString}' judgement's '${frameString}' frame...`);
+    context.trace(`Verifying the '${frameString}' frame...`);
 
     frameVerified = this.frame.verify(assignments, stated, context);
 
     if (frameVerified) {
-      context.debug(`...verified the '${judgementString}' judgement's '${frameString}' frame.`);
+      context.debug(`...verified the '${frameString}' frame.`);
     }
 
     return frameVerified;
@@ -90,15 +86,14 @@ export default domAssigned(class Judgement {
   verifyDeclaration(assignments, stated, context) {
     let declarationVerified;
 
-    const judgementString = this.string,  ///
-          declarationString = this.declaration.getString();
+    const declarationString = this.declaration.getString();
 
-    context.trace(`Verifying the '${judgementString}' judgement's '${declarationString}' declaration...`);
+    context.trace(`Verifying the '${declarationString}' declaration...`);
 
     declarationVerified = this.declaration.verify(assignments, stated, context);
 
     if (declarationVerified) {
-      context.debug(`...verified the '${judgementString}' judgement's '${declarationString}' declaration.`);
+      context.debug(`...verified the '${declarationString}' declaration.`);
     }
 
     return declarationVerified;
@@ -158,7 +153,7 @@ export default domAssigned(class Judgement {
   static fromStatementNode(statementNode, context) {
     let judgement = null;
 
-    const judgementNode = judgementNodeQuery(statementNode);
+    const judgementNode = statementNode.getJudgementNode();
 
     if (judgementNode !== null) {
       const { Frame, Declaration} = dom,

package/src/dom/lemma.js

@@ -33,5 +33,10 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
 
   static name = "Lemma";
 
-  static fromNode(node, fileContext) { return TopLevelAssertion.fromNode(Lemma, node, fileContext); }
+  static fromLemmaNode(lemmaNode, fileContext) {
+    const node = lemmaNode, ///
+          lemma = TopLevelAssertion.fromNode(Lemma, node, fileContext);
+
+    return lemma;
+  }
 });

package/src/dom/metaLemma.js

@@ -31,5 +31,10 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext); }
+  static fromMetaLemmaNode(metaLemmaNode, fileContext) {
+    const node = metaLemmaNode, ///
+          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext);
+
+    return metaLemma;
+  }
 });

package/src/dom/metaType.js

@@ -2,12 +2,9 @@
 
 import LocalContext from "../context/local";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
-const metavariableDeclarationMetaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
-
 class MetaType {
   constructor(name) {
     this.name = name;
@@ -61,8 +58,7 @@ class MetaType {
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const metavariableDeclarationMetaTypeNode = metavariableDeclarationMetaTypeNodeQuery(metavariableDeclarationNode),
-          metaTypeNode = metavariableDeclarationMetaTypeNode, ///
+    const metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
           metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);

package/src/dom/metatheorem.js

@@ -31,5 +31,10 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext); }
+  static fromMetatheoremNode(metatheoremNode, fileContext) {
+    const node = metatheoremNode, ///
+          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext);
+
+    return metatheorem;
+  }
 });

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;
@@ -70,10 +67,9 @@ export default domAssigned(class PropertyRelation {
   verifyTerm(context) {
     let termVerified;
 
-    const termString = this.term.getString(),
-          propertyRelationString = this.string; ///
+    const termString = this.term.getString();
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation's '${termString}' term...`);
+    context.trace(`Verifying the '${termString}' term...`);
 
     termVerified = this.term.verify(context, () => {
       const verifiedAhead = true;
@@ -82,7 +78,7 @@ export default domAssigned(class PropertyRelation {
     });
 
     if (termVerified) {
-      context.debug(`...verified the '${propertyRelationString}' property relation's '${termString}' term.`);
+      context.debug(`...verified the '${termString}' term.`);
     }
 
     return termVerified;
@@ -91,29 +87,28 @@ export default domAssigned(class PropertyRelation {
   verifyProperty(context) {
     let propertyVerified;
 
-    const propertyString = this.property.getString(),
-          propertyRelationString = this.string; ///
+    const propertyString = this.property.getString();
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation's '${propertyString}' property...`);
+    context.trace(`Verifying the '${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);
 
@@ -121,7 +116,7 @@ export default domAssigned(class PropertyRelation {
     }
 
     if (propertyVerified) {
-      context.debug(`...verified the '${propertyRelationString}' property relation's '${propertyString}' property.`);
+      context.debug(`...verified the '${propertyString}' property.`);
     }
 
     return propertyVerified;
@@ -131,8 +126,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;