occam-verify-cli 1.0.317 → 1.0.320

package/src/dom/property.js

@@ -28,7 +28,7 @@ export default domAssigned(class Property {
     this.type = type;
   }
 
-  matchTypeName(typeName) { return this.type.matchTypeName(typeName); }
+  matchTypeName(typeName, prefixed, context) { return this.type.matchTypeName(typeName, prefixed, context); }
 
   matchPropertyName(propertyName) {
     const propertyNameMatches = (this.name === propertyName);

package/src/dom/topLevelAssertion.js

@@ -68,21 +68,9 @@ export default class TopLevelAssertion {
     return this.hypotheses;
   }
 
-  setContext(context) { this.context = context; }
-
-  setString(string) { this.string = string; }
-
-  setLabels(labels) { this.labels = labels; }
-
-  setSuppositions(suppositions) { this.suppositions = suppositions; }
-
-  setDeduction(deduction) { this.deduction = deduction; }
-
-  setProof(proof) { this.proof = proof; }
-
-  setSignature(signature) { this.signature = signature; }
-
-  setHypotheses(hypotheses) { this.hypotheses = hypotheses; }
+  setHypotheses(hypotheses) {
+    this.hypotheses = hypotheses;
+  }
 
   getStatement() { return this.deduction.getStatement(); }
 

package/src/dom/type.js

@@ -7,13 +7,14 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../constants";
 import { typeFromTypeNode } from "../utilities/node";
-import { stringFromTypeNameNameAndSuperTypes } from "../utilities/type";
+import { stringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/type";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
 class Type {
-  constructor(string, name, superTypes, properties, provisional) {
+  constructor(context, string, name, superTypes, properties, provisional) {
+    this.context = context;
     this.string = string;
     this.name = name;
     this.superTypes = superTypes;
@@ -21,6 +22,10 @@ class Type {
     this.provisional = provisional;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getString() {
     return this.string;
   }
@@ -67,10 +72,6 @@ class Type {
     return provisional;
   }
 
-  setString(string) {
-    this.string = string;
-  }
-
   setName(name) {
     this.name = name;
   }
@@ -87,6 +88,42 @@ class Type {
     this.provisional = provisional;
   }
 
+  getPrefix() {
+    let prefix = null;
+
+    if (this.context !== null) {
+      const typePrefix = this.context.getTypePrefix();
+
+      prefix = typePrefix;  ///
+    }
+
+    return prefix;
+  }
+
+  isInternal(context) {
+    let internal,
+        fileContext,
+        releaseContext;
+
+    if (this.context !== null) {
+      fileContext = this.context; ///
+
+      releaseContext = fileContext.getReleaseContext();
+
+      const internalReleaseContext = releaseContext; ///
+
+      fileContext = context;  ///
+
+      releaseContext = fileContext.getReleaseContext();
+
+      internal = (internalReleaseContext === releaseContext); ///
+    } else {
+      internal = false;
+    }
+
+    return internal;
+  }
+
   isBasic() {
     let basic = false;
 
@@ -182,8 +219,22 @@ class Type {
     return equalToOrSuperTypeOf;
   }
 
-  matchTypeName(typeName) {
-    const typeNameMatches = (this.name === typeName);
+  matchTypeName(typeName, prefixed, context) {
+    let typeNameMatches;
+
+    const naked = !prefixed,
+          internal = this.isInternal(context);
+
+    if (naked || internal) {
+      typeNameMatches = (this.name === typeName);
+    } else {
+      const prefix = this.getPrefix(),
+            name = (prefix !== null) ?
+                    `${prefix}${this.name}` :
+                       this.name;
+
+      typeNameMatches = (name === typeName);
+    }
 
     return typeNameMatches;
   }
@@ -226,8 +277,9 @@ class Type {
           properties = propertiesFromJSON(json, context),
           superTypes = superTypesFromJSON(json, context),
           typeName = name,  ///
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
+          typePrefixName = null,
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(context, string, name, superTypes, properties, provisional);
 
     return type;
   }
@@ -246,16 +298,18 @@ class Type {
   }
 
   static fromTypeAndProvisional(type, provisional) {
-    const name = type.getName(),
+    const context = type.getContext(),
+          name = type.getName(),
           superType = type, ///
           typeName = name,  ///
+          typePrefixName = null,
           superTypes = [
             superType
           ],
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
           properties = type.getProperties();
 
-    type = new Type(string, name, superTypes, properties, provisional);  ///
+    type = new Type(context, string, name, superTypes, properties, provisional);  ///
 
     return type;
   }
@@ -271,10 +325,11 @@ class Type {
     const properties = [],
           provisional = simpleTypeDeclarationNode.isProvisional(),
           typeName = simpleTypeDeclarationNode.getTypeName(),
+          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
           name = typeName,  ///
           superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(context, string, name, superTypes, properties, provisional);
 
     return type;
   }
@@ -282,11 +337,12 @@ class Type {
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
     const provisional = complexTypeDeclarationNode.isProvisional(),
           typeName = complexTypeDeclarationNode.getTypeName(),
-          name = typeName,
+          typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),
+          name = typeName,  ///
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
+          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
+          type = new Type(context, string, name, superTypes, properties, provisional);
 
     return type;
   }
@@ -348,12 +404,13 @@ function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, co
 
 class ObjectType extends Type {
   static fromNothing() {
-    const name = OBJECT_TYPE_NAME,
+    const context = null,
+          name = OBJECT_TYPE_NAME,
           string = name,  ///
           superTypes = [],
           properties = [],
           provisional = false,
-          objectType = new ObjectType(string, name, superTypes, properties, provisional);
+          objectType = new ObjectType(context, string, name, superTypes, properties, provisional);
 
     return objectType;
   }

package/src/dom/typePrefix.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { domAssigned } from "../dom";
+
+class TypePrefix {
+  constructor(string, name) {
+    this.string = string;
+    this.name = name;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  matchTypePrefixName(typePrefixName) {
+    const typePrefixNameMatches = (this.name === typePrefixName);
+
+    return typePrefixNameMatches;
+  }
+
+  toJSON() {
+    const name = this.name,
+          json = {
+            name
+          };
+
+    return json;
+  }
+
+  static name = "TypePrefix";
+
+  static fromJSON(json, context) {
+    const { name } = json,
+          string = name,  ///
+          typePrefix = new TypePrefix(string, name);
+
+    return typePrefix;
+  }
+
+  static fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context) {
+    const typePrefix = typePrefixDeclarationNode.getTypePrefix(),
+          name = typePrefix,  ///
+          string = name,  ///
+          type = new TypePrefix(string, name);
+
+    return type;
+  }
+}
+
+export default domAssigned(TypePrefix);

package/src/dom/variable.js

@@ -217,7 +217,7 @@ export default domAssigned(class Variable {
     const { Variable } = dom,
           provisional = variableDeclarationNode.isProvisional(),
           typeNode = variableDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode);
+          type = typeFromTypeNode(typeNode, context);
 
     type.setProvisional(provisional);
 

package/src/index.js

@@ -25,6 +25,7 @@ import Judgement from "./dom/judgement";
 import MetaLemma from "./dom/metaLemma";
 import Deduction from "./dom/deduction";
 import Signature from "./dom/signature";
+import TypePrefix from "./dom/typePrefix";
 import Conjecture from "./dom/conjecture";
 import Conclusion from "./dom/conclusion";
 import Derivation from "./dom/derivation";
@@ -53,6 +54,7 @@ import SimpleTypeDeclaration from "./dom/declaration/simpleType";
 import StatementSubstitution from "./dom/substitution/statement";
 import ReferenceSubstitution from "./dom/substitution/reference";
 import CombinatorDeclaration from "./dom/declaration/combinator";
+import TypePrefixDeclaration from "./dom/declaration/typePrefix";
 import ConstructorDeclaration from "./dom/declaration/constructor";
 import ComplexTypeDeclaration from "./dom/declaration/complexType";
 import MetavariableDeclaration from "./dom/declaration/metavariable";

package/src/node/declaration/complexType.js

@@ -28,6 +28,13 @@ export default class ComplexTypeDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  isPrefixed() {
+    const typeNode = this.getTypeNode(),
+          prefixed = typeNode.isPrefixed();
+
+    return prefixed;
+  }
+
   getTypeName() {
     const typeNode = this.getTypeNode(),
           typeName = typeNode.getTypeName();
@@ -63,6 +70,13 @@ export default class ComplexTypeDeclarationNode extends NonTerminalNode {
     return superTypeNodes;
   }
 
+  getTypePrefixName() {
+    const typeNode = this.getTypeNode(),
+          typePrefixName = typeNode.getTypePrefixName();
+
+    return typePrefixName;
+  }
+
   getPropertyDeclarationNodes() {
     const ruleName = PROPERTY_DECLARATION_RULE_NAME,
           propertyDeclarationNodes = this.getNodesByRuleName(ruleName);

package/src/node/declaration/simpleType.js

@@ -28,6 +28,13 @@ export default class SimpleTypeDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  isPrefixed() {
+    const typeNode = this.getTypeNode(),
+          prefixed = typeNode.isPrefixed();
+
+    return prefixed;
+  }
+
   getTypeName() {
     let typeName = null;
 
@@ -54,6 +61,13 @@ export default class SimpleTypeDeclarationNode extends NonTerminalNode {
     return typesNode;
   }
 
+  getTypePrefixName() {
+    const typeNode = this.getTypeNode(),
+          typePrefixName = typeNode.getTypePrefixName();
+
+    return typePrefixName;
+  }
+
   getSuperTypeNodes() {
     let superTypeNodes = [];
 

package/src/node/declaration/typePrefix.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { TYPE_PREFIX_RULE_NAME } from "../../ruleNames";
+
+export default class TypePrefixDeclarationNode extends NonTerminalNode {
+  getTypePrefix() {
+    const typePrefixNode = this.getTypePrefixNode(),
+          typePrefixName = typePrefixNode.getTypePrefixName();
+
+    return typePrefixName;
+  }
+
+  getTypePrefixNode() {
+    const ruleName = TYPE_PREFIX_RULE_NAME,
+          typePrefixNode = this.getNodeByRuleName(ruleName);
+
+    return typePrefixNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypePrefixDeclarationNode, ruleName, childNodes, opacity, precedence); }
+}
+

package/src/node/type.js

@@ -3,15 +3,23 @@
 import NonTerminalNode from "../node/nonTerminal";
 
 export default class TypeNode extends NonTerminalNode {
+  isPrefixed() {
+    const multiplicity = this.getMultiplicity(),
+          prefixed = (multiplicity > 1);
+
+    return prefixed;
+  }
+
   getTypeName() {
     let typeName;
 
-    this.someChildNode((childNode) => {
-      const childNodeTerminalNode = childNode.isTerminalNode();
+    const prefixed = this.isPrefixed(),
+          nameIndex = prefixed ? 2 : 0;
 
-      if (childNodeTerminalNode) {
-        const terminalNode = childNode, ///
-              content = terminalNode.getContent();
+    this.someChildNode((childNode, index) => {
+      if (index === nameIndex) {
+        const typeTerminalNode = childNode, ///
+              content = typeTerminalNode.getContent();
 
         typeName = content; ///
 
@@ -22,23 +30,27 @@ export default class TypeNode extends NonTerminalNode {
     return typeName;
   }
 
-  getTypePrefix() {
-    let typePrefix;
+  getTypePrefixName() {
+    let typePrefixName = null;
 
-    this.someChildNode((childNode) => {
-      const childNodeTerminalNode = childNode.isTerminalNode();
+    const prefixed = this.isPrefixed();
 
-      if (childNodeTerminalNode) {
-        const terminalNode = childNode, ///
-          content = terminalNode.getContent();
+    if (prefixed) {
+      const prefixIndex = 0;
 
-        typePrefix = content; ///
+      this.someChildNode((childNode, index) => {
+        if (index === prefixIndex) {
+          const typeTerminalNode = childNode, ///
+                content = typeTerminalNode.getContent();
 
-        return true;
-      }
-    });
+          typePrefixName = content; ///
+
+          return true;
+        }
+      });
+    }
 
-    return typePrefix;
+    return typePrefixName;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeNode, ruleName, childNodes, opacity, precedence); }

package/src/node/typePrefix.js

@@ -3,8 +3,8 @@
 import NonTerminalNode from "../node/nonTerminal";
 
 export default class TypePrefixNode extends NonTerminalNode {
-  getTypePrefix() {
-    let typePrefix;
+  getTypePrefixName() {
+    let typePrefixName;
 
     this.someChildNode((childNode) => {
       const childNodeTerminalNode = childNode.isTerminalNode();
@@ -13,13 +13,13 @@ export default class TypePrefixNode extends NonTerminalNode {
         const terminalNode = childNode, ///
               content = terminalNode.getContent();
 
-        typePrefix = content; ///
+        typePrefixName = content; ///
 
         return true;
       }
     });
 
-    return typePrefix;
+    return typePrefixName;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypePrefixNode, ruleName, childNodes, opacity, precedence); }

package/src/nonTerminalNodeMap.js

@@ -22,7 +22,7 @@ import PropertyNode from "./node/property";
 import MetaTypeNode from "./node/metaType";
 import EqualityNode from "./node/equality";
 import VariableNode from "./node/variable";
-import ruleBodyNode from "./node/body/rule";
+import RuleBodyNode from "./node/body/rule";
 import StatementNode from "./node/statement";
 import ReferenceNode from "./node/reference";
 import DeductionNode from "./node/deduction";
@@ -30,37 +30,38 @@ import JudgementNode from "./node/judgement";
 import MetaLemmaNode from "./node/metaLemma";
 import ParameterNode from "./node/parameter";
 import SignatureNode from "./node/signature";
-import axiomBodyNode from "./node/body/axiom";
-import lemmaBodyNode from "./node/body/lemma";
+import AxiomBodyNode from "./node/body/axiom";
+import LemmaBodyNode from "./node/body/lemma";
 import DerivationNode from "./node/derivation";
 import CombinatorNode from "./node/combinator";
 import ConclusionNode from "./node/conclusion";
 import ConjectureNode from "./node/conjecture";
 import HypothesisNode from "./node/hypothesis";
-import ruleHeaderNode from "./node/header/rule";
+import TypePrefixNode from "./node/typePrefix";
+import RuleHeaderNode from "./node/header/rule";
 import SuppositionNode from "./node/supposition";
 import ConstructorNode from "./node/constructor";
 import DeclarationNode from "./node/declaration";
 import MetatheoremNode from "./node/metatheorem";
-import theoremBodyNode from "./node/body/theorem";
-import axiomHeaderNode from "./node/header/axiom";
-import lemmaHeaderNode from "./node/header/lemma";
+import TheoremBodyNode from "./node/body/theorem";
+import AxiomHeaderNode from "./node/header/axiom";
+import LemmaHeaderNode from "./node/header/lemma";
 import MetaArgumentNode from "./node/metaArgument";
 import MetavariableNode from "./node/metavariable";
 import QualificationNode from "./node/qualification";
-import theoremHeaderNode from "./node/header/theorem";
-import metaLemmaBodyNode from "./node/body/metaLemma";
 import ProcedureCallNode from "./node/procedureCall";
 import SubDerivationNode from "./node/subDerivation";
+import TheoremHeaderNode from "./node/header/theorem";
+import MetaLemmaBodyNode from "./node/body/metaLemma";
 import TypeAssertionNode from "./node/assertion/type";
-import conjectureBodyNode from "./node/body/conjecture";
-import metatheoremBodyNode from "./node/body/metatheorem";
-import metaLemmaHeaderNode from "./node/header/metaLemma";
+import ConjectureBodyNode from "./node/body/conjecture";
+import MetatheoremBodyNode from "./node/body/metatheorem";
+import MetaLemmaHeaderNode from "./node/header/metaLemma";
 import PropertyRelationNode from "./node/propertyRelation"
 import DefinedAssertionNode from "./node/assertion/defined";
 import TermSubstitutionNode from "./node/substitution/term";
-import conjectureHeaderNode from "./node/header/conjecture";
-import metatheoremHeaderNode from "./node/header/metatheorem";
+import ConjectureHeaderNode from "./node/header/conjecture";
+import MetatheoremHeaderNode from "./node/header/metatheorem";
 import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
 import FrameSubstitutionNode from "./node/substitution/frame";
@@ -69,13 +70,14 @@ import ContainedAssertionNode from "./node/assertion/contained";
 import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
-import variableDeclarationNode from "./node/declaration/variable";
+import VariableDeclarationNode from "./node/declaration/variable";
 import StatementSubstitutionNode from "./node/substitution/statement";
 import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
-import combinatorDeclarationNode from "./node/declaration/combinator";
-import complexTypeDeclarationNode from "./node/declaration/complexType";
-import constructorDeclarationNode from "./node/declaration/constructor";
-import metavariableDeclarationNode from "./node/declaration/metavariable";
+import CombinatorDeclarationNode from "./node/declaration/combinator";
+import TypePrefixDeclarationNode from "./node/declaration/typePrefix";
+import ComplexTypeDeclarationNode from "./node/declaration/complexType";
+import DonstructorDeclarationNode from "./node/declaration/constructor";
+import MetavariableDeclarationNode from "./node/declaration/metavariable";
 
 import { RULE_RULE_NAME,
          STEP_RULE_NAME,
@@ -114,10 +116,11 @@ import { RULE_RULE_NAME,
          HYPOTHESIS_RULE_NAME,
          AXIOM_BODY_RULE_NAME,
          LEMMA_BODY_RULE_NAME,
+         TYPE_PREFIX_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
          RULE_HEADER_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          DECLARATION_RULE_NAME,
-         SUPPOSITION_RULE_NAME,
          METATHEOREM_RULE_NAME,
          AXIOM_HEADER_RULE_NAME,
          LEMMA_HEADER_RULE_NAME,
@@ -151,6 +154,7 @@ import { RULE_RULE_NAME,
          COMBINATOR_DECLARATION_RULE_NAME,
          SIMPLE_TYPE_DECLARATION_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
+         TYPE_PREFIX_DECLARATION_RULE_NAME,
          COMPLEX_TYPE_DECLARATION_RULE_NAME,
          METAVARIABLE_DECLARATION_RULE_NAME } from "./ruleNames";
 
@@ -176,7 +180,7 @@ const NonTerminalNodeMap = {
   [EQUALITY_RULE_NAME]: EqualityNode,
   [VARIABLE_RULE_NAME]: VariableNode,
   [NONSENSE_RULE_NAME]: NonsenseNode,
-  [RULE_BODY_RULE_NAME]: ruleBodyNode,
+  [RULE_BODY_RULE_NAME]: RuleBodyNode,
   [META_TYPE_RULE_NAME]: MetaTypeNode,
   [SIGNATURE_RULE_NAME]: SignatureNode,
   [REFERENCE_RULE_NAME]: ReferenceNode,
@@ -184,38 +188,39 @@ const NonTerminalNodeMap = {
   [DEDUCTION_RULE_NAME]: DeductionNode,
   [PARAMETER_RULE_NAME]: ParameterNode,
   [STATEMENT_RULE_NAME]: StatementNode,
-  [AXIOM_BODY_RULE_NAME]: axiomBodyNode,
-  [LEMMA_BODY_RULE_NAME]: lemmaBodyNode,
+  [AXIOM_BODY_RULE_NAME]: AxiomBodyNode,
+  [LEMMA_BODY_RULE_NAME]: LemmaBodyNode,
   [META_LEMMA_RULE_NAME]: MetaLemmaNode,
   [COMBINATOR_RULE_NAME]: CombinatorNode,
   [CONCLUSION_RULE_NAME]: ConclusionNode,
   [CONJECTURE_RULE_NAME]: ConjectureNode,
   [DERIVATION_RULE_NAME]: DerivationNode,
   [HYPOTHESIS_RULE_NAME]: HypothesisNode,
-  [RULE_HEADER_RULE_NAME]: ruleHeaderNode,
+  [RULE_HEADER_RULE_NAME]: RuleHeaderNode,
+  [TYPE_PREFIX_RULE_NAME]: TypePrefixNode,
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [DECLARATION_RULE_NAME]: DeclarationNode,
   [METATHEOREM_RULE_NAME]: MetatheoremNode,
-  [AXIOM_HEADER_RULE_NAME]: axiomHeaderNode,
-  [LEMMA_HEADER_RULE_NAME]: lemmaHeaderNode,
-  [THEOREM_BODY_RULE_NAME]: theoremBodyNode,
+  [AXIOM_HEADER_RULE_NAME]: AxiomHeaderNode,
+  [LEMMA_HEADER_RULE_NAME]: LemmaHeaderNode,
+  [THEOREM_BODY_RULE_NAME]: TheoremBodyNode,
   [METAVARIABLE_RULE_NAME]: MetavariableNode,
   [META_ARGUMENT_RULE_NAME]: MetaArgumentNode,
   [QUALIFICATION_RULE_NAME]: QualificationNode,
   [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,
   [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
   [SUB_DERIVATION_RULE_NAME]: SubDerivationNode,
-  [THEOREM_HEADER_RULE_NAME]: theoremHeaderNode,
-  [META_LEMMA_BODY_RULE_NAME]: metaLemmaBodyNode,
-  [CONJECTURE_BODY_RULE_NAME]: conjectureBodyNode,
-  [METATHEOREM_BODY_RULE_NAME]: metatheoremBodyNode,
-  [META_LEMMA_HEADER_RULE_NAME]: metaLemmaHeaderNode,
-  [CONJECTURE_HEADER_RULE_NAME]: conjectureHeaderNode,
+  [THEOREM_HEADER_RULE_NAME]: TheoremHeaderNode,
+  [META_LEMMA_BODY_RULE_NAME]: MetaLemmaBodyNode,
+  [CONJECTURE_BODY_RULE_NAME]: ConjectureBodyNode,
+  [METATHEOREM_BODY_RULE_NAME]: MetatheoremBodyNode,
+  [META_LEMMA_HEADER_RULE_NAME]: MetaLemmaHeaderNode,
+  [CONJECTURE_HEADER_RULE_NAME]: ConjectureHeaderNode,
   [PROPERTY_RELATION_RULE_NAME]: PropertyRelationNode,
   [DEFINED_ASSERTION_RULE_NAME]: DefinedAssertionNode,
   [TERM_SUBSTITUTION_RULE_NAME]: TermSubstitutionNode,
-  [METATHEOREM_HEADER_RULE_NAME]: metatheoremHeaderNode,
+  [METATHEOREM_HEADER_RULE_NAME]: MetatheoremHeaderNode,
   [SUBPROOF_ASSERTION_RULE_NAME]: SubproofAssertionNode,
   [PROPERTY_ASSERTION_RULE_NAME]: PropertyAssertionNode,
   [FRAME_SUBSTITUTION_RULE_NAME]: FrameSubstitutionNode,
@@ -223,14 +228,15 @@ const NonTerminalNodeMap = {
   [SATISFIES_ASSERTION_RULE_NAME]: SatisfiesAssertionNode,
   [CONTAINED_ASSERTION_RULE_NAME]: ContainedAssertionNode,
   [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
-  [VARIABLE_DECLARATION_RULE_NAME]: variableDeclarationNode,
+  [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
-  [COMBINATOR_DECLARATION_RULE_NAME]: combinatorDeclarationNode,
+  [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [SIMPLE_TYPE_DECLARATION_RULE_NAME]: SimpleTypeDeclarationNode,
-  [CONSTRUCTOR_DECLARATION_RULE_NAME]: constructorDeclarationNode,
-  [COMPLEX_TYPE_DECLARATION_RULE_NAME]: complexTypeDeclarationNode,
-  [METAVARIABLE_DECLARATION_RULE_NAME]: metavariableDeclarationNode
+  [TYPE_PREFIX_DECLARATION_RULE_NAME]: TypePrefixDeclarationNode,
+  [CONSTRUCTOR_DECLARATION_RULE_NAME]: DonstructorDeclarationNode,
+  [COMPLEX_TYPE_DECLARATION_RULE_NAME]: ComplexTypeDeclarationNode,
+  [METAVARIABLE_DECLARATION_RULE_NAME]: MetavariableDeclarationNode
 };
 
 export default NonTerminalNodeMap;