Refactor test archetypes implementation.

llvm-svn: 278319

2 files changed, 135 insertions, 99 deletions

diff --git a/libcxx/test/support/archetypes.hpp b/libcxx/test/support/archetypes.hpp
index d5b6bcbf4c2..5b294049658 100644
--- a/libcxx/test/support/archetypes.hpp
+++ b/libcxx/test/support/archetypes.hpp
@@ -5,105 +5,32 @@
 
 #if TEST_STD_VER >= 11
 
-struct NoDefault {
-    NoDefault() = delete;
-};
-
-// Implicit copy/move types
-
-struct AllCtors {
-  AllCtors() = default;
-  AllCtors(AllCtors const&) = default;
-  AllCtors(AllCtors &&) = default;
-  AllCtors& operator=(AllCtors const&) = default;
-  AllCtors& operator=(AllCtors &&) = default;
-};
-
-struct Copyable {
-  Copyable() = default;
-  Copyable(Copyable const &) = default;
-  Copyable &operator=(Copyable const &) = default;
-};
-
-struct CopyOnly {
-  CopyOnly() = default;
-  CopyOnly(CopyOnly const &) = default;
-  CopyOnly &operator=(CopyOnly const &) = default;
-  CopyOnly(CopyOnly &&) = delete;
-  CopyOnly &operator=(CopyOnly &&) = delete;
-};
-
-struct NonCopyable {
-  NonCopyable() = default;
-  NonCopyable(NonCopyable const &) = delete;
-  NonCopyable &operator=(NonCopyable const &) = delete;
-};
-
-struct MoveOnly {
-  MoveOnly() = default;
-  MoveOnly(MoveOnly &&) = default;
-  MoveOnly &operator=(MoveOnly &&) = default;
-};
-
-struct ConvertingType {
-  ConvertingType() = default;
-  ConvertingType(ConvertingType const&) = default;
-  ConvertingType(ConvertingType &&) = default;
-  ConvertingType& operator=(ConvertingType const&) = default;
-  ConvertingType& operator=(ConvertingType &&) = default;
-  template <class ...Args>
-  ConvertingType(Args&&...) {}
-  template <class Arg>
-  ConvertingType& operator=(Arg&&) { return *this; }
-};
-
-struct ExplicitConvertingType {
-  ExplicitConvertingType() = default;
-  explicit ExplicitConvertingType(ExplicitConvertingType const&) = default;
-  explicit ExplicitConvertingType(ExplicitConvertingType &&) = default;
-  ExplicitConvertingType& operator=(ExplicitConvertingType const&) = default;
-  ExplicitConvertingType& operator=(ExplicitConvertingType &&) = default;
-  template <class ...Args>
-  explicit ExplicitConvertingType(Args&&...) {}
-  template <class Arg>
-  ExplicitConvertingType& operator=(Arg&&) { return *this; }
-};
-
-// Explicit copy/move types
-
-struct ExplicitAllCtors {
-  explicit ExplicitAllCtors() = default;
-  explicit ExplicitAllCtors(ExplicitAllCtors const&) = default;
-  explicit ExplicitAllCtors(ExplicitAllCtors &&) = default;
-  ExplicitAllCtors& operator=(ExplicitAllCtors const&) = default;
-  ExplicitAllCtors& operator=(ExplicitAllCtors &&) = default;
-};
-
-struct ExplicitCopyable {
-  explicit ExplicitCopyable() = default;
-  explicit ExplicitCopyable(ExplicitCopyable const &) = default;
-  ExplicitCopyable &operator=(ExplicitCopyable const &) = default;
-};
-
-struct ExplicitCopyOnly {
-  explicit ExplicitCopyOnly() = default;
-  explicit ExplicitCopyOnly(ExplicitCopyOnly const &) = default;
-  ExplicitCopyOnly &operator=(ExplicitCopyOnly const &) = default;
-  explicit ExplicitCopyOnly(ExplicitCopyOnly &&) = delete;
-  ExplicitCopyOnly &operator=(ExplicitCopyOnly &&) = delete;
-};
-
-struct ExplicitNonCopyable {
-  explicit ExplicitNonCopyable() = default;
-  explicit ExplicitNonCopyable(ExplicitNonCopyable const &) = delete;
-  ExplicitNonCopyable &operator=(ExplicitNonCopyable const &) = delete;
-};
-
-struct ExplicitMoveOnly {
-  explicit ExplicitMoveOnly() = default;
-  explicit ExplicitMoveOnly(ExplicitMoveOnly &&) = default;
-  ExplicitMoveOnly &operator=(ExplicitMoveOnly &&) = default;
-};
+//============================================================================//
+// Trivial Implicit Test Types
+namespace ImplicitTypes {
+#include "archetypes.ipp"
+}
+
+//============================================================================//
+// Trivial Explicit Test Types
+namespace ExplicitTypes {
+#define DEFINE_EXPLICIT explicit
+#include "archetypes.ipp"
+}
+
+//============================================================================//
+// Non-Trivial Implicit Test Types
+namespace NonLiteralTypes {
+#define DEFINE_DTOR(Name) ~Name() {}
+#include "archetypes.ipp"
+}
+
+//============================================================================//
+// Non-Trivially Copyable Implicit Test Types
+namespace NonTrivialTypes {
+#define DEFINE_CTOR {}
+#include "archetypes.ipp"
+}
 
 #endif // TEST_STD_VER >= 11
 
diff --git a/libcxx/test/support/archetypes.ipp b/libcxx/test/support/archetypes.ipp
new file mode 100644
index 00000000000..094440a9783
--- /dev/null
+++ b/libcxx/test/support/archetypes.ipp
@@ -0,0 +1,109 @@
+
+#ifndef DEFINE_EXPLICIT
+#define DEFINE_EXPLICIT
+#endif
+#ifndef DEFINE_CTOR
+#define DEFINE_CTOR = default
+#endif
+#ifndef DEFINE_ASSIGN
+#define DEFINE_ASSIGN = default
+#endif
+#ifndef DEFINE_DTOR
+#define DEFINE_DTOR(Name)
+#endif
+
+struct NoDefault {
+  DEFINE_EXPLICIT NoDefault() = delete;
+  DEFINE_DTOR(NoDefault)
+};
+
+struct AllCtors {
+  DEFINE_EXPLICIT AllCtors() DEFINE_CTOR;
+  DEFINE_EXPLICIT AllCtors(AllCtors const&) DEFINE_CTOR;
+  DEFINE_EXPLICIT AllCtors(AllCtors &&) DEFINE_CTOR;
+  AllCtors& operator=(AllCtors const&) DEFINE_ASSIGN;
+  AllCtors& operator=(AllCtors &&) DEFINE_ASSIGN;
+  DEFINE_DTOR(AllCtors)
+};
+
+struct Copyable {
+  DEFINE_EXPLICIT Copyable() DEFINE_CTOR;
+  DEFINE_EXPLICIT Copyable(Copyable const &) DEFINE_CTOR;
+  Copyable &operator=(Copyable const &) DEFINE_ASSIGN;
+  DEFINE_DTOR(Copyable)
+};
+
+struct CopyOnly {
+  DEFINE_EXPLICIT CopyOnly() DEFINE_CTOR;
+  DEFINE_EXPLICIT CopyOnly(CopyOnly const &) DEFINE_CTOR;
+  DEFINE_EXPLICIT CopyOnly(CopyOnly &&) = delete;
+  CopyOnly &operator=(CopyOnly const &) DEFINE_ASSIGN;
+  CopyOnly &operator=(CopyOnly &&) = delete;
+  DEFINE_DTOR(CopyOnly)
+};
+
+struct NonCopyable {
+  DEFINE_EXPLICIT NonCopyable() DEFINE_CTOR;
+  DEFINE_EXPLICIT NonCopyable(NonCopyable const &) = delete;
+  NonCopyable &operator=(NonCopyable const &) = delete;
+  DEFINE_DTOR(NonCopyable)
+};
+
+struct MoveOnly {
+  DEFINE_EXPLICIT MoveOnly() DEFINE_CTOR;
+  DEFINE_EXPLICIT MoveOnly(MoveOnly &&) DEFINE_CTOR;
+  MoveOnly &operator=(MoveOnly &&) DEFINE_ASSIGN;
+  DEFINE_DTOR(MoveOnly)
+};
+
+struct CopyAssignable {
+    DEFINE_EXPLICIT CopyAssignable() = delete;
+    CopyAssignable& operator=(CopyAssignable const&) DEFINE_ASSIGN;
+    DEFINE_DTOR(CopyAssignable)
+};
+
+struct CopyAssignOnly {
+    DEFINE_EXPLICIT CopyAssignOnly() = delete;
+    CopyAssignOnly& operator=(CopyAssignOnly const&) DEFINE_ASSIGN;
+    CopyAssignOnly& operator=(CopyAssignOnly &&) = delete;
+    DEFINE_DTOR(CopyAssignOnly)
+};
+
+struct MoveAssignOnly {
+    DEFINE_EXPLICIT MoveAssignOnly() = delete;
+    MoveAssignOnly& operator=(MoveAssignOnly const&) = delete;
+    MoveAssignOnly& operator=(MoveAssignOnly &&) DEFINE_ASSIGN;
+    DEFINE_DTOR(MoveAssignOnly)
+};
+
+struct ConvertingType {
+  DEFINE_EXPLICIT ConvertingType() DEFINE_CTOR;
+  DEFINE_EXPLICIT ConvertingType(ConvertingType const&) DEFINE_CTOR;
+  DEFINE_EXPLICIT ConvertingType(ConvertingType &&) DEFINE_CTOR;
+  ConvertingType& operator=(ConvertingType const&) DEFINE_ASSIGN;
+  ConvertingType& operator=(ConvertingType &&) DEFINE_ASSIGN;
+  template <class ...Args>
+  DEFINE_EXPLICIT ConvertingType(Args&&...) {}
+  template <class Arg>
+  ConvertingType& operator=(Arg&&) { return *this; }
+  DEFINE_DTOR(ConvertingType)
+};
+
+template <template <class...> class List>
+using ApplyTypes = List<
+    NoDefault,
+    AllCtors,
+    Copyable,
+    CopyOnly,
+    NonCopyable,
+    MoveOnly,
+    CopyAssignable,
+    CopyAssignOnly,
+    MoveAssignOnly,
+    ConvertingType
+  >;
+
+#undef DEFINE_EXPLICIT
+#undef DEFINE_CTOR
+#undef DEFINE_ASSIGN
+#undef DEFINE_DTOR