Remove unnecessary synchronization on dispatcher by making it immutable

runtime/src/main/java/dev/cel/runtime/BUILD.bazel

@@ -60,7 +60,6 @@ INTERPRABLE_SOURCES = [
 # keep sorted
 DISPATCHER_SOURCES = [
     "DefaultDispatcher.java",
-    "Dispatcher.java",
 ]
 
 java_library(
@@ -125,7 +124,6 @@ java_library(
         ":resolved_overload_internal",
         "//:auto_value",
         "//common:error_codes",
-        "//common/annotations",
         "//runtime:function_resolver",
         "@maven//:com_google_code_findbugs_annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
@@ -146,7 +144,6 @@ cel_android_library(
         ":resolved_overload_internal_android",
         "//:auto_value",
         "//common:error_codes",
-        "//common/annotations",
         "@maven//:com_google_code_findbugs_annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven_android//:com_google_guava_guava",

runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java

@@ -287,12 +287,12 @@ public CelRuntimeLegacyImpl build() {
 
       functionBindingsBuilder.putAll(customFunctionBindings);
 
-      DefaultDispatcher dispatcher = DefaultDispatcher.create();
+      DefaultDispatcher.Builder dispatcherBuilder = DefaultDispatcher.newBuilder();
       functionBindingsBuilder
           .buildOrThrow()
           .forEach(
               (String overloadId, CelFunctionBinding func) ->
-                  dispatcher.add(
+                  dispatcherBuilder.addOverload(
                       overloadId, func.getArgTypes(), func.isStrict(), func.getDefinition()));
 
       RuntimeTypeProvider runtimeTypeProvider;
@@ -313,7 +313,7 @@ public CelRuntimeLegacyImpl build() {
           new DefaultInterpreter(
               DescriptorTypeResolver.create(),
               runtimeTypeProvider,
-              dispatcher.immutableCopy(),
+              dispatcherBuilder.build(),
               options);
 
       return new CelRuntimeLegacyImpl(

runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java

@@ -14,41 +14,29 @@
 
 package dev.cel.runtime;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoBuilder;
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.annotations.Immutable;
-import javax.annotation.concurrent.ThreadSafe;
-import com.google.errorprone.annotations.concurrent.GuardedBy;
 import dev.cel.common.CelErrorCode;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
-/**
- * Default implementation of {@link Dispatcher}.
- *
- * <p>Should be final, do not mock; mocking {@link Dispatcher} instead.
- */
-@ThreadSafe
-final class DefaultDispatcher implements Dispatcher {
-  public static DefaultDispatcher create() {
-    return new DefaultDispatcher();
-  }
+/** Default implementation of dispatcher. */
+@Immutable
+final class DefaultDispatcher implements CelFunctionResolver {
 
-  @GuardedBy("this")
-  private final Map<String, ResolvedOverload> overloads = new HashMap<>();
-
-  public synchronized void add(
-      String overloadId, List<Class<?>> argTypes, boolean isStrict, CelFunctionOverload overload) {
-    overloads.put(overloadId, CelResolvedOverload.of(overloadId, overload, isStrict, argTypes));
-  }
+  private final ImmutableMap<String, ResolvedOverload> overloads;
 
   @Override
-  public synchronized Optional<ResolvedOverload> findOverload(
+  public Optional<ResolvedOverload> findOverload(
       String functionName, List<String> overloadIds, Object[] args) throws CelEvaluationException {
-    return DefaultDispatcher.findOverload(functionName, overloadIds, overloads, args);
+    return findOverload(functionName, overloadIds, overloads, args);
   }
 
   /** Finds the overload that matches the given function name, overload IDs, and arguments. */
@@ -87,31 +75,36 @@ public static Optional<ResolvedOverload> findOverload(
     return Optional.ofNullable(match);
   }
 
-  @Override
-  public synchronized Dispatcher.ImmutableCopy immutableCopy() {
-    return new ImmutableCopy(overloads);
+  static Builder newBuilder() {
+    return new AutoBuilder_DefaultDispatcher_Builder();
   }
 
-  @Immutable
-  private static final class ImmutableCopy implements Dispatcher.ImmutableCopy {
-    private final ImmutableMap<String, ResolvedOverload> overloads;
+  @AutoBuilder(ofClass = DefaultDispatcher.class)
+  abstract static class Builder {
 
-    private ImmutableCopy(Map<String, ResolvedOverload> overloads) {
-      this.overloads = ImmutableMap.copyOf(overloads);
-    }
+    abstract ImmutableMap<String, ResolvedOverload> overloads();
 
-    @Override
-    public Optional<ResolvedOverload> findOverload(
-        String functionName, List<String> overloadIds, Object[] args)
-        throws CelEvaluationException {
-      return DefaultDispatcher.findOverload(functionName, overloadIds, overloads, args);
-    }
+    abstract ImmutableMap.Builder<String, ResolvedOverload> overloadsBuilder();
+
+    @CanIgnoreReturnValue
+    Builder addOverload(
+        String overloadId,
+        List<Class<?>> argTypes,
+        boolean isStrict,
+        CelFunctionOverload overload) {
+      checkNotNull(overloadId);
+      checkNotNull(argTypes);
+      checkNotNull(overload);
 
-    @Override
-    public Dispatcher.ImmutableCopy immutableCopy() {
+      overloadsBuilder()
+          .put(overloadId, CelResolvedOverload.of(overloadId, overload, isStrict, argTypes));
       return this;
     }
+
+    abstract DefaultDispatcher build();
   }
 
-  private DefaultDispatcher() {}
+  DefaultDispatcher(ImmutableMap<String, ResolvedOverload> overloads) {
+    this.overloads = overloads;
+  }
 }

runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java

@@ -64,7 +64,7 @@ final class DefaultInterpreter implements Interpreter {
 
   private final TypeResolver typeResolver;
   private final RuntimeTypeProvider typeProvider;
-  private final Dispatcher dispatcher;
+  private final DefaultDispatcher dispatcher;
   private final CelOptions celOptions;
 
   /**
@@ -102,7 +102,7 @@ static IntermediateResult create(Object value) {
   public DefaultInterpreter(
       TypeResolver typeResolver,
       RuntimeTypeProvider typeProvider,
-      Dispatcher dispatcher,
+      DefaultDispatcher dispatcher,
       CelOptions celOptions) {
     this.typeResolver = checkNotNull(typeResolver);
     this.typeProvider = checkNotNull(typeProvider);
@@ -120,20 +120,20 @@ public Interpretable createInterpretable(CelAbstractSyntaxTree ast) {
   static final class DefaultInterpretable implements Interpretable, UnknownTrackingInterpretable {
     private final TypeResolver typeResolver;
     private final RuntimeTypeProvider typeProvider;
-    private final Dispatcher.ImmutableCopy dispatcher;
+    private final DefaultDispatcher dispatcher;
     private final Metadata metadata;
     private final CelAbstractSyntaxTree ast;
     private final CelOptions celOptions;
 
     DefaultInterpretable(
         TypeResolver typeResolver,
         RuntimeTypeProvider typeProvider,
-        Dispatcher dispatcher,
+        DefaultDispatcher dispatcher,
         CelAbstractSyntaxTree ast,
         CelOptions celOptions) {
       this.typeResolver = checkNotNull(typeResolver);
       this.typeProvider = checkNotNull(typeProvider);
-      this.dispatcher = checkNotNull(dispatcher).immutableCopy();
+      this.dispatcher = checkNotNull(dispatcher);
       this.ast = checkNotNull(ast);
       this.metadata = new DefaultMetadata(ast);
       this.celOptions = checkNotNull(celOptions);

runtime/src/main/java/dev/cel/runtime/LiteRuntimeImpl.java

@@ -176,22 +176,19 @@ public CelLiteRuntime build() {
 
       functionBindingsBuilder.putAll(customFunctionBindings);
 
-      DefaultDispatcher dispatcher = DefaultDispatcher.create();
+      DefaultDispatcher.Builder dispatcherBuilder = DefaultDispatcher.newBuilder();
       functionBindingsBuilder
           .buildOrThrow()
           .forEach(
               (String overloadId, CelFunctionBinding func) ->
-                  dispatcher.add(
-                      overloadId,
-                      func.getArgTypes(),
-                      func.isStrict(),
-                      (args) -> func.getDefinition().apply(args)));
+                  dispatcherBuilder.addOverload(
+                      overloadId, func.getArgTypes(), func.isStrict(), func.getDefinition()));
 
       Interpreter interpreter =
           new DefaultInterpreter(
               TypeResolver.create(),
               CelValueRuntimeTypeProvider.newInstance(celValueProvider),
-              dispatcher,
+              dispatcherBuilder.build(),
               celOptions);
 
       return new LiteRuntimeImpl(

runtime/src/test/java/dev/cel/runtime/DefaultInterpreterTest.java

@@ -74,14 +74,15 @@ public Object adapt(String messageName, Object message) {
           }
         };
     CelAbstractSyntaxTree ast = celCompiler.compile("[1].all(x, [2].all(y, error()))").getAst();
-    DefaultDispatcher dispatcher = DefaultDispatcher.create();
-    dispatcher.add(
+    DefaultDispatcher.Builder dispatcherBuilder = DefaultDispatcher.newBuilder();
+    dispatcherBuilder.addOverload(
         "error",
         ImmutableList.of(long.class),
         /* isStrict= */ true,
         (args) -> new IllegalArgumentException("Always throws"));
     DefaultInterpreter defaultInterpreter =
-        new DefaultInterpreter(new TypeResolver(), emptyProvider, dispatcher, CelOptions.DEFAULT);
+        new DefaultInterpreter(
+            new TypeResolver(), emptyProvider, dispatcherBuilder.build(), CelOptions.DEFAULT);
     DefaultInterpretable interpretable =
         (DefaultInterpretable) defaultInterpreter.createInterpretable(ast);