occam-verify-cli 1.0.192 → 1.0.198

package/src/mixins/term/verify.js

@@ -2,10 +2,6 @@
 
 import dom from "../../dom";
 
-import { nodeQuery } from "../../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
-
 function unifyWithBracketedConstructor(term, context, verifyAhead) {
   let unifiedWithBracketedConstructor;
 
@@ -39,14 +35,12 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
   const { Variable } = dom,
         context = localContext, ///
         termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
-
-  let variable;
-
-  variable = Variable.fromVariableNode(variableNode, context);
+        singularVariableNode = termNode.getSingularVariableNode();
 
-  if (variable !== null) {
-    const termString = term.getString();
+  if (singularVariableNode !== null) {
+    const variableNode = singularVariableNode,
+          variable = Variable.fromVariableNode(variableNode, context),
+          termString = term.getString();
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`);
 

package/src/node/argument.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME } from "../ruleNames";
+
+export default class ArgumentNode extends NonTerminalNode {
+  getSingularTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          singularTermNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ArgumentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assertion/contained.js

@@ -1,42 +1,50 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeTermNode, isNodeFrameNode, isNodeStatementNode } from "../../utilities/node";
+import { MISSING } from "../../constants";
+import { TERM_RULE_NAME, FRAME_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class ContainedAssertionNode extends NonTerminalNode {
-  getTermNode() {
-    const termNode = this.findChildNode((childNode) => {
-      const childNodeTermNode = isNodeTermNode(childNode);
+  isNegated() {
+    let negated = false;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent(),
+              contentMessing = (content === MISSING);
 
-      if (childNodeTermNode) {
-        return true;
+        if (contentMessing) {
+          negated = true;
+
+          return true;
+        }
       }
-    }) || null;
+    });
+
+    return negated;
+  }
+
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
 
     return termNode;
   }
 
   getFrameNode() {
-    const frameNode = this.findChildNode((childNode) => {
-      const childNodeFrameNode = isNodeFrameNode(childNode);
-
-      if (childNodeFrameNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = FRAME_RULE_NAME,
+          frameNode = this.getNodeByRuleName(ruleName);
 
     return frameNode;
   }
 
   getStatementNode() {
-    const statementNode = this.findChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }

package/src/node/assertion/defined.js

@@ -1,30 +1,43 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeTermNode, isNodeFrameNode } from "../../utilities/node";
+import { UNDEFINED } from "../../constants";
+import { FRAME_RULE_NAME, TERM_RULE_NAME } from "../../ruleNames";
 
 export default class DefinedAssertionNode extends NonTerminalNode {
-  getTermNode() {
-    const termNode = this.findChildNode((childNode) => {
-      const childNodeTermNode = isNodeTermNode(childNode);
+  isNegated() {
+    let negated = false;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent(),
+              contentUndefined = (content === UNDEFINED);
 
-      if (childNodeTermNode) {
-        return true;
+        if (contentUndefined) {
+          negated = true;
+
+          return true;
+        }
       }
-    }) || null;
+    });
+
+    return negated;
+  }
+
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
 
     return termNode;
   }
 
   getFrameNode() {
-    const frameNode = this.findChildNode((childNode) => {
-      const childNodeFrameNode = isNodeFrameNode(childNode);
-
-      if (childNodeFrameNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = FRAME_RULE_NAME,
+          frameNode = this.getNodeByRuleName(ruleName);
 
     return frameNode;
   }

package/src/node/assertion/property.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeTermNode, isNodePropertyRelationNode } from "../../utilities/node";
+import { TERM_RULE_NAME, PROPERTY_RELATION_RULE_NAME } from "../../ruleNames";
 
 export default class PropertyAssertionNode extends NonTerminalNode {
   getTermNode() {
-    const termNode = this.findChildNode((childNode) => {
-      const childNodeTermNode = isNodeTermNode(childNode);
-
-      if (childNodeTermNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
 
     return termNode;
   }
 
-  getPropertyRelationNode() {
-    const propertyRelationNode = this.findChildNode((childNode) => {
-      const childNodePropertyRelationNode = isNodePropertyRelationNode(childNode);
-
-      if (childNodePropertyRelationNode) {
-        return true;
-      }
-    }) || null;
+  getFrameNode() {
+    const ruleName = PROPERTY_RELATION_RULE_NAME,
+          propertyRelationNode = this.getNodeByRuleName(ruleName);
 
     return propertyRelationNode;
   }

package/src/node/assertion/satisfies.js

@@ -1,18 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeMetavariableNode } from "../../utilities/node";
+import { TERM_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
 export default class SatisfiesAssertionNode extends NonTerminalNode {
-  getMetavariableNode() {
-    const metavariableNode = this.findChildNode((childNode) => {
-      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
 
-      if (childNodeMetavariableNode) {
-        return true;
-      }
-    }) || null;
+    return termNode;
+  }
+
+  getFrameNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
 
     return metavariableNode;
   }

package/src/node/assertion/subproof.js

@@ -1,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeStatementNode } from "../../utilities/node";
+import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class SubproofAssertionNode extends NonTerminalNode {
   getStatementNodes() {
-    const statementNodes = this.filterChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    });
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNodes = this.getNodesByRuleName(ruleName);
 
     return statementNodes;
   }

package/src/node/assertion/type.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeTermNode, isNodeTypeNode } from "../../utilities/node";
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
 
 export default class TypeAssertionNode extends NonTerminalNode {
   getTermNode() {
-    const termNode = this.findChildNode((childNode) => {
-      const childNodeTermNode = isNodeTermNode(childNode);
-
-      if (childNodeTermNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
 
     return termNode;
   }
 
   getTypeNode() {
-    const typeNode = this.findChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
     return typeNode;
   }

package/src/node/combinator.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 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,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStatementNode } from "../utilities/node";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class ConclusionNode extends NonTerminalNode {
   getStatementNode() {
-    const statementNode = this.findChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }

package/src/node/constructor.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 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,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeStatementNode } from "../../utilities/node";
+import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class ContainedDeclarationNode extends NonTerminalNode {
   getStatementNode() {
-    const statementNode = this.findChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }

package/src/node/declaration/complexType.js

@@ -1,29 +1,11 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONAL } from "../../constants";
-import { isNodeTypeNode, isNodePropertyDeclarationNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, TYPES_RULE_NAME, PROPERTY_DECLARATION_RULE_NAME } from "../../ruleNames";
 
 export default class ComplexTypeDeclarationNode extends NonTerminalNode {
-  getTypeName() {
-    let typeName = null;
-
-    this.someChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
-
-        typeName = typeNode.getTypeName();
-
-        return true;
-      }
-    });
-
-    return typeName;
-  }
-
   isProvisional() {
     let provisional = false;
 
@@ -46,30 +28,44 @@ export default class ComplexTypeDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  getTypeName() {
+    const typeNode = this.getTypeNode(),
+          typeName = typeNode.getTypeName();
+
+    return typeName;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
+  }
+
+  getTypesNode() {
+    const ruleName = TYPES_RULE_NAME,
+          typesNode = this.getNodeByRuleName(ruleName);
+
+    return typesNode;
+  }
+
   getSuperTypeNodes() {
-    const typeNodes = this.filterChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+    let superTypeNodes = [];
 
-      if (childNodeTypeNode) {
-        return true;
-      }
-    });
+    const typesNode = this.getTypesNode();
 
-    typeNodes.pop();
+    if (typesNode !== null) {
+      const typeNodes = typesNode.getTypeNodes();
 
-    const superTypeNodes = typeNodes; ///
+      superTypeNodes = typeNodes; ///
+    }
 
     return superTypeNodes;
   }
 
   getPropertyDeclarationNodes() {
-    const propertyDeclarationNodes = this.filterChildNode((childNode) => {
-      const childNodePropertyDeclarationNode = isNodePropertyDeclarationNode(childNode);
-
-      if (childNodePropertyDeclarationNode) {
-        return true;
-      }
-    });
+    const ruleName = PROPERTY_DECLARATION_RULE_NAME,
+          propertyDeclarationNodes = this.getNodesByRuleName(ruleName);
 
     return propertyDeclarationNodes;
   }

package/src/node/declaration/constructor.js

@@ -1,35 +1,11 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONALLY } from "../../constants";
-import { isNodeTermNode, isNodeTypeNode } from "../../utilities/node";
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
 
 export default class ConstructorDeclarationNode 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;
-  }
-
   isProvisional() {
     let provisional = false;
 
@@ -52,5 +28,19 @@ export default class ConstructorDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/metavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeMetaTypeNode, isNodeMetavariableNode } from "../../utilities/node";
+import { META_TYPE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
 export default class MetavariableDeclarationNode extends NonTerminalNode {
   getTypeNode() {
@@ -13,25 +13,15 @@ export default class MetavariableDeclarationNode extends NonTerminalNode {
   }
 
   getMetaTypeNode() {
-    const metaTypeNode = this.findChildNode((childNode) => {
-      const childNodeMetaTypeNode = isNodeMetaTypeNode(childNode);
-
-      if (childNodeMetaTypeNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = META_TYPE_RULE_NAME,
+          metaTypeNode = this.getNodeByRuleName(ruleName);
 
     return metaTypeNode
   }
 
   getMetavariableNode() {
-    const metavariableNode = this.findChildNode((childNode) => {
-      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
-
-      if (childNodeMetavariableNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
 
     return metavariableNode;
   }

package/src/node/declaration/property.js

@@ -1,40 +1,30 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodeTypeNode, isNodePropertyNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, PROPERTY_RULE_NAME } from "../../ruleNames";
 
 export default class PropertyDeclarationNode extends NonTerminalNode {
-  getTypeNode() {
-    const typeNode = this.findChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
 
-      if (childNodeTypeNode) {
-        return true;
-      }
-    }) || null;
+    return propertyName;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
     return typeNode;
   }
 
   getPropertyNode() {
-    const propertyNode = this.findChildNode((childNode) => {
-      const childNodePropertyNode = isNodePropertyNode(childNode);
-
-      if (childNodePropertyNode) {
-        return true;
-      }
-    }) || null;
+    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(PropertyDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }