Merge branch '3.8-dev'

Author: spmallette

CHANGELOG.asciidoc

@@ -104,9 +104,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,12 +18,13 @@
  */
 package org.apache.tinkerpop.gremlin.language.grammar;
 
-import org.apache.tinkerpop.gremlin.process.traversal.GremlinTypeErrorException;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GType;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
 import java.lang.reflect.Array;
+import java.util.Date;
 import java.util.Map;
 import java.util.Objects;
 
@@ -38,6 +39,62 @@ public ArgumentVisitor(final VariableResolver resolver, final GremlinAntlrToJava
         this.antlr = antlr;
     }
 
+    /**
+     * Wrapper to visit function for boolean.
+     */
+    public boolean parseBoolean(final GremlinParser.BooleanArgumentContext ctx) {
+        return (boolean) visitBooleanArgument(ctx);
+    }
+
+    /**
+     * Wrapper to visit function for integer types.
+     */
+    public Number parseNumber(final GremlinParser.IntegerArgumentContext ctx) {
+        return (Number) visitIntegerArgument(ctx);
+    }
+
+    /**
+     * Wrapper to visit function for float types.
+     */
+    public Number parseNumber(final GremlinParser.FloatArgumentContext ctx) {
+        return (Number) visitFloatArgument(ctx);
+    }
+
+    /**
+     * Wrapper to visit function for string types.
+     */
+    public String parseString(final GremlinParser.StringArgumentContext ctx) {
+        return (String) visitStringArgument(ctx);
+    }
+
+    /**
+     * Wrapper to visit function for Date type.
+     */
+    public Date parseDate(final GremlinParser.DateArgumentContext ctx) {
+        return (Date) visitDateArgument(ctx);
+    }
+
+    /**
+     * Wrapper for visit function for object types.
+     */
+    public Object parseObject(final GremlinParser.GenericLiteralArgumentContext ctx) {
+        return visitGenericLiteralArgument(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 {@code Map} types.
+     */
+    public Map parseMap(final GremlinParser.GenericLiteralMapArgumentContext ctx) {
+        return (Map) visitGenericLiteralMapArgument(ctx);
+    }
+
     /**
      * Wrapper for visit function for {@code Map} types.
      */
@@ -76,13 +133,13 @@ public Object[] parseObjectVarargs(final GremlinParser.GenericLiteralListArgumen
     }
 
     /**
-     * Parse a string argument varargs, and return an string array
+     * Parse a string literal varargs, and return a string array
      */
-    public GValue<String>[] parseStringVarargs(final GremlinParser.StringLiteralVarargsContext varargsContext) {
-        if (varargsContext == null || varargsContext.stringNullableArgument() == null) {
+    public GValue<String>[] parseStringVarargs(final GremlinParser.StringLiteralVarargsArgumentContext varargsArgumentContext) {
+        if (varargsArgumentContext == null || varargsArgumentContext.stringNullableArgument() == null) {
             return new GValue[0];
         }
-        return varargsContext.stringNullableArgument()
+        return varargsArgumentContext.stringNullableArgument()
                 .stream()
                 .filter(Objects::nonNull)
                 .map(antlr.argumentVisitor::parseString)

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

@@ -1082,7 +1082,7 @@ protected void notImplemented(final ParseTree ctx) {
 	/**
 	 * {@inheritDoc}
 	 */
-	@Override public T visitTraversalToken(final GremlinParser.TraversalTokenContext ctx) { notImplemented(ctx); return null; }
+	@Override public T visitTraversalT(final GremlinParser.TraversalTContext ctx) { notImplemented(ctx); return null; }
 	/**
 	 * {@inheritDoc}
 	 */
@@ -1621,10 +1621,6 @@ protected void notImplemented(final ParseTree ctx) {
 	 * {@inheritDoc}
 	 */
 	@Override public T visitGenericLiteralListArgument(GremlinParser.GenericLiteralListArgumentContext ctx) { notImplemented(ctx); return null; }
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override public T visitStructureVertexArgument(GremlinParser.StructureVertexArgumentContext ctx) { notImplemented(ctx);  return null; }
 	/**
 	 * {@inheritDoc}
 	 */
@@ -1681,4 +1677,40 @@ protected void notImplemented(final ParseTree ctx) {
 	 * {@inheritDoc}
 	 */
 	@Override public T visitGenericLiteralSet(final GremlinParser.GenericLiteralSetContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalTShort(final GremlinParser.TraversalTShortContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalTLong(final GremlinParser.TraversalTLongContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalDirectionShort(final GremlinParser.TraversalDirectionShortContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalDirectionLong(final GremlinParser.TraversalDirectionLongContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitGenericLiteralMapNullable(final GremlinParser.GenericLiteralMapNullableContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitStringLiteralVarargsArgument(final GremlinParser.StringLiteralVarargsArgumentContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitMapKey(final GremlinParser.MapKeyContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitNakedKey(final GremlinParser.NakedKeyContext ctx) { notImplemented(ctx); return null;}
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitStructureVertexArgument(final GremlinParser.StructureVertexArgumentContext ctx) { notImplemented(ctx); return null; }
 }