TINKERPOP-3047 Keywords are allowed as Map keys in grammar.

Major refactoring to the grammar itself, translators. Removed a few gherkin tests that tested lambdas which weren't really necessary given they will be reserved for embedded cases. Changed infinity/nan to be able to parse to float. Removed duplicate test from SeedStrategy.feature - see coin tests. Removed gremlinValue but left some test infrastructure for future.

Author: spmallette

CHANGELOG.asciidoc

@@ -34,9 +34,11 @@ This release also includes changes from <<release-3-7-XXX, 3.7.XXX>>.
 * Removed the deprecated `withGraph()` option from `AnonymousTraversalSource`.
 * Modified the `split()` step to split a string into a list of its characters if the given separator is an empty string.
 * Changed `GremlinLangScriptEngine` via `GenericLiteralVisitor` to treat floating-point literals as `Double` by default instead of `BigDecimal` for better alignment with common programming language conventions.
+* Modified the Gremlin grammar to to treat `Infinity` and `NaN` as floating-points.
 * Added `withoutStrategies()` syntax to the Gremlin ANTLR grammar.
 * Modified the Gremlin ANTLR grammar to more dynamically interact with any strategies registered globally to the `TraversalStrategies` cache sets.
 * Made `new` keyword optional in the Gremlin grammar.
+* Allowed keywords to be used as `Map` keys when defined using the shorthand without quotes.
 * Added integer overflow checks.
 * Added missing strategies to the `TraversalStrategies` global cache as well as `CoreImports` in `gremlin-groovy`.
 * Added missing strategies to `strategies.py` in `gremlin-python`.

docs/src/upgrade/release-3.8.x.asciidoc

@@ -79,7 +79,7 @@ these were deserialized into arrays.
 
 ==== Gremlin Grammar Changes
 
-A number of changes have been introduce to the Gremlin grammar to help make it be more consistent and easier to use.
+A number of changes have been introduced to the Gremlin grammar to help make it be more consistent and easier to use.
 
 *`new` keyword is now optional*
 
@@ -98,16 +98,79 @@ In a future version, it is likely that the `new` keyword will be removed entirel
 *Supports withoutStrategies()*
 
 The `withoutStrategies()` configuration step is now supported syntax for the grammar. While this option is not commonly
-used it is still a part of the Gremlin language and there are times where it is helpful to have this fine grained
+used it is still a part of the Gremlin language and there are times where it is helpful to have this fine-grained
 control over how a traversal works.
 
 [source,groovy]
 ----
 g.V().withoutStrategies(CountStrategy)
 ----
 
+*`Map` keys restrictions*
+
+Earlier versions of the grammar allowed a wide range of values for the keys. In many cases, these didn't really make
+sense for Gremlin and were just inherited from the Groovy language since Gremlin tends to follow that language in many
+ways. That said, Gremlin did take some liberties with that syntax and introduced its own shorthand for some cases. Those
+shorthands created unfortunate situations where certain words were being prevented as being able to be used as keys
+which could lead to confusion.
+
+A `Map` is still defined in the same way it always has been, where the following two lines produce an equivalent `Map`:
+
+[source,groovy]
+----
+[label: 100]
+["label": 100]
+----
+
+Note that when quotes are not use to denote a string, Gremlin will assume that the intention is to shorthand a string
+key and not reference a Gremlin keyword. To reference an allowable keyword as the key, either wrap it with parenthesis
+or use its longhand form as shown in the following examples which all produce the same `Map`:
+
+[source,groovy]
+----
+[T.id: 100]
+[(T.id): 100]
+[(id): 100]
+----
+
+Note that the first example is a Gremlin convenience that is not compatible in Groovy. This does produce a syntax error
+in Groovy's case. When upgrading to 3.8.0, it will be important to evaluate any code that is using scripts with `Map`
+keys that match keywords that are not wrapped in parentheses. On upgrade they will begin to be treated as `String` keys
+rather than their `Enum` value. This is particularly relevant for `property(Map)`, `mergeV` and `mergeE` which use a
+'Map` for their arguments and commonly require that `T` and `Direction` be used as keys.
+
+The following examples show some `Map` usage from older versions that will work without need for changes in 3.8.0:
+
+[source,groovy]
+----
+// the long forms are used and each are wrapped in parenthesis
+g.mergeE([(T.label):'Sibling',created:'2022-02-07',(Direction.from):1,(Direction.to):2])
+
+// the short forms are used and each are wrapped in parenthesis
+g.mergeE([(label):'Sibling',created:'2022-02-07',(Direction.from):1,(Direction.to):2])
+
+// the long forms are used and for Gremlin this is a syntax convenience to spare typing
+// the parenthesis
+g.mergeE([T.label:'Sibling',created:'2022-02-07',Direction.from:1,Direction.to:2])
+
+// while the following line mixes qualified enums with T and uses shorthand for Direction
+// with from and to all of the enums are wrapped in parenthesis
+g.mergeE([(T.label):'Sibling',created:'2022-02-07',(from):1,(to):2])
+----
+
+In this next example, the `Map` keys are defined in a way that changes will be necessary in 3.8.0:
+
+[source,groovy]
+----
+// none of the keys below are qualified with their enum long form nor are they wrapped in
+// parenthesis and as a result will be treated as String key values in 3.8.0 unless a
+// change is made
+g.mergeE([label:'Sibling',created:'2022-02-07',from:1,to:2])
+----
+
 See: link:https://issues.apache.org/jira/browse/TINKERPOP-2862[TINKERPOP-2862],
