occam-verify-cli 1.0.185 → 1.0.198

package/src/node/rule.js

@@ -1,7 +1,44 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class RuleNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
+import {  PROOF_RULE_NAME, PREMISE_RULE_NAME, CONCLUSION_RULE_NAME, PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
+
+export default class RuleNode extends NonTerminalNode {
+  getLabelNodes() {
+    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode(),
+          labelNodes = parenthesisedLabelsNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getProofNode() {
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
+
+    return proofNode;
+  }
+
+  getPremiseNodes() {
+    const ruleName = PREMISE_RULE_NAME,
+          premiseNodes = this.getNodesByRuleName(ruleName);
+
+    return premiseNodes;
+  }
+
+  getConclusionNode() {
+    const ruleName = CONCLUSION_RULE_NAME,
+          conclusionNode = this.getNodeByRuleName(ruleName);
+
+    return conclusionNode;
+  }
+
+  getParenthesisedLabelsNode() {
+    const ruleName = PARENTHESISED_LABELS_RULE_NAME,
+          parenthesisedLabelsNode = this.getNodeByRuleName(ruleName);
+
+    return parenthesisedLabelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/statement.js

@@ -1,7 +1,155 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class StatementNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
+import { TERM_RULE_NAME,
+         FRAME_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         META_ARGUMENT_RULE_NAME,
+         TYPE_ASSERTION_RULE_NAME,
+         DEFINED_ASSERTION_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
+         PROPERTY_ASSERTION_RULE_NAME,
+         SUBPROOF_ASSERTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
+         SATISFIES_ASSERTION_RULE_NAME,
+         CONTAINED_ASSERTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+
+export default class StatementNode extends NonTerminalNode {
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodeByRuleName(ruleName);
+
+    return termNodes;
+  }
+
+  getFrameNodes() {
+    const ruleName = FRAME_RULE_NAME,
+          frameNodes = this.getNodeByRuleName(ruleName);
+
+    return frameNodes;
+  }
+
+  getEqualityNode() {
+    const ruleName = EQUALITY_RULE_NAME,
+          equalityNode = this.getNodeByRuleName(ruleName);
+
+    return equalityNode;
+  }
+
+  getJudgementNode() {
+    const ruleName = JUDGEMENT_RULE_NAME,
+          judgementNode = this.getNodeByRuleName(ruleName);
+
+    return judgementNode;
+  }
+
+  getMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  getTypeAssertionNode() {
+    const ruleName = TYPE_ASSERTION_RULE_NAME,
+          typeAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return typeAssertionNode;
+  }
+
+  getDefinedAssertionNode() {
+    const ruleName = DEFINED_ASSERTION_RULE_NAME,
+          definedAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return definedAssertionNode;
+  }
+
+  getTermSubstitutionNode() {
+    const ruleName = TERM_SUBSTITUTION_RULE_NAME,
+          termSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return termSubstitutionNode;
+  }
+
+  getFrameSubstitutionNode() {
+    const ruleName = FRAME_SUBSTITUTION_RULE_NAME,
+          frameSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return frameSubstitutionNode;
+  }
+
+  getSubproofAssertionNode() {
+    const ruleName = SUBPROOF_ASSERTION_RULE_NAME,
+          subproofAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return subproofAssertionNode;
+  }
+
+  getPropertyAssertionNode() {
+    const ruleName = PROPERTY_ASSERTION_RULE_NAME,
+          propertyAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return propertyAssertionNode;
+  }
+
+  getSingularStatementNode() {
+    let singularStatementNode = null;
+
+    const singularMetaArgumentNode = this.getSingularMetaArgumentNode();
+
+    if (singularMetaArgumentNode !== null) {
+      singularStatementNode = singularMetaArgumentNode.getSingularStatementNode();
+    }
+
+    return singularStatementNode;
+  }
+
+  getContainedAssertionNode() {
+    const ruleName = CONTAINED_ASSERTION_RULE_NAME,
+          containedAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return containedAssertionNode;
+  }
+
+  getSatisfiedAssertionNode() {
+    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
+          satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return satisfiedAssertionNode;
+  }
+
+  getSingularMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          singularMetavariableNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularMetavariableNode;
+  }
+
+  getSingularMetaArgumentNode() {
+    const ruleName = META_ARGUMENT_RULE_NAME,
+          singularMetaArgumentNode = this.getNodeByRuleName(ruleName);
+
+    return singularMetaArgumentNode;
+  }
+
+  getReferenceSubstitutionNode() {
+    const ruleName = REFERENCE_SUBSTITUTION_RULE_NAME,
+      referenceSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return referenceSubstitutionNode;
+  }
+
+  getStatementSubstitutionNode() {
+    const ruleName = STATEMENT_SUBSTITUTION_RULE_NAME,
+          statementSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return statementSubstitutionNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/step.js

@@ -1,7 +1,35 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class StepNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
+import { REFERENCE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class StepNode extends NonTerminalNode {
+  isStepNode() {
+    const stepNode = true;
+
+    return stepNode;
+  }
+
+  isSubproofNode() {
+    const subproofNode = false;
+
+    return subproofNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  getReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
+
+    return referenceNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/subDerivation.js

@@ -1,7 +1,26 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class SubDerivationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SubDerivationNode, ruleName, childNodes, opacity, precedence); }
+import { STEP_RULE_NAME, SUBPROOF_RULE_NAME } from "../ruleNames";
+
+export default class SubDerivationNode extends NonTerminalNode {
+  getLastStepNode() {
+    const ruleName = STEP_RULE_NAME,
+          lastStepNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastStepNode;
+  }
+
+  getStepOrSubproofNodes() {
+    const ruleNames = [
+            STEP_RULE_NAME,
+            SUBPROOF_RULE_NAME,
+          ],
+          stepOrSubproofNodes = this.getNodesByRuleName(...ruleNames);
+
+    return stepOrSubproofNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubDerivationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/subproof.js

@@ -1,7 +1,42 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class SubproofNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SubproofNode, ruleName, childNodes, opacity, precedence); }
+import { SUPPOSITION_RULE_NAME, SUB_DERIVATION_RULE_NAME } from "../ruleNames";
+
+export default class SubproofNode extends NonTerminalNode {
+  isStepNode() {
+    const stepNode = false;
+
+    return stepNode;
+  }
+
+  isSubproofNode() {
+    const subproofNode = true;
+
+    return subproofNode;
+  }
+
+  getLastStepNode() {
+    const subDerivationNode = this.getSubDerivationNode(),
+          lastStepNode = subDerivationNode.getLastStepNode();
+
+    return lastStepNode;
+  }
+
+  getSubDerivationNode() {
+    const ruleName = SUB_DERIVATION_RULE_NAME,
+          subDerivationNode = this.getNodeByRuleName(ruleName);
+
+    return subDerivationNode;
+  }
+
+  getSuppositionNodes() {
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
+
+    return suppositionNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/frame.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { FRAME_RULE_NAME } from "../../ruleNames";
+
+export default class FrameSubstitutionNode extends NonTerminalNode {
+  getLastFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          lastFrameNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastFrameNode;
+  }
+
+  getFirstFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          firstFrameNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstFrameNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/substitution/reference.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { REFERENCE_RULE_NAME } from "../../ruleNames";
+
+export default class ReferenceSubstitutionNode extends NonTerminalNode {
+  getLastReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          lastReferenceNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastReferenceNode;
+  }
+
+  getFirstReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          firstReferenceNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstReferenceNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/substitution/statement.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { STATEMENT_RULE_NAME } from "../../ruleNames";
+
+export default class StatementSubstitutionNode extends NonTerminalNode {
+  getLastStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          lastStatementNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastStatementNode;
+  }
+
+  getFirstStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          firstStatementNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstStatementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/substitution/term.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+export default class TermSubstitutionNode extends NonTerminalNode {
+  getLastTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          lastTermNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastTermNode;
+  }
+
+  getFirstTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          firstTermNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/supposition.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class SuppositionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SuppositionNode, ruleName, childNodes, opacity, precedence); }
+import { STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
+
+export default class SuppositionNode 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(SuppositionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/term.js

@@ -1,7 +1,42 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class TermNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
+import { ARGUMENT_RULE_NAME, VARIABLE_RULE_NAME } from "../ruleNames";
+
+export default class TermNode extends NonTerminalNode {
+  getVariableNodes() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNodes = this.getNodesByRuleName(ruleName);
+
+    return variableNodes;
+  }
+
+  getSingularTermNode() {
+    let singularTermNode = null;
+
+    const singularArgumentNode = this.getSingularArgumentNode();
+
+    if (singularArgumentNode !== null) {
+      singularTermNode = singularArgumentNode.getSingularTermNode();
+    }
+
+    return singularTermNode;
+  }
+
+  getSingularArgumentNode() {
+    const ruleName = ARGUMENT_RULE_NAME,
+          singularArgumentNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularArgumentNode;
+  }
+
+  getSingularVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          singularVariableNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularVariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/theorem.js

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

package/src/node/topLevelAssertion.js

@@ -1,7 +1,73 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class TopLevelAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TopLevelAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { SATISFIABLE } from "../constants";
+import { PROOF_RULE_NAME,
+         DEDUCTION_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
+         PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
+
+export default class TopLevelAssertionNode extends NonTerminalNode {
+  isSatisfiable() {
+    let satisfiable = false;
+
+    this.someChildNode((childNode, index) => {
+      const terminalNode = childNode,
+            content = terminalNode.getContent(),
+            contentSatisfiable = (content === SATISFIABLE);
+
+      if (contentSatisfiable) {
+        satisfiable = true;
+      }
+
+      if (index === 0) {
+        return true;
+      }
+    });
+
+    return satisfiable;
+  }
+
+  getLabelNodes() {
+    let labelNodes = [];
+
+    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode();
+
+    if (parenthesisedLabelsNode !== null) {
+      labelNodes = parenthesisedLabelsNode.getLabelNodes();
+    }
+
+    return labelNodes;
+  }
+
+  getProofNode() {
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
+
+    return proofNode;
+  }
+
+  getDeductionNode() {
+    const ruleName = DEDUCTION_RULE_NAME,
+          deductionNode = this.getNodeByRuleName(ruleName);
+
+    return deductionNode;
+  }
+
+  getSuppositionNodes() {
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
+
+    return suppositionNodes;
+  }
+
+  getParenthesisedLabelsNode() {
+    const ruleName = PARENTHESISED_LABELS_RULE_NAME,
+          parenthesisedLabelsNode = this.getNodesByRuleName(ruleName);
+
+    return parenthesisedLabelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/topLevelMetaAssertion.js

@@ -1,7 +1,44 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class TopLevelMetaAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TopLevelMetaAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME, PARENTHESISED_LABEL_RULE_NAME } from "../ruleNames";
+
+export default class TopLevelMetaAssertionNode extends NonTerminalNode {
+  getLabelNode() {
+    const parenthesisedLabelNode = this.getParenthesisedLabelNode(),
+          labelNodes = parenthesisedLabelNode.getLabelNode();
+
+    return labelNodes;
+  }
+
+  getProofNode() {
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
+
+    return proofNode;
+  }
+
+  getDeductionNode() {
+    const ruleName = DEDUCTION_RULE_NAME,
+          deductionNode = this.getNodeByRuleName(ruleName);
+
+    return deductionNode;
+  }
+
+  getSuppositionNodes() {
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
+
+    return suppositionNodes;
+  }
+
+  getParenthesisedLabelNode() {
+    const ruleName = PARENTHESISED_LABEL_RULE_NAME,
+          parenthesisedLabelNode = this.getNodeByRuleName(ruleName);
+
+    return parenthesisedLabelNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/type.js

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

package/src/node/types.js

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