Fastbuilder - shadow PR

build.gradle

@@ -223,6 +223,15 @@ tasks.named('jmhJar') {
     }
 }
 
+jmh {
+    if (project.hasProperty('jmhInclude')) {
+        includes = [project.property('jmhInclude')]
+    }
+    if (project.hasProperty('jmhProfilers')) {
+        profilers = [project.property('jmhProfilers')]
+    }
+}
+
 
 task extractWithoutGuava(type: Copy) {
     from({ zipTree({ "build/libs/graphql-java-${project.version}.jar" }) }) {

src/jmh/java/benchmark/BuildSchemaBenchmark.java

@@ -0,0 +1,54 @@
+package benchmark;
+
+import graphql.schema.idl.FastSchemaGenerator;
+import graphql.schema.idl.RuntimeWiring;
+import graphql.schema.idl.SchemaGenerator;
+import graphql.schema.idl.SchemaParser;
+import graphql.schema.idl.TypeDefinitionRegistry;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+@Warmup(iterations = 2, time = 5)
+@Measurement(iterations = 3)
+@Fork(2)
+@State(Scope.Benchmark)
+public class BuildSchemaBenchmark {
+
+    static String largeSDL = BenchmarkUtils.loadResource("large-schema-4.graphqls");
+
+    private TypeDefinitionRegistry registry;
+
+    @Setup
+    public void setup() {
+        // Parse SDL once before benchmarks run
+        registry = new SchemaParser().parse(largeSDL);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void benchmarkBuildSchemaAvgTime(Blackhole blackhole) {
+        blackhole.consume(new SchemaGenerator().makeExecutableSchema(registry, RuntimeWiring.MOCKED_WIRING));
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void benchmarkBuildSchemaAvgTimeFast(Blackhole blackhole) {
+        blackhole.consume(new FastSchemaGenerator().makeExecutableSchema(
+                SchemaGenerator.Options.defaultOptions().withValidation(false),
+                registry,
+                RuntimeWiring.MOCKED_WIRING));
+    }
+}

src/jmh/java/benchmark/CreateSchemaBenchmark.java

@@ -1,6 +1,7 @@
 package benchmark;
 
 import graphql.schema.GraphQLSchema;
+import graphql.schema.idl.FastSchemaGenerator;
 import graphql.schema.idl.RuntimeWiring;
 import graphql.schema.idl.SchemaGenerator;
 import graphql.schema.idl.SchemaParser;
@@ -21,7 +22,7 @@
 @Fork(2)
 public class CreateSchemaBenchmark {
 
-    static String largeSDL = BenchmarkUtils.loadResource("large-schema-3.graphqls");
+    static String largeSDL = BenchmarkUtils.loadResource("large-schema-4.graphqls");
 
     @Benchmark
     @BenchmarkMode(Mode.Throughput)
@@ -37,11 +38,26 @@ public void benchmarkLargeSchemaCreateAvgTime(Blackhole blackhole) {
         blackhole.consume(createSchema(largeSDL));
     }
 
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public void benchmarkLargeSchemaCreateAvgTimeFast(Blackhole blackhole) {
+        blackhole.consume(createSchemaFast(largeSDL));
+    }
+
     private static GraphQLSchema createSchema(String sdl) {
         TypeDefinitionRegistry registry = new SchemaParser().parse(sdl);
         return new SchemaGenerator().makeExecutableSchema(registry, RuntimeWiring.MOCKED_WIRING);
     }
 
+    private static GraphQLSchema createSchemaFast(String sdl) {
+        TypeDefinitionRegistry registry = new SchemaParser().parse(sdl);
+        return new FastSchemaGenerator().makeExecutableSchema(
+                SchemaGenerator.Options.defaultOptions().withValidation(false),
+                registry,
+                RuntimeWiring.MOCKED_WIRING);
+    }
+
     @SuppressWarnings("InfiniteLoopStatement")
     /// make this a main method if you want to run it in JProfiler etc..
     public static void mainXXX(String[] args) {
@@ -54,4 +70,4 @@ public static void mainXXX(String[] args) {
             }
         }
     }
-}
+}

src/main/java/graphql/Assert.java

@@ -5,7 +5,6 @@
 
 import java.util.Collection;
 import java.util.function.Supplier;
-import java.util.regex.Pattern;
 
 import static java.lang.String.format;
 
@@ -224,8 +223,6 @@ public static void assertFalse(boolean condition, String msgFmt, Object arg1, Ob
 
     private static final String invalidNameErrorMessage = "Name must be non-null, non-empty and match [_A-Za-z][_0-9A-Za-z]* - was '%s'";
 
-    private static final Pattern validNamePattern = Pattern.compile("[_A-Za-z][_0-9A-Za-z]*");
-
     /**
      * Validates that the Lexical token name matches the current spec.
      * currently non null, non empty,
@@ -234,11 +231,37 @@ public static void assertFalse(boolean condition, String msgFmt, Object arg1, Ob
      *
      * @return the name if valid, or AssertException if invalid.
      */
-    public static String assertValidName(String name) {
-        if (name != null && !name.isEmpty() && validNamePattern.matcher(name).matches()) {
+    public static String assertValidName(@Nullable String name) {
+        if (name != null && isValidName(name)) {
             return name;
         }
-        return throwAssert(invalidNameErrorMessage, name);
+        return throwAssert(invalidNameErrorMessage, String.valueOf(name));
+    }
+
+    /**
+     * Fast character-by-character validation without regex.
+     * Checks if name matches [_A-Za-z][_0-9A-Za-z]*
+     */
+    private static boolean isValidName(String name) {
+        if (name.isEmpty()) {
+            return false;
+        }
+
+        // First character must be [_A-Za-z]
+        char first = name.charAt(0);
+        if (!(first == '_' || (first >= 'A' && first <= 'Z') || (first >= 'a' && first <= 'z'))) {
+            return false;
+        }
+
+        // Remaining characters must be [_0-9A-Za-z]
+        for (int i = 1; i < name.length(); i++) {
+            char c = name.charAt(i);
+            if (!(c == '_' || (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     private static <T> T throwAssert(String format, Object... args) {