occam-parsers 23.0.146 → 23.0.147

package/src/rule/bnf/callAheadModifier.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import CallAheadModifierBNFNode from "../../node/bnf/callAheadModifier";
 import CallAheadModifierRuleDefinition from "../../definition/callAheadModifierRule";
 
-import { callAheadModifierRuleName } from "../../ruleNames";
+import { CALL_AHEAD_MODIFIER_RULE_NAME } from "../../ruleNames";
 
 export default class CallAheadModifierBNFRule extends Rule {
   static fromNothing() {
-    const name = callAheadModifierRuleName, ///
+    const name = CALL_AHEAD_MODIFIER_RULE_NAME, ///
           callAheadModifierRuleDefinition = CallAheadModifierRuleDefinition.fromNothing(),
           opacity = null,
           definitions = [
             callAheadModifierRuleDefinition
           ],
-          NonTerminalNode = CallAheadModifierBNFNode,  ///
-          callAheadModifierRule = new CallAheadModifierBNFRule(name, opacity, definitions, NonTerminalNode);
+          callAheadModifierRule = new CallAheadModifierBNFRule(name, opacity, definitions);
 
     return callAheadModifierRule;
   }

package/src/rule/bnf/choiceOfParts.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import ChoiceOfPartsBNFNode from "../../node/bnf/choiceOfParts";
 import ChoiceOfPartsDefinition from "../../definition/choiceOfParts";
 
-import { choiceOfPartsRuleName } from "../../ruleNames";
+import { CHOICE_OF_PARTS_RULE_NAME } from "../../ruleNames";
 
 export default class ChoiceOfPartsBNFRule extends Rule {
   static fromNothing() {
-    const name = choiceOfPartsRuleName, ///
+    const name = CHOICE_OF_PARTS_RULE_NAME, ///
           choiceOfPartsDefinition = ChoiceOfPartsDefinition.fromNothing(),
           opacity = null,
           definitions = [
             choiceOfPartsDefinition
           ],
-          NonTerminalNode = ChoiceOfPartsBNFNode, ///
-          choiceOfPartsRule = new ChoiceOfPartsBNFRule(name, opacity, definitions, NonTerminalNode);
+          choiceOfPartsRule = new ChoiceOfPartsBNFRule(name, opacity, definitions);
 
     return choiceOfPartsRule;
   }

package/src/rule/bnf/definition.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import DefinitionBNFNode from "../../node/bnf/definition";
 import DefinitionDefinition from "../../definition/definition";
 
-import { definitionRuleName } from "../../ruleNames";
+import { DEFINITION_RULE_NAME } from "../../ruleNames";
 
 export default class DefinitionBNFRule extends Rule {
   static fromNothing() {
-    const name = definitionRuleName,  ///
+    const name = DEFINITION_RULE_NAME,  ///
           definitionDefinition = DefinitionDefinition.fromNothing(),
           opacity = null,
           definitions = [
             definitionDefinition
           ],
-          NonTerminalNode = DefinitionBNFNode,  ///
-          definitionRule = new DefinitionBNFRule(name, opacity, definitions, NonTerminalNode);
+          definitionRule = new DefinitionBNFRule(name, opacity, definitions);
 
     return definitionRule;
   }

package/src/rule/bnf/definitions.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import DefinitionsBNFNode from "../../node/bnf/definitions";
 import DefinitionsDefinition from "../../definition/definitions";
 
-import { definitionsRuleName } from "../../ruleNames";
+import { DEFINITIONS_RULE_NAME } from "../../ruleNames";
 
 export default class DefinitionsBNFRule extends Rule {
   static fromNothing() {
     const definitionsDefinition = DefinitionsDefinition.fromNothing(),
-          name = definitionsRuleName, ///
+          name = DEFINITIONS_RULE_NAME, ///
           opacity = null,
           definitions = [
             definitionsDefinition
           ],
-          NonTerminalNode = DefinitionsBNFNode, ///
-          definitionsRule = new DefinitionsBNFRule(name, opacity, definitions, NonTerminalNode);
+          definitionsRule = new DefinitionsBNFRule(name, opacity, definitions);
 
     return definitionsRule;
   }

package/src/rule/bnf/document.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import DocumentBNFNode from "../../node/bnf/document";
 import DocumentDefinition from "../../definition/document";
 
-import { documentRuleName } from "../../ruleNames";
+import { DOCUMENT_RULE_NAME } from "../../ruleNames";
 
 export default class DocumentBNFRule extends Rule {
   static fromNothing() {
     const documentDefinition = DocumentDefinition.fromNothing(),
-          name = documentRuleName,  ///
+          name = DOCUMENT_RULE_NAME,  ///
           opacity = null,
           definitions = [
             documentDefinition
           ],
-          NonTerminalNode = DocumentBNFNode,  ///
-          documentRule = new DocumentBNFRule(name, opacity, definitions, NonTerminalNode);
+          documentRule = new DocumentBNFRule(name, opacity, definitions);
 
     return documentRule;
   }

package/src/rule/bnf/endOfLine.js

@@ -3,10 +3,9 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import EndOfLineBNFNode from "../../node/bnf/endOfLine";
 import TerminalSymbolDefinition from "../../definition/terminalSymbol";
 
-import { endOfLineRuleName } from "../../ruleNames";
+import { END_OF_LINE_RULE_NAME } from "../../ruleNames";
 
 const { endOfLine } = specialSymbols;
 
@@ -14,13 +13,12 @@ export default class EndOfLineBNFRule extends Rule {
   static fromNothing() {
     const content = endOfLine,
           endOfLineTerminalSymbolDefinition = TerminalSymbolDefinition.fromContent(content),
-          name = endOfLineRuleName, ///
+          name = END_OF_LINE_RULE_NAME, ///
           opacity = null,
           definitions = [
             endOfLineTerminalSymbolDefinition
           ],
-          NonTerminalNode = EndOfLineBNFNode, ///
-          endOfLineRule = new EndOfLineBNFRule(name, opacity, definitions, NonTerminalNode);
+          endOfLineRule = new EndOfLineBNFRule(name, opacity, definitions);
 
     return endOfLineRule;
   }

package/src/rule/bnf/epsilon.js

@@ -3,10 +3,9 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import EpsilonBNFNode from "../../node/bnf/epsilon";
 import TerminalSymbolDefinition from "../../definition/terminalSymbol";
 
-import { epsilonRuleName } from "../../ruleNames";
+import { EPSILON_RULE_NAME } from "../../ruleNames";
 
 const { epsilon } = specialSymbols;
 
@@ -14,13 +13,12 @@ export default class EpsilonBNFRule extends Rule {
   static fromNothing() {
     const content = epsilon, ///
           epsilonTerminalSymbolDefinition = TerminalSymbolDefinition.fromContent(content),
-          name = epsilonRuleName, ///
+          name = EPSILON_RULE_NAME, ///
           opacity = null,
           definitions = [
             epsilonTerminalSymbolDefinition
           ],
-          NonTerminalNode = EpsilonBNFNode, ///
-          epsilonRule = new EpsilonBNFRule(name, opacity, definitions, NonTerminalNode);
+          epsilonRule = new EpsilonBNFRule(name, opacity, definitions);
 
     return epsilonRule;
   }

package/src/rule/bnf/error.js

@@ -3,23 +3,21 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import ErrorBNFNode from "../../node/bnf/error";
 import ErrorDefinition from "../../definition/error";
 
-import { errorRuleName } from "../../ruleNames";
+import { ERROR_RULE_NAME } from "../../ruleNames";
 
 const { opaque } = specialSymbols;
 
 export default class ErrorBNFRule extends Rule {
   static fromNothing() {
     const errorDefinition = ErrorDefinition.fromNothing(),
-          name = errorRuleName, ///
+          name = ERROR_RULE_NAME, ///
           opacity = opaque, ///
           definitions = [
             errorDefinition
           ],
-          NonTerminalNode = ErrorBNFNode, ///
-          errorRule = new ErrorBNFRule(name, opacity, definitions, NonTerminalNode);
+          errorRule = new ErrorBNFRule(name, opacity, definitions);
 
     return errorRule;
   }

package/src/rule/bnf/name.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import NameBNFNode from "../../node/bnf/name";
 import NameDefinition from "../../definition/name";
 
-import { nameRuleName } from "../../ruleNames";
+import { NAME_RULE_NAME } from "../../ruleNames";
 
 export default class NameBNFRule extends Rule {
   static fromNothing() {
     const nameDefinition = NameDefinition.fromNothing(),
-          name = nameRuleName,  ///
+          name = NAME_RULE_NAME,  ///
           opacity = null,
           definitions = [
             nameDefinition
           ],
-          NonTerminalNode = NameBNFNode,  ///
-          nameRule = new NameBNFRule(name, opacity, definitions, NonTerminalNode);
+          nameRule = new NameBNFRule(name, opacity, definitions);
 
     return nameRule;
   }

package/src/rule/bnf/noWhitespacePart.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import NoWhitespacePartBNFNode from "../../node/bnf/noWhitespacePart";
 import NoWhitespacePartDefinition from "../../definition/noWhitespacePart";
 
-import { noWhitespacePartRuleName } from "../../ruleNames";
+import { NO_WHITESPACE_PART_RULE_NAME } from "../../ruleNames";
 
 export default class NoWhitespacePartBNFRule extends Rule {
   static fromNothing() {
     const noWhitespacePartDefinition = NoWhitespacePartDefinition.fromNothing(),
-          name = noWhitespacePartRuleName,  ///
+          name = NO_WHITESPACE_PART_RULE_NAME,  ///
           opacity = null,
           definitions = [
             noWhitespacePartDefinition
           ],
-          NonTerminalNode = NoWhitespacePartBNFNode,  ///
-          noWhitespacePartRule = new NoWhitespacePartBNFRule(name, opacity, definitions, NonTerminalNode);
+          noWhitespacePartRule = new NoWhitespacePartBNFRule(name, opacity, definitions);
 
     return noWhitespacePartRule;
   }

package/src/rule/bnf/nonTerminalPart.js

@@ -2,16 +2,23 @@
 
 import Rule from "../../rule";
 import RuleNameDefinition from "../../definition/ruleName";
-import NonTerminalPartBNFNode from "../../node/bnf/part/nonTerminal";
 import RuleNameNonTerminalPartRuleDefinition from "../../definition/partRule/nonTerminal/ruleName";
 
-import { nonTerminalPartRuleName, choiceOfPartsRuleName, sequenceOfPartsRuleName } from "../../ruleNames";
+import { CHOICE_OF_PARTS_RULE_NAME, SEQUENCE_OF_PARTS_RULE_NAME, NON_TERMINAL_PART_RULE_NAME } from "../../ruleNames";
 
 export default class NonTerminalPartBNFRule extends Rule {
   static fromNothing() {
-    const name = nonTerminalPartRuleName, ///
-          choiceOfPartsRuleNameDefinition = RuleNameDefinition.fromRuleName(choiceOfPartsRuleName),
-          sequenceOfPartsRuleNameDefinition = RuleNameDefinition.fromRuleName(sequenceOfPartsRuleName),
+    let ruleName;
+
+    const name = NON_TERMINAL_PART_RULE_NAME; ///
+
+    ruleName = CHOICE_OF_PARTS_RULE_NAME;
+
+    const choiceOfPartsRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = SEQUENCE_OF_PARTS_RULE_NAME;
+
+    const sequenceOfPartsRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName),
           ruleNameNonTerminalPartRuleDefinition = RuleNameNonTerminalPartRuleDefinition.fromNothing(),
           opacity = null,
           definitions = [
@@ -19,8 +26,7 @@ export default class NonTerminalPartBNFRule extends Rule {
             sequenceOfPartsRuleNameDefinition,
             ruleNameNonTerminalPartRuleDefinition
           ],
-          NonTerminalNode = NonTerminalPartBNFNode, ///
-          nonTerminalPartRule = new NonTerminalPartBNFRule(name, opacity, definitions, NonTerminalNode);
+          nonTerminalPartRule = new NonTerminalPartBNFRule(name, opacity, definitions);
 
     return nonTerminalPartRule;
   }

package/src/rule/bnf/oneOrMoreQuantifier.js

@@ -3,24 +3,22 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import QuantifierBNFNode from "../../node/bnf/quantifier";
 import QuantifierRuleDefinition from "../../definition/quantifierRule";
 
-import { oneOrMoreQuantifierRuleName } from "../../ruleNames";
+import { ONE_OR_MORE_QUANTIFIER_RULE_NAME } from "../../ruleNames";
 
 const { plus } = specialSymbols;
 
 export default class OneOrMoreQuantifierBNFRule extends Rule {
   static fromNothing() {
-    const name = oneOrMoreQuantifierRuleName, ///
+    const name = ONE_OR_MORE_QUANTIFIER_RULE_NAME, ///
           specialSymbol = plus, ///
           oneOrMoreQuantifierRuleDefinition = QuantifierRuleDefinition.fromSpecialSymbol(specialSymbol),
           opacity = null,
           definitions = [
             oneOrMoreQuantifierRuleDefinition
           ],
-          NonTerminalNode = QuantifierBNFNode,  ///
-          oneOrMoreQuantifierRule = new OneOrMoreQuantifierBNFRule(name, opacity, definitions, NonTerminalNode);
+          oneOrMoreQuantifierRule = new OneOrMoreQuantifierBNFRule(name, opacity, definitions);
 
     return oneOrMoreQuantifierRule;
   }

package/src/rule/bnf/opacityModifier.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import OpacityModifierBNFNode from "../../node/bnf/opacityModifier";
 import OpacityModifierRuleDefinition from "../../definition/opacityModifierRule";
 
-import { opacityModifierRuleName } from "../../ruleNames";
+import { OPACITY_MODIFIER_RULE_NAME } from "../../ruleNames";
 
 export default class OpacityModifierBNFRule extends Rule {
   static fromNothing() {
-    const name = opacityModifierRuleName, ///
+    const name = OPACITY_MODIFIER_RULE_NAME, ///
           opacityModifierRuleDefinition = OpacityModifierRuleDefinition.fromNothing(),
           opacity = null,
           definitions = [
             opacityModifierRuleDefinition
           ],
-          NonTerminalNode = OpacityModifierBNFNode, ///
-          opacityModifierRule = new OpacityModifierBNFRule(name, opacity, definitions, NonTerminalNode);
+          opacityModifierRule = new OpacityModifierBNFRule(name, opacity, definitions);
 
     return opacityModifierRule;
   }

package/src/rule/bnf/optionalQuantifier.js

@@ -3,24 +3,22 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import QuantifierBNFNode from "../../node/bnf/quantifier";
 import QuantifierRuleDefinition from "../../definition/quantifierRule";
 
-import { optionalQuantifierRuleName } from "../../ruleNames";
+import { OPTIONAL_QUANTIFIER_RULE_NAME } from "../../ruleNames";
 
 const { questionMark } = specialSymbols;
 
 export default class OptionalQuantifierBNFRule extends Rule {
   static fromNothing() {
-    const name = optionalQuantifierRuleName,  ///
+    const name = OPTIONAL_QUANTIFIER_RULE_NAME,  ///
           specialSymbol = questionMark, ///
           optionalQuantifierRuleDefinition = QuantifierRuleDefinition.fromSpecialSymbol(specialSymbol),
           opacity = null,
           definitions = [
             optionalQuantifierRuleDefinition
           ],
-          NonTerminalNode = QuantifierBNFNode,  ///
-          optionalQuantifierRule = new OptionalQuantifierBNFRule(name, opacity, definitions, NonTerminalNode);
+          optionalQuantifierRule = new OptionalQuantifierBNFRule(name, opacity, definitions);
 
     return optionalQuantifierRule;
   }

package/src/rule/bnf/part.js

@@ -1,15 +1,14 @@
 "use strict";
 
 import Rule from "../../rule";
-import PartBNFNode from "../../node/bnf/part";
 import TerminalPartRuleDefinition from "../../definition/partRule/terminal";
 import NonTerminalPartRuleDefinition from "../../definition/partRule/nonTerminal";
 
-import { partRuleName } from "../../ruleNames";
+import { PART_RULE_NAME } from "../../ruleNames";
 
 export default class PartBNFRule extends Rule {
   static fromNothing() {
-    const name = partRuleName,  ///
+    const name = PART_RULE_NAME,  ///
           terminalPartRuleDefinition = TerminalPartRuleDefinition.fromNothing(),
           nonTerminalPartRuleDefinition = NonTerminalPartRuleDefinition.fromNothing(),
           opacity = null,
@@ -17,8 +16,7 @@ export default class PartBNFRule extends Rule {
             nonTerminalPartRuleDefinition,
             terminalPartRuleDefinition
           ],
-          NonTerminalNode = PartBNFNode,  ///
-          partRule = new PartBNFRule(name, opacity, definitions, NonTerminalNode);
+          partRule = new PartBNFRule(name, opacity, definitions);
 
     return partRule;
   }

package/src/rule/bnf/partChoice.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import PartChoiceBNFNode from "../../node/bnf/partChoice";
 import PartChoiceDefinition from "../../definition/partChoice";
 
-import { partChoiceRuleName } from "../../ruleNames";
+import { PART_CHOICE_RULE_NAME } from "../../ruleNames";
 
 export default class PartChoiceBNFRule extends Rule {
   static fromNothing() {
-    const name = partChoiceRuleName,  ///
+    const name = PART_CHOICE_RULE_NAME,  ///
           partChoiceDefinition = PartChoiceDefinition.fromNothing(),
           opacity = null,
           definitions = [
             partChoiceDefinition
           ],
-          NonTerminalNode = PartChoiceBNFNode,  ///
-          definitionRule = new PartChoiceBNFRule(name, opacity, definitions, NonTerminalNode);
+          definitionRule = new PartChoiceBNFRule(name, opacity, definitions);
 
     return definitionRule;
   }

package/src/rule/bnf/precedence.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import PrecedenceBNFNode from "../../node/bnf/precedence";
 import PrecedenceDefinition from "../../definition/precedence";
 
-import { precedenceRuleName } from "../../ruleNames";
+import { PRECEDENCE_RULE_NAME } from "../../ruleNames";
 
 export default class PrecedenceBNFRule extends Rule {
   static fromNothing() {
-    const name = precedenceRuleName,  ///
+    const name = PRECEDENCE_RULE_NAME,  ///
           precedenceDefinition = PrecedenceDefinition.fromNothing(),
           opacity = null,
           definitions = [
             precedenceDefinition
           ],
-          NonTerminalNode = PrecedenceBNFNode,  ///
-          precedenceRule = new PrecedenceBNFRule(name, opacity, definitions, NonTerminalNode);
+          precedenceRule = new PrecedenceBNFRule(name, opacity, definitions);
 
     return precedenceRule;
   }

package/src/rule/bnf/quantifier.js

@@ -1,25 +1,33 @@
 "use strict";
 
 import Rule from "../../rule";
-import PartBNFNode from "../../node/bnf/part";
 import RuleNameDefinition from "../../definition/ruleName";
 
-import { quantifierRuleName, optionalQuantifierRuleName, oneOrMoreQuantifierRuleName, zeroOrMoreQuantifierRuleName } from "../../ruleNames";
+import { QUANTIFIER_RULE_NAME, OPTIONAL_QUANTIFIER_RULE_NAME, ONE_OR_MORE_QUANTIFIER_RULE_NAME, ZERO_OR_MORE_QUANTIFIER_RULE_NAME } from "../../ruleNames";
 
 export default class QuantifierBNFRule extends Rule {
   static fromNothing() {
-    const name = quantifierRuleName,  ///
-          optionalQuantifierRuleNameDefinition = RuleNameDefinition.fromRuleName(optionalQuantifierRuleName),
-          oneOrMoreQuantifierRuleNameDefinition = RuleNameDefinition.fromRuleName(oneOrMoreQuantifierRuleName),
-          zeroOrMoreQuantifierRuleNameDefinition = RuleNameDefinition.fromRuleName(zeroOrMoreQuantifierRuleName),
+    let ruleName;
+    const name = QUANTIFIER_RULE_NAME;  ///
+
+    ruleName = OPTIONAL_QUANTIFIER_RULE_NAME
+
+    const optionalQuantifierRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = ONE_OR_MORE_QUANTIFIER_RULE_NAME;
+
+    const oneOrMoreQuantifierRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = ZERO_OR_MORE_QUANTIFIER_RULE_NAME;
+
+    const zeroOrMoreQuantifierRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName),
           opacity = null,
           definitions = [
             optionalQuantifierRuleNameDefinition,
             oneOrMoreQuantifierRuleNameDefinition,
             zeroOrMoreQuantifierRuleNameDefinition
           ],
-          NonTerminalNode = PartBNFNode,  ///
-          quantifierRule = new QuantifierBNFRule(name, opacity, definitions, NonTerminalNode);
+          quantifierRule = new QuantifierBNFRule(name, opacity, definitions);
 
     return quantifierRule;
   }

package/src/rule/bnf/regularExpression.js

@@ -3,10 +3,9 @@
 import { types } from "occam-lexers";
 
 import Rule from "../../rule";
-import RegularExpressionBNFNode from "../../node/bnf/regularExpression";
 import SignificantTokenTypeDefinition from "../../definition/significantTokenType";
 
-import { regularExpressionRuleName } from "../../ruleNames";
+import { REGULAR_EXPRESSION_RULE_NAME } from "../../ruleNames";
 
 const { regularExpressionType } = types;
 
@@ -14,13 +13,12 @@ export default class RegularExpressionBNFRule extends Rule {
   static fromNothing() {
     const significantTokenType = regularExpressionType,  ///
           regularExpressionSignificantTokenTypeDefinition = SignificantTokenTypeDefinition.fromSignificantTokenType(significantTokenType),
-          name = regularExpressionRuleName, ///
+          name = REGULAR_EXPRESSION_RULE_NAME, ///
           opacity = null,
           definitions = [
             regularExpressionSignificantTokenTypeDefinition
           ],
-          NonTerminalNode = RegularExpressionBNFNode, ///
-          regularExpressionRule = new RegularExpressionBNFRule(name, opacity, definitions, NonTerminalNode);
+          regularExpressionRule = new RegularExpressionBNFRule(name, opacity, definitions);
 
     return regularExpressionRule;
   }

package/src/rule/bnf/rule.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import RuleBNFNode from "../../node/bnf/rule";
 import RuleDefinition from "../../definition/rule";
 
-import { ruleRuleName } from "../../ruleNames";
+import { RULE_RULE_NAME } from "../../ruleNames";
 
 export default class RuleBNFRule extends Rule {
   static fromNothing() {
     const ruleDefinition = RuleDefinition.fromNothing(),
-          name = ruleRuleName,  ///
+          name = RULE_RULE_NAME,  ///
           opacity = null,
           definitions = [
             ruleDefinition
           ],
-          NonTerminalNode = RuleBNFNode,  ///
-          ruleRule = new RuleBNFRule(name, opacity, definitions, NonTerminalNode);
+          ruleRule = new RuleBNFRule(name, opacity, definitions);
 
     return ruleRule;
   }

package/src/rule/bnf/ruleName.js

@@ -2,20 +2,18 @@
 
 import Rule from "../../rule";
 import NameDefinition from "../../definition/name";
-import RuleNameBNFNode from "../../node/bnf/ruleName";
 
-import { ruleNameRuleName } from "../../ruleNames";
+import { RULE_NAME_RULE_NAME } from "../../ruleNames";
 
 export default class RuleNameBNFRule extends Rule {
   static fromNothing() {
     const nameDefinition = NameDefinition.fromNothing(),
-          name = ruleNameRuleName,  ///
+          name = RULE_NAME_RULE_NAME,  ///
           opacity = null,
           definitions = [
             nameDefinition  ///
           ],
-          NonTerminalNode = RuleNameBNFNode,  ///
-          ruleNameRule = new RuleNameBNFRule(name, opacity, definitions, NonTerminalNode);
+          ruleNameRule = new RuleNameBNFRule(name, opacity, definitions);
 
     return ruleNameRule;
   }

package/src/rule/bnf/sequenceOfParts.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import SequenceOfPartsBNFNode from "../../node/bnf/sequenceOfParts";
 import SequenceOfPartsDefinition from "../../definition/sequenceOfParts";
 
-import { sequenceOfPartsRuleName } from "../../ruleNames";
+import { SEQUENCE_OF_PARTS_RULE_NAME } from "../../ruleNames";
 
 export default class SequenceOfPartsBNFRule extends Rule {
   static fromNothing() {
-    const name = sequenceOfPartsRuleName, ///
+    const name = SEQUENCE_OF_PARTS_RULE_NAME, ///
           sequenceOfPartsDefinition = SequenceOfPartsDefinition.fromNothing(),
           opacity = null,
           definitions = [
             sequenceOfPartsDefinition
           ],
-          NonTerminalNode = SequenceOfPartsBNFNode, ///
-          sequenceOfPartsRule = new SequenceOfPartsBNFRule(name, opacity, definitions, NonTerminalNode);
+          sequenceOfPartsRule = new SequenceOfPartsBNFRule(name, opacity, definitions);
 
     return sequenceOfPartsRule;
   }

package/src/rule/bnf/significantTokenType.js

@@ -3,10 +3,9 @@
 import { types } from "occam-lexers";
 
 import Rule from "../../rule";
-import SignificantTokenTypeBNFNode from "../../node/bnf/significantTokenType";
 import SignificantTokenTypeDefinition from "../../definition/significantTokenType";
 
-import { significantTokenTypeRuleName } from "../../ruleNames";
+import { SIGNIFICANT_TOKEN_TYPE_RULE_NAME } from "../../ruleNames";
 
 const { typeType } = types;
 
@@ -14,13 +13,12 @@ export default class SignificantTokenTypeBNFRule extends Rule {
   static fromNothing() {
     const significantTokenType = typeType,  ///
           typeSignificantTokenTypeDefinition = SignificantTokenTypeDefinition.fromSignificantTokenType(significantTokenType),
-          name = significantTokenTypeRuleName,  ///
+          name = SIGNIFICANT_TOKEN_TYPE_RULE_NAME,  ///
           opacity = null,
           definitions = [
             typeSignificantTokenTypeDefinition
           ],
-          NonTerminalNode = SignificantTokenTypeBNFNode,  ///
-          significantTokenTypeRule = new SignificantTokenTypeBNFRule(name, opacity, definitions, NonTerminalNode);
+          significantTokenTypeRule = new SignificantTokenTypeBNFRule(name, opacity, definitions);
 
     return significantTokenTypeRule;
   }