occam-verify-cli 1.0.428 → 1.0.436

package/src/element/typePrefix.js

@@ -1,20 +1,14 @@
 "use strict";
 
-import { define } from "../elements";
+import Element from "../element";
 
-export default define(class TypePrefix {
-  constructor(string, node, name) {
-    this.string = string;
-    this.node = node;
-    this.name = name;
-  }
+import { define } from "../elements";
 
-  getString() {
-    return this.string;
-  }
+export default define(class TypePrefix extends Element {
+  constructor(context, string, node, name) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.name = name;
   }
 
   getName() {
@@ -41,7 +35,8 @@ export default define(class TypePrefix {
   static fromJSON(json, context) {
     const { name } = json,
           string = name,  ///
-          typePrefix = new TypePrefix(string, name);
+          node = null,
+          typePrefix = new TypePrefix(context, string, node, name);
 
     return typePrefix;
   }

package/src/element/variable.js

@@ -1,30 +1,21 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { EMPTY_STRING } from "../constants";
-import { typeFromTypeNode } from "../utilities/node.old";
 import { instantiateVariable } from "../process/instantiate";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
-export default define(class Variable {
-  constructor(string, node, type, identifier, propertyRelations) {
-    this.string = string;
-    this.node = node;
+export default define(class Variable extends Element {
+  constructor(context, string, node, type, identifier, propertyRelations) {
+    super(context, string, node);
+
     this.type = type;
     this.identifier = identifier;
     this.propertyRelations = propertyRelations;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getIdentifier() {
     return this.identifier;
   }
@@ -43,14 +34,6 @@ export default define(class Variable {
 
   getTypeString() { return this.type.getString(); }
 
-  isEqualTo(variable) {
-    const variableNode = variable.getNode(),
-          matches = this.node.match(variableNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   matchParameter(parameter) {
     const parameterName = parameter.getName(),
           parameterNameMatchesIdentifier = (parameterName === this.identifier),
@@ -197,94 +180,8 @@ export default define(class Variable {
           identifier = variableIdentifier,  ///
           type = typeFromJSON(json, context),
           propertyRelations = [],
-          variable = new Variable(string, node, type, identifier, propertyRelations);
-
-    return variable;
-  }
-
-  static fromTermNode(termNode, context) {
-    let variable = null;
-
-    const singularVariableNode = termNode.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      const variableNode = singularVariableNode,  ///
-            type = null;
-
-      variable = variableFromVariableNodeAndType(variableNode, type);
-    }
-
-    return variable;
-  }
-
-  static fromVariableNode(variableNode, context) {
-    let variable = null;
-
-    if (variableNode !== null) {
-      const type = null;
-
-      variable = variableFromVariableNodeAndType(variableNode, type);
-    }
-
-    return variable;
-  }
-
-  static fromVariableNodeAndType(variableNode, type, context) {
-    const variable = variableFromVariableNodeAndType(variableNode, type);
-
-    return variable;
-  }
-
-  static fromVariableDeclarationNode(variableDeclarationNode, context) {
-    const { Variable } = elements,
-          provisional = variableDeclarationNode.isProvisional(),
-          typeNode = variableDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, context);
-
-    type.setProvisional(provisional);
-
-    const variableNode = variableDeclarationNode.getVariableNode(),
-          variableIdentifier = variableDeclarationNode.getVariableIdentifier(),
-          node = variableNode,  ///
-          identifier = variableIdentifier,  ///
-          string = identifier,  ///
-          propertyRelations = [],
-          variable = new Variable(string, node, type, identifier, propertyRelations);
-
-    return variable;
-  }
-
-  static fromVariableAndPropertyRelation(variable, propertyRelation, context) {
-    let propertyRelations;
-
-    const node = variable.getNode(),
-          type = variable.getType(),
-          identifier = variable.getIdentifier();
-
-    propertyRelations = variable.getPropertyRelations();
-
-    propertyRelations = [
-      ...propertyRelations,
-      propertyRelation
-    ];
-
-    const string = stringFromNameAndPropertyRelations(identifier, propertyRelations);
-
-    variable = new Variable(string, node, type, identifier, propertyRelations);
+          variable = new Variable(context, string, node, type, identifier, propertyRelations);
 
     return variable;
   }
 });
-
-function stringFromNameAndPropertyRelations(identifier, propertyRelations) {
-  const propertyRelationsString = propertyRelations.reduce((propertyRelationsString, propertyRelation) => {
-          const propertyRelationString = propertyRelation.getString();
-
-          propertyRelationsString = `${propertyRelationsString}, ${propertyRelationString}`;
-
-          return propertyRelationsString;
-        }, EMPTY_STRING),
-        string = `${identifier}${propertyRelationsString}`;
-
-  return string;
-}

package/src/element.js

@@ -0,0 +1,29 @@
+"use strict";
+
+export default class Element {
+  constructor(context, string, node) {
+    this.context = context;
+    this.string = string;
+    this.node = node;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  isEQualTo(element) {
+    const elementNode = element.getNode(),
+          matches = this.node.match(elementNode),
+          equalTo = matches;  ///
+
+    return equalTo;
+  }
+}

package/src/node/{nonsense.js → equivalences.js}

@@ -2,6 +2,6 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-export default class NonsenseNode extends NonTerminalNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(NonsenseNode, ruleName, childNodes, opacity, precedence); }
+export default class EquivalencesNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(EquivalencesNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/frame.js

@@ -27,17 +27,22 @@ export default class FrameNode extends NonTerminalNode {
   getMetavariableName() {
     let metavariableName = null;
 
-    const singular = this.isSingular();
+    const metavariableNode = this.getMetavariableNode();
 
-    if (singular) {
-      const singularMetavariableNode = this.getSingularMetavariableNode();
-
-      metavariableName = singularMetavariableNode.getMetavariableName();
+    if (metavariableName !== null) {
+      metavariableName = metavariableNode.getMetavariableName();
     }
 
     return metavariableName;
   }
 
+  getMetavariableNode() {
+    const singularMetavariableNode = this.getSingularMetavariableNode(),
+          metavariableNode = singularMetavariableNode;  ///
+
+    return metavariableNode;
+  }
+
   getMetavariableNodes() {
     const ruleName = METAVARIABLE_RULE_NAME,
           metavariableNodes = this.getNodesByRuleName(ruleName);

package/src/node/procedureReference.js

@@ -3,8 +3,8 @@
 import NonTerminalNode from "../nonTerminalNode";
 
 export default class ProcedureReferenceNode extends NonTerminalNode {
-  getProcedureName() {
-    let procedureName;
+  getName() {
+    let name;
 
     this.someChildNode((childNode) => {
       const childNodeTerminalNode = childNode.isTerminalNode();
@@ -13,13 +13,13 @@ export default class ProcedureReferenceNode extends NonTerminalNode {
         const terminalNode = childNode, ///
               content = terminalNode.getContent();
 
-        procedureName = content; ///
+        name = content; ///
 
         return true;
       }
     });
 
-    return procedureName;
+    return name;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureReferenceNode, ruleName, childNodes, opacity, precedence); }

package/src/node/statement.js

@@ -22,17 +22,22 @@ export default class StatementNode extends NonTerminalNode {
   getMetavariableName() {
     let metavariableName = null;
 
-    const singular = this.isSingular();
+    const metavariableNode = this.getMetavariableNode();
 
-    if (singular) {
-      const singularMetavariableNode = this.getSingularMetavariableNode();
-
-      metavariableName = singularMetavariableNode.getMetavariableName();
+    if (metavariableName !== null) {
+      metavariableName = metavariableNode.getMetavariableName();
     }
 
     return metavariableName;
   }
 
+  getMetavariableNode() {
+    const singularMetavariableNode = this.getSingularMetavariableNode(),
+          metavariableNode = singularMetavariableNode;  ///
+
+    return metavariableNode;
+  }
+
   getSubstitutionNode() {
     const frameSubstitutionNode = this.getFrameSubstitutionNode(),
           termSubstitutionNode = this.getTermSubstitutionNode(),

package/src/node/term.js

@@ -19,6 +19,13 @@ export default class TermNode extends NonTerminalNode {
     return variableIdentifier;
   }
 
+  getVariableNode() {
+    const singularVariableNode = this.getSingularVariableNode(),
+          variableNode = singularVariableNode;  //
+
+    return variableNode;
+  }
+
   isSingular() {
     let singular = false;
 

package/src/nonTerminalNodeMap.js

@@ -15,7 +15,6 @@ import LabelsNode from "./node/labels";
 import SectionNode from "./node/section";
 import PremiseNode from "./node/premise";
 import TheoremNode from "./node/theorem";
-import NonsenseNode from "./node/nonsense";
 import ArgumentNode from "./node/argument";
 import SubproofNode from "./node/subproof";
 import PropertyNode from "./node/property";
@@ -49,6 +48,7 @@ import AxiomHeaderNode from "./node/header/axiom";
 import LemmaHeaderNode from "./node/header/lemma";
 import MetatheoremNode from "./node/metatheorem";
 import EquivalenceNode from "./node/equivalence";
+import EquivalencesNode from "./node/equivalences";
 import MetaArgumentNode from "./node/metaArgument";
 import MetavariableNode from "./node/metavariable";
 import QualificationNode from "./node/qualification";
@@ -99,7 +99,6 @@ import {
   THEOREM_RULE_NAME,
   PREMISE_RULE_NAME,
   SECTION_RULE_NAME,
-  NONSENSE_RULE_NAME,
   ARGUMENT_RULE_NAME,
   SUBPROOF_RULE_NAME,
   PROPERTY_RULE_NAME,
@@ -130,6 +129,7 @@ import {
   CONSTRUCTOR_RULE_NAME,
   METATHEOREM_RULE_NAME,
   EQUIVALENCE_RULE_NAME,
+  EQUIVALENCES_RULE_NAME,
   AXIOM_HEADER_RULE_NAME,
   LEMMA_HEADER_RULE_NAME,
   THEOREM_BODY_RULE_NAME,
@@ -188,7 +188,6 @@ const NonTerminalNodeMap = {
   [SUBPROOF_RULE_NAME]: SubproofNode,
   [EQUALITY_RULE_NAME]: EqualityNode,
   [VARIABLE_RULE_NAME]: VariableNode,
-  [NONSENSE_RULE_NAME]: NonsenseNode,
   [DOCUMENT_RULE_NAME]: DocumentNode,
   [RULE_BODY_RULE_NAME]: RuleBodyNode,
   [META_TYPE_RULE_NAME]: MetaTypeNode,
@@ -218,6 +217,7 @@ const NonTerminalNodeMap = {
   [LEMMA_HEADER_RULE_NAME]: LemmaHeaderNode,
   [THEOREM_BODY_RULE_NAME]: TheoremBodyNode,
   [METAVARIABLE_RULE_NAME]: MetavariableNode,
+  [EQUIVALENCES_RULE_NAME]: EquivalencesNode,
   [META_ARGUMENT_RULE_NAME]: MetaArgumentNode,
   [QUALIFICATION_RULE_NAME]: QualificationNode,
   [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,

package/src/process/instantiate.js

@@ -1,13 +1,10 @@
 "use strict";
 
-import nominalContext from "../context/nominal";
-
 import { ruleFromBNF } from "../utilities/bnf";
-import { BASE_TYPE_SYMBOL } from "../constants";
-import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       variablePlaceholderBNF = ` _ ::= variable... <END_OF_LINE> ; `,
+      referencePlaceholderBNF = ` _ ::= reference... <END_OF_LINE> ; `,
       statementPlaceholderBNF = ` _ ::= statement... <END_OF_LINE> ; `,
       equivalencePlaceholderBNF = ` _ ::= equivalence... <END_OF_LINE> ; `,
       metavariablePlaceholderBNF = ` _ ::= metavariable... <END_OF_LINE> ; `,
@@ -17,6 +14,7 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       referenceSubstitutionPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
       termPlaceholderRule = ruleFromBNF(termPlaceholderBNF),
       variablePlaceholderRule = ruleFromBNF(variablePlaceholderBNF),
+      referencePlaceholderRule = ruleFromBNF(referencePlaceholderBNF),
       statementPlaceholderRule = ruleFromBNF(statementPlaceholderBNF),
       equivalencePlaceholderRule = ruleFromBNF(equivalencePlaceholderBNF),
       metavariablePlaceholderRule = ruleFromBNF(metavariablePlaceholderBNF),
@@ -25,16 +23,12 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       statementSubstitutionPlaceholderRule = ruleFromBNF(statementSubstitutionPlaceholderBNF),
       referenceSubstitutionPlaceholderRule = ruleFromBNF(referenceSubstitutionPlaceholderBNF);
 
-let bracketedConstructorTermNode = null,
-    bracketedCombinatorStatementNode = null;
-
-export const bracketedConstructorTermString = `(${BASE_TYPE_SYMBOL})`;
-export const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
-
 export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
 
 export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
 
+export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
+
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
 
 export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
@@ -49,32 +43,6 @@ export function instantiateStatementSubstitution(string, context) { return insta
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateBracketedConstructorTerm() {
-  if (bracketedConstructorTermNode === null) {
-    const placeholderRule = termPlaceholderRule, ///
-          string = bracketedConstructorTermString,
-          context = nominalContext, ///
-          node = instantiate(placeholderRule, string, context);
-
-    bracketedConstructorTermNode = node;  ///
-  }
-
-  return bracketedConstructorTermNode;
-}
-
-export function instantiateBracketedCombinatorStatement() {
-  if (bracketedCombinatorStatementNode === null) {
-    const placeholderRule = statementPlaceholderRule, ///
-          string = bracketedCombinatorStatementString,  ///
-          context = nominalContext, ///
-          node = instantiate(placeholderRule, string, context);
-
-    bracketedCombinatorStatementNode = node;  ///
-  }
-
-  return bracketedCombinatorStatementNode;
-}
-
 function instantiate(placeholderRule, string, context) {
   let node;
 

package/src/process/verify.js

@@ -1,22 +1,36 @@
 "use strict";
 
-import elements from "../elements";
-
 import { nodeQuery } from "../utilities/query";
 import { isLastRemainingArgumentFunction } from "../utilities/pass";
-
-const nonTerminalNodeQuery = nodeQuery("/*");
-
-const termNodeQuery = nodeQuery("/term"),
+import { termFromTermNode,
+         ruleFromRuleNode,
+         errorFromErrorNode,
+         axiomFromAxiomNode,
+         lemmaFromLemmaNode,
+         sectionFromSectionNode,
+         theoremFromTheoremNode,
+         metaLemmaFromMetaLemmaNode,
+         statementFromStatementNode,
+         conjectureFromConjectureNode,
+         metatheoremFromMetatheoremNode,
+         variableDeclarationFromVariableDeclarationNode,
+         simpleTypeDeclarationFromSimpleTypeDeclarationNode,
+         typePrefixDeclarationFromTypePrefixDeclarationNode,
+         combinatorDeclarationFromCombinatorDeclarationNode,
+         constructorDeclarationFromConstructorDeclarationNode,
+         complexTypeDeclarationFromComplexTypeDeclarationNode,
+         metavariableDeclarationFromMetavariableDeclarationNode } from "../utilities/element";
+
+const nonTerminalNodeQuery = nodeQuery("/*"),
+      termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type"),
-      statementNodeQuery = nodeQuery("/statement");
-
-const errorNodeQuery = nodeQuery("/error"),
       ruleNodeQuery = nodeQuery("/rule"),
+      errorNodeQuery = nodeQuery("/error"),
       axiomNodeQuery = nodeQuery("/axiom"),
       lemmaNodeQuery = nodeQuery("/lemma"),
       sectionNodeQuery = nodeQuery("/section"),
       theoremNodeQuery = nodeQuery("/theorem"),
+      statementNodeQuery = nodeQuery("/statement"),
       metaLemmaNodeQuery = nodeQuery("/metaLemma"),
       conjectureNodeQuery = nodeQuery("/conjecture"),
       metatheoremNodeQuery = nodeQuery("/metatheorem"),
@@ -182,8 +196,7 @@ class TopLevelPass extends Pass {
       run: (errorNode, context) => {
         let success = false;
 
-        const { Error } = elements,
-              error = Error.fromErrorNode(errorNode, context),
+        const error = errorFromErrorNode(errorNode, context),
               errorVerifies = error.verify();
 
         if (errorVerifies) {
@@ -198,8 +211,7 @@ class TopLevelPass extends Pass {
       run: (ruleNode, context) => {
         let success = false;
 
-        const { Rule } = elements,
-              rule = Rule.fromRuleNode(ruleNode, context),
+        const rule = ruleFromRuleNode(ruleNode, context),
               ruleVerifies = rule.verify();
 
         if (ruleVerifies) {
@@ -214,8 +226,7 @@ class TopLevelPass extends Pass {
       run: (axiomNode, context) => {
         let success = false;
 
-        const { Axiom } = elements,
-              axiom = Axiom.fromAxiomNode(axiomNode, context),
+        const axiom = axiomFromAxiomNode(axiomNode, context),
               axiomVerifies = axiom.verify();
 
         if (axiomVerifies) {
@@ -230,8 +241,7 @@ class TopLevelPass extends Pass {
       run: (lemmaNode, context) => {
         let success = false;
 
-        const { Lemma } = elements,
-              lemma = Lemma.fromLemmaNode(lemmaNode, context),
+        const lemma = lemmaFromLemmaNode(lemmaNode, context),
               lemmaVerifies = lemma.verify();
 
         if (lemmaVerifies) {
@@ -246,8 +256,7 @@ class TopLevelPass extends Pass {
       run: (sectionNode, context) => {
         let success = false;
 
-        const { Section } = elements,
-              section = Section.fromSectionNode(sectionNode, context),
+        const section = sectionFromSectionNode(sectionNode, context),
               sectionVerifies = section.verify();
 
         if (sectionVerifies) {
@@ -262,8 +271,7 @@ class TopLevelPass extends Pass {
       run: (theoremNode, context) => {
         let success = false;
 
-        const { Theorem } = elements,
-              theorem = Theorem.fromTheoremNode(theoremNode, context),
+        const theorem = theoremFromTheoremNode(theoremNode, context),
               theoremVerifies = theorem.verify();
 
         if (theoremVerifies) {
@@ -278,8 +286,7 @@ class TopLevelPass extends Pass {
       run: (metaLemmaNode, context) => {
         let success = false;
 
-        const { MetaLemma } = elements,
-              metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, context),
+        const metaLemma = metaLemmaFromMetaLemmaNode(metaLemmaNode, context),
               metaLemmaVerifies = metaLemma.verify();
 
         if (metaLemmaVerifies) {
@@ -294,8 +301,7 @@ class TopLevelPass extends Pass {
       run: (conjectureNode, context) => {
         let success = false;
 
-        const { Conjecture } = elements,
-              conjecture = Conjecture.fromConjectureNode(conjectureNode, context),
+        const conjecture = conjectureFromConjectureNode(conjectureNode, context),
               conjectureVerifies = conjecture.verify();
 
         if (conjectureVerifies) {
@@ -310,8 +316,7 @@ class TopLevelPass extends Pass {
       run: (metatheoremNode, context) => {
         let success = false;
 
-        const { Metatheorem } = elements,
-              metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, context),
+        const metatheorem = metatheoremFromMetatheoremNode(metatheoremNode, context),
               metatheoremVerifies = metatheorem.verify();
 
         if (metatheoremVerifies) {
@@ -326,8 +331,7 @@ class TopLevelPass extends Pass {
       run: (variableDeclarationNode, context) => {
         let success = false;
 
-        const { VariableDeclaration } = elements,
-              variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, context),
+        const variableDeclaration = variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context),
               variableDeclarationVerifies = variableDeclaration.verify();
 
         if (variableDeclarationVerifies) {
@@ -342,8 +346,7 @@ class TopLevelPass extends Pass {
       run: (simpleTypeDeclarationNode, context) => {
         let success = false;
 
-        const { SimpleTypeDeclaration } = elements,
-              simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
+        const simpleTypeDeclaration = simpleTypeDeclarationFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
               simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();
 
         if (simpleTypeDeclarationVerifies) {
@@ -358,8 +361,7 @@ class TopLevelPass extends Pass {
       run: (typePrefixDeclarationNode, context) => {
         let success = false;
 
-        const { TypePrefixDeclaration } = elements,
-              typePrefixDeclaration = TypePrefixDeclaration.fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),
+        const typePrefixDeclaration = typePrefixDeclarationFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),
               typePrefixDeclarationVerifies = typePrefixDeclaration.verify();
 
         if (typePrefixDeclarationVerifies) {
@@ -374,8 +376,7 @@ class TopLevelPass extends Pass {
       run: (combinatorDeclarationNode, context) => {
         let success = false;
 
-        const { CombinatorDeclaration } = elements,
-              combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
+        const combinatorDeclaration = combinatorDeclarationFromCombinatorDeclarationNode(combinatorDeclarationNode, context),
               combinatorDeclarationVerifies = combinatorDeclaration.verify();
 
         if (combinatorDeclarationVerifies) {
@@ -390,8 +391,7 @@ class TopLevelPass extends Pass {
       run: (constructorDeclarationNode, context) => {
         let success = false;
 
-        const { ConstructorDeclaration } = elements,
-              constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, context),
+        const constructorDeclaration = constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context),
               constructorDeclarationVerifies = constructorDeclaration.verify();
 
         if (constructorDeclarationVerifies) {
@@ -406,8 +406,7 @@ class TopLevelPass extends Pass {
       run: (complexTypeDeclarationNode, context) => {
         let success = false;
 
-        const { ComplexTypeDeclaration } = elements,
-              complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        const complexTypeDeclaration = complexTypeDeclarationFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
               complexTypeDeclarationVerifies = complexTypeDeclaration.verify();
 
         if (complexTypeDeclarationVerifies) {
@@ -422,8 +421,7 @@ class TopLevelPass extends Pass {
       run: (metavariableDeclarationNode, context) => {
         let success = false;
 
-        const { MetavariableDeclaration } = elements,
-              metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
+        const metavariableDeclaration = metavariableDeclarationFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
               metavariableDeclarationVerifies = metavariableDeclaration.verify();
 
         if (metavariableDeclarationVerifies) {
@@ -457,8 +455,7 @@ class CombinatorPass extends Pass {
       run: (statementNode, context) => {
         let success = false;
 
-        const { Statement } = elements,
-              statement = Statement.fromStatementNode(statementNode, context),
+        const statement = statementFromStatementNode(statementNode, context),
               assignments = null,
               stated = false,
               statementVerifies = statement.verify(assignments, stated, context);
@@ -475,8 +472,7 @@ class CombinatorPass extends Pass {
       run: (termNode, context) => {
         let success = false;
 
-        const { Term } = elements,
-              term = Term.fromTermNode(termNode, context),
+        const term = termFromTermNode(termNode, context),
               termVerifies = term.verify(context, () => {
                 const verifiesAhead = true;
 
@@ -529,8 +525,7 @@ class ConstructorPass extends Pass {
       run: (termNode, context, verifyAhead) => {
         let success = false;
 
-        const { Term } = elements,
-              term = Term.fromTermNode(termNode, context),
+        const term = termFromTermNode(termNode, context),
               termVerifies = term.verify(context, verifyAhead);
 
         if (termVerifies) {