Merge pull request #159 from google/cpp-sync

OSS export

Author: kyessenov

base/ast.h

@@ -371,6 +371,15 @@ class CreateStruct {
 
     const Expr& map_key() const;
 
+    Expr& mutable_map_key() {
+      auto* value = absl::get_if<std::unique_ptr<Expr>>(&key_kind_);
+      if (value != nullptr) {
+        if (*value != nullptr) return **value;
+      }
+      key_kind_.emplace<std::unique_ptr<Expr>>(std::make_unique<Expr>());
+      return *absl::get<std::unique_ptr<Expr>>(key_kind_);
+    }
+
     bool has_value() const { return value_ != nullptr; }
 
     const Expr& value() const;
@@ -411,6 +420,8 @@ class CreateStruct {
 
   std::vector<Entry>& mutable_entries() { return entries_; }
 
+  const std::string& message_name() const { return message_name_; }
+
   bool operator==(const CreateStruct& other) const {
     return message_name_ == other.message_name_ && entries_ == other.entries_;
   }
@@ -672,6 +683,15 @@ class Expr {
     return *default_constant;
   }
 
+  Constant& mutable_const_expr() {
+    auto* value = absl::get_if<Constant>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<Constant>();
+    return absl::get<Constant>(expr_kind_);
+  }
+
   const Ident& ident_expr() const {
     auto* value = absl::get_if<Ident>(&expr_kind_);
     if (value != nullptr) {
@@ -681,6 +701,15 @@ class Expr {
     return *default_ident;
   }
 
+  Ident& mutable_ident_expr() {
+    auto* value = absl::get_if<Ident>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<Ident>();
+    return absl::get<Ident>(expr_kind_);
+  }
+
   const Select& select_expr() const {
     auto* value = absl::get_if<Select>(&expr_kind_);
     if (value != nullptr) {
@@ -690,6 +719,15 @@ class Expr {
     return *default_select;
   }
 
+  Select& mutable_select_expr() {
+    auto* value = absl::get_if<Select>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<Select>();
+    return absl::get<Select>(expr_kind_);
+  }
+
   const Call& call_expr() const {
     auto* value = absl::get_if<Call>(&expr_kind_);
     if (value != nullptr) {
@@ -699,6 +737,15 @@ class Expr {
     return *default_call;
   }
 
+  Call& mutable_call_expr() {
+    auto* value = absl::get_if<Call>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<Call>();
+    return absl::get<Call>(expr_kind_);
+  }
+
   const CreateList& list_expr() const {
     auto* value = absl::get_if<CreateList>(&expr_kind_);
     if (value != nullptr) {
@@ -708,6 +755,15 @@ class Expr {
     return *default_create_list;
   }
 
+  CreateList& mutable_list_expr() {
+    auto* value = absl::get_if<CreateList>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<CreateList>();
+    return absl::get<CreateList>(expr_kind_);
+  }
+
   const CreateStruct& struct_expr() const {
     auto* value = absl::get_if<CreateStruct>(&expr_kind_);
     if (value != nullptr) {
@@ -717,6 +773,15 @@ class Expr {
     return *default_create_struct;
   }
 
+  CreateStruct& mutable_struct_expr() {
+    auto* value = absl::get_if<CreateStruct>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<CreateStruct>();
+    return absl::get<CreateStruct>(expr_kind_);
+  }
+
   const Comprehension& comprehension_expr() const {
     auto* value = absl::get_if<Comprehension>(&expr_kind_);
     if (value != nullptr) {
@@ -726,6 +791,15 @@ class Expr {
     return *default_comprehension;
   }
 
+  Comprehension& mutable_comprehension_expr() {
+    auto* value = absl::get_if<Comprehension>(&expr_kind_);
+    if (value != nullptr) {
+      return *value;
+    }
+    expr_kind_.emplace<Comprehension>();
+    return absl::get<Comprehension>(expr_kind_);
+  }
+
   bool operator==(const Expr& other) const {
     return id_ == other.id_ && expr_kind_ == other.expr_kind_;
   }

base/ast_test.cc

@@ -172,6 +172,16 @@ TEST(AstTest, CreateStructEntryMutableValue) {
   ASSERT_EQ(absl::get<Ident>(entry.value().expr_kind()).name(), "var");
 }
 
+TEST(AstTest, CreateStructEntryMutableMapKey) {
+  CreateStruct::Entry entry;
+  entry.mutable_map_key().set_expr_kind(Ident("key"));
+  ASSERT_TRUE(absl::holds_alternative<Ident>(entry.map_key().expr_kind()));
+  ASSERT_EQ(absl::get<Ident>(entry.map_key().expr_kind()).name(), "key");
+  entry.mutable_map_key().set_expr_kind(Ident("new_key"));
+  ASSERT_TRUE(absl::holds_alternative<Ident>(entry.map_key().expr_kind()));
+  ASSERT_EQ(absl::get<Ident>(entry.map_key().expr_kind()).name(), "new_key");
+}
+
 TEST(AstTest, ExprConstructionComprehension) {
   Comprehension comprehension;
   comprehension.set_iter_var("iter_var");
@@ -385,6 +395,36 @@ TEST(AstTest, TypeComparatorTest) {
   EXPECT_FALSE(type.type() == Type());
 }
 
+TEST(AstTest, ExprMutableConstruction) {
+  Expr expr;
+  expr.mutable_const_expr().set_constant_kind(true);
+  ASSERT_TRUE(expr.has_const_expr());
+  EXPECT_TRUE(expr.const_expr().bool_value());
+  expr.mutable_ident_expr().set_name("expr");
+  ASSERT_TRUE(expr.has_ident_expr());
+  EXPECT_FALSE(expr.has_const_expr());
+  EXPECT_EQ(expr.ident_expr().name(), "expr");
+  expr.mutable_select_expr().set_field("field");
+  ASSERT_TRUE(expr.has_select_expr());
+  EXPECT_FALSE(expr.has_ident_expr());
+  EXPECT_EQ(expr.select_expr().field(), "field");
+  expr.mutable_call_expr().set_function("function");
+  ASSERT_TRUE(expr.has_call_expr());
+  EXPECT_FALSE(expr.has_select_expr());
+  EXPECT_EQ(expr.call_expr().function(), "function");
+  expr.mutable_list_expr();
+  EXPECT_TRUE(expr.has_list_expr());
+  EXPECT_FALSE(expr.has_call_expr());
+  expr.mutable_struct_expr().set_message_name("name");
+  ASSERT_TRUE(expr.has_struct_expr());
+  EXPECT_EQ(expr.struct_expr().message_name(), "name");
+  EXPECT_FALSE(expr.has_list_expr());
+  expr.mutable_comprehension_expr().set_accu_var("accu_var");
+  ASSERT_TRUE(expr.has_comprehension_expr());
+  EXPECT_FALSE(expr.has_list_expr());
+  EXPECT_EQ(expr.comprehension_expr().accu_var(), "accu_var");
+}
+
 }  // namespace
 }  // namespace internal
 }  // namespace ast

base/handle.h

@@ -188,7 +188,7 @@ class Persistent final : private base_internal::HandlePolicy<T> {
   friend struct base_internal::HandleFactory;
 
   template <typename... Args>
-  explicit Persistent(absl::in_place_t in_place, Args&&... args)
+  explicit Persistent(absl::in_place_t, Args&&... args)
       : impl_(std::forward<Args>(args)...) {}
 
   Handle impl_;

base/internal/data.h

@@ -162,15 +162,6 @@ class HeapData /* : public Data */ {
       0;
 };
 
-inline constexpr size_t HeapDataMetadataAndReferenceCountOffset() {
-  return offsetof(HeapData, metadata_and_reference_count_);
-}
-
-static_assert(HeapDataMetadataAndReferenceCountOffset() == sizeof(uintptr_t),
-              "Expected vptr to be at offset 0");
-static_assert(sizeof(HeapData) == sizeof(uintptr_t) * 2,
-              "Unexpected class size");
-
 // Provides introspection for `Data`.
 class Metadata final {
  public:
@@ -302,7 +293,8 @@ union alignas(Align) AnyDataStorage final {
 // dereference our stored pointers as it may have already been deleted. Thus we
 // need to know if it was arena allocated without dereferencing the pointer.
 template <size_t Size, size_t Align>
-struct AnyData {
+class AnyData {
+ public:
   static_assert(Size >= sizeof(uintptr_t),
                 "Size must be at least sizeof(uintptr_t)");
   static_assert(Align >= alignof(uintptr_t),

base/type.h

@@ -106,8 +106,7 @@ class PersistentTypeHandle final {
   PersistentTypeHandle() = default;
 
   template <typename T, typename... Args>
-  explicit PersistentTypeHandle(absl::in_place_type_t<T> in_place_type,
-                                Args&&... args) {
+  explicit PersistentTypeHandle(absl::in_place_type_t<T>, Args&&... args) {
     data_.ConstructInline<T>(std::forward<Args>(args)...);
   }
 

base/type_provider.h

@@ -49,7 +49,7 @@ class TypeProvider {
   //
   // An empty handle is returned if the provider cannot find the requested type.
   virtual absl::StatusOr<Persistent<const Type>> ProvideType(
-      TypeFactory& type_factory, absl::string_view name) const {
+      TypeFactory&, absl::string_view) const {
     return absl::UnimplementedError("ProvideType is not yet implemented");
   }
 };

eval/compiler/flat_expr_builder_short_circuiting_conformance_test.cc

@@ -252,8 +252,7 @@ TEST_P(ShortCircuitingTest, UnknownAnd) {
   const UnknownAttributeSet& attrs =
       result.UnknownSetOrDie()->unknown_attributes();
   ASSERT_THAT(attrs.attributes(), testing::SizeIs(1));
-  EXPECT_THAT(attrs.attributes()[0]->variable().ident_expr().name(),
-              testing::Eq("var1"));
+  EXPECT_THAT(attrs.attributes()[0]->variable_name(), testing::Eq("var1"));
 }
 
 TEST_P(ShortCircuitingTest, UnknownOr) {
@@ -285,8 +284,7 @@ TEST_P(ShortCircuitingTest, UnknownOr) {
   const UnknownAttributeSet& attrs =
       result.UnknownSetOrDie()->unknown_attributes();
   ASSERT_THAT(attrs.attributes(), testing::SizeIs(1));
-  EXPECT_THAT(attrs.attributes()[0]->variable().ident_expr().name(),
-              testing::Eq("var1"));
+  EXPECT_THAT(attrs.attributes()[0]->variable_name(), testing::Eq("var1"));
 }
 
 TEST_P(ShortCircuitingTest, BasicTernary) {
@@ -369,7 +367,7 @@ TEST_P(ShortCircuitingTest, TernaryUnknownCondHandling) {
   const auto& attrs =
       result.UnknownSetOrDie()->unknown_attributes().attributes();
   ASSERT_THAT(attrs, SizeIs(1));
-  EXPECT_THAT(attrs[0]->variable().ident_expr().name(), Eq("cond"));
+  EXPECT_THAT(attrs[0]->variable_name(), Eq("cond"));
 
   // Unknown branches are discarded if condition is unknown
   activation.set_unknown_attribute_patterns({CelAttributePattern("cond", {}),
@@ -382,7 +380,7 @@ TEST_P(ShortCircuitingTest, TernaryUnknownCondHandling) {
   const auto& attrs2 =
       result.UnknownSetOrDie()->unknown_attributes().attributes();
   ASSERT_THAT(attrs2, SizeIs(1));
-  EXPECT_THAT(attrs2[0]->variable().ident_expr().name(), Eq("cond"));
+  EXPECT_THAT(attrs2[0]->variable_name(), Eq("cond"));
 }
 
 TEST_P(ShortCircuitingTest, TernaryUnknownArgsHandling) {
@@ -418,7 +416,7 @@ TEST_P(ShortCircuitingTest, TernaryUnknownArgsHandling) {
   const auto& attrs3 =
       result.UnknownSetOrDie()->unknown_attributes().attributes();
   ASSERT_THAT(attrs3, SizeIs(1));
-  EXPECT_EQ(attrs3[0]->variable().ident_expr().name(), "arg2");
+  EXPECT_EQ(attrs3[0]->variable_name(), "arg2");
 }
 
 TEST_P(ShortCircuitingTest, TernaryUnknownAndErrorHandling) {
@@ -456,7 +454,7 @@ TEST_P(ShortCircuitingTest, TernaryUnknownAndErrorHandling) {
   const auto& attrs =
       result.UnknownSetOrDie()->unknown_attributes().attributes();
   ASSERT_THAT(attrs, SizeIs(1));
-  EXPECT_EQ(attrs[0]->variable().ident_expr().name(), "cond");
+  EXPECT_EQ(attrs[0]->variable_name(), "cond");
 }
 
 const char* TestName(testing::TestParamInfo<bool> info) {

eval/compiler/flat_expr_builder_test.cc

@@ -1706,12 +1706,9 @@ TEST(FlatExprBuilderTest, Ternary) {
     ASSERT_TRUE(result.IsUnknownSet());
     const UnknownSet* result_set = result.UnknownSetOrDie();
     EXPECT_THAT(result_set->unknown_attributes().attributes().size(), Eq(1));
-    EXPECT_THAT(result_set->unknown_attributes()
-                    .attributes()[0]
-                    ->variable()
-                    .ident_expr()
-                    .name(),
-                Eq("selector"));
+    EXPECT_THAT(
+        result_set->unknown_attributes().attributes()[0]->variable_name(),
+        Eq("selector"));
   }
 }
 

eval/eval/attribute_trail.cc

@@ -24,8 +24,8 @@ AttributeTrail AttributeTrail::Step(CelAttributeQualifier qualifier,
 
   std::vector<CelAttributeQualifier> qualifiers = attribute_->qualifier_path();
   qualifiers.push_back(qualifier);
-  auto attribute =
-      manager.New<CelAttribute>(attribute_->variable(), std::move(qualifiers));
+  auto attribute = manager.New<CelAttribute>(
+      std::string(attribute_->variable_name()), std::move(qualifiers));
   return AttributeTrail(attribute.release());
 }
 

eval/eval/comprehension_step_test.cc

@@ -158,7 +158,7 @@ TEST_F(ListKeysStepTest, MapPartiallyUnknown) {
       eval_result->UnknownSetOrDie()->unknown_attributes().attributes();
 
   EXPECT_THAT(attrs, SizeIs(1));
-  EXPECT_THAT(attrs.at(0)->variable().ident_expr().name(), Eq("var"));
+  EXPECT_THAT(attrs.at(0)->variable_name(), Eq("var"));
   EXPECT_THAT(attrs.at(0)->qualifier_path(), SizeIs(0));
 }