Update TypeChecker builder to error when adding overloads that overlap with built-in macros.

PiperOrigin-RevId: 689157529

Author: jnthntatum

checker/BUILD

@@ -90,6 +90,10 @@ cc_library(
         "//checker/internal:type_checker_impl",
         "//common:decl",
         "//common:type",
+        "//internal:status_macros",
+        "//parser:macro",
+        "@com_google_absl//absl/base:no_destructor",
+        "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/status",

checker/type_checker_builder.cc

@@ -13,10 +13,14 @@
 // limitations under the License.
 #include "checker/type_checker_builder.h"
 
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
+#include "absl/base/no_destructor.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -26,8 +30,51 @@
 #include "checker/type_checker.h"
 #include "common/decl.h"
 #include "common/type_introspector.h"
+#include "internal/status_macros.h"
+#include "parser/macro.h"
 
 namespace cel {
+namespace {
+
+const absl::flat_hash_map<std::string, std::vector<Macro>>& GetStdMacros() {
+  static const absl::NoDestructor<
+      absl::flat_hash_map<std::string, std::vector<Macro>>>
+      kStdMacros({
+          {"has", {HasMacro()}},
+          {"all", {AllMacro()}},
+          {"exists", {ExistsMacro()}},
+          {"exists_one", {ExistsOneMacro()}},
+          {"filter", {FilterMacro()}},
+          {"map", {Map2Macro(), Map3Macro()}},
+          {"optMap", {OptMapMacro()}},
+          {"optFlatMap", {OptFlatMapMacro()}},
+      });
+  return *kStdMacros;
+}
+
+absl::Status CheckStdMacroOverlap(const FunctionDecl& decl) {
+  const auto& std_macros = GetStdMacros();
+  auto it = std_macros.find(decl.name());
+  if (it == std_macros.end()) {
+    return absl::OkStatus();
+  }
+  const auto& macros = it->second;
+  for (const auto& macro : macros) {
+    bool macro_member = macro.is_receiver_style();
+    size_t macro_arg_count = macro.argument_count() + (macro_member ? 1 : 0);
+    for (const auto& ovl : decl.overloads()) {
+      if (ovl.member() == macro_member &&
+          ovl.args().size() == macro_arg_count) {
+        return absl::InvalidArgumentError(absl::StrCat(
+            "overload for name '", macro.function(), "' with ", macro_arg_count,
+            " argument(s) overlaps with predefined macro"));
+      }
+    }
+  }
+  return absl::OkStatus();
+}
+
+}  // namespace
 
 absl::StatusOr<std::unique_ptr<TypeChecker>> TypeCheckerBuilder::Build() && {
   if (env_.type_providers().empty() && env_.parent() == nullptr) {
@@ -61,6 +108,7 @@ absl::Status TypeCheckerBuilder::AddVariable(const VariableDecl& decl) {
 }
 
 absl::Status TypeCheckerBuilder::AddFunction(const FunctionDecl& decl) {
+  CEL_RETURN_IF_ERROR(CheckStdMacroOverlap(decl));
   bool inserted = env_.InsertFunctionIfAbsent(decl);
   if (!inserted) {
     return absl::AlreadyExistsError(
@@ -75,6 +123,8 @@ absl::Status TypeCheckerBuilder::MergeFunction(const FunctionDecl& decl) {
     return AddFunction(decl);
   }
 
+  CEL_RETURN_IF_ERROR(CheckStdMacroOverlap(decl));
+
   FunctionDecl merged = *existing;
 
   for (const auto& overload : decl.overloads()) {

checker/type_checker_builder_test.cc

@@ -139,5 +139,93 @@ TEST(TypeCheckerBuilderTest, AddLibraryForwardsErrors) {
               StatusIs(absl::StatusCode::kInternal, HasSubstr("test error")));
 }
 
+TEST(TypeCheckerBuilderTest, AddFunctionOverlapsWithStdMacroError) {
+  TypeCheckerBuilder builder;
+
+  ASSERT_OK_AND_ASSIGN(
+      auto fn_decl, MakeFunctionDecl("map", MakeMemberOverloadDecl(
+                                                "ovl_3", ListType(), ListType(),
+                                                DynType(), DynType())));
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'map' with 3 argument(s) overlaps "
+                       "with predefined macro"));
+
+  fn_decl.set_name("filter");
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'filter' with 3 argument(s) overlaps "
+                       "with predefined macro"));
+
+  fn_decl.set_name("exists");
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'exists' with 3 argument(s) overlaps "
+                       "with predefined macro"));
+
+  fn_decl.set_name("exists_one");
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'exists_one' with 3 argument(s) "
+                       "overlaps with predefined macro"));
+
+  fn_decl.set_name("all");
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'all' with 3 argument(s) overlaps "
+                       "with predefined macro"));
+
+  fn_decl.set_name("optMap");
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'optMap' with 3 argument(s) overlaps "
+                       "with predefined macro"));
+
+  fn_decl.set_name("optFlatMap");
+
+  EXPECT_THAT(
+      builder.AddFunction(fn_decl),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               "overload for name 'optFlatMap' with 3 argument(s) overlaps "
+               "with predefined macro"));
+
+  ASSERT_OK_AND_ASSIGN(
+      fn_decl, MakeFunctionDecl(
+                   "has", MakeOverloadDecl("ovl_1", BoolType(), DynType())));
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'has' with 1 argument(s) overlaps "
+                       "with predefined macro"));
+
+  ASSERT_OK_AND_ASSIGN(
+      fn_decl, MakeFunctionDecl("map", MakeMemberOverloadDecl(
+                                           "ovl_4", ListType(), ListType(),
+
+                                           DynType(), DynType(), DynType())));
+
+  EXPECT_THAT(builder.AddFunction(fn_decl),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "overload for name 'map' with 4 argument(s) overlaps "
+                       "with predefined macro"));
+}
+
+TEST(TypeCheckerBuilderTest, AddFunctionNoOverlapWithStdMacroError) {
+  TypeCheckerBuilder builder;
+
+  ASSERT_OK_AND_ASSIGN(
+      auto fn_decl,
+      MakeFunctionDecl("has", MakeMemberOverloadDecl("ovl", BoolType(),
+                                                     DynType(), StringType())));
+
+  EXPECT_THAT(builder.AddFunction(fn_decl), IsOk());
+}
+
 }  // namespace
 }  // namespace cel