Rename sus_no_unique_address to _sus_no_unique_address

danakj · danakj · commit e335cd42544f · 2023-12-10T16:48:04.000-05:00
This makes it considered as a private macro.
diff --git a/PRINCIPLES.md b/PRINCIPLES.md
@@ -128,7 +128,7 @@ This library is an experiment and not intended for use. See the
          inner type, i.e. a const `ref<T>` can be copied or moved to a non-const
          `ref<T>`.
 1. Class members which have tail padding, or can have based on templates, should
-   be marked as [[sus_no_unique_address]] when there are other fields that can
+   be marked as [[_sus_no_unique_address]] when there are other fields that can
    be packed into the tail padding, if it exists and is usable by the compiler
    implementation.
 1. Bounds are always checked unless you explicitly ask for them to not be.
diff --git a/sus/choice/__private/storage.h b/sus/choice/__private/storage.h
@@ -279,8 +279,8 @@ union Storage<I, ::sus::Tuple<Ts...>, Elements...> {
   }
   inline constexpr auto into_inner() && { return ::sus::move(tuple_); }
 
-  [[sus_no_unique_address]] Type tuple_;
-  [[sus_no_unique_address]] Storage<I + 1, Elements...> more_;
+  [[_sus_no_unique_address]] Type tuple_;
+  [[_sus_no_unique_address]] Storage<I + 1, Elements...> more_;
 };
 
 template <size_t I, class... Elements>
@@ -375,7 +375,7 @@ union Storage<I, Nothing, Elements...> {
     }
   }
 
-  [[sus_no_unique_address]] Storage<I + 1, Elements...> more_;
+  [[_sus_no_unique_address]] Storage<I + 1, Elements...> more_;
 };
 
 template <size_t I, class T, class... Elements>
@@ -509,8 +509,8 @@ union Storage<I, ::sus::Tuple<T>, Elements...> {
     return ::sus::move(tuple_).template into_inner<0>();
   }
 
-  [[sus_no_unique_address]] Type tuple_;
-  [[sus_no_unique_address]] Storage<I + 1, Elements...> more_;
+  [[_sus_no_unique_address]] Type tuple_;
+  [[_sus_no_unique_address]] Storage<I + 1, Elements...> more_;
 };
 
 template <size_t I, class... Ts>
@@ -603,7 +603,7 @@ union Storage<I, ::sus::Tuple<Ts...>> {
   }
   inline constexpr auto into_inner() && { return ::sus::move(tuple_); }
 
-  [[sus_no_unique_address]] Type tuple_;
+  [[_sus_no_unique_address]] Type tuple_;
 };
 
 template <size_t I>
@@ -733,7 +733,7 @@ union Storage<I, ::sus::Tuple<T>> {
     return ::sus::move(tuple_).template into_inner<0>();
   }
 
-  [[sus_no_unique_address]] ::sus::Tuple<T> tuple_;
+  [[_sus_no_unique_address]] ::sus::Tuple<T> tuple_;
 };
 
 template <size_t I, class S>
diff --git a/sus/choice/choice.h b/sus/choice/choice.h
@@ -903,7 +903,7 @@ class Choice<__private::TypeList<Ts...>, Tags...> final {
  private:
   constexpr explicit Choice(IndexType i) noexcept : index_(i) {}
 
-  // TODO: We don't use `[[sus_no_unique_address]]` here as the compiler
+  // TODO: We don't use `[[_sus_no_unique_address]]` here as the compiler
   // overwrites the `index_` when we move-construct into the Storage union.
   // Clang: https://github.com/llvm/llvm-project/issues/60711
   // GCC: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108775
diff --git a/sus/collections/array.h b/sus/collections/array.h
@@ -54,8 +54,8 @@ namespace __private {
 
 template <class T, size_t N>
 struct Storage final {
-  [[sus_no_unique_address]] sus::iter::IterRefCounter iter_refs_;
-  [[sus_no_unique_address]] T data_[N];
+  [[_sus_no_unique_address]] sus::iter::IterRefCounter iter_refs_;
+  [[_sus_no_unique_address]] T data_[N];
 };
 
 template <class T>
diff --git a/sus/collections/iterators/chunks.h b/sus/collections/iterators/chunks.h
@@ -116,7 +116,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] Chunks final
     sus_check(chunk_size > 0u);
   }
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   ::sus::num::usize chunk_size_;
 
@@ -218,7 +218,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] ChunksMut final
     sus_check(chunk_size > 0u);
   }
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   ::sus::num::usize chunk_size_;
 
@@ -333,7 +333,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] ChunksExact final
         rem_(remainder),
         chunk_size_(chunk_size) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   Slice<ItemT> rem_;
   ::sus::num::usize chunk_size_;
@@ -447,7 +447,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] ChunksExactMut final
         rem_(remainder),
         chunk_size_(chunk_size) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   SliceMut<ItemT> rem_;
   ::sus::num::usize chunk_size_;
