Add support for resolving aliases.

PiperOrigin-RevId: 904596936

Author: jnthntatum

checker/internal/BUILD

@@ -89,8 +89,12 @@ cc_library(
     srcs = ["namespace_generator.cc"],
     hdrs = ["namespace_generator.h"],
     deps = [
+        "//common:container",
         "//internal:lexis",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/functional:function_ref",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
@@ -104,6 +108,7 @@ cc_test(
     srcs = ["namespace_generator_test.cc"],
     deps = [
         ":namespace_generator",
+        "//common:container",
         "//internal:testing",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/strings:string_view",

checker/internal/namespace_generator.cc

@@ -20,27 +20,28 @@
 #include <vector>
 
 #include "absl/functional/function_ref.h"
-#include "absl/status/status.h"
+#include "absl/log/absl_check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "common/container.h"
 #include "internal/lexis.h"
 
 namespace cel::checker_internal {
 namespace {
 
-bool FieldSelectInterpretationCandidates(
+bool FieldSelectInterpretationCandidatesImpl(
     absl::string_view prefix,
-    absl::Span<const std::string> partly_qualified_name,
+    absl::Span<const std::string> partly_qualified_name, bool prefix_is_alias,
     absl::FunctionRef<bool(absl::string_view, int)> callback) {
   for (int i = 0; i < partly_qualified_name.size(); ++i) {
     std::string buf;
     int count = partly_qualified_name.size() - i;
-    auto end_idx = count - 1;
+    auto end_idx = count - (prefix_is_alias ? 0 : 1);
     auto ident = absl::StrJoin(partly_qualified_name.subspan(0, count), ".");
     absl::string_view candidate = ident;
     if (absl::StartsWith(candidate, ".")) {
@@ -54,28 +55,44 @@ bool FieldSelectInterpretationCandidates(
       return false;
     }
   }
+  if (prefix_is_alias) {
+    return callback(prefix, 0);
+  }
   return true;
 }
 
+bool FieldSelectInterpretationCandidates(
+    absl::string_view prefix,
+    absl::Span<const std::string> partly_qualified_name,
+    absl::FunctionRef<bool(absl::string_view, int)> callback) {
+  return FieldSelectInterpretationCandidatesImpl(
+      prefix, partly_qualified_name, /*prefix_is_alias=*/false, callback);
+}
+
+bool FieldSelectInterpretationCandidatesWithAlias(
+    absl::string_view prefix,
+    absl::Span<const std::string> partly_qualified_name,
+    absl::FunctionRef<bool(absl::string_view, int)> callback) {
+  return FieldSelectInterpretationCandidatesImpl(
+      prefix, partly_qualified_name, /*prefix_is_alias=*/true, callback);
+}
+
 }  // namespace
 
 absl::StatusOr<NamespaceGenerator> NamespaceGenerator::Create(
-    absl::string_view container) {
+    const ExpressionContainer& expression_container) {
   std::vector<std::string> candidates;
 
+  absl::string_view container = expression_container.container();
   if (container.empty()) {
-    return NamespaceGenerator(std::move(candidates));
+    return NamespaceGenerator(&expression_container, std::move(candidates));
   }
 
-  if (absl::StartsWith(container, ".")) {
-    return absl::InvalidArgumentError("container must not start with a '.'");
-  }
   std::string prefix;
   for (auto segment : absl::StrSplit(container, '.')) {
-    if (!internal::LexisIsIdentifier(segment)) {
-      return absl::InvalidArgumentError(
-          "container must only contain valid identifier segments");
-    }
+    // Assumes the the ExpressionContainer has already validated the container
+    // and aliases.
+    ABSL_DCHECK(internal::LexisIsIdentifier(segment));
     if (prefix.empty()) {
       prefix = segment;
     } else {
@@ -84,31 +101,75 @@ absl::StatusOr<NamespaceGenerator> NamespaceGenerator::Create(
     candidates.push_back(prefix);
   }
   std::reverse(candidates.begin(), candidates.end());
-  return NamespaceGenerator(std::move(candidates));
+  return NamespaceGenerator(&expression_container, std::move(candidates));
 }
 
 void NamespaceGenerator::GenerateCandidates(
-    absl::string_view unqualified_name,
-    absl::FunctionRef<bool(absl::string_view)> callback) {
-  if (absl::StartsWith(unqualified_name, ".")) {
-    callback(unqualified_name.substr(1));
+    absl::string_view simple_name,
+    absl::FunctionRef<bool(absl::string_view)> callback) const {
+  // Special case for root-relative names. Aliases still apply first.
+  bool is_root_relative = absl::StartsWith(simple_name, ".");
+  if (is_root_relative) {
+    simple_name = simple_name.substr(1);
+  }
+
+  // The name is unqualified, but may include a namespace (struct creation).
+  // This is just a quirk of the parser.
+  if (auto dot_pos = simple_name.find('.');
+      dot_pos != absl::string_view::npos) {
+    absl::string_view first_segment = simple_name.substr(0, dot_pos);
+    absl::string_view rest = simple_name.substr(dot_pos + 1);
+    if (auto resolved_alias = expression_container_->FindAlias(first_segment);
+        !resolved_alias.empty()) {
+      callback(absl::StrCat(resolved_alias, ".", rest));
+      return;
+    }
+  } else {
+    if (auto resolved_alias = expression_container_->FindAlias(simple_name);
+        !resolved_alias.empty()) {
+      callback(resolved_alias);
+      return;
+    }
+  }
+
+  if (is_root_relative) {
+    callback(simple_name);
     return;
   }
+
   for (const auto& prefix : candidates_) {
-    std::string candidate = absl::StrCat(prefix, ".", unqualified_name);
+    std::string candidate = absl::StrCat(prefix, ".", simple_name);
     if (!callback(candidate)) {
       return;
     }
   }
-  callback(unqualified_name);
+  callback(simple_name);
 }
 
 void NamespaceGenerator::GenerateCandidates(
     absl::Span<const std::string> partly_qualified_name,
-    absl::FunctionRef<bool(absl::string_view, int)> callback) {
-  // Special case for explicit root relative name. e.g. '.com.example.Foo'
-  if (!partly_qualified_name.empty() &&
-      absl::StartsWith(partly_qualified_name[0], ".")) {
+    absl::FunctionRef<bool(absl::string_view, int)> callback) const {
+  if (partly_qualified_name.empty()) {
+    return;
+  }
+
+  // Special case for root-relative names. Aliases still apply first.
+  absl::string_view first_segment = partly_qualified_name[0];
+  bool is_root_relative = absl::StartsWith(first_segment, ".");
+  if (is_root_relative) {
+    first_segment = first_segment.substr(1);
+  }
+
+  if (auto resolved_alias = expression_container_->FindAlias(first_segment);
+      !resolved_alias.empty()) {
+    FieldSelectInterpretationCandidatesWithAlias(
+        resolved_alias, partly_qualified_name.subspan(1), callback);
+    // If the alias matches, we don't check the container even if name
+    // resolution fails.
+    return;
+  }
+
+  if (is_root_relative) {
     FieldSelectInterpretationCandidates("", partly_qualified_name, callback);
     return;
   }

checker/internal/namespace_generator.h

@@ -19,18 +19,26 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/attributes.h"
+#include "absl/base/nullability.h"
 #include "absl/functional/function_ref.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "common/container.h"
 
 namespace cel::checker_internal {
 
 // Utility class for generating namespace qualified candidates for reference
 // resolution.
+//
+// This class is expected to be scoped to a single type checking operation and
+// borrows the ExpressionContainer from the TypeCheckEnv.
 class NamespaceGenerator {
  public:
-  static absl::StatusOr<NamespaceGenerator> Create(absl::string_view container);
+  static absl::StatusOr<NamespaceGenerator> Create(
+      const ExpressionContainer& expression_container
+          ABSL_ATTRIBUTE_LIFETIME_BOUND);
 
   // Copyable and movable.
   NamespaceGenerator(const NamespaceGenerator&) = default;
@@ -51,8 +59,18 @@ class NamespaceGenerator {
   // and unqualified name foo
   //
   // com.google.foo, com.foo, foo
-  void GenerateCandidates(absl::string_view unqualified_name,
-                          absl::FunctionRef<bool(absl::string_view)> callback);
+  //
+  // If aliases are present, they override the normal container resolution.
+  //
+  // Example:
+  // container (com.google)
+  // alias (foo = com.example)
+  // unqualified name foo
+  //
+  // com.example
+  void GenerateCandidates(
+      absl::string_view simple_name,
+      absl::FunctionRef<bool(absl::string_view)> callback) const;
 
   // For a partially qualified name, generate all the qualified candidates in
   // order of resolution precedence and pass them to the provided callback. The
@@ -72,16 +90,30 @@ class NamespaceGenerator {
   // (com.Foo).bar, <com.Foo, 0>
   // (Foo.bar), <Foo.bar, 1>
   // (Foo).bar, <Foo, 0>
+  //
+  // If aliases are present, they override the normal container resolution.
+  //
+  // Example:
+  // container (com.google)
+  // alias (Foo = com.example.Foo)
+  // partially qualified name Foo.bar
+  //
+  // (com.example.Foo.bar), <com.example.Foo.bar, 1>
+  // (com.example.Foo).bar, <com.example.Foo, 0>
   void GenerateCandidates(
       absl::Span<const std::string> partly_qualified_name,
-      absl::FunctionRef<bool(absl::string_view, int)> callback);
+      absl::FunctionRef<bool(absl::string_view, int)> callback) const;
 
  private:
-  explicit NamespaceGenerator(std::vector<std::string> candidates)
-      : candidates_(std::move(candidates)) {}
+  explicit NamespaceGenerator(
+      const ExpressionContainer* absl_nonnull expression_container,
+      std::vector<std::string> candidates)
+      : candidates_(std::move(candidates)),
+        expression_container_(expression_container) {}
 
   // list of prefixes ordered from most qualified to least.
   std::vector<std::string> candidates_;
+  const ExpressionContainer* absl_nonnull expression_container_;
 };
 }  // namespace cel::checker_internal
 

checker/internal/namespace_generator_test.cc

@@ -18,19 +18,20 @@
 #include <utility>
 #include <vector>
 
-#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "common/container.h"
 #include "internal/testing.h"
 
 namespace cel::checker_internal {
 namespace {
 
-using ::absl_testing::StatusIs;
+using ::absl_testing::IsOk;
 using ::testing::ElementsAre;
 using ::testing::Pair;
 
 TEST(NamespaceGeneratorTest, EmptyContainer) {
-  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(""));
+  ExpressionContainer container;
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
   std::vector<std::string> candidates;
   generator.GenerateCandidates("foo", [&](absl::string_view candidate) {
     candidates.push_back(std::string(candidate));
@@ -40,8 +41,9 @@ TEST(NamespaceGeneratorTest, EmptyContainer) {
 }
 
 TEST(NamespaceGeneratorTest, MultipleSegments) {
-  ASSERT_OK_AND_ASSIGN(auto generator,
-                       NamespaceGenerator::Create("com.example"));
+  ExpressionContainer container;
+  ASSERT_THAT(container.SetContainer("com.example"), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
   std::vector<std::string> candidates;
   generator.GenerateCandidates("foo", [&](absl::string_view candidate) {
     candidates.push_back(std::string(candidate));
@@ -51,8 +53,9 @@ TEST(NamespaceGeneratorTest, MultipleSegments) {
 }
 
 TEST(NamespaceGeneratorTest, MultipleSegmentsRootNamespace) {
-  ASSERT_OK_AND_ASSIGN(auto generator,
-                       NamespaceGenerator::Create("com.example"));
+  ExpressionContainer container;
+  ASSERT_THAT(container.SetContainer("com.example"), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
   std::vector<std::string> candidates;
   generator.GenerateCandidates(".foo", [&](absl::string_view candidate) {
     candidates.push_back(std::string(candidate));
@@ -61,18 +64,46 @@ TEST(NamespaceGeneratorTest, MultipleSegmentsRootNamespace) {
   EXPECT_THAT(candidates, ElementsAre("foo"));
 }
 
-TEST(NamespaceGeneratorTest, InvalidContainers) {
-  EXPECT_THAT(NamespaceGenerator::Create(".com.example"),
-              StatusIs(absl::StatusCode::kInvalidArgument));
-  EXPECT_THAT(NamespaceGenerator::Create("com..example"),
-              StatusIs(absl::StatusCode::kInvalidArgument));
-  EXPECT_THAT(NamespaceGenerator::Create("com.$example"),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretation) {
+  ExpressionContainer container;
+  ASSERT_THAT(container.SetContainer("com.example"), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
+  std::vector<std::string> qualified_ident = {"foo", "Bar"};
+  std::vector<std::pair<std::string, int>> candidates;
+  generator.GenerateCandidates(
+      qualified_ident, [&](absl::string_view candidate, int segment_index) {
+        candidates.push_back(std::pair(std::string(candidate), segment_index));
+        return true;
+      });
+  EXPECT_THAT(
+      candidates,
+      ElementsAre(Pair("com.example.foo.Bar", 1), Pair("com.example.foo", 0),
+                  Pair("com.foo.Bar", 1), Pair("com.foo", 0),
+                  Pair("foo.Bar", 1), Pair("foo", 0)));
 }
 
-TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretation) {
-  ASSERT_OK_AND_ASSIGN(auto generator,
-                       NamespaceGenerator::Create("com.example"));
+TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretationAliasMatch) {
+  ExpressionContainer container;
+  ASSERT_THAT(container.SetContainer("com.example"), IsOk());
+  ASSERT_THAT(container.AddAlias("foo", "bar.baz"), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
+  std::vector<std::string> qualified_ident = {"foo", "Bar"};
+  std::vector<std::pair<std::string, int>> candidates;
+  generator.GenerateCandidates(
+      qualified_ident, [&](absl::string_view candidate, int segment_index) {
+        candidates.push_back(std::pair(std::string(candidate), segment_index));
+        return true;
+      });
+  EXPECT_THAT(candidates,
+              ElementsAre(Pair("bar.baz.Bar", 1), Pair("bar.baz", 0)));
+}
+
+TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretationAliasNoMatch) {
+  ExpressionContainer container;
+  ASSERT_THAT(container.SetContainer("com.example"), IsOk());
+  ASSERT_THAT(container.AddAbbreviation("foo.Bar"), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
+  // No match on the alias (Bar) since it's not the first segment.
   std::vector<std::string> qualified_ident = {"foo", "Bar"};
   std::vector<std::pair<std::string, int>> candidates;
   generator.GenerateCandidates(
@@ -89,8 +120,9 @@ TEST(NamespaceGeneratorTest, MultipleSegmentsSelectInterpretation) {
 
 TEST(NamespaceGeneratorTest,
      MultipleSegmentsSelectInterpretationRootNamespace) {
-  ASSERT_OK_AND_ASSIGN(auto generator,
-                       NamespaceGenerator::Create("com.example"));
+  ExpressionContainer container;
+  ASSERT_THAT(container.SetContainer("com.example"), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto generator, NamespaceGenerator::Create(container));
   std::vector<std::string> qualified_ident = {".foo", "Bar"};
   std::vector<std::pair<std::string, int>> candidates;
   generator.GenerateCandidates(