occam-verify-cli 1.0.185 → 1.0.198

package/src/node/equality.js

@@ -1,7 +1,36 @@
 "use strict";
 
-import Node from "../node";
+import { arrayUtilities } from "necessary";
 
-export default class EqualityNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(EqualityNode, ruleName, childNodes, opacity, precedence); }
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME } from "../ruleNames";
+
+const { first, last } = arrayUtilities;
+
+export default class EqualityNode extends NonTerminalNode {
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodeByRuleName(ruleName);
+
+    return termNodes;
+  }
+
+  getLeftTermNode() {
+    const termNodes = this.getTermNodes(),
+          firstTermNode = first(termNodes),
+          leftTermNode = firstTermNode; ///
+
+    return leftTermNode;
+  }
+
+  getRightTermNode() {
+    const termNodes = this.getTermNodes(),
+          firstTermNode = last(termNodes),
+          rightTermNode = firstTermNode; ///
+
+    return rightTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(EqualityNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/error.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ErrorNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ErrorNode, ruleName, childNodes, opacity, precedence); }
+export default class ErrorNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ErrorNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/frame.js

@@ -1,7 +1,30 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class FrameNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(FrameNode, ruleName, childNodes, opacity, precedence); }
+import { DECLARATION_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
+
+export default class FrameNode extends NonTerminalNode {
+  getDeclarationNodes() {
+    const ruleName = DECLARATION_RULE_NAME,
+          declarationNodes = this.getNodesByRuleName(ruleName);
+
+    return declarationNodes;
+  }
+
+  getMetavariableNodes() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNodes = this.getNodesByRuleName(ruleName);
+
+    return metavariableNodes;
+  }
+
+  getSingularMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          singularMetavariableNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularMetavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/judgement.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class JudgementNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(JudgementNode, ruleName, childNodes, opacity, precedence); }
+import { FRAME_RULE_NAME, DECLARATION_RULE_NAME } from "../ruleNames";
+
+export default class JudgementNode extends NonTerminalNode {
+  getFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          frameNode = this.getNodesByRuleName(ruleName);
+
+    return frameNode;
+  }
+
+  getDeclarationNodes() {
+    const ruleName = DECLARATION_RULE_NAME,
+          declarationNodes = this.getNodesByRuleName(ruleName);
+
+    return declarationNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(JudgementNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/label.js

@@ -1,7 +1,16 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class LabelNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(LabelNode, ruleName, childNodes, opacity, precedence); }
+import { METAVARIABLE_RULE_NAME } from "../ruleNames";
+
+export default class LabelNode extends NonTerminalNode {
+  getMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LabelNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/labels.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { LABEL_RULE_NAME } from "../ruleNames";
+
+export default class LabelsNode extends NonTerminalNode {
+  getLabelNodes() {
+    const ruleName = LABEL_RULE_NAME,
+          labelNodes = this.getNodesByRuleName(ruleName);
+
+    return labelNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LabelsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/lemma.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
-export default class LemmaNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
+export default class LemmaNode extends TopLevelAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metaArgument.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class MetaArgumentNode extends NonTerminalNode {
+  getSingularStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          singularStatementNode = this.getNodeByRuleName(ruleName);
+
+    return singularStatementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaArgumentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/metaLemma.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
-export default class MetaLemmaNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
+export default class MetaLemmaNode extends TopLevelMetaAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metaType.js

@@ -1,19 +1,26 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class MetaTypeNode extends Node {
+export default class MetaTypeNode extends NonTerminalNode {
   getMetaTypeName() {
-    const metaTypeName = this.fromFirstChildNode((firstChildNode) => {
-      const metaTypeTerminalNode = firstChildNode,  ///
-            content = metaTypeTerminalNode.getContent(),
-            metaTypeName = content; ///
+    let metaTypeName;
 
-      return metaTypeName;
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent();
+
+        metaTypeName = content; ///
+
+        return true;
+      }
     });
 
     return metaTypeName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetaTypeNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaTypeNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metatheorem.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
-export default class MetatheoremNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
+export default class MetatheoremNode extends TopLevelMetaAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metavariable.js

@@ -1,19 +1,42 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
+
+export default class MetavariableNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
+  }
 
-export default class MetavariableNode extends Node {
   getMetavariableName() {
-    const metavariableName = this.fromFirstChildNode((firstChildNode) => {
-      const nameTerminalNode = firstChildNode,  ///
-            content = nameTerminalNode.getContent(),
-            metavariableName = content; ///
+    let metaVariableName;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+               content = terminalNode.getContent();
+
+        metaVariableName = content; ///
 
-      return metavariableName;
+        return true;
+      }
     });
 
-    return metavariableName;
+    return metaVariableName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/nonTerminal.js

@@ -0,0 +1,112 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { NonTerminalNode as NonTerminalNodeBase } from "occam-parsers";
+
+const { first, forwardsFind, backwardsFind } = arrayUtilities;
+
+export default class NonTerminalNode extends NonTerminalNodeBase {
+  getNodeByRuleName(...ruleNames) {
+    const node = this.findChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          return true;
+        }
+      }
+    }) || null;
+
+    return node;
+  }
+
+  getNodesByRuleName(...ruleNames) {
+    const nodes = this.filterChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          return true;
+        }
+      }
+    });
+
+    return nodes;
+  }
+
+  getLastNodeByRuleName(...ruleNames) {
+    const childNodes = this.getChildNodes(),
+          lastNode = backwardsFind(childNodes, (childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode, ///
+                    ruleName = nonTerminalNode.getRuleName(),
+                    ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+              if (ruleNamesIncludesRuleName) {
+                return true;
+              }
+            }
+          }) || null;
+
+    return lastNode;
+  }
+
+  getFirstNodeByRuleName(...ruleNames) {
+    const childNodes = this.getChildNodes(),
+          firstNode = forwardsFind(childNodes, (childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode, ///
+                    ruleName = nonTerminalNode.getRuleName(),
+                    ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+              if (ruleNamesIncludesRuleName) {
+                return true;
+              }
+            }
+          }) || null;
+
+    return firstNode;
+  }
+
+  getSingularTNodeByRuleName(...ruleNames) {
+    let singularNode = null;
+
+    const nodes = this.filterChildNode((childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode, ///
+                    ruleName = nonTerminalNode.getRuleName(),
+                    ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+              if (ruleNamesIncludesRuleName) {
+                return true;
+              }
+            }
+          }),
+          nodesLength = nodes.length;
+
+    if (nodesLength === 1) {
+      const firstNode = first(nodes);
+
+      singularNode = firstNode; ///
+    }
+
+    return singularNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNodeBase.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/parameter.js