-link:https://issues.apache.org/jira/browse/TINKERPOP-3046[TINKERPOP-3046]
+link:https://issues.apache.org/jira/browse/TINKERPOP-3046[TINKERPOP-3046],
+link:https://issues.apache.org/jira/browse/TINKERPOP-3047[TINKERPOP-3047]
 
 ==== SeedStrategy Construction
 

gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitor.java

@@ -18,25 +18,13 @@
  */
 package org.apache.tinkerpop.gremlin.language.grammar;
 
-import org.apache.tinkerpop.gremlin.process.traversal.DT;
-import org.apache.tinkerpop.gremlin.process.traversal.Merge;
-import org.apache.tinkerpop.gremlin.process.traversal.Operator;
-import org.apache.tinkerpop.gremlin.process.traversal.Order;
-import org.apache.tinkerpop.gremlin.process.traversal.Pop;
-import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
-import org.apache.tinkerpop.gremlin.process.traversal.Scope;
-import org.apache.tinkerpop.gremlin.structure.Column;
-import org.apache.tinkerpop.gremlin.structure.Direction;
-import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
-import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
 import java.lang.reflect.Array;
-import java.util.Comparator;
 import java.util.Date;
 import java.util.Map;
-import java.util.function.Function;
+import java.util.Objects;
 
 public class ArgumentVisitor extends DefaultGremlinBaseVisitor<Object> {
 
@@ -91,90 +79,13 @@ public Object parseObject(final GremlinParser.GenericLiteralArgumentContext ctx)
         return visitGenericLiteralArgument(ctx);
     }
 
-    /**
-     * Wrapper for visit function for {@link Direction} types.
-     */
-    public Direction parseDirection(final GremlinParser.TraversalDirectionArgumentContext ctx) {
-        return (Direction) visitTraversalDirectionArgument(ctx);
-    }
-
     /**
      * Wrapper for visit function for {@link Vertex} types.
      */
     public Vertex parseVertex(final GremlinParser.StructureVertexArgumentContext ctx) {
         return (Vertex) visitStructureVertexArgument(ctx);
     }
 
-    /**
-     * Wrapper for visit function for {@link Order} types.
-     */
-    public Order parseOrder(final GremlinParser.TraversalOrderArgumentContext ctx) {
-        return (Order) visitTraversalOrderArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link Scope} types.
-     */
-    public Scope parseScope(final GremlinParser.TraversalScopeArgumentContext ctx) {
-        return (Scope) visitTraversalScopeArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link T} types.
-     */
-    public T parseT(final GremlinParser.TraversalTokenArgumentContext ctx) {
-        return (T) visitTraversalTokenArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link VertexProperty.Cardinality} types.
-     */
-    public VertexProperty.Cardinality parseCardinality(final GremlinParser.TraversalCardinalityArgumentContext ctx) {
-        return (VertexProperty.Cardinality) visitTraversalCardinalityArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link Merge} types.
-     */
-    public Merge parseMerge(final GremlinParser.TraversalMergeArgumentContext ctx) {
-        return (Merge) visitTraversalMergeArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link Pop} types.
-     */
-    public Pop parsePop(final GremlinParser.TraversalPopArgumentContext ctx) {
-        return (Pop) visitTraversalPopArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link DT} types.
-     */
-    public DT parseDT(final GremlinParser.TraversalDTArgumentContext ctx) {
-        return (DT) visitTraversalDTArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@link Pop} types.
-     */
-    public Column parseColumn(final GremlinParser.TraversalColumnArgumentContext ctx) {
-        return (Column) visitTraversalColumnArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@code Function} types like {@link T} and {@link Column}.
-     */
-    public Function parseFunction(final GremlinParser.TraversalFunctionArgumentContext ctx) {
-        return (Function) visitTraversalFunctionArgument(ctx);
-    }
-
-    /**
-     * Wrapper for visit function for {@code Comparator} types like {@link Order}.
-     */
-    public Comparator parseComparator(final GremlinParser.TraversalComparatorArgumentContext ctx) {
-        return (Comparator) visitTraversalComparatorArgument(ctx);
-    }
-
     /**
      * Wrapper for visit function for {@code Map} types.
      */
