Add native rule implementation for the standard protovalidate rules

Makefile

@@ -29,8 +29,9 @@ clean:  ## Delete intermediate build artifacts
 	$(GRADLE) clean
 
 .PHONY: conformance
-conformance: ## Execute conformance tests.
-	$(GRADLE) conformance:conformance
+conformance: ## Execute conformance tests with native rule evaluators enabled and disabled.
+	ENABLE_NATIVE_RULES=true $(GRADLE) conformance:conformance
+	ENABLE_NATIVE_RULES=false $(GRADLE) conformance:conformance
 
 .PHONY: help
 help: ## Describe useful make targets

README.md

@@ -64,6 +64,19 @@ Highlights for Java developers include:
 * A comprehensive RPC quickstart for [Java and gRPC][grpc-java]
 * A [migration guide for protoc-gen-validate][migration-guide] users
 
+## Native rule evaluators (opt-out)
+
+The standard rules can be evaluated either through CEL or through native Java code. Native evaluation is functionally identical (the conformance suite passes in both modes) but skips CEL compilation and runtime overhead for the rules it covers — a single `validate()` call on a complex message can run an order of magnitude faster and allocate ~10× less.
+
+Native rules are **opt-out**. Disable them by configuring the validator:
+
+```java
+Config config = Config.newBuilder().setEnableNativeRules(false).build();
+Validator validator = ValidatorFactory.newBuilder().withConfig(config).build();
+```
+
+Forward compatibility is preserved by a clone-and-clear contract: when protovalidate adds a new rule that this codebase hasn't yet implemented natively, the rule remains on the residual `FieldRules` and CEL enforces it. Native evaluation is an optimization, never a replacement.
+
 ## Additional languages and repositories
 
 Protovalidate isn't just for Java! You might be interested in sibling repositories for other languages:

benchmarks/README.md

@@ -54,6 +54,26 @@ compileValidatorForRepeated  alloc   12950196.95 B/op  3262651.61 B/op   -74.8%
 `jmhCompare` diffs `results-before.json` against `results.json` by default.
 Pass explicit paths with `-Pbefore=<path> -Pafter=<path>`.
 
+## Comparing native rules vs CEL
+
+Benchmarks A/B the `enableNativeRules` flag via `@Param({"false", "true"})`, so a single run produces both variants.
+Diff them in place:
+
+```
+./gradlew :benchmarks:jmh
+./gradlew :benchmarks:jmhCompareNativeRules
+```
+
+Output (`before` = CEL, `after` = native; negative delta means native is faster / allocates less):
+
+```
+benchmark              metric  cel              native           delta
+buildBenchInt32GT      time    1234567.89 ns/op  456789.01 ns/op  -63.0%
+buildBenchInt32GT      alloc   123456.78 B/op    45678.90 B/op    -63.0%
+```
+
+Override the input file with `-Presults=<path>`.
+
 ## Adding a new benchmark
 
 Benchmarks live in `src/jmh/java/...` and target proto messages in `src/jmh/proto/...`.

benchmarks/build.gradle.kts

@@ -143,3 +143,26 @@ tasks.register<Exec>("jmhCompare") {
         after, // $3
     )
 }
+
+// Diffs the two enableNativeRules variants within a single results.json.
+// `before` column is CEL (enableNativeRules=false), `after` is native
+// (enableNativeRules=true), so a negative delta means native is faster /
+// allocates less.
+//
+// Override the input file:
+//   ./gradlew :benchmarks:jmhCompareNative -Presults=path/to/results.json
+tasks.register<Exec>("jmhCompareNativeRules") {
+    description = "Diffs enableNativeRules=true vs false from a single JMH results.json."
+    val results =
+        project.findProperty("results")?.toString()
+            ?: jmhResults.get().asFile.absolutePath
+    val jqScript = file("jmh-compare-native-rules.jq").absolutePath
+    commandLine(
+        "bash",
+        "-c",
+        "jq --raw-output --from-file \"\$1\" \"\$2\" | column -t -s \$'\\t'",
+        "jmh-compare-native-rules", // $0
+        jqScript, // $1
+        results, // $2
+    )
+}

benchmarks/jmh-compare-native-rules.jq

@@ -0,0 +1,32 @@
+# this script builds a comparison between runs that used the CEL interpreter for
+# protovalidate rule evaluation vs runs that used native Java code for protovalidate
+# rule evaluation. The differentiator is the value of the "native" field (true for
+# native, false for CEL) and this script groups rows that have the same benchmark
+# and metric name, but different values for native.
+def pct(a; b):
+  if a == null or b == null or b == 0 then "~"
+  else (((a - b) / b * 100) * 10 | round / 10) as $d
+    | if $d > 0 then "+\($d)%" elif $d == 0 then "~" else "\($d)%" end
+  end;
+def num(x):
+  if x == null then "-"
+  else (x * 100 | round / 100 | tostring)
+  end;
+
+def row: {
+  key: (.benchmark | split(".") | last),
+  native: .params.enableNativeRules,
+  time: .primaryMetric.score,
+  unit: .primaryMetric.scoreUnit,
+  alloc: (.secondaryMetrics["·gc.alloc.rate.norm"].score // null)
+};
+
+map(row)
+| group_by(.key)
+| (["benchmark", "metric", "cel", "native", "delta"] | @tsv),
+  (.[]
+    | (map(select(.native == "false"))[0]) as $b
+    | (map(select(.native == "true"))[0])  as $a
+    | select($b and $a)
+    | ([$b.key, "time",  "\(num($b.time)) \($b.unit)",  "\(num($a.time)) \($a.unit)",  pct($a.time;  $b.time)]  | @tsv),
+      ([$b.key, "alloc", "\(num($b.alloc)) B/op",       "\(num($a.alloc)) B/op",       pct($a.alloc; $b.alloc)] | @tsv))