@@ -1,7 +1,24 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ParameterNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }
+export default class ParameterNode extends NonTerminalNode {
+  getParameterName() {
+    let parameterName;
+
+    this.someChildNode((childNode, index) => {
+      const nameTerminalNode = childNode, ///
+            content = nameTerminalNode.getContent();
+
+      parameterName = content;  ///
+
+      if (index === 0) {
+        return true;
+      }
+    });
+
+    return parameterName;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/parenthesisedLabel.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { LABEL_RULE_NAME } from "../ruleNames";
+
+export default class ParenthesisedLabelNode extends NonTerminalNode {
+  getLabelNode() {
+    const ruleName = LABEL_RULE_NAME,
+          labelNode = this.getNodeByRuleName(ruleName);
+
+    return labelNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParenthesisedLabelNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/parenthesisedLabels.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { LABELS_RULE_NAME } from "../ruleNames";
+
+export default class ParenthesisedLabelsNode extends NonTerminalNode {
+  getLabelNodes() {
+    const labelsNode = this.getLabelsNode(),
+          labelNodes = labelsNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getLabelsNode() {
+    const ruleName = LABELS_RULE_NAME,
+          labelsNode = this.getNodeByRuleName(ruleName);
+
+    return labelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParenthesisedLabelsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/premise.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class PremiseNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
+import { STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
+
+export default class PremiseNode extends NonTerminalNode {
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  getProcedureCallNode() {
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/procedureCall.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ProcedureCallNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureCallNode, ruleName, childNodes, opacity, precedence); }
+import { REFERENCE_RULE_NAME, PARAMETER_RULE_NAME } from "../ruleNames";
+
+export default class ProcedureCallNode extends NonTerminalNode {
+  getReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
+
+    return referenceNode;
+  }
+
+  getParameterNodes() {
+    const ruleName = PARAMETER_RULE_NAME,
+          parameterNodes = this.getNodesByRuleName(ruleName);
+
+    return parameterNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureCallNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/proof.js

@@ -1,7 +1,16 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ProofNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ProofNode, ruleName, childNodes, opacity, precedence); }
+import { DERIVATION_RULE_NAME } from "../ruleNames";
+
+export default class ProofNode extends NonTerminalNode {
+  getDerivationNode() {
+    const ruleName = DERIVATION_RULE_NAME,
+          derivationNode = this.getNodeByRuleName(ruleName);
+
+    return derivationNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProofNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/property.js

@@ -1,22 +1,28 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class PropertyNode extends Node {
+import { SINGLE_SPACE } from "../constants";
+
+export default class PropertyNode extends NonTerminalNode {
   getPropertyName() {
-    const propertyName = this.reduceChildNode((propertyName, firstChildNode) => {
-      const nameTerminalNode = firstChildNode,  ///
-            content = nameTerminalNode.getContent();
+    const names = this.getNames(),
+          propertyName = names.join(SINGLE_SPACE);
 
-      propertyName = (propertyName !== null) ?
-                       `${propertyName} ${content}` :
-                          content;  ///
+    return propertyName;
+  }
 
-      return propertyName;
-    }, null);
+  getNames() {
+    const names = this.mapChildNode((childNode) => {
+      const terminalNode = childNode, ///
+            content = terminalNode.getContent(),
+            name = content; //
 
-    return propertyName;
+      return name;
+    });
+
+    return names;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/propertyRelation.js

@@ -1,7 +1,30 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class PropertyRelationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }
+import { TERM_RULE_NAME, PROPERTY_RULE_NAME } from "../ruleNames";
+
+export default class PropertyRelationNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getPropertyNode() {
+    const ruleName = PROPERTY_RULE_NAME,
+          propertyNode = this.getNodeByRuleName(ruleName);
+
+    return propertyNode;
+  }
+
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
+
+    return propertyName;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/reference.js

@@ -1,7 +1,16 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ReferenceNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceNode, ruleName, childNodes, opacity, precedence); }
+import { METAVARIABLE_RULE_NAME } from "../ruleNames";
+
+export default class ReferenceNode extends NonTerminalNode {
+  getMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceNode, ruleName, childNodes, opacity, precedence); }
 }