occam-verify-cli 1.0.184 → 1.0.192

package/src/dom/type.js

@@ -4,17 +4,14 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { typeFromTypeNode } from "../utilities/node";
-import { superTypesStringFromSuperTypes } from "../utilities/type";
+import { stringFromTypeNameNameAndSuperTypes } from "../utilities/type";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
-const typeAssertionTypeNodeQuery = nodeQuery("/typeAssertion/type");
-
 class Type {
   constructor(string, name, superTypes, properties, provisional) {
     this.string = string;
@@ -108,15 +105,7 @@ class Type {
   }
 
   isEqualTo(type) {
-    let equalTo = false;
-
-    if (this.type === type) {
-      equalTo = true;
-    } else {
-      if (type.name === null) {
-
-      }
-    }
+    const equalTo = (this === type);
 
     return equalTo;
   }
@@ -224,7 +213,8 @@ class Type {
     const { name, provisional } = json,
           properties = propertiesFromJSON(json, fileContext),
           superTypes = superTypesFromJSON(json, fileContext),
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          typeName = name,  ///
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -237,8 +227,7 @@ class Type {
   }
 
   static fromTypeAssertionNode(typeAssertionNode, fileContext) {
-    const typeAssertionTypeNode = typeAssertionTypeNodeQuery(typeAssertionNode),
-          typeNode = typeAssertionTypeNode, ///
+    const typeNode = typeAssertionNode.getTypeNode(),
           type = typeFromTypeNode(typeNode, fileContext);
 
     return type;
@@ -247,10 +236,11 @@ class Type {
   static fromTypeAndProvisional(type, provisional) {
     const name = type.getName(),
           superType = type, ///
+          typeName = name,  ///
           superTypes = [
             superType
           ],
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           properties = type.getProperties();
 
     type = new Type(string, name, superTypes, properties, provisional);  ///
@@ -264,7 +254,7 @@ class Type {
           typeName = typeDeclarationNode.getTypeName(),
           name = typeName,  ///
           superTypes = superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext),
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -301,7 +291,7 @@ class Type {
           typeName = complexTypeDeclarationNode.getTypeName(),
           name = typeName,
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -310,22 +300,6 @@ class Type {
 
 export default domAssigned(Type);
 
-function stringFromNameAndSuperTypes(name, superTypes) {
-  let string;
-
-  if (name === null) {
-    string = OBJECT_TYPE_NAME;  ///
-  } else {
-    const superTypesString = superTypesStringFromSuperTypes(superTypes);
-
-    string = (superTypesString !== null) ?
-               `${name}:${superTypesString}` :
-                  name; ///
-  }
-
-  return string;
-}
-
 function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
   const superTypeNodes = typeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {

package/src/dom/variable.js

@@ -4,16 +4,12 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import TermSubstitution from "../substitution/term";
 
-import { nodeQuery } from "../utilities/query";
-import { ObjectType } from "./type";
 import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
 import { typeFromTypeNode } from "../utilities/node";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { variableNodeFromVariableString } from "../context/partial/variable";
 
-const termVariableNodeQuery = nodeQuery("/term/variable!");
-
 export default domAssigned(class Variable {
   constructor(string, node, name, type, propertyRelations) {
     this.string = string;
@@ -209,10 +205,10 @@ export default domAssigned(class Variable {
   static fromTermNode(termNode, context) {
     let variable = null;
 
-    const termVariableNode = termVariableNodeQuery(termNode);
+    const singularVariableNode = termNode.getSingularVariableNode();
 
-    if (termVariableNode !== null) {
-      const variableNode = termVariableNode,  ///
+    if (singularVariableNode !== null) {
+      const variableNode = singularVariableNode,  ///
             type = null;
 
       variable = variableFromVariableNodeAndType(variableNode, type, context);
@@ -234,11 +230,7 @@ export default domAssigned(class Variable {
   }
 
   static fromVariableNodeAndType(variableNode, type, context) {
-    let variable = null;
-
-    if (variableNode !== null) {
-      variable = variableFromVariableNodeAndType(variableNode, type, context);
-    }
+    const variable = variableFromVariableNodeAndType(variableNode, type, context);
 
     return variable;
   }

package/src/node/assertion/contained.js

@@ -1,7 +1,45 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ContainedAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeTermNode, isNodeFrameNode, isNodeStatementNode } from "../../utilities/node";
+
+export default class ContainedAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
+
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return termNode;
+  }
+
+  getFrameNode() {
+    const frameNode = this.findChildNode((childNode) => {
+      const childNodeFrameNode = isNodeFrameNode(childNode);
+
+      if (childNodeFrameNode) {
+        return true;
+      }
+    }) || null;
+
+    return frameNode;
+  }
+
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/defined.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class DefinedAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DefinedAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeTermNode, isNodeFrameNode } from "../../utilities/node";
+
+export default class DefinedAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
+
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return termNode;
+  }
+
+  getFrameNode() {
+    const frameNode = this.findChildNode((childNode) => {
+      const childNodeFrameNode = isNodeFrameNode(childNode);
+
+      if (childNodeFrameNode) {
+        return true;
+      }
+    }) || null;
+
+    return frameNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DefinedAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/property.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class PropertyAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeTermNode, isNodePropertyRelationNode } from "../../utilities/node";
+
+export default class PropertyAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
+
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return termNode;
+  }
+
+  getPropertyRelationNode() {
+    const propertyRelationNode = this.findChildNode((childNode) => {
+      const childNodePropertyRelationNode = isNodePropertyRelationNode(childNode);
+
+      if (childNodePropertyRelationNode) {
+        return true;
+      }
+    }) || null;
+
+    return propertyRelationNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/satisfies.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class SatisfiesAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeMetavariableNode } from "../../utilities/node";
+
+export default class SatisfiesAssertionNode extends NonTerminalNode {
+  getMetavariableNode() {
+    const metavariableNode = this.findChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    }) || null;
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/subproof.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class SubproofAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SubproofAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode } from "../../utilities/node";
+
+export default class SubproofAssertionNode extends NonTerminalNode {
+  getStatementNodes() {
+    const statementNodes = this.filterChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    });
+
+    return statementNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/type.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class TypeAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TypeAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeTermNode, isNodeTypeNode } from "../../utilities/node";
+
+export default class TypeAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
+
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return termNode;
+  }
+
+  getTypeNode() {
+    const typeNode = this.findChildNode((childNode) => {
+      const childNodeTypeNode = isNodeTypeNode(childNode);
+
+      if (childNodeTypeNode) {
+        return true;
+      }
+    }) || null;
+
+    return typeNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/axiom.js

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

package/src/node/combinator.js

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

package/src/node/conclusion.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ConclusionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ConclusionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode } from "../utilities/node";
+
+export default class ConclusionNode extends NonTerminalNode {
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConclusionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/conjecture.js

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

package/src/node/constructor.js

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

package/src/node/declaration/combinator.js

@@ -1,17 +1,21 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ContainedDeclarationNode extends Node {
+import { isNodeStatementNode } from "../../utilities/node";
+
+export default class ContainedDeclarationNode extends NonTerminalNode {
   getStatementNode() {
-    const statementNode = this.fromSecondChildNode((secondChildNode) => {
-      const statementNode = secondChildNode;  ///
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
 
-      return statementNode;
-    });
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
 
     return statementNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ContainedDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/complexType.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
 import { PROVISIONAL } from "../../constants";
 import { isNodeTypeNode, isNodePropertyDeclarationNode } from "../../utilities/node";
 
-export default class ComplexTypeDeclarationNode extends Node {
+export default class ComplexTypeDeclarationNode extends NonTerminalNode {
   getTypeName() {
-    let typeName;
+    let typeName = null;
 
     this.someChildNode((childNode) => {
       const childNodeTypeNode = isNodeTypeNode(childNode);
@@ -25,30 +25,35 @@ export default class ComplexTypeDeclarationNode extends Node {
   }
 
   isProvisional() {
-    const provisional = this.fromFirstChildNode((firstChildNode) => {
-      const terminalNode = firstChildNode,  ///
-            content = terminalNode.getContent(),
-            contentProvisional = (content === PROVISIONAL),
-            provisional = contentProvisional; ///
+    let provisional = false;
 
-      return provisional;
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode,
+              content = terminalNode.getContent(),
+              contentProvisional = (content === PROVISIONAL);
+
+        if (contentProvisional) {
+          provisional = true;
+
+          return true;
+        }
+      }
     });
 
     return provisional;
   }
 
   getSuperTypeNodes() {
-    const typeNodes = this.reduceChildNode((typeNodes, childNode) => {
+    const typeNodes = this.filterChildNode((childNode) => {
       const childNodeTypeNode = isNodeTypeNode(childNode);
 
       if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
-
-        typeNodes.push(typeNode);
+        return true;
       }
-
-      return typeNodes;
-    }, []);
+    });
 
     typeNodes.pop();
 
@@ -58,20 +63,16 @@ export default class ComplexTypeDeclarationNode extends Node {
   }
 
   getPropertyDeclarationNodes() {
-    const propertyDeclarationNodes = this.reduceChildNode((propertyDeclarationNodes, childNode) => {
+    const propertyDeclarationNodes = this.filterChildNode((childNode) => {
       const childNodePropertyDeclarationNode = isNodePropertyDeclarationNode(childNode);
 
       if (childNodePropertyDeclarationNode) {
-        const propertyDeclarationNode = childNode;  ///
-
-        propertyDeclarationNodes.push(propertyDeclarationNode);
+        return true;
       }
-
-      return propertyDeclarationNodes;
-    }, []);
+    });
 
     return propertyDeclarationNodes;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ComplexTypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ComplexTypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/constructor.js

@@ -1,51 +1,56 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
 import { PROVISIONALLY } from "../../constants";
+import { isNodeTermNode, isNodeTypeNode } from "../../utilities/node";
 
-export default class ConstructorDeclarationNode extends Node {
+export default class ConstructorDeclarationNode extends NonTerminalNode {
   getTermNode() {
-    const termNode = this.fromSecondChildNode((secondChildNode) => {
-      const termNode = secondChildNode; ///
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
 
-      return termNode;
-    });
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
 
     return termNode;
   }
 
   getTypeNode() {
-    const typeNode = this.fromFourthChildNode((fourthChildNode) => {
-      const typeNode = fourthChildNode; ///
+    const typeNode = this.findChildNode((childNode) => {
+      const childNodeTypeNode = isNodeTypeNode(childNode);
 
-      return typeNode;
+      if (childNodeTypeNode) {
+        return true;
+      }
     }) || null;
 
     return typeNode;
   }
 
   isProvisional() {
-    const provisional = this.fromSecondLastChildNode((secondLastChildNode) => {
-      let provisional = false;
+    let provisional = false;
 
-      const secondLastChildNodeTerminalNode = secondLastChildNode.isTerminalNode();
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
 
-      if (secondLastChildNodeTerminalNode) {
-        const terminalNode = secondLastChildNode, ///
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode,
               content = terminalNode.getContent(),
               contentProvisionally = (content === PROVISIONALLY);
 
         if (contentProvisionally) {
           provisional = true;
+
+          return true;
         }
       }
-
-      return provisional;
     });
 
     return provisional;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }