Mark structured-headers constructors and operators noexcept where relevant

PiperOrigin-RevId: 989723455

quiche/common/structured_headers.cc

diff --git a/quiche/common/structured_headers.cc b/quiche/common/structured_headers.cc
index b209e37..572e8a8 100644
--- a/quiche/common/structured_headers.cc
+++ b/quiche/common/structured_headers.cc
@@ -809,31 +809,32 @@
   return true;
 }
 
-Item::Item() = default;
-Item::Item(int64_t value) : value_(value) {}
-Item::Item(double value) : value_(value) {}
-Item::Item(bool value) : value_(value) {}
+Item::Item() noexcept = default;
+Item::Item(int64_t value) noexcept : value_(value) {}
+Item::Item(double value) noexcept : value_(value) {}
+Item::Item(bool value) noexcept : value_(value) {}
 
 Item::Item(string_t, const char* value) : value_(std::string(value)) {}
 Item::Item(string_t, absl::string_view value) : value_(std::string(value)) {}
-Item::Item(string_t, std::string value) : value_(std::move(value)) {}
+Item::Item(string_t, std::string value) noexcept : value_(std::move(value)) {}
 
 Item::Item(token_t, const char* value) : value_(Token(value)) {}
 Item::Item(token_t, absl::string_view value)
     : value_(Token(std::string(value))) {}
-Item::Item(token_t, std::string value) : value_(Token(std::move(value))) {}
+Item::Item(token_t, std::string value) noexcept
+    : value_(Token(std::move(value))) {}
 
 Item::Item(byte_sequence_t, const char* value) : value_(ByteSequence(value)) {}
 Item::Item(byte_sequence_t, absl::string_view value)
     : value_(ByteSequence(std::string(value))) {}
-Item::Item(byte_sequence_t, std::string value)
+Item::Item(byte_sequence_t, std::string value) noexcept
     : value_(ByteSequence(std::move(value))) {}
 
 Item::Item(const Item&) = default;
 Item& Item::operator=(const Item&) = default;
 
-Item::Item(Item&&) = default;
-Item& Item::operator=(Item&&) = default;
+Item::Item(Item&&) noexcept = default;
+Item& Item::operator=(Item&&) noexcept = default;
 
 Item::~Item() = default;
 
@@ -881,62 +882,67 @@
 
 bool operator==(const Item&, const Item&) = default;
 
-ParameterizedItem::ParameterizedItem() = default;
+ParameterizedItem::ParameterizedItem() noexcept = default;
 ParameterizedItem::ParameterizedItem(const ParameterizedItem&) = default;
 ParameterizedItem& ParameterizedItem::operator=(const ParameterizedItem&) =
     default;
-ParameterizedItem::ParameterizedItem(ParameterizedItem&&) = default;
-ParameterizedItem& ParameterizedItem::operator=(ParameterizedItem&&) = default;
-ParameterizedItem::ParameterizedItem(Item item, Parameters params)
+ParameterizedItem::ParameterizedItem(ParameterizedItem&&) noexcept = default;
+ParameterizedItem& ParameterizedItem::operator=(ParameterizedItem&&) noexcept =
+    default;
+ParameterizedItem::ParameterizedItem(Item item, Parameters params) noexcept
     : item(std::move(item)), params(std::move(params)) {}
-ParameterizedItem::ParameterizedItem(Item item) : item(std::move(item)) {}
+ParameterizedItem::ParameterizedItem(Item item) noexcept
+    : item(std::move(item)) {}
 ParameterizedItem::~ParameterizedItem() = default;
 
-InnerList::InnerList() = default;
+InnerList::InnerList() noexcept = default;
 
-InnerList::InnerList(std::vector<ParameterizedItem> items)
+InnerList::InnerList(std::vector<ParameterizedItem> items) noexcept
     : items(std::move(items)) {}
 
-InnerList::InnerList(std::vector<ParameterizedItem> items, Parameters params)
+InnerList::InnerList(std::vector<ParameterizedItem> items,
+                     Parameters params) noexcept
     : items(std::move(items)), params(std::move(params)) {}
 
 InnerList::InnerList(const InnerList&) = default;
 
 InnerList& InnerList::operator=(const InnerList&) = default;
 
-InnerList::InnerList(InnerList&&) = default;
+InnerList::InnerList(InnerList&&) noexcept = default;
 
-InnerList& InnerList::operator=(InnerList&&) = default;
+InnerList& InnerList::operator=(InnerList&&) noexcept = default;
 
 InnerList::~InnerList() = default;
 
-ParameterizedMember::ParameterizedMember() = default;
+ParameterizedMember::ParameterizedMember() noexcept = default;
 ParameterizedMember::ParameterizedMember(const ParameterizedMember&) = default;
 ParameterizedMember& ParameterizedMember::operator=(
     const ParameterizedMember&) = default;
-ParameterizedMember::ParameterizedMember(ParameterizedMember&&) = default;
-ParameterizedMember& ParameterizedMember::operator=(ParameterizedMember&&) =
+ParameterizedMember::ParameterizedMember(ParameterizedMember&&) noexcept =
     default;
+ParameterizedMember& ParameterizedMember::operator=(
+    ParameterizedMember&&) noexcept = default;
 
 ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> items,
-                                         Parameters params)
+                                         Parameters params) noexcept
     : value_(std::in_place_type<InnerList>, std::move(items),
              std::move(params)) {}
 
-ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> items)
+ParameterizedMember::ParameterizedMember(
+    std::vector<ParameterizedItem> items) noexcept
     : value_(std::in_place_type<InnerList>, std::move(items)) {}
 
-ParameterizedMember::ParameterizedMember(Item item, Parameters params)
+ParameterizedMember::ParameterizedMember(Item item, Parameters params) noexcept
     : value_(std::in_place_type<ParameterizedItem>, std::move(item),
              std::move(params)) {}
 
-ParameterizedMember::ParameterizedMember(Item item)
+ParameterizedMember::ParameterizedMember(Item item) noexcept
     : value_(std::in_place_type<ParameterizedItem>, std::move(item)) {}
 
-ParameterizedMember::ParameterizedMember(ParameterizedItem item)
+ParameterizedMember::ParameterizedMember(ParameterizedItem item) noexcept
     : value_(std::move(item)) {}
 
-ParameterizedMember::ParameterizedMember(InnerList inner_list)
+ParameterizedMember::ParameterizedMember(InnerList inner_list) noexcept
     : value_(std::move(inner_list)) {}
 
 ParameterizedMember::~ParameterizedMember() = default;
@@ -960,25 +966,26 @@
 bool operator==(const ParameterizedMember&,
                 const ParameterizedMember&) = default;
 
-ParameterisedIdentifier::ParameterisedIdentifier() = default;
+ParameterisedIdentifier::ParameterisedIdentifier() noexcept = default;
 ParameterisedIdentifier::ParameterisedIdentifier(
     const ParameterisedIdentifier&) = default;
 ParameterisedIdentifier& ParameterisedIdentifier::operator=(
     const ParameterisedIdentifier&) = default;
-ParameterisedIdentifier::ParameterisedIdentifier(ParameterisedIdentifier&&) =
-    default;
+ParameterisedIdentifier::ParameterisedIdentifier(
+    ParameterisedIdentifier&&) noexcept = default;
 ParameterisedIdentifier& ParameterisedIdentifier::operator=(
-    ParameterisedIdentifier&&) = default;
-ParameterisedIdentifier::ParameterisedIdentifier(Item id, Parameters ps)
+    ParameterisedIdentifier&&) noexcept = default;
+ParameterisedIdentifier::ParameterisedIdentifier(Item id,
+                                                 Parameters ps) noexcept
     : identifier(std::move(id)), params(std::move(ps)) {}
 ParameterisedIdentifier::~ParameterisedIdentifier() = default;
 
-Dictionary::Dictionary() = default;
+Dictionary::Dictionary() noexcept = default;
 Dictionary::Dictionary(const Dictionary&) = default;
 Dictionary& Dictionary::operator=(const Dictionary&) = default;
-Dictionary::Dictionary(Dictionary&&) = default;
-Dictionary& Dictionary::operator=(Dictionary&&) = default;
-Dictionary::Dictionary(std::vector<DictionaryMember> members)
+Dictionary::Dictionary(Dictionary&&) noexcept = default;
+Dictionary& Dictionary::operator=(Dictionary&&) noexcept = default;
+Dictionary::Dictionary(std::vector<DictionaryMember> members) noexcept
     : members_(std::move(members)) {}
 Dictionary::~Dictionary() = default;
 Dictionary::iterator Dictionary::begin() { return members_.begin(); }
@@ -1095,19 +1102,21 @@
   return std::nullopt;
 }
 
-ItemView::ItemView() = default;
-ItemView::ItemView(int64_t value) : value_(value) {}
-ItemView::ItemView(double value) : value_(value) {}
-ItemView::ItemView(bool value) : value_(value) {}
+ItemView::ItemView() noexcept = default;
+ItemView::ItemView(int64_t value) noexcept : value_(value) {}
+ItemView::ItemView(double value) noexcept : value_(value) {}
+ItemView::ItemView(bool value) noexcept : value_(value) {}
 
-ItemView::ItemView(string_t, absl::string_view value) : value_(value) {}
+ItemView::ItemView(string_t, absl::string_view value) noexcept
+    : value_(value) {}
 
-ItemView::ItemView(token_t, absl::string_view value) : value_(Token(value)) {}
+ItemView::ItemView(token_t, absl::string_view value) noexcept
+    : value_(Token(value)) {}
 
-ItemView::ItemView(byte_sequence_t, absl::string_view value)
+ItemView::ItemView(byte_sequence_t, absl::string_view value) noexcept
     : value_(ByteSequence(value)) {}
 
-ItemView::ItemView(const Item& value)
+ItemView::ItemView(const Item& value) noexcept
     : value_(value.Visit([](const auto& value) { return Variant(value); })) {}
 
 }  // namespace structured_headers

quiche/common/structured_headers.h

diff --git a/quiche/common/structured_headers.h b/quiche/common/structured_headers.h
index 95cf71f..363596f 100644
--- a/quiche/common/structured_headers.h
+++ b/quiche/common/structured_headers.h
@@ -98,10 +98,10 @@
     friend bool operator==(const ByteSequence&, const ByteSequence&) = default;
   };
 
-  Item();
-  explicit Item(int64_t value);
-  explicit Item(double value);
-  explicit Item(bool value);
+  Item() noexcept;
+  explicit Item(int64_t value) noexcept;
+  explicit Item(double value) noexcept;
+  explicit Item(bool value) noexcept;
 
   // Prevent pointers from implicitly converting to bool.
   template <typename T>
@@ -110,21 +110,21 @@
 
   Item(string_t, const char* value);
   Item(string_t, absl::string_view value);
-  Item(string_t, std::string value);
+  Item(string_t, std::string value) noexcept;
 
   Item(token_t, const char* value);
   Item(token_t, absl::string_view value);
-  Item(token_t, std::string value);
+  Item(token_t, std::string value) noexcept;
 
   Item(byte_sequence_t, const char* value);
   Item(byte_sequence_t, absl::string_view value);
-  Item(byte_sequence_t, std::string value);
+  Item(byte_sequence_t, std::string value) noexcept;
 
   Item(const Item&);
   Item& operator=(const Item&);
 
-  Item(Item&&);
-  Item& operator=(Item&&);
+  Item(Item&&) noexcept;
+  Item& operator=(Item&&) noexcept;
 
   ~Item();
 
@@ -220,12 +220,12 @@
   Item identifier;
   Parameters params;
 
-  ParameterisedIdentifier();
+  ParameterisedIdentifier() noexcept;
   ParameterisedIdentifier(const ParameterisedIdentifier&);
   ParameterisedIdentifier& operator=(const ParameterisedIdentifier&);
-  ParameterisedIdentifier(ParameterisedIdentifier&&);
-  ParameterisedIdentifier& operator=(ParameterisedIdentifier&&);
-  ParameterisedIdentifier(Item, Parameters);
+  ParameterisedIdentifier(ParameterisedIdentifier&&) noexcept;
+  ParameterisedIdentifier& operator=(ParameterisedIdentifier&&) noexcept;
+  ParameterisedIdentifier(Item, Parameters) noexcept;
   ~ParameterisedIdentifier();
 
   friend bool operator==(const ParameterisedIdentifier&,
@@ -238,18 +238,18 @@
   Item item;
   Parameters params;
 
-  ParameterizedItem();
+  ParameterizedItem() noexcept;
 
   // Convenience constructor for empty parameters.
-  explicit ParameterizedItem(Item);
+  explicit ParameterizedItem(Item) noexcept;
 
-  ParameterizedItem(Item, Parameters);
+  ParameterizedItem(Item, Parameters) noexcept;
 
   ParameterizedItem(const ParameterizedItem&);
   ParameterizedItem& operator=(const ParameterizedItem&);
 
-  ParameterizedItem(ParameterizedItem&&);
-  ParameterizedItem& operator=(ParameterizedItem&&);
+  ParameterizedItem(ParameterizedItem&&) noexcept;
+  ParameterizedItem& operator=(ParameterizedItem&&) noexcept;
 
   ~ParameterizedItem();
 
@@ -262,17 +262,17 @@
   std::vector<ParameterizedItem> items;
   Parameters params;
 
-  InnerList();
+  InnerList() noexcept;
 
-  explicit InnerList(std::vector<ParameterizedItem> items);
+  explicit InnerList(std::vector<ParameterizedItem> items) noexcept;
 
-  InnerList(std::vector<ParameterizedItem> items, Parameters params);
+  InnerList(std::vector<ParameterizedItem> items, Parameters params) noexcept;
 
   InnerList(const InnerList&);
   InnerList& operator=(const InnerList&);
 
-  InnerList(InnerList&&);
-  InnerList& operator=(InnerList&&);
+  InnerList(InnerList&&) noexcept;
+  InnerList& operator=(InnerList&&) noexcept;
 
   ~InnerList();
 
@@ -284,28 +284,28 @@
 // TODO(apaseltiner): Use `class` instead of `struct`, since some members are
 // private.
 struct QUICHE_EXPORT ParameterizedMember {
-  explicit ParameterizedMember(ParameterizedItem);
-  explicit ParameterizedMember(InnerList);
+  explicit ParameterizedMember(ParameterizedItem) noexcept;
+  explicit ParameterizedMember(InnerList) noexcept;
 
   // Constructor for a member that is an inner list.
-  ParameterizedMember(std::vector<ParameterizedItem>, Parameters);
+  ParameterizedMember(std::vector<ParameterizedItem>, Parameters) noexcept;
 
   // Convenience constructor for a member that is an inner list with empty
   // parameters.
-  explicit ParameterizedMember(std::vector<ParameterizedItem>);
+  explicit ParameterizedMember(std::vector<ParameterizedItem>) noexcept;
 
   // Constructor for a member that is a single Item.
-  ParameterizedMember(Item, Parameters);
+  ParameterizedMember(Item, Parameters) noexcept;
 
   // Convenience constructor for a member that is a single Item with empty
   // parameters.
-  explicit ParameterizedMember(Item);
+  explicit ParameterizedMember(Item) noexcept;
 
   ParameterizedMember(const ParameterizedMember&);
   ParameterizedMember& operator=(const ParameterizedMember&);
 
-  ParameterizedMember(ParameterizedMember&&);
-  ParameterizedMember& operator=(ParameterizedMember&&);
+  ParameterizedMember(ParameterizedMember&&) noexcept;
+  ParameterizedMember& operator=(ParameterizedMember&&) noexcept;
 
   ~ParameterizedMember();
 
@@ -334,7 +334,7 @@
   // what the default should actually be, but it is convenient for code that
   // defers assignment. As is, it produces an invalid value where both
   // `GetIfItem()` and `GetIfInnerList()` return `nullptr`.
-  ParameterizedMember();
+  ParameterizedMember() noexcept;
 
  private:
   std::variant<std::monostate, ParameterizedItem, InnerList> value_;
@@ -351,13 +351,13 @@
   using mapped_type = ParameterizedMember;
   using value_type = std::pair<const std::string, ParameterizedMember>;
 
-  Dictionary();
+  Dictionary() noexcept;
   Dictionary(const Dictionary&);
-  Dictionary(Dictionary&&);
-  explicit Dictionary(std::vector<DictionaryMember> members);
+  Dictionary(Dictionary&&) noexcept;
+  explicit Dictionary(std::vector<DictionaryMember> members) noexcept;
   ~Dictionary();
   Dictionary& operator=(const Dictionary&);
-  Dictionary& operator=(Dictionary&&);
+  Dictionary& operator=(Dictionary&&) noexcept;
 
   iterator begin();
   const_iterator begin() const;
@@ -463,30 +463,32 @@
   static constexpr token_t token{};
   static constexpr byte_sequence_t byte_sequence{};
 
-  ItemView();
-  ItemView(int64_t value);
-  ItemView(double value);
-  ItemView(bool value);
+  ItemView() noexcept;
+  ItemView(int64_t value) noexcept;
+  ItemView(double value) noexcept;
+  ItemView(bool value) noexcept;
 
   // Prevent pointers from implicitly converting to bool.
   template <typename T>
   explicit ItemView(const T*) = delete;
   explicit ItemView(std::nullptr_t) = delete;
 
-  ItemView(string_t, absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND);
+  ItemView(string_t,
+           absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept;
 
-  ItemView(token_t, absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND);
+  ItemView(token_t,
+           absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept;
 
   ItemView(byte_sequence_t,
-           absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND);
+           absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept;
 
-  ItemView(const Item& value ABSL_ATTRIBUTE_LIFETIME_BOUND);
+  ItemView(const Item& value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept;
 
-  ItemView(const ItemView&) = default;
-  ItemView& operator=(const ItemView&) = default;
+  ItemView(const ItemView&) noexcept = default;
+  ItemView& operator=(const ItemView&) noexcept = default;
 
-  ItemView(ItemView&&) = default;
-  ItemView& operator=(ItemView&&) = default;
+  ItemView(ItemView&&) noexcept = default;
+  ItemView& operator=(ItemView&&) noexcept = default;
 
   ~ItemView() = default;
 
@@ -497,20 +499,23 @@
   struct Token {
     absl::string_view value;
 
-    explicit Token(absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND)
+    explicit Token(
+        absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
         : value(value) {}
 
-    Token(const Item::Token& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
+    Token(const Item::Token& value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
         : value(value.value) {}
   };
 
   struct ByteSequence {
     absl::string_view value;
 
-    explicit ByteSequence(absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND)
+    explicit ByteSequence(
+        absl::string_view value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
         : value(value) {}
 
-    ByteSequence(const Item::ByteSequence& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
+    ByteSequence(
+        const Item::ByteSequence& value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
         : value(value.value) {}
   };