No public description

PiperOrigin-RevId: 996768728

Author: l46kok

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

@@ -427,6 +427,7 @@ cel_android_library(
         "//common/annotations",
         "//common/exceptions:divide_by_zero",
         "//common/exceptions:index_out_of_bounds",
+        "//common/exceptions:invalid_argument",
         "//common/exceptions:numeric_overflow",
         "//common/internal:converter",
         "//common/values:values_android",
@@ -451,6 +452,7 @@ java_library(
         "//common/annotations",
         "//common/exceptions:divide_by_zero",
         "//common/exceptions:index_out_of_bounds",
+        "//common/exceptions:invalid_argument",
         "//common/exceptions:numeric_overflow",
         "//common/internal:converter",
         "//common/values",

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

@@ -23,10 +23,12 @@
 import com.google.protobuf.Duration;
 import com.google.protobuf.MessageLiteOrBuilder;
 import com.google.re2j.Pattern;
+import com.google.re2j.PatternSyntaxException;
 import dev.cel.common.CelOptions;
 import dev.cel.common.annotations.Internal;
 import dev.cel.common.exceptions.CelDivideByZeroException;
 import dev.cel.common.exceptions.CelIndexOutOfBoundsException;
+import dev.cel.common.exceptions.CelInvalidArgumentException;
 import dev.cel.common.exceptions.CelNumericOverflowException;
 import dev.cel.common.internal.Converter;
 import dev.cel.common.values.NullValue;
@@ -76,16 +78,28 @@ public static java.time.Duration createJavaDurationFromString(String d) {
     }
   }
 
-  public static boolean matches(String string, String regexp, CelOptions celOptions) {
-    Pattern pattern = Pattern.compile(regexp);
+  /**
+   * Compiles the given RE2J regex pattern string and validates it against {@link
+   * CelOptions#maxRegexProgramSize()}.
+   */
+  public static Pattern compileRegexPattern(String regexp, CelOptions celOptions) {
+    Pattern pattern;
+    try {
+      pattern = Pattern.compile(regexp);
+    } catch (PatternSyntaxException e) {
+      throw new CelInvalidArgumentException(e);
+    }
     int maxProgramSize = celOptions.maxRegexProgramSize();
     if (maxProgramSize >= 0 && pattern.programSize() > maxProgramSize) {
-      throw new IllegalArgumentException(
+      throw new CelInvalidArgumentException(
           String.format(
               "Regex pattern exceeds allowed program size. Allowed: %d, Provided: %d",
               maxProgramSize, pattern.programSize()));
     }
+    return pattern;
+  }
 
+  public static boolean matches(String string, Pattern pattern, CelOptions celOptions) {
     if (!celOptions.enableRegexPartialMatch()) {
       // Uses re2 for consistency across languages.
       return pattern.matcher(string).matches();
@@ -95,6 +109,10 @@ public static boolean matches(String string, String regexp, CelOptions celOption
     return pattern.matcher(string).find();
   }
 
+  public static boolean matches(String string, String regexp, CelOptions celOptions) {
+    return matches(string, compileRegexPattern(regexp, celOptions), celOptions);
+  }
+
   /** Concatenates two lists into a new list. */
   public static <E> List<E> concat(List<E> first, List<E> second) {
     if (first instanceof ConcatenatedListView) {

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

@@ -53,6 +53,7 @@ java_library(
         "//common/ast",
         "//common/ast:cel_block",
         "//common/exceptions:overload_not_found",
+        "//common/exceptions:runtime_exception",
         "//common/types",
         "//common/types:type_providers",
         "//common/values",
@@ -61,12 +62,15 @@ java_library(
         "//runtime:dispatcher",
         "//runtime:evaluation_exception",
         "//runtime:evaluation_exception_builder",
+        "//runtime:function_binding",
         "//runtime:function_overload",
         "//runtime:resolved_overload",
         "//runtime:runtime_equality",
+        "//runtime:runtime_helpers",
         "@maven//:com_google_code_findbugs_annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
+        "@maven//:com_google_re2j_re2j",
         "@maven//:org_jspecify_jspecify",
     ],
 )
@@ -718,6 +722,7 @@ cel_android_library(
         "//common/ast:ast_android",
         "//common/ast:cel_block_android",
         "//common/exceptions:overload_not_found",
+        "//common/exceptions:runtime_exception",
         "//common/types:type_providers_android",
         "//common/types:types_android",
         "//common/values:cel_value_provider_android",
@@ -726,11 +731,14 @@ cel_android_library(
         "//runtime:dispatcher_android",
         "//runtime:evaluation_exception",
         "//runtime:evaluation_exception_builder",
+        "//runtime:function_binding_android",
         "//runtime:function_overload_android",
         "//runtime:resolved_overload_android",
         "//runtime:runtime_equality_android",
+        "//runtime:runtime_helpers_android",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
+        "@maven//:com_google_re2j_re2j",
         "@maven//:org_jspecify_jspecify",
         "@maven_android//:com_google_guava_guava",
     ],

runtime/src/main/java/dev/cel/runtime/planner/EvalConstant.java

@@ -29,6 +29,10 @@ Object evalInternal(GlobalResolver resolver, ExecutionFrame frame) {
     return constant;
   }
 
+  Object constantValue() {
+    return constant;
+  }
+
   static EvalConstant create(CelExpr expr, Object value) {
     return new EvalConstant(expr, value);
   }

runtime/src/main/java/dev/cel/runtime/planner/ProgramPlanner.java

@@ -25,6 +25,7 @@
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.errorprone.annotations.CheckReturnValue;
 import com.google.errorprone.annotations.Immutable;
+import com.google.re2j.Pattern;
 import dev.cel.common.CelAbstractSyntaxTree;
 import dev.cel.common.CelContainer;
 import dev.cel.common.CelOptions;
@@ -43,6 +44,7 @@
 import dev.cel.common.ast.CelExpr.ExprKind.Kind;
 import dev.cel.common.ast.CelReference;
 import dev.cel.common.exceptions.CelOverloadNotFoundException;
+import dev.cel.common.exceptions.CelRuntimeException;
 import dev.cel.common.types.CelKind;
 import dev.cel.common.types.CelType;
 import dev.cel.common.types.CelTypeProvider;
@@ -54,9 +56,11 @@
 import dev.cel.runtime.CelAsyncFunctionOverload;
 import dev.cel.runtime.CelEvaluationException;
 import dev.cel.runtime.CelEvaluationExceptionBuilder;
+import dev.cel.runtime.CelFunctionBinding;
 import dev.cel.runtime.CelResolvedOverload;
 import dev.cel.runtime.DefaultDispatcher;
 import dev.cel.runtime.RuntimeEquality;
+import dev.cel.runtime.RuntimeHelpers;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.NoSuchElementException;
@@ -71,6 +75,8 @@
 @Internal
 public final class ProgramPlanner {
   private static final String MAP_INSERT_FUNCTION = "cel.@mapInsert";
+  private static final ImmutableList<Class<?>> MATCHES_PARAMETER_TYPES =
+      ImmutableList.of(String.class, String.class);
 
   private final CelTypeProvider typeProvider;
   private final CelValueProvider valueProvider;
@@ -107,10 +113,11 @@ public PlannedProgram plan(CelAbstractSyntaxTree ast) throws CelEvaluationExcept
               .map(celBlock -> planBlock(celBlock, ctx))
               .orElseGet(() -> plan(ast.getExpr(), ctx));
     } catch (RuntimeException e) {
-      throw CelEvaluationExceptionBuilder.newBuilder(e.getMessage())
-          .setMetadata(errorMetadata, ast.getExpr().id())
-          .setCause(e)
-          .build();
+      CelEvaluationExceptionBuilder builder =
+          e instanceof CelRuntimeException
+              ? CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) e)
+              : CelEvaluationExceptionBuilder.newBuilder(e.getMessage()).setCause(e);
+      throw builder.setMetadata(errorMetadata, ast.getExpr().id()).build();
     }
 
     return PlannedProgram.create(
@@ -355,6 +362,11 @@ private PlannedInterpretable planCall(CelExpr expr, PlannerContext ctx) {
               evaluatedArgs[1],
               celValueConverter);
         }
+        PlannedInterpretable regexMatches =
+            maybePlanRegexMatches(expr, resolvedOverload, evaluatedArgs).orElse(null);
+        if (regexMatches != null) {
+          return regexMatches;
+        }
         return EvalBinary.create(
             expr,
             functionName,
@@ -368,6 +380,39 @@ private PlannedInterpretable planCall(CelExpr expr, PlannerContext ctx) {
     }
   }
 
+  private Optional<PlannedInterpretable> maybePlanRegexMatches(
+      CelExpr expr, CelResolvedOverload resolvedOverload, PlannedInterpretable[] evaluatedArgs) {
+    String overloadId = resolvedOverload.getOverloadId();
+    if (!overloadId.equals("matches") && !overloadId.equals("matches_string")) {
+      return Optional.empty();
+    }
+    if (!resolvedOverload.getParameterTypes().equals(MATCHES_PARAMETER_TYPES)) {
+      return Optional.empty();
+    }
+    if (!(evaluatedArgs[1] instanceof EvalConstant)) {
+      return Optional.empty();
+    }
+    Object rawConstant = ((EvalConstant) evaluatedArgs[1]).constantValue();
+    if (!(rawConstant instanceof String)) {
+      return Optional.empty();
+    }
+    Pattern compiledPattern = RuntimeHelpers.compileRegexPattern((String) rawConstant, options);
+    CelFunctionBinding binding =
+        CelFunctionBinding.from(
+            overloadId,
+            String.class,
+            target -> RuntimeHelpers.matches(target, compiledPattern, options));
+    CelResolvedOverload unaryOverload =
+        CelResolvedOverload.of(
+            "matches",
+            overloadId,
+            binding.getDefinition(),
+            binding.isStrict(),
+            binding.getArgTypes());
+    return Optional.of(
+        EvalUnary.create(expr, "matches", unaryOverload, evaluatedArgs[0], celValueConverter));
+  }
+
   private PlannedInterpretable planBlock(CelBlock celBlock, PlannerContext ctx) {
     ImmutableList<CelExpr> indices = celBlock.indices();
 

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

@@ -1045,7 +1045,6 @@ java_library(
     deps = [
         ":standard_overload",
         "//common:options",
-        "//common/exceptions:invalid_argument",
         "//runtime:function_binding",
         "//runtime:runtime_equality",
         "//runtime:runtime_helpers",
@@ -1063,7 +1062,6 @@ cel_android_library(
         ":standard_function_android",
         ":standard_overload_android",
         "//common:options",
-        "//common/exceptions:invalid_argument",
         "//runtime:function_binding_android",
         "//runtime:runtime_equality_android",
         "//runtime:runtime_helpers_android",

runtime/src/main/java/dev/cel/runtime/standard/MatchesFunction.java

@@ -16,7 +16,6 @@
 
 import com.google.common.collect.ImmutableSet;
 import dev.cel.common.CelOptions;
-import dev.cel.common.exceptions.CelInvalidArgumentException;
 import dev.cel.runtime.CelFunctionBinding;
 import dev.cel.runtime.RuntimeEquality;
 import dev.cel.runtime.RuntimeHelpers;
@@ -46,27 +45,17 @@ public enum MatchesOverload implements CelStandardOverload {
                 "matches",
                 String.class,
                 String.class,
-                (String string, String regexp) -> {
-                  try {
-                    return RuntimeHelpers.matches(string, regexp, celOptions);
-                  } catch (RuntimeException e) {
-                    throw new CelInvalidArgumentException(e);
-                  }
-                })),
+                (String string, String regexp) ->
+                    RuntimeHelpers.matches(string, regexp, celOptions))),
     // Duplicate receiver-style matches overload.
     MATCHES_STRING(
         (celOptions, runtimeEquality) ->
             CelFunctionBinding.from(
                 "matches_string",
                 String.class,
                 String.class,
-                (String string, String regexp) -> {
-                  try {
-                    return RuntimeHelpers.matches(string, regexp, celOptions);
-                  } catch (RuntimeException e) {
-                    throw new CelInvalidArgumentException(e);
-                  }
-                })),
+                (String string, String regexp) ->
+                    RuntimeHelpers.matches(string, regexp, celOptions))),
     ;
 
     private final CelStandardOverload standardOverload;