@@ -553,7 +553,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] RChunks final
     sus_check(chunk_size > 0u);
   }
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   ::sus::num::usize chunk_size_;
 
@@ -649,7 +649,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] RChunksMut final
     sus_check(chunk_size > 0u);
   }
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   ::sus::num::usize chunk_size_;
 
@@ -757,7 +757,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] RChunksExact final
         rem_(remainder),
         chunk_size_(chunk_size) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   Slice<ItemT> rem_;
   ::sus::num::usize chunk_size_;
@@ -863,7 +863,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] RChunksExactMut final
         rem_(remainder),
         chunk_size_(chunk_size) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   SliceMut<ItemT> rem_;
   ::sus::num::usize chunk_size_;
diff --git a/sus/collections/iterators/slice_iter.h b/sus/collections/iterators/slice_iter.h
@@ -106,7 +106,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] SliceIter final
   }
 
  private:
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   const RawItem* ptr_;
   const RawItem* end_;
 
@@ -197,7 +197,7 @@ struct [[_sus_trivial_abi]] SliceIterMut final
   }
 
  private:
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   RawItem* ptr_;
   RawItem* end_;
 
diff --git a/sus/collections/iterators/split.h b/sus/collections/iterators/split.h
@@ -176,7 +176,7 @@ class [[nodiscard]] Split final
                   Pred&& pred) noexcept
       : ref_(::sus::move(ref)), v_(values), pred_(::sus::move(pred)) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   Pred pred_;
   bool finished_ = false;
@@ -291,7 +291,7 @@ class [[nodiscard]] SplitMut final
                      Pred&& pred) noexcept
       : ref_(::sus::move(ref)), v_(values), pred_(::sus::move(pred)) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   Pred pred_;
   bool finished_ = false;
@@ -401,7 +401,7 @@ class [[nodiscard]] SplitInclusive final
         pred_(::sus::move(pred)),
         finished_(v_.is_empty()) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   Pred pred_;
   bool finished_;
@@ -513,7 +513,7 @@ class [[nodiscard]] SplitInclusiveMut final
         pred_(::sus::move(pred)),
         finished_(v_.is_empty()) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   Pred pred_;
   bool finished_;
diff --git a/sus/collections/iterators/windows.h b/sus/collections/iterators/windows.h
@@ -96,7 +96,7 @@ class [[nodiscard]] [[_sus_trivial_abi]] Windows final
                     /* TODO: NonZeroUsize*/ usize size) noexcept
       : ref_(::sus::move(ref)), v_(values), size_(size) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
   /* TODO: NonZeroUsize*/ usize size_;
 
@@ -178,7 +178,7 @@ class [[nodiscard]] [[_sus_trivial_abi]] WindowsMut final
                        /* TODO: NonZeroUsize*/ usize size) noexcept
       : ref_(::sus::move(ref)), v_(values), size_(size) {}
 
