occam-furtle 3.0.521 → 3.0.524

package/src/element/reduce.js

@@ -10,7 +10,7 @@ import { LIST_TYPE_NAME } from "../typeNames";
 import { valueFromNominalValue } from "../utilities/value";
 
 const { reduce } = continuationUtilities,
-      { breakable } = breakPointUtilities;
+      { unbreakable } = breakPointUtilities;
 
 export default define(class Reduce extends Element {
   constructor(context, string, node, breakPoint, variable, initialValue, anonymousProcedure) {
@@ -33,10 +33,10 @@ export default define(class Reduce extends Element {
     return this.anonymousProcedure;
   }
 
-  evaluate = breakable(function (context, forward, back) {
+  evaluate = unbreakable(function (context, forward, back) {
     const reduceString = this.getString();
 
-    context.trace(`Evaluating the '${reduceString}' reduce...`);
+    context.trace(`Evaluating the '${reduceString}' function...`);
 
     return this.variable.evaluate(context, (value, back) => {
       const valueType = value.getType(),
@@ -59,7 +59,7 @@ export default define(class Reduce extends Element {
         }, initialValue, (value, back) => {
           const valueString = value.getString();
 
-          context.trace(`...evaluated the '${reduceString}' reduce as '${valueString}'.`);
+          context.trace(`...evaluated the '${reduceString}' function as '${valueString}'.`);
 
           return forward(value, back);
         }, back);

package/src/element/referenceListLiteral.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { Element } from "occam-languages";
+
+import { define } from "../elements";
+
+export default define(class ReferenceListLiteral extends Element {
+  constructor(context, string, node, breakPoint, references) {
+    super(context, string, node, breakPoint);
+
+    this.references = references;
+  }
+
+  getReferences() {
+    return this.references;
+  }
+
+  static name = "ReferenceListLiteral";
+});

package/src/element/references.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { Element } from "occam-languages";
+
+import { define } from "../elements";
+
+export default define(class References extends Element {
+  constructor(context, string, node, breakPoint, array) {
+    super(context, string, node, breakPoint);
+
+    this.array = array;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getLength() {
+    const length = this.array.length;
+
+    return length;
+  }
+
+  getReference(index) {
+    const reference = this.array[index] || null;
+
+    return reference;
+  }
+
+  static name = "References";
+});

package/src/element/some.js

@@ -10,7 +10,7 @@ import { LIST_TYPE_NAME, BOOLEAN_TYPE_NAME } from "../typeNames";
 import { valueFromBoolean, valueFromNominalValue } from "../utilities/value";
 
 const { some } = continuationUtilities,
-      { breakable } = breakPointUtilities;
+      { unbreakable } = breakPointUtilities;
 
 export default define(class Some extends Element {
   constructor(context, string, node, breakPoint, variable, anonymousProcedure) {
@@ -28,10 +28,10 @@ export default define(class Some extends Element {
     return this.anonymousProcedure;
   }
 
-  evaluate = breakable(function (context, forward, back) {
+  evaluate = unbreakable(function (context, forward, back) {
     const someString = this.getString();
 
-    context.trace(`Evaluating the '${someString}' some...`);
+    context.trace(`Evaluating the '${someString}' function...`);
 
     return this.variable.evaluate(context, (value, back) => {
       const valueType = value.getType(),
@@ -50,11 +50,12 @@ export default define(class Some extends Element {
 
       return some(nominalValues, (nominalValue, forward, back) => {
         return this.evaluateAnonymousProcedure(nominalValue, context, forward, back);
-      }, (boolean, back) => {
-        const value = valueFromBoolean(boolean, context),
+      }, context, (context, back) => {
+        const boolean = true,
+              value = valueFromBoolean(boolean, context),
               valueString = value.getString();
 
-        context.trace(`...evaluated the '${someString}' some as '${valueString}'.`);
+        context.trace(`...evaluated the '${someString}' function as '${valueString}'.`);
 
         return forward(value, back);
       }, back);

package/src/element/terms.js

@@ -44,7 +44,7 @@ export default define(class Terms extends Element {
     return this.mapTerm((term, forward, back) => {
       return term.evaluate(context, forward, back);
     }, (valuesArray) => {
-      const valuesString = valuesStringFromValuesArray(valuesArray, context),
+      const valuesString = valuesStringFromValuesArray(valuesArray),
             string = valuesString, ///
             array = valuesArray, ///
             node = null,

package/src/element/values.js

@@ -46,7 +46,7 @@ export default define(class Values extends Element {
     return this.mapValue((value, forward, back) => {
       return value.evaluate(context, forward, back);
     }, (valuesArray, back) => {
-      const valuesString = valuesStringFromValuesArray(valuesArray, context),
+      const valuesString = valuesStringFromValuesArray(valuesArray),
             string = valuesString, ///
             array = valuesArray, ///
             node = null,
@@ -60,13 +60,37 @@ export default define(class Values extends Element {
     }, back);
   }
 
+  merge(values, context) {
+    let array;
+
+    array = values.getArray();
+
+    const valuesArray = [
+            ...this.array,
+            ...array,
+          ],
+          valuesString = valuesStringFromValuesArray(valuesArray),
+          string = valuesString; ///
+
+    array = valuesArray; ///
+
+    const node = null,
+          breakPoint = null;
+
+    context = null;
+
+    values = new Values(context, string, node, breakPoint, array);
+
+    return values;
+  }
+
   static name = "Values";
 
   static fromValue(value, context) {
     const valuesArray = [
             value
           ],
-          valuesString = valuesStringFromValuesArray(valuesArray, context),
+          valuesString = valuesStringFromValuesArray(valuesArray),
           string = valuesString, ///
           array = valuesArray, ///
           node = null,

package/src/example/furtle/bnf.js

@@ -28,7 +28,7 @@ const bnf = `
     
     objectAssignment        ::=  "{" namedBindings "}" "=" variable ";" ;
     
-    listAssignment         ::=  "[" bindings "]" "=" variable ";" ;
+    listAssignment          ::=  "[" bindings "]" "=" variable ";" ;
     
 
 

package/src/node/all.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { VALUES_RULE_NAME, VARIABLE_RULE_NAME, REFERENCE_LIST_LITERAL_RULE_NAME } from "../ruleNames";
+
+export default class AllNode extends NonTerminalNode {
+  getReferencesNode() {
+    const referenceListLiteralNode = this.getReferenceListLiteralNode(),
+          referencesNode = referenceListLiteralNode.getReferencesNode();
+
+    return referencesNode;
+  }
+
+  getValueNodes() {
+    const valuesNode = this.getValuesNode(),
+          valueNodes = valuesNode.getValueNodes();
+
+    return valueNodes;
+  }
+
+  getValuesNode() {
+    const ruleName = VALUES_RULE_NAME,
+          valuesNode = this.getNodeByRuleName(ruleName);
+
+    return valuesNode;
+  }
+
+  getVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
+
+    return variableNode;
+  }
+
+  getReferenceListLiteralNode() {
+    const ruleName = REFERENCE_LIST_LITERAL_RULE_NAME,
+          referenceListLiteralNode = this.getNodeByRuleName(ruleName);
+
+    return referenceListLiteralNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(AllNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/exists.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { VALUES_RULE_NAME, VARIABLE_RULE_NAME, REFERENCE_LIST_LITERAL_RULE_NAME } from "../ruleNames";
+
+export default class ExistsNode extends NonTerminalNode {
+  getReferencesNode() {
+    const referenceListLiteralNode = this.getReferenceListLiteralNode(),
+          referencesNode = referenceListLiteralNode.getReferencesNode();
+
+    return referencesNode;
+  }
+
+  getValueNodes() {
+    const valuesNode = this.getValuesNode(),
+          valueNodes = valuesNode.getValueNodes();
+
+    return valueNodes;
+  }
+
+  getValuesNode() {
+    const ruleName = VALUES_RULE_NAME,
+          valuesNode = this.getNodeByRuleName(ruleName);
+
+    return valuesNode;
+  }
+
+  getVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
+
+    return variableNode;
+  }
+
+  getReferenceListLiteralNode() {
+    const ruleName = REFERENCE_LIST_LITERAL_RULE_NAME,
+          referenceListLiteralNode = this.getNodeByRuleName(ruleName);
+
+    return referenceListLiteralNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ExistsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/expression.js

@@ -2,10 +2,12 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { TERM_RULE_NAME,
+import { ALL_RULE_NAME,
+         TERM_RULE_NAME,
          SOME_RULE_NAME,
          EVERY_RULE_NAME,
          REDUCE_RULE_NAME,
+         EXISTS_RULE_NAME,
          TERNARY_RULE_NAME,
          CONTAINS_RULE_NAME,
          LENGTH_OF_RULE_NAME,
@@ -19,6 +21,13 @@ import { TERM_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
 export default class ExpressionNode extends NonTerminalNode {
+  getAllNode() {
+    const ruleName = ALL_RULE_NAME,
+          allNode = this.getNodeByRuleName(ruleName);
+
+    return allNode;
+  }
+
   getTermNode() {
     const ruleName = TERM_RULE_NAME,
           termNode = this.getNodeByRuleName(ruleName);
@@ -47,6 +56,13 @@ export default class ExpressionNode extends NonTerminalNode {
     return reduceNode;
   }
 
+  getExistsNode() {
+    const ruleName = EXISTS_RULE_NAME,
+          existsNode = this.getNodeByRuleName(ruleName);
+
+    return existsNode;
+  }
+
   getTernaryNode() {
     const ruleName = TERNARY_RULE_NAME,
       ternaryNode = this.getNodeByRuleName(ruleName);

package/src/node/references.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { REFERENCE_RULE_NAME } from "../ruleNames";
+
+export default class ReferencesNode extends NonTerminalNode {
+  getReferenceNodes() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNodes = this.getNodesByRuleName(ruleName);
+
+    return referenceNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferencesNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/referencesListLiteral.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { REFERENCES_RULE_NAME } from "../ruleNames";
+
+export default class ReferencesListLiteralNode extends NonTerminalNode {
+  getReferenceNodes() {
+    const referencesNode = this.getReferencesNode(),
+          referenceNodes = referencesNode.getReferenceNodes();
+
+    return referenceNodes;
+  }
+
+  getReferencesNode() {
+    const ruleName = REFERENCES_RULE_NAME,
+          referencesNode = this.getNodeByRuleName(ruleName);
+
+    return referencesNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferencesListLiteralNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nominalValueProperties.js

@@ -8,10 +8,34 @@ import NominalValueProperty from "./nominalValueProperty";
 
 import { nominalValuePropertiesStringFromNominalValuePropertiesArray } from "./utilities/string";
 import { LIST_TYPE_NAME, STRING_TYPE_NAME, BOOLEAN_TYPE_NAME, NOMINAL_VALUE_TYPE_NAME } from "./typeNames";
-import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME, NO_WHITESPACE_PARAMETER_NAME } from "./parameterNames";
+import { TYPE_PARAMETER_NAME, CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME, NO_WHITESPACE_PARAMETER_NAME } from "./parameterNames";
 
 const { some } = continuationUtilities;
 
+const properties = [
+  {
+    name: TYPE_PARAMETER_NAME,
+    typeName: STRING_TYPE_NAME
+  },
+  {
+    name: CONTENT_PARAMETER_NAME,
+    typeName: STRING_TYPE_NAME
+  },
+  {
+    name: TERMINAL_PARAMETER_NAME,
+    typeName: BOOLEAN_TYPE_NAME
+  },
+  {
+    name: NO_WHITESPACE_PARAMETER_NAME,
+    typeName: BOOLEAN_TYPE_NAME
+  },
+  {
+    name: CHILD_NODES_PARAMETER_NAME,
+    typeName: LIST_TYPE_NAME,
+    argumentTypeName: NOMINAL_VALUE_TYPE_NAME
+  }
+];
+
 class NominalValueProperties {
   constructor(string, array) {
     this.string = string;
@@ -71,30 +95,9 @@ const nominalValueProperties = NominalValueProperties.fromNothing();
 export default nominalValueProperties;
 
 function nominalValuePropertiesArrayFromNothing() {
-  const names = [
-          CONTENT_PARAMETER_NAME,
-          TERMINAL_PARAMETER_NAME,
-          NO_WHITESPACE_PARAMETER_NAME,
-          CHILD_NODES_PARAMETER_NAME,
-        ],
-        typeNames = [
-          STRING_TYPE_NAME,
-          BOOLEAN_TYPE_NAME,
-          BOOLEAN_TYPE_NAME,
-          LIST_TYPE_NAME
-        ],
-        argumentTypeNames = [
-          null,
-          null,
-          null,
-          NOMINAL_VALUE_TYPE_NAME
-        ],
-        nominalValuePropertiesArray = names.map((name, index) => {
-          const { Type } = elements,
-                context = null,
-                typeName = typeNames[index],
-                argumentTypeName = argumentTypeNames[index],
-                type = Type.fromTypeNameAndArgumentTypeName(typeName, argumentTypeName, context),
+  const nominalValuePropertiesArray = properties.map((property) => {
+          const name = nameFromProperty(property),
+                type = typeFromProperty(property),
                 nominalValueProperty = NominalValueProperty.fromNameAndType(name, type);
 
           return nominalValueProperty;
@@ -102,3 +105,18 @@ function nominalValuePropertiesArrayFromNothing() {
 
   return nominalValuePropertiesArray;
 }
+
+function nameFromProperty(property) {
+  const { name } = property;
+
+  return name;
+}
+
+function typeFromProperty(property) {
+  const { typeName, argumentTypeName = null } = property,
+        { Type } = elements,
+        context = null,
+        type = Type.fromTypeNameAndArgumentTypeName(typeName, argumentTypeName, context);
+
+  return type;
+}

package/src/nonTerminalNodeMap.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import AllNode from "./node/all";
 import SomeNode from "./node/some";
 import TermNode from "./node/term";
 import TypeNode from "./node/type";
@@ -8,6 +9,7 @@ import EveryNode from "./node/every";
 import LabelNode from "./node/label";
 import ErrorNode from "./node/error";
 import ValueNode from "./node/value";
+import ExistsNode from "./node/exists";
 import ValuesNode from "./node/values";
 import ReduceNode from "./node/reduce";
 import TernaryNode from "./node/ternary";
@@ -26,6 +28,7 @@ import StatementNode from "./node/statement";
 import NodeQueryNode from "./node/nodeQuery";
 import ToIntegerNode from "./node/toInteger";
 import ProcedureNode from "./node/procedure";
+import ReferencesNode from "./node/references";
 import StartsWithNode from "./node/startsWith";
 import TryIntegerNode from "./node/tryInteger";
 import NodesQueryNode from "./node/nodesQuery";
@@ -48,8 +51,10 @@ import ObjectAssignmentNode from "./node/assignment/object";
 import AnonymousProcedureNode from "./node/anoymousProcedure";
 import VariableAssignmentNode from "./node/assignment/variable";
 import VariableAssignmentsNode from "./node/assignments/variable";
+import ReferenceListLiteralNode from "./node/referencesListLiteral";
 
-import { SOME_RULE_NAME,
+import { ALL_RULE_NAME,
+         SOME_RULE_NAME,
          TERM_RULE_NAME,
          TYPE_RULE_NAME,
          TERMS_RULE_NAME,
@@ -57,6 +62,7 @@ import { SOME_RULE_NAME,
          LABEL_RULE_NAME,
          ERROR_RULE_NAME,
          VALUE_RULE_NAME,
+         EXISTS_RULE_NAME,
          VALUES_RULE_NAME,
          REDUCE_RULE_NAME,
          TERNARY_RULE_NAME,
@@ -77,6 +83,7 @@ import { SOME_RULE_NAME,
          EXPRESSION_RULE_NAME,
          PARAMETERS_RULE_NAME,
          TO_INTEGER_RULE_NAME,
+         REFERENCES_RULE_NAME,
          TRY_INTEGER_RULE_NAME,
          NODES_QUERY_RULE_NAME,
          STARTS_WITH_RULE_NAME,
@@ -96,9 +103,11 @@ import { SOME_RULE_NAME,
          OBJECT_ASSIGNMENT_RULE_NAME,
          VARIABLE_ASSIGNMENT_RULE_NAME,
          ANONYMOUS_PROCEDURE_RULE_NAME,
-         VARIABLE_ASSIGNMENTS_RULE_NAME } from "./ruleNames";
+         VARIABLE_ASSIGNMENTS_RULE_NAME,
+         REFERENCE_LIST_LITERAL_RULE_NAME } from "./ruleNames";
 
 const NonTerminalNodeMap = {
+  [ALL_RULE_NAME]: AllNode,
   [SOME_RULE_NAME]: SomeNode,
   [TERM_RULE_NAME]: TermNode,
   [TYPE_RULE_NAME]: TypeNode,
@@ -107,6 +116,7 @@ const NonTerminalNodeMap = {
   [LABEL_RULE_NAME]: LabelNode,
   [ERROR_RULE_NAME]: ErrorNode,
   [VALUE_RULE_NAME]: ValueNode,
+  [EXISTS_RULE_NAME]: ExistsNode,
   [VALUES_RULE_NAME]: ValuesNode,
   [REDUCE_RULE_NAME]: ReduceNode,
   [TERNARY_RULE_NAME]: TernaryNode,
@@ -127,6 +137,7 @@ const NonTerminalNodeMap = {
   [NODE_QUERY_RULE_NAME]: NodeQueryNode,
   [EXPRESSION_RULE_NAME]: ExpressionNode,
   [PARAMETERS_RULE_NAME]: ParametersNode,
+  [REFERENCES_RULE_NAME]: ReferencesNode,
   [STARTS_WITH_RULE_NAME]: StartsWithNode,
   [TRY_INTEGER_RULE_NAME]: TryIntegerNode,
   [NODES_QUERY_RULE_NAME]: NodesQueryNode,
@@ -146,7 +157,8 @@ const NonTerminalNodeMap = {
   [OBJECT_ASSIGNMENT_RULE_NAME]: ObjectAssignmentNode,
   [ANONYMOUS_PROCEDURE_RULE_NAME]: AnonymousProcedureNode,
   [VARIABLE_ASSIGNMENT_RULE_NAME]: VariableAssignmentNode,
-  [VARIABLE_ASSIGNMENTS_RULE_NAME]: VariableAssignmentsNode
+  [VARIABLE_ASSIGNMENTS_RULE_NAME]: VariableAssignmentsNode,
+  [REFERENCE_LIST_LITERAL_RULE_NAME]: ReferenceListLiteralNode
 };
 
 export default NonTerminalNodeMap;

package/src/parameterNames.js

@@ -1,5 +1,6 @@
 "use strict";
 
+export const TYPE_PARAMETER_NAME = "type";
 export const CONTENT_PARAMETER_NAME = "content";
 export const TERMINAL_PARAMETER_NAME = "terminal";
 export const CHILD_NODES_PARAMETER_NAME = "childNodes";

package/src/preamble.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import All from "./element/all";
 import Some from "./element/some";
 import Term from "./element/term";
 import Type from "./element/type";
@@ -10,6 +11,7 @@ import Every from "./element/every";
 import Value from "./element/value";
 import Values from "./element/values";
 import Reduce from "./element/reduce";
+import Exists from "./element/exists";
 import Ternary from "./element/ternary";
 import Binding from "./element/binding";
 import Bindings from "./element/bindings";
@@ -29,20 +31,22 @@ import TryInteger from "./element/tryInteger";
 import Parameters from "./element/parameters";
 import NodesQuery from "./element/nodesQuery";
 import Expression from "./element/expression";
+import References from "./element/references";
 import ReturnBlock from "./element/returnBlock";
 import NegatedTerm from "./element/term/negated";
 import LogicalTerm from "./element/term/logical";
 import NamedBinding from "./element/binding/named";
 import ProcedureCall from "./element/procedureCall";
+import ImportBinding from "./element/importBinding";
 import NamedBindings from "./element/bindings/named";
 import BracketedTerm from "./element/term/bracketed";
-import ImportBinding from "./element/importBinding";
+import ImportBindings from "./element/importBindings";
 import listAssignment from "./element/assignment/list";
 import ComparisonTerm from "./element/term/comparison";
-import ImportBindings from "./element/importBindings";
 import ImportStatement from "./element/importStatement";
 import ReturnStatement from "./element/returnStatement";
 import ObjectAssignment from "./element/assignment/object";
 import AnonymousProcedure from "./element/anonymousProcedure";
 import VariableAssignment from "./element/assignment/variable";
 import VariableAssignments from "./element/assignments/variable";
+import ReferenceListLiteral from "./element/referenceListLiteral";

package/src/process/instantiate.js

@@ -3,7 +3,12 @@
 import { bnfUtilities } from "occam-languages";
 
 import { PERIOD, PERIOD_STRING_LITERAL } from "../constants";
-import { TYPE_RULE_NAME, LABEL_RULE_NAME, REFERENCE_RULE_NAME, PARAMETERS_RULE_NAME, IMPORT_BINDING_RULE_NAME, IMPORT_STATEMENT_RULE_NAME } from "../ruleNames";
+import { TYPE_RULE_NAME,
+         LABEL_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         PARAMETERS_RULE_NAME,
+         IMPORT_BINDING_RULE_NAME,
+         IMPORT_STATEMENT_RULE_NAME } from "../ruleNames";
 
 const { instantiate, ruleFromRuleName } = bnfUtilities;
 

package/src/ruleNames.js

@@ -1,5 +1,6 @@
 "use strict";
 
+export const ALL_RULE_NAME = "all";
 export const SOME_RULE_NAME = "some";
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
@@ -8,6 +9,7 @@ export const EVERY_RULE_NAME = "every";
 export const LABEL_RULE_NAME = "label";
 export const ERROR_RULE_NAME = "error";
 export const VALUE_RULE_NAME = "value";
+export const EXISTS_RULE_NAME = "exists";
 export const VALUES_RULE_NAME = "values";
 export const REDUCE_RULE_NAME = "reduce";
 export const TERNARY_RULE_NAME = "ternary";
@@ -24,6 +26,7 @@ export const PRIMITIVE_RULE_NAME = "primitive";
 export const REFERENCE_RULE_NAME = "reference";
 export const PARAMETER_RULE_NAME = "parameter";
 export const ENDS_WITH_RULE_NAME = "endsWith";
+export const REFERENCES_RULE_NAME = "references";
 export const NODE_QUERY_RULE_NAME = "nodeQuery";
 export const EXPRESSION_RULE_NAME = "expression";
 export const PARAMETERS_RULE_NAME = "parameters";
@@ -48,3 +51,4 @@ export const OBJECT_ASSIGNMENT_RULE_NAME = "objectAssignment";
 export const VARIABLE_ASSIGNMENT_RULE_NAME = "variableAssignment";
 export const ANONYMOUS_PROCEDURE_RULE_NAME = "anonymousProcedure";
 export const VARIABLE_ASSIGNMENTS_RULE_NAME = "variableAssignments";
+export const REFERENCE_LIST_LITERAL_RULE_NAME = "referencesListLiteral";