@@ -293,15 +204,6 @@ public Object visitGenericLiteralListArgument(final GremlinParser.GenericLiteral
         }
     }
 
-    @Override
-    public Object visitTraversalDirectionArgument(final GremlinParser.TraversalDirectionArgumentContext ctx) {
-        if (ctx.traversalDirection() != null) {
-            return TraversalEnumParser.parseTraversalDirectionFromContext(ctx.traversalDirection());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
     @Override
     public Object visitStructureVertexArgument(final GremlinParser.StructureVertexArgumentContext ctx) {
         if (ctx.structureVertex() != null) {
@@ -311,112 +213,6 @@ public Object visitStructureVertexArgument(final GremlinParser.StructureVertexAr
         }
     }
 
-    @Override
-    public Object visitTraversalOrderArgument(final GremlinParser.TraversalOrderArgumentContext ctx) {
-        if (ctx.traversalOrder() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Order.class, ctx.traversalOrder());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalScopeArgument(final GremlinParser.TraversalScopeArgumentContext ctx) {
-        if (ctx.traversalScope() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.traversalScope());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalTokenArgument(final GremlinParser.TraversalTokenArgumentContext ctx) {
-        if (ctx.traversalToken() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx.traversalToken());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalCardinalityArgument(final GremlinParser.TraversalCardinalityArgumentContext ctx) {
-        if (ctx.traversalCardinality() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(VertexProperty.Cardinality.class, ctx.traversalCardinality());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalMergeArgument(final GremlinParser.TraversalMergeArgumentContext ctx) {
-        if (ctx.traversalMerge() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Merge.class, ctx.traversalMerge());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalPopArgument(final GremlinParser.TraversalPopArgumentContext ctx) {
-        if (ctx.traversalPop() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Pop.class, ctx.traversalPop());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalDTArgument(final GremlinParser.TraversalDTArgumentContext ctx) {
-        if (ctx.traversalDT() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(DT.class, ctx.traversalDT());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalColumnArgument(final GremlinParser.TraversalColumnArgumentContext ctx) {
-        if (ctx.traversalColumn() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, ctx.traversalColumn());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalComparatorArgument(final GremlinParser.TraversalComparatorArgumentContext ctx) {
-        if (ctx.traversalComparator() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Order.class, ctx.traversalComparator().traversalOrder());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalFunctionArgument(final GremlinParser.TraversalFunctionArgumentContext ctx) {
-        if (ctx.traversalFunction() != null) {
-            final GremlinParser.TraversalFunctionContext tfc = ctx.traversalFunction();
-            if (tfc.traversalToken() != null) {
-                return TraversalEnumParser.parseTraversalEnumFromContext(T.class, tfc.traversalToken());
-            } else if (tfc.traversalColumn() != null)
-                return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, tfc.traversalColumn());
-            else {
-                throw new GremlinParserException("Unrecognized enum for traversal function");
-            }
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
-    @Override
-    public Object visitTraversalBiFunctionArgument(final GremlinParser.TraversalBiFunctionArgumentContext ctx) {
-        if (ctx.traversalBiFunction() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(Operator.class, ctx.traversalBiFunction().traversalOperator());
-        } else {
-            return visitVariable(ctx.variable());
-        }
-    }
-
     @Override
     public Object visitGenericLiteralMapArgument(final GremlinParser.GenericLiteralMapArgumentContext ctx) {
         if (ctx.genericLiteralMap() != null) {
@@ -437,13 +233,18 @@ public Object visitGenericLiteralMapNullableArgument(final GremlinParser.Generic
         }
     }
 
-    @Override
-    public Object visitTraversalSackMethodArgument(final GremlinParser.TraversalSackMethodArgumentContext ctx) {
-        if (ctx.traversalSackMethod() != null) {
-            return TraversalEnumParser.parseTraversalEnumFromContext(SackFunctions.Barrier.class, ctx.traversalSackMethod());
-        } else {
-            return visitVariable(ctx.variable());
+    /**
+     * Parse a string literal varargs, and return a string array
+     */
+    public String[] parseStringVarargs(final GremlinParser.StringLiteralVarargsArgumentContext varargsArgumentContext) {
+        if (varargsArgumentContext == null || varargsArgumentContext.stringNullableArgument() == null) {
+            return new String[0];
         }
+        return varargsArgumentContext.stringNullableArgument()
+                .stream()
+                .filter(Objects::nonNull)
+                .map(antlr.argumentVisitor::parseString)
+                .toArray(String[]::new);
     }
 
     @Override