Use Java 17

Author: mpkorstanje

java/pom.xml

@@ -120,7 +120,7 @@
                 <executions>
                     <execution>
                         <id>validate</id>
-                        <phase>verify</phase>
+                        <phase>validate</phase>
                         <goals>
                             <goal>check</goal>
                         </goals>

java/src/main/java/io/cucumber/cucumberexpressions/CucumberExpressionException.java

@@ -64,6 +64,7 @@ static CucumberExpressionException createParameterIsNotAllowedInOptional(Node no
                 "An optional may not contain a parameter type",
                 "If you did not mean to use an parameter type you can use '\\{' to escape the '{'"));
     }
+
     static CucumberExpressionException createOptionalIsNotAllowedInOptional(Node node, String expression) {
         return new CucumberExpressionException(message(
                 node.start(),
@@ -83,7 +84,7 @@ static CucumberExpressionException createOptionalMayNotBeEmpty(Node node, String
     }
 
     static CucumberExpressionException createAlternativeMayNotExclusivelyContainOptionals(Node node,
-            String expression) {
+                                                                                          String expression) {
         return new CucumberExpressionException(message(
                 node.start(),
                 expression,
@@ -129,7 +130,7 @@ static CucumberExpressionException createInvalidParameterTypeName(Token token, S
     }
 
     static String message(int index, String expression, String pointer, String problem,
-            String solution) {
+                          String solution) {
         return thisCucumberExpressionHasAProblemAt(index) +
                 "\n" +
                 expression + "\n" +

java/src/main/java/io/cucumber/cucumberexpressions/CucumberExpressionGenerator.java

@@ -79,7 +79,9 @@ public List<GeneratedExpression> generateExpressions(String text) {
     }
 
     private String escape(String s) {
-        return s.replaceAll("%", "%%") // Escape for String.format
+        return s
+                // Escape for String.format
+                .replaceAll("%", "%%")
                 .replaceAll("\\(", "\\\\(")
                 .replaceAll("\\{", "\\\\{")
                 .replaceAll("/", "\\\\/");

java/src/main/java/io/cucumber/cucumberexpressions/CucumberExpressionParser.java

@@ -4,7 +4,6 @@
 import org.apiguardian.api.API;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 import static io.cucumber.cucumberexpressions.Node.Type.ALTERNATION_NODE;
@@ -63,10 +62,10 @@ public final class CucumberExpressionParser {
         Token token = tokens.get(current);
         return switch (token.type) {
             case WHITE_SPACE, TEXT -> new Result(1, new Node(TEXT_NODE, token.start(), token.end(), token.text));
-            case BEGIN_OPTIONAL, 
-                 END_OPTIONAL, 
-                 BEGIN_PARAMETER, 
-                 END_PARAMETER, 
+            case BEGIN_OPTIONAL,
+                 END_OPTIONAL,
+                 BEGIN_PARAMETER,
+                 END_PARAMETER,
                  ALTERNATION -> throw createInvalidParameterTypeName(token, expression);
             // If configured correctly this will never happen
             default -> new Result(0);
@@ -88,6 +87,7 @@ public final class CucumberExpressionParser {
      * option := optional | parameter | text
      */
     private static final Parser optionalParser;
+
     static {
         List<Parser> parsers = new ArrayList<>();
         optionalParser = parseBetween(
@@ -158,7 +158,8 @@ public final class CucumberExpressionParser {
     );
 
     /**
-     * Parses as Cucumber expression into an AST of {@link Node nodes}. 
+     * Parses as Cucumber expression into an AST of {@link Node nodes}.
+     *
      * @param expression the expression to parse
      * @return an AST of nodes
      * @throws CucumberExpressionException if the expression could not be parsed
@@ -170,26 +171,6 @@ public Node parse(String expression) {
         return result.ast.get(0);
     }
 
-    private interface Parser {
-        Result parse(String expression, List<Token> tokens, int current);
-
-    }
-
-    private static final class Result {
-        final int consumed;
-        final List<Node> ast;
-
-        private Result(int consumed, Node... ast) {
-            this(consumed, Arrays.asList(ast));
-        }
-
-        private Result(int consumed, List<Node> ast) {
-            this.consumed = consumed;
-            this.ast = ast;
-        }
-
-    }
-
     private static Parser parseBetween(
             Node.Type type,
             Token.Type beginToken,
@@ -241,8 +222,8 @@ private static Result parseTokensUntil(
     }
 
     private static Result parseToken(String expression, List<Parser> parsers,
-            List<Token> tokens,
-            int startAt) {
+                                     List<Token> tokens,
+                                     int startAt) {
         for (Parser parser : parsers) {
             Result result = parser.parse(expression, tokens, startAt);
             if (result.consumed != 0) {
@@ -311,4 +292,14 @@ private static List<Node> createAlternativeNodes(int start, int end, List<Node>
         return nodes;
     }
 
+    private interface Parser {
+        Result parse(String expression, List<Token> tokens, int current);
+
+    }
+
+    private record Result(int consumed, List<Node> ast) {
+        private Result(int consumed, Node... ast) {
+            this(consumed, asList(ast));
+        }
+    }
 }

java/src/main/java/io/cucumber/cucumberexpressions/CucumberExpressionTokenizer.java

@@ -7,7 +7,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.NoSuchElementException;
-import java.util.Objects;
 import java.util.PrimitiveIterator.OfInt;
 
 import static io.cucumber.cucumberexpressions.CucumberExpressionException.createCantEscape;

java/src/main/java/io/cucumber/cucumberexpressions/Expression.java

@@ -5,7 +5,6 @@
 
 import java.lang.reflect.Type;
 import java.util.List;
-import java.util.Set;
 import java.util.regex.Pattern;
 
 @API(status = API.Status.STABLE)

java/src/main/java/io/cucumber/cucumberexpressions/ExpressionFactory.java

@@ -2,7 +2,6 @@
 
 import org.apiguardian.api.API;
 
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 
@@ -11,9 +10,9 @@
  * using heuristics. This is particularly useful for languages that don't have a
  * literal syntax for regular expressions. In Java, a regular expression has to be represented as a String.
  *
- *  A string that starts with `^` and/or ends with `$` (or written in script style, i.e. starting with `/` 
- *  and ending with `/`) is considered a regular expression.
- *  Everything else is considered a Cucumber expression.
+ * <p>A string that starts with `^` and/or ends with `$` (or written in script style, i.e. starting with `/`
+ * and ending with `/`) is considered a regular expression.
+ * Everything else is considered a Cucumber expression.
  */
 @API(status = API.Status.STABLE)
 public final class ExpressionFactory {

java/src/main/java/io/cucumber/cucumberexpressions/GeneratedExpression.java

@@ -12,7 +12,7 @@
 import java.util.Map;
 
 @API(status = API.Status.STABLE)
-public class GeneratedExpression {
+public final class GeneratedExpression {
     private static final Collator ENGLISH_COLLATOR = Collator.getInstance(Locale.ENGLISH);
     private static final String[] JAVA_KEYWORDS = {
             "abstract", "assert", "boolean", "break", "byte", "case",
@@ -36,7 +36,7 @@ public class GeneratedExpression {
     }
 
     private static boolean isJavaKeyword(@Nullable String keyword) {
-        return (Arrays.binarySearch(JAVA_KEYWORDS, keyword, ENGLISH_COLLATOR) >= 0);
+        return Arrays.binarySearch(JAVA_KEYWORDS, keyword, ENGLISH_COLLATOR) >= 0;
     }
 
     public String getSource() {

java/src/main/java/io/cucumber/cucumberexpressions/Group.java

@@ -13,7 +13,7 @@
 import java.util.Collection;
 
 @API(status = API.Status.STABLE)
-public class Group {
+public final class Group {
     private final List<Group> children;
     private final @Nullable String value;
     private final int start;
@@ -25,6 +25,7 @@ public class Group {
         this.end = end;
         this.children = children;
     }
+    
     @Nullable
     public String getValue() {
         return value;

java/src/main/java/io/cucumber/cucumberexpressions/GroupBuilder.java

@@ -5,7 +5,6 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Objects;
 import java.util.regex.Matcher;
 
 import static java.util.Objects.requireNonNull;