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",
@@ -470,8 +471,17 @@ java_library(
     deps = [
         ":attribute",
         ":eval_attribute",
+        ":eval_const",
+        ":eval_unary",
         ":planned_interpretable",
+        "//common:options",
         "//common/ast",
+        "//common/values",
+        "//runtime:function_binding",
+        "//runtime:resolved_overload",
+        "//runtime:runtime_helpers",
+        "@maven//:com_google_guava_guava",
+        "@maven//:com_google_re2j_re2j",
     ],
 )
 
@@ -718,6 +728,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",
@@ -1137,8 +1148,17 @@ cel_android_library(
     deps = [
         ":attribute_android",
         ":eval_attribute_android",
+        ":eval_const_android",
+        ":eval_unary_android",
         ":planned_interpretable_android",
+        "//common:options",
         "//common/ast:ast_android",
+        "//common/values:values_android",
+        "//runtime:function_binding_android",
+        "//runtime:resolved_overload_android",
+        "//runtime:runtime_helpers_android",
+        "@maven//:com_google_re2j_re2j",
+        "@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/PlannerHelpers.java

@@ -14,9 +14,20 @@
 
 package dev.cel.runtime.planner;
 
+import com.google.common.collect.ImmutableList;
+import com.google.re2j.Pattern;
+import dev.cel.common.CelOptions;
 import dev.cel.common.ast.CelConstant;
+import dev.cel.common.ast.CelExpr;
+import dev.cel.common.values.CelValueConverter;
+import dev.cel.runtime.CelFunctionBinding;
+import dev.cel.runtime.CelResolvedOverload;
+import dev.cel.runtime.RuntimeHelpers;
+import java.util.Optional;
 
 final class PlannerHelpers {
+  private static final ImmutableList<Class<?>> MATCHES_PARAMETER_TYPES =
+      ImmutableList.of(String.class, String.class);
 
   static Attribute resolveBaseAttribute(
       PlannedInterpretable operand, AttributeFactory attributeFactory) {
@@ -47,5 +58,42 @@ static Object resolveConstant(CelConstant celConstant) {
     }
   }
 
+  static Optional<PlannedInterpretable> maybePlanRegexMatches(
+      CelExpr expr,
+      CelResolvedOverload resolvedOverload,
+      PlannedInterpretable[] evaluatedArgs,
+      CelOptions options,
+      CelValueConverter celValueConverter) {
+    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 PlannerHelpers() {}
 }

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

@@ -43,6 +43,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;
@@ -107,10 +108,15 @@ 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();
+      // Preserve specific CelErrorCode (e.g., INVALID_ARGUMENT, OVERLOAD_NOT_FOUND) from
+      // plan-time validation failures.
+      CelEvaluationExceptionBuilder builder;
+      if (e instanceof CelRuntimeException) {
+        builder = CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) e);
+      } else {
+        builder = CelEvaluationExceptionBuilder.newBuilder(e.getMessage()).setCause(e);
+      }
+      throw builder.setMetadata(errorMetadata, ast.getExpr().id()).build();
     }
 
     return PlannedProgram.create(
@@ -355,6 +361,13 @@ private PlannedInterpretable planCall(CelExpr expr, PlannerContext ctx) {
               evaluatedArgs[1],
               celValueConverter);
         }
+        PlannedInterpretable regexMatches =
+            PlannerHelpers.maybePlanRegexMatches(
+                    expr, resolvedOverload, evaluatedArgs, options, celValueConverter)
+                .orElse(null);
+        if (regexMatches != null) {
+          return regexMatches;
+        }
         return EvalBinary.create(
             expr,
             functionName,

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;