-  [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
   /* TODO: NonZeroUsize*/ usize size_;
 
diff --git a/sus/collections/slice.h b/sus/collections/slice.h
@@ -264,7 +264,7 @@ class [[_sus_trivial_abi]] Slice final {
   template <class VecT>
   friend class Vec;
 
-  [[sus_no_unique_address]] ::sus::iter::IterRefCounter iter_refs_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRefCounter iter_refs_;
   T* data_;
   usize len_;
 
diff --git a/sus/collections/vec.h b/sus/collections/vec.h
@@ -979,11 +979,11 @@ class Vec final {
   /// signal its moved-from state.
   static constexpr usize kMovedFromCapacity = 0_usize;
 
-  [[sus_no_unique_address]] std::allocator<T> allocator_;
+  [[_sus_no_unique_address]] std::allocator<T> allocator_;
   usize capacity_;
   // These are in the same order as Slice/SliceMut, and come last to make it
   // easier to reuse the same stack space.
-  [[sus_no_unique_address]] ::sus::iter::IterRefCounter iter_refs_;
+  [[_sus_no_unique_address]] ::sus::iter::IterRefCounter iter_refs_;
   T* data_;
   usize len_;
 
diff --git a/sus/macros/no_unique_address.h b/sus/macros/no_unique_address.h
@@ -24,6 +24,6 @@
 /// https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/
 //
 // clang-format off
-#define sus_no_unique_address \
+#define _sus_no_unique_address \
     sus_clang_bug_49358_else(sus_if_msvc(msvc::)no_unique_address)
 // clang-format on
diff --git a/sus/mem/__private/data_size_finder.h b/sus/mem/__private/data_size_finder.h
@@ -28,7 +28,7 @@ constexpr inline size_t min_size(size_t a, size_t b) { return a < b ? a : b; }
 
 template <class T, size_t bytes>
 struct NoUnique {
-  [[sus_no_unique_address]] T x;
+  [[_sus_no_unique_address]] T x;
   char c[bytes];
 };
 
diff --git a/sus/mem/size_of_unittest.cc b/sus/mem/size_of_unittest.cc
@@ -59,12 +59,12 @@ struct SubNonTrivial : public NonTrivial {
 };
 
 struct HoldNonStandard {
-  [[sus_no_unique_address]] NonStandard x;
+  [[_sus_no_unique_address]] NonStandard x;
   i32 c;
 };
 
 struct HoldNonTrivial {
-  [[sus_no_unique_address]] NonTrivial x;
+  [[_sus_no_unique_address]] NonTrivial x;
   i32 c;
 };
 
@@ -122,12 +122,12 @@ struct NonTrivialFinal final {
 static_assert(!std::is_trivial_v<NonTrivialFinal>);
 
 struct HoldNonStandardFinal {
-  [[sus_no_unique_address]] NonStandard x;
+  [[_sus_no_unique_address]] NonStandard x;
   i32 c;
 };
 
 struct HoldNonTrivialFinal {
-  [[sus_no_unique_address]] NonTrivial x;
+  [[_sus_no_unique_address]] NonTrivial x;
   i32 c;
 };
 
diff --git a/sus/result/__private/storage.h b/sus/result/__private/storage.h
@@ -50,7 +50,7 @@ struct MaybeNoUniqueAddress<T, true> {
   constexpr MaybeNoUniqueAddress(WithE, U&&... v) noexcept
       : v(WITH_E, ::sus::forward<U>(v)...) {}
 
-  [[sus_no_unique_address]] T v;
+  [[_sus_no_unique_address]] T v;
 };
 
 template <class E>
diff --git a/sus/result/result_unittest.cc b/sus/result/result_unittest.cc
@@ -68,7 +68,7 @@ static_assert(sizeof(Result<void, TailPadding>) ==
 
 template <class T>
 struct Holds {
-  [[sus_no_unique_address]] T t;
+  [[_sus_no_unique_address]] T t;
   char c = 0;
 };
 // An element in the Result's union has tail padding, so it can't allow anything
diff --git a/sus/tuple/__private/storage.h b/sus/tuple/__private/storage.h
@@ -50,7 +50,7 @@ struct TupleStorage<T> {
   inline constexpr T&& into_inner() && noexcept { return ::sus::move(value); }
 
  private:
-  [[sus_no_unique_address]] T value;
+  [[_sus_no_unique_address]] T value;
 };
 
 template <class T>
@@ -84,7 +84,7 @@ struct TupleStorage<T, Ts...> : TupleStorage<Ts...> {
   inline constexpr T&& into_inner() && noexcept { return ::sus::move(value); }
 
  private:
-  [[sus_no_unique_address]] T value;
+  [[_sus_no_unique_address]] T value;
 };
 
 template <class T, class... Ts>
diff --git a/sus/tuple/tuple.h b/sus/tuple/tuple.h
@@ -400,7 +400,7 @@ class Tuple final {
   // `[[no_unique_address]]` on the Tuple. For example, Choice does this with
   // its internal Tuples to put its tag inside the Tuples' storage when
   // possible.
-  [[sus_no_unique_address]] Storage storage_;
+  [[_sus_no_unique_address]] Storage storage_;
 
   sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn, T, Ts...);
 };
diff --git a/sus/tuple/tuple_unittest.cc b/sus/tuple/tuple_unittest.cc
@@ -105,15 +105,15 @@ TEST(Tuple, TailPadding) {
   // The Tuple type, if it has tail padding, allows types to make use of that
   // tail padding.
   struct WithTuple {
-    [[sus_no_unique_address]] PackedTuple t;
+    [[_sus_no_unique_address]] PackedTuple t;
     char c;  // Is stored in the padding of `t` (except on MSVC).
   };
   static_assert(sizeof(WithTuple) == sizeof(std::declval<WithTuple&>().t) +
                                          sus_if_msvc_else(sizeof(i64), 0));
 
   // The example from the Tuple docs.
   struct ExampleFromDocs {
-    [[sus_no_unique_address]] Tuple<u32, u64> tuple;  // 16 bytes.
+    [[_sus_no_unique_address]] Tuple<u32, u64> tuple;  // 16 bytes.
     u32 val;                                          // 4 bytes.
   };  // 16 bytes, since `val` is stored inside `tuple`.
   static_assert(sizeof(ExampleFromDocs) == (16 + sus_if_msvc_else(8, 0)));

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ struct [[nodiscard]] [[_sus_trivial_abi]] SliceIter final`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`private:`
`109`		`- [[sus_no_unique_address]] ::sus::iter::IterRef ref_;`
	`109`	`+ [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;`
`110`	`110`	`const RawItem* ptr_;`
`111`	`111`	`const RawItem* end_;`
`112`	`112`
`@@ -197,7 +197,7 @@ struct [[_sus_trivial_abi]] SliceIterMut final`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`private:`
`200`		`- [[sus_no_unique_address]] ::sus::iter::IterRef ref_;`
	`200`	`+ [[_sus_no_unique_address]] ::sus::iter::IterRef ref_;`
`201`	`201`	`RawItem* ptr_;`
`202`	`202`	`RawItem* end_;`
`203`	`203`