Fix operator overloads: remove _==_/_!=_, fix _%_, add size(bytes)->int64

FunctionDecl for operators replaces the entire built-in, removing all
standard overloads. The previous _==_ and _!=_ FunctionDecls broke
bool/bool, int/int, bytes/bytes, etc. equality comparisons.

Fix by:
- Removing _==_ and _!=_ FunctionDecls entirely
- Adding size(bytes)->int64 overload so "this.size() == 4" uses the
  built-in _==_(int64, int64) instead of needing cross-type equality
- Fixing _%_ to include all standard overloads (int/int, uint/uint)
  plus the cross-type (int/uint)->uint overload

Author: stefanvanburen

protovalidate/internal/extra_func.py

@@ -1778,59 +1778,53 @@ def make_extra_funcs() -> cel.CelExtension:
                     )
                 ],
             ),
-            # Cross-type int/uint arithmetic overloads.
-            # CEL predefined rules for uint types use uint literals (e.g. "this % 2u == 0u"),
-            # but Python int values are mapped to CEL int64. These overloads bridge the gap.
+            # Override size(bytes) -> int64 so that comparisons like "this.size() == 4"
+            # use the built-in _==_(int64, int64) operator. The C++ CEL runtime's built-in
+            # size(bytes) returns uint64, but integer literals (e.g. 4) are int64, causing
+            # "this.size() == 4" to always be false due to strict type checking.
+            # Extension function FunctionDecls add overloads without replacing other
+            # parameter-type variants, so size(string)/size(list)/size(map) are unaffected.
             cel.FunctionDecl(
-                "_%_",
+                "size",
                 [
                     cel.Overload(
-                        "_mod__int_uint",
+                        "size_bytes_int",
                         return_type=cel.Type.INT,
-                        parameters=[cel.Type.INT, cel.Type.UINT],
-                        is_member=False,
-                        impl=lambda a, b: a % b,
+                        parameters=[cel.Type.BYTES],
+                        is_member=True,
+                        impl=lambda b: len(b),
                     ),
                 ],
             ),
-            # Cross-type int/uint equality overloads.
-            # CEL built-in size() for bytes returns uint64, but integer literals are int64.
-            # These overloads allow comparisons like "this.size() == 4" to work correctly.
+            # Cross-type int/uint modulo overload.
+            # CEL predefined rules for uint types use uint literals (e.g. "this % 2u == 0u"),
+            # but Python int values are mapped to CEL int64. The result is uint64 so that
+            # the subsequent "== 0u" comparison uses the built-in _==_(uint64, uint64).
+            # Operator FunctionDecls replace the built-in, so all standard overloads must
+            # be included here alongside the cross-type overload.
             cel.FunctionDecl(
-                "_==_",
+                "_%_",
                 [
                     cel.Overload(
-                        "_eq__int_uint",
-                        return_type=cel.Type.BOOL,
-                        parameters=[cel.Type.INT, cel.Type.UINT],
+                        "_mod__int_int",
+                        return_type=cel.Type.INT,
+                        parameters=[cel.Type.INT, cel.Type.INT],
                         is_member=False,
-                        impl=lambda a, b: a == b,
+                        impl=lambda a, b: a % b,
                     ),
                     cel.Overload(
-                        "_eq__uint_int",
-                        return_type=cel.Type.BOOL,
-                        parameters=[cel.Type.UINT, cel.Type.INT],
+                        "_mod__uint_uint",
+                        return_type=cel.Type.UINT,
+                        parameters=[cel.Type.UINT, cel.Type.UINT],
                         is_member=False,
-                        impl=lambda a, b: a == b,
+                        impl=lambda a, b: a % b,
                     ),
-                ],
-            ),
-            cel.FunctionDecl(
-                "_!=_",
-                [
                     cel.Overload(
-                        "_ne__int_uint",
-                        return_type=cel.Type.BOOL,
+                        "_mod__int_uint",
+                        return_type=cel.Type.UINT,
                         parameters=[cel.Type.INT, cel.Type.UINT],
                         is_member=False,
-                        impl=lambda a, b: a != b,
-                    ),
-                    cel.Overload(
-                        "_ne__uint_int",
-                        return_type=cel.Type.BOOL,
-                        parameters=[cel.Type.UINT, cel.Type.INT],
-                        is_member=False,
-                        impl=lambda a, b: a != b,
+                        impl=lambda a, b: a % b,
                     ),
                 ],
             ),