From 0f1dccfb5921f0a6f2a5e994418daed0263da023 Mon Sep 17 00:00:00 2001 From: delimbetov <1starfall1@gmail.com> Date: Wed, 21 Aug 2024 17:42:30 +0100 Subject: [PATCH 1/3] rename is_incomplete_type -> is_complete_type Signed-off-by: delimbetov <1starfall1@gmail.com> --- clang/lib/Sema/Metafunctions.cpp | 16 ++--- libcxx/include/experimental/meta | 10 +-- .../reflection/define-class.pass.cpp | 32 ++++----- .../reflection/entity-classification.pass.cpp | 68 +++++++++---------- ...96-ex-compile-time-ticket-counter.pass.cpp | 4 +- .../reflection/substitute.pass.cpp | 4 +- 6 files changed, 67 insertions(+), 67 deletions(-) diff --git a/clang/lib/Sema/Metafunctions.cpp b/clang/lib/Sema/Metafunctions.cpp index a46f54b87b20b1..9214ab80773262 100644 --- a/clang/lib/Sema/Metafunctions.cpp +++ b/clang/lib/Sema/Metafunctions.cpp @@ -284,9 +284,9 @@ static bool is_alias(APValue &Result, Sema &S, EvalFn Evaluator, DiagFn Diagnoser, QualType ResultTy, SourceRange Range, ArrayRef Args); -static bool is_incomplete_type(APValue &Result, Sema &S, EvalFn Evaluator, - DiagFn Diagnoser, QualType ResultTy, - SourceRange Range, ArrayRef Args); +static bool is_complete_type(APValue &Result, Sema &S, EvalFn Evaluator, + DiagFn Diagnoser, QualType ResultTy, + SourceRange Range, ArrayRef Args); static bool is_template(APValue &Result, Sema &S, EvalFn Evaluator, DiagFn Diagnoser, QualType ResultTy, SourceRange Range, @@ -551,7 +551,7 @@ static constexpr Metafunction Metafunctions[] = { { Metafunction::MFRK_bool, 1, 1, is_variable }, { Metafunction::MFRK_bool, 1, 1, is_type }, { Metafunction::MFRK_bool, 1, 1, is_alias }, - { Metafunction::MFRK_bool, 1, 1, is_incomplete_type }, + { Metafunction::MFRK_bool, 1, 1, is_complete_type }, { Metafunction::MFRK_bool, 1, 1, is_template }, { Metafunction::MFRK_bool, 1, 1, is_function_template }, { Metafunction::MFRK_bool, 1, 1, is_variable_template }, @@ -3856,9 +3856,9 @@ bool is_alias(APValue &Result, Sema &S, EvalFn Evaluator, DiagFn Diagnoser, llvm_unreachable("unknown reflection kind"); } -bool is_incomplete_type(APValue &Result, Sema &S, EvalFn Evaluator, - DiagFn Diagnoser, QualType ResultTy, SourceRange Range, - ArrayRef Args) { +bool is_complete_type(APValue &Result, Sema &S, EvalFn Evaluator, + DiagFn Diagnoser, QualType ResultTy, SourceRange Range, + ArrayRef Args) { assert(Args[0]->getType()->isReflectionType()); assert(ResultTy == S.Context.BoolTy); @@ -3873,7 +3873,7 @@ bool is_incomplete_type(APValue &Result, Sema &S, EvalFn Evaluator, if (Decl *typeDecl = findTypeDecl(RV.getReflectedType())) (void) ensureInstantiated(S, typeDecl, Range); - result = RV.getReflectedType()->isIncompleteType(); + result = !RV.getReflectedType()->isIncompleteType(); } return SetAndSucceed(Result, makeBool(S.Context, result)); } diff --git a/libcxx/include/experimental/meta b/libcxx/include/experimental/meta index e57e2d6addbd8f..d9fadeac7c3260 100644 --- a/libcxx/include/experimental/meta +++ b/libcxx/include/experimental/meta @@ -158,7 +158,7 @@ consteval auto is_variable(info) -> bool; consteval auto is_type(info) -> bool; consteval auto is_type_alias(info) -> bool; consteval auto is_namespace_alias(info) -> bool; -consteval auto is_incomplete_type(info) -> bool; +consteval auto is_complete_type(info) -> bool; consteval auto is_template(info) -> bool; consteval auto is_function_template(info) -> bool; consteval auto is_variable_template(info) -> bool; @@ -467,7 +467,7 @@ enum : unsigned { __metafn_is_variable, __metafn_is_type, __metafn_is_alias, - __metafn_is_incomplete_type, + __metafn_is_complete_type, __metafn_is_template, __metafn_is_function_template, __metafn_is_variable_template, @@ -1088,9 +1088,9 @@ consteval auto is_namespace_alias(info r) -> bool { return is_namespace(r) && __metafunction(detail::__metafn_is_alias, r); } -// Returns true if the reflected entity is an incomplete type. -consteval auto is_incomplete_type(info r) -> bool { - return __metafunction(detail::__metafn_is_incomplete_type, r); +// Returns true if the reflected entity is a complete type. +consteval auto is_complete_type(info r) -> bool { + return __metafunction(detail::__metafn_is_complete_type, r); } // Returns true if the reflected entity is a template. diff --git a/libcxx/test/std/experimental/reflection/define-class.pass.cpp b/libcxx/test/std/experimental/reflection/define-class.pass.cpp index 1e82b8f8a6b781..c52fec95ea3715 100644 --- a/libcxx/test/std/experimental/reflection/define-class.pass.cpp +++ b/libcxx/test/std/experimental/reflection/define-class.pass.cpp @@ -32,15 +32,15 @@ namespace completion_with_no_fields { struct S; class C; union U; -static_assert(is_incomplete_type(^S)); -static_assert(is_incomplete_type(^C)); -static_assert(is_incomplete_type(^U)); +static_assert(!is_complete_type(^S)); +static_assert(!is_complete_type(^C)); +static_assert(!is_complete_type(^U)); static_assert(is_type(define_class(^S, {}))); static_assert(is_type(define_class(^C, {}))); static_assert(is_type(define_class(^U, {}))); -static_assert(!is_incomplete_type(^S)); -static_assert(!is_incomplete_type(^C)); -static_assert(!is_incomplete_type(^U)); +static_assert(is_complete_type(^S)); +static_assert(is_complete_type(^C)); +static_assert(is_complete_type(^U)); static_assert(nonstatic_data_members_of(^S).size() == 0); static_assert(nonstatic_data_members_of(^C).size() == 0); static_assert(nonstatic_data_members_of(^U).size() == 0); @@ -56,14 +56,14 @@ U u; namespace test_all_flags { struct S; -static_assert(is_incomplete_type(^S)); +static_assert(!is_complete_type(^S)); static_assert(is_type(define_class(^S, { data_member_spec(^int, {.name="count", .alignment=16}), data_member_spec(^bool, {.name="flag"}), data_member_spec(^int, {.width=0}), data_member_spec(^int, {.width=5}), }))); -static_assert(!is_incomplete_type(^S)); +static_assert(is_complete_type(^S)); // unnamed bitfields are not nonstatic data members. static_assert(nonstatic_data_members_of(^S).size() == 3); static_assert(alignment_of(^S::count) == 16); @@ -91,12 +91,12 @@ static_assert(sizeof(WithEmpty) == sizeof(int)); // ================ namespace class_completion { class C; -static_assert(is_incomplete_type(^C)); +static_assert(!is_complete_type(^C)); static_assert(is_type(define_class(^C, { data_member_spec(^int, {.name="count"}), data_member_spec(^bool, {.name="flag"}), }))); -static_assert(!is_incomplete_type(^C)); +static_assert(is_complete_type(^C)); static_assert(nonstatic_data_members_of(^C).size() == 2); static_assert( (members_of(^C) | @@ -112,12 +112,12 @@ C c; namespace union_completion { union U; -static_assert(is_incomplete_type(^U)); +static_assert(!is_complete_type(^U)); static_assert(is_type(define_class(^U, { data_member_spec(^int, {.name="count"}), data_member_spec(^bool, {.name="flag"}), }))); -static_assert(!is_incomplete_type(^U)); +static_assert(is_complete_type(^U)); static_assert(size_of(^U) == size_of(^U::count)); static_assert(nonstatic_data_members_of(^U).size() == 2); static_assert( @@ -139,7 +139,7 @@ template <> struct S<2> {}; consteval int nextIncompleteIdx() { for (int Idx = 0;; ++Idx) - if (is_incomplete_type(substitute(^S, {std::meta::reflect_value(Idx)}))) + if (!is_complete_type(substitute(^S, {std::meta::reflect_value(Idx)}))) return Idx; } static_assert(is_type(define_class(^S, { @@ -155,7 +155,7 @@ static_assert(type_of(^S<1>::mem) == ^int); static_assert(nonstatic_data_members_of(^S<2>).size() == 0); static_assert(nonstatic_data_members_of(^S<3>).size() == 1); static_assert(type_of(^S<3>::mem) == ^bool); -static_assert(is_incomplete_type(^S<4>)); +static_assert(!is_complete_type(^S<4>)); } // namespace template_specialization_completion // ============================ @@ -169,11 +169,11 @@ consteval bool completeDefn() { } struct S; -static_assert(is_incomplete_type(^S)); +static_assert(!is_complete_type(^S)); static_assert(completeDefn()); -static_assert(!is_incomplete_type(^S)); +static_assert(is_complete_type(^S)); static_assert(nonstatic_data_members_of(^S).size() == 2); S s; diff --git a/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp b/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp index b70c68399166e5..276a0e8e152912 100644 --- a/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp +++ b/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp @@ -40,7 +40,7 @@ enum class EnumCls { A }; constexpr std::meta::info null_reflection; static_assert(!is_type(null_reflection)); -static_assert(!is_incomplete_type(null_reflection)); +static_assert(is_complete_type(null_reflection)); static_assert(!is_type_alias(null_reflection)); static_assert(!is_namespace_alias(null_reflection)); static_assert(!is_function(null_reflection)); @@ -60,7 +60,7 @@ static_assert(!is_user_provided(null_reflection)); static_assert(!is_data_member_spec(null_reflection)); static_assert(!is_type(std::meta::reflect_value(3))); -static_assert(!is_incomplete_type(std::meta::reflect_value(3))); +static_assert(is_complete_type(std::meta::reflect_value(3))); static_assert(!is_type_alias(std::meta::reflect_value(3))); static_assert(!is_namespace_alias(std::meta::reflect_value(3))); static_assert(!is_function(std::meta::reflect_value(3))); @@ -79,7 +79,7 @@ static_assert(!is_enumerator(std::meta::reflect_value(3))); static_assert(!is_data_member_spec(std::meta::reflect_value(3))); static_assert(is_type(^type)); -static_assert(!is_incomplete_type(^type)); +static_assert(is_complete_type(^type)); static_assert(!is_type_alias(^type)); static_assert(!is_namespace_alias(^type)); static_assert(!is_function(^type)); @@ -98,7 +98,7 @@ static_assert(!is_enumerator(^type)); static_assert(!is_data_member_spec(^type)); static_assert(!is_type(^func)); -static_assert(!is_incomplete_type(^func)); +static_assert(is_complete_type(^func)); static_assert(!is_type_alias(^func)); static_assert(!is_namespace_alias(^func)); static_assert(is_function(^func)); @@ -118,7 +118,7 @@ static_assert(is_user_provided(^func)); static_assert(!is_data_member_spec(^func)); static_assert(is_type(^alias)); -static_assert(!is_incomplete_type(^alias)); +static_assert(is_complete_type(^alias)); static_assert(is_type_alias(^alias)); static_assert(!is_namespace_alias(^alias)); static_assert(!is_function(^alias)); @@ -137,7 +137,7 @@ static_assert(!is_enumerator(^alias)); static_assert(!is_data_member_spec(^alias)); static_assert(!is_type(^var)); -static_assert(!is_incomplete_type(^var)); +static_assert(is_complete_type(^var)); static_assert(!is_type_alias(^var)); static_assert(!is_namespace_alias(^var)); static_assert(!is_function(^var)); @@ -156,7 +156,7 @@ static_assert(!is_enumerator(^var)); static_assert(!is_data_member_spec(^var)); static_assert(!is_type(^ref)); -static_assert(!is_incomplete_type(^ref)); +static_assert(is_complete_type(^ref)); static_assert(!is_type_alias(^ref)); static_assert(!is_namespace_alias(^ref)); static_assert(!is_function(^ref)); @@ -175,7 +175,7 @@ static_assert(!is_enumerator(^ref)); static_assert(!is_data_member_spec(^ref)); static_assert(!is_type(^TCls)); -static_assert(!is_incomplete_type(^TCls)); +static_assert(is_complete_type(^TCls)); static_assert(!is_type_alias(^TCls)); static_assert(!is_namespace_alias(^TCls)); static_assert(!is_function(^TCls)); @@ -194,7 +194,7 @@ static_assert(!is_enumerator(^TCls)); static_assert(!is_data_member_spec(^TCls)); static_assert(is_type(^IncompleteTCls)); -static_assert(is_incomplete_type(^IncompleteTCls)); +static_assert(!is_complete_type(^IncompleteTCls)); static_assert(!is_type_alias(^IncompleteTCls)); static_assert(!is_namespace_alias(^IncompleteTCls)); static_assert(!is_function(^IncompleteTCls)); @@ -213,7 +213,7 @@ static_assert(!is_enumerator(^IncompleteTCls)); static_assert(!is_data_member_spec(^IncompleteTCls)); static_assert(is_type(^TCls)); -static_assert(!is_incomplete_type(^TCls)); +static_assert(is_complete_type(^TCls)); static_assert(!is_type_alias(^TCls)); static_assert(!is_namespace_alias(^TCls)); static_assert(!is_function(^TCls)); @@ -232,7 +232,7 @@ static_assert(!is_enumerator(^TCls)); static_assert(!is_data_member_spec(^TCls)); static_assert(!is_type(^TFn)); -static_assert(!is_incomplete_type(^TFn)); +static_assert(is_complete_type(^TFn)); static_assert(!is_type_alias(^TFn)); static_assert(!is_namespace_alias(^TFn)); static_assert(!is_function(^TFn)); @@ -251,7 +251,7 @@ static_assert(!is_enumerator(^TFn)); static_assert(!is_data_member_spec(^TFn)); static_assert(!is_type(^TFn)); -static_assert(!is_incomplete_type(^TFn)); +static_assert(is_complete_type(^TFn)); static_assert(!is_type_alias(^TFn)); static_assert(!is_namespace_alias(^TFn)); static_assert(is_function(^TFn)); @@ -271,7 +271,7 @@ static_assert(!is_enumerator(^TFn)); static_assert(!is_data_member_spec(^TFn)); static_assert(!is_type(^TConcept)); -static_assert(!is_incomplete_type(^TConcept)); +static_assert(is_complete_type(^TConcept)); static_assert(!is_type_alias(^TConcept)); static_assert(!is_namespace_alias(^TConcept)); static_assert(!is_function(^TConcept)); @@ -290,7 +290,7 @@ static_assert(!is_enumerator(^TConcept)); static_assert(!is_data_member_spec(^TConcept)); static_assert(!is_type(substitute(^TConcept,{^int}))); -static_assert(!is_incomplete_type(substitute(^TConcept, {^int}))); +static_assert(is_complete_type(substitute(^TConcept, {^int}))); static_assert(!is_type_alias(substitute(^TConcept, {^int}))); static_assert(!is_namespace_alias(substitute(^TConcept, {^int}))); static_assert(!is_function(substitute(^TConcept, {^int}))); @@ -309,7 +309,7 @@ static_assert(!is_enumerator(substitute(^TConcept, {^int}))); static_assert(!is_data_member_spec(substitute(^TConcept, {^int}))); static_assert(!is_type(^TVar)); -static_assert(!is_incomplete_type(^TVar)); +static_assert(is_complete_type(^TVar)); static_assert(!is_type_alias(^TVar)); static_assert(!is_namespace_alias(^TVar)); static_assert(!is_function(^TVar)); @@ -328,7 +328,7 @@ static_assert(!is_enumerator(^TVar)); static_assert(!is_data_member_spec(^TVar)); static_assert(!is_type(^TVar)); -static_assert(!is_incomplete_type(^TVar)); +static_assert(is_complete_type(^TVar)); static_assert(!is_type_alias(^TVar)); static_assert(!is_namespace_alias(^TVar)); static_assert(!is_function(^TVar)); @@ -347,7 +347,7 @@ static_assert(!is_enumerator(^TVar)); static_assert(!is_data_member_spec(^TVar)); static_assert(!is_type(^TClsAlias)); -static_assert(!is_incomplete_type(^TClsAlias)); +static_assert(is_complete_type(^TClsAlias)); static_assert(!is_type_alias(^TClsAlias)); static_assert(!is_namespace_alias(^TClsAlias)); static_assert(!is_function(^TClsAlias)); @@ -366,7 +366,7 @@ static_assert(!is_enumerator(^TClsAlias)); static_assert(!is_data_member_spec(^TClsAlias)); static_assert(is_type(^TClsAlias)); -static_assert(!is_incomplete_type(^TClsAlias)); +static_assert(is_complete_type(^TClsAlias)); static_assert(is_type_alias(^TClsAlias)); static_assert(!is_namespace_alias(^TClsAlias)); static_assert(!is_function(^TClsAlias)); @@ -385,7 +385,7 @@ static_assert(!is_enumerator(^TClsAlias)); static_assert(!is_data_member_spec(^TClsAlias)); static_assert(!is_type(^::)); -static_assert(!is_incomplete_type(^::)); +static_assert(is_complete_type(^::)); static_assert(!is_type_alias(^::)); static_assert(!is_namespace_alias(^::)); static_assert(!is_function(^::)); @@ -404,7 +404,7 @@ static_assert(!is_enumerator(^::)); static_assert(!is_data_member_spec(^::)); static_assert(!is_type(^ns)); -static_assert(!is_incomplete_type(^ns)); +static_assert(is_complete_type(^ns)); static_assert(!is_type_alias(^ns)); static_assert(!is_namespace_alias(^ns)); static_assert(!is_function(^ns)); @@ -423,7 +423,7 @@ static_assert(!is_enumerator(^ns)); static_assert(!is_data_member_spec(^ns)); static_assert(!is_type(^ns_alias)); -static_assert(!is_incomplete_type(^ns_alias)); +static_assert(is_complete_type(^ns_alias)); static_assert(!is_type_alias(^ns_alias)); static_assert(is_namespace_alias(^ns_alias)); static_assert(!is_function(^ns_alias)); @@ -442,7 +442,7 @@ static_assert(!is_enumerator(^ns_alias)); static_assert(!is_data_member_spec(^ns_alias)); static_assert(is_type(^Enum)); -static_assert(!is_incomplete_type(^Enum)); +static_assert(is_complete_type(^Enum)); static_assert(!is_type_alias(^Enum)); static_assert(!is_namespace_alias(^Enum)); static_assert(!is_function(^Enum)); @@ -461,7 +461,7 @@ static_assert(!is_enumerator(^Enum)); static_assert(!is_data_member_spec(^Enum)); static_assert(!is_type(^Enum::A)); -static_assert(!is_incomplete_type(^Enum::A)); +static_assert(is_complete_type(^Enum::A)); static_assert(!is_type_alias(^Enum::A)); static_assert(!is_namespace_alias(^Enum::A)); static_assert(!is_function(^Enum::A)); @@ -480,7 +480,7 @@ static_assert(is_enumerator(^Enum::A)); static_assert(!is_data_member_spec(^Enum::A)); static_assert(is_type(^EnumCls)); -static_assert(!is_incomplete_type(^EnumCls)); +static_assert(is_complete_type(^EnumCls)); static_assert(!is_type_alias(^EnumCls)); static_assert(!is_namespace_alias(^EnumCls)); static_assert(!is_function(^EnumCls)); @@ -499,7 +499,7 @@ static_assert(!is_enumerator(^EnumCls)); static_assert(!is_data_member_spec(^EnumCls)); static_assert(!is_type(^EnumCls::A)); -static_assert(!is_incomplete_type(^EnumCls::A)); +static_assert(is_complete_type(^EnumCls::A)); static_assert(!is_type_alias(^EnumCls::A)); static_assert(!is_namespace_alias(^EnumCls::A)); static_assert(!is_function(^EnumCls::A)); @@ -519,7 +519,7 @@ static_assert(!is_data_member_spec(^EnumCls::A)); constexpr auto dms = data_member_spec(^int, {}); static_assert(!is_type(dms)); -static_assert(!is_incomplete_type(dms)); +static_assert(is_complete_type(dms)); static_assert(!is_type_alias(dms)); static_assert(!is_namespace_alias(dms)); static_assert(!is_function(dms)); @@ -539,18 +539,18 @@ static_assert(is_data_member_spec(dms)); struct incomplete_type; using incomplete_alias = incomplete_type; -static_assert(is_incomplete_type(^incomplete_type)); -static_assert(is_incomplete_type(^incomplete_alias)); +static_assert(!is_complete_type(^incomplete_type)); +static_assert(!is_complete_type(^incomplete_alias)); struct incomplete_type {}; -static_assert(!is_incomplete_type(^incomplete_type)); -static_assert(!is_incomplete_type(^incomplete_alias)); +static_assert(is_complete_type(^incomplete_type)); +static_assert(is_complete_type(^incomplete_alias)); template using IncompleteTClsAlias = IncompleteTCls; -static_assert(is_incomplete_type(^IncompleteTCls)); -static_assert(is_incomplete_type(^IncompleteTClsAlias)); +static_assert(!is_complete_type(^IncompleteTCls)); +static_assert(!is_complete_type(^IncompleteTClsAlias)); template struct IncompleteTCls {}; -static_assert(!is_incomplete_type(^IncompleteTCls)); -static_assert(!is_incomplete_type(^IncompleteTClsAlias)); +static_assert(is_complete_type(^IncompleteTCls)); +static_assert(is_complete_type(^IncompleteTClsAlias)); struct Base {}; struct Derived : Base {}; diff --git a/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp b/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp index 43a07d3560e127..8eb2fea3784779 100644 --- a/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp +++ b/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp @@ -31,8 +31,8 @@ class TU_Ticket { // Search for the next incomplete 'Helper'. std::meta::info r; - while (!is_incomplete_type(r = substitute(^Helper, - { std::meta::reflect_value(k) }))) + while (is_complete_type(r = substitute(^Helper, + { std::meta::reflect_value(k) }))) ++k; // Define 'Helper' and return its index. diff --git a/libcxx/test/std/experimental/reflection/substitute.pass.cpp b/libcxx/test/std/experimental/reflection/substitute.pass.cpp index 9ff57c4b842e69..9bdc99e81676fe 100644 --- a/libcxx/test/std/experimental/reflection/substitute.pass.cpp +++ b/libcxx/test/std/experimental/reflection/substitute.pass.cpp @@ -38,11 +38,11 @@ struct Cls; static_assert(can_substitute(^Cls, {^int, RVal<1>, ^std::array})); [[maybe_unused]] constexpr auto obj1 = substitute(^Cls, {^int, RVal<1>, ^std::array}); -static_assert(is_incomplete_type(^Cls)); +static_assert(!is_complete_type(^Cls)); template class C> struct Cls {}; -static_assert(!is_incomplete_type(^Cls)); +static_assert(is_complete_type(^Cls)); // Template arguments are dependent. template class C> From 7301258fe0c15d8d2279df8c1a8ab1969e5d4340 Mon Sep 17 00:00:00 2001 From: delimbetov <1starfall1@gmail.com> Date: Wed, 21 Aug 2024 22:32:48 +0100 Subject: [PATCH 2/3] fix entity classification test Signed-off-by: delimbetov <1starfall1@gmail.com> --- .../reflection/entity-classification.pass.cpp | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp b/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp index 276a0e8e152912..817bbfe45d0ee6 100644 --- a/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp +++ b/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp @@ -40,7 +40,7 @@ enum class EnumCls { A }; constexpr std::meta::info null_reflection; static_assert(!is_type(null_reflection)); -static_assert(is_complete_type(null_reflection)); +static_assert(!is_complete_type(null_reflection)); static_assert(!is_type_alias(null_reflection)); static_assert(!is_namespace_alias(null_reflection)); static_assert(!is_function(null_reflection)); @@ -60,7 +60,7 @@ static_assert(!is_user_provided(null_reflection)); static_assert(!is_data_member_spec(null_reflection)); static_assert(!is_type(std::meta::reflect_value(3))); -static_assert(is_complete_type(std::meta::reflect_value(3))); +static_assert(!is_complete_type(std::meta::reflect_value(3))); static_assert(!is_type_alias(std::meta::reflect_value(3))); static_assert(!is_namespace_alias(std::meta::reflect_value(3))); static_assert(!is_function(std::meta::reflect_value(3))); @@ -98,7 +98,7 @@ static_assert(!is_enumerator(^type)); static_assert(!is_data_member_spec(^type)); static_assert(!is_type(^func)); -static_assert(is_complete_type(^func)); +static_assert(!is_complete_type(^func)); static_assert(!is_type_alias(^func)); static_assert(!is_namespace_alias(^func)); static_assert(is_function(^func)); @@ -137,7 +137,7 @@ static_assert(!is_enumerator(^alias)); static_assert(!is_data_member_spec(^alias)); static_assert(!is_type(^var)); -static_assert(is_complete_type(^var)); +static_assert(!is_complete_type(^var)); static_assert(!is_type_alias(^var)); static_assert(!is_namespace_alias(^var)); static_assert(!is_function(^var)); @@ -156,7 +156,7 @@ static_assert(!is_enumerator(^var)); static_assert(!is_data_member_spec(^var)); static_assert(!is_type(^ref)); -static_assert(is_complete_type(^ref)); +static_assert(!is_complete_type(^ref)); static_assert(!is_type_alias(^ref)); static_assert(!is_namespace_alias(^ref)); static_assert(!is_function(^ref)); @@ -175,7 +175,7 @@ static_assert(!is_enumerator(^ref)); static_assert(!is_data_member_spec(^ref)); static_assert(!is_type(^TCls)); -static_assert(is_complete_type(^TCls)); +static_assert(!is_complete_type(^TCls)); static_assert(!is_type_alias(^TCls)); static_assert(!is_namespace_alias(^TCls)); static_assert(!is_function(^TCls)); @@ -232,7 +232,7 @@ static_assert(!is_enumerator(^TCls)); static_assert(!is_data_member_spec(^TCls)); static_assert(!is_type(^TFn)); -static_assert(is_complete_type(^TFn)); +static_assert(!is_complete_type(^TFn)); static_assert(!is_type_alias(^TFn)); static_assert(!is_namespace_alias(^TFn)); static_assert(!is_function(^TFn)); @@ -251,7 +251,7 @@ static_assert(!is_enumerator(^TFn)); static_assert(!is_data_member_spec(^TFn)); static_assert(!is_type(^TFn)); -static_assert(is_complete_type(^TFn)); +static_assert(!is_complete_type(^TFn)); static_assert(!is_type_alias(^TFn)); static_assert(!is_namespace_alias(^TFn)); static_assert(is_function(^TFn)); @@ -271,7 +271,7 @@ static_assert(!is_enumerator(^TFn)); static_assert(!is_data_member_spec(^TFn)); static_assert(!is_type(^TConcept)); -static_assert(is_complete_type(^TConcept)); +static_assert(!is_complete_type(^TConcept)); static_assert(!is_type_alias(^TConcept)); static_assert(!is_namespace_alias(^TConcept)); static_assert(!is_function(^TConcept)); @@ -290,7 +290,7 @@ static_assert(!is_enumerator(^TConcept)); static_assert(!is_data_member_spec(^TConcept)); static_assert(!is_type(substitute(^TConcept,{^int}))); -static_assert(is_complete_type(substitute(^TConcept, {^int}))); +static_assert(!is_complete_type(substitute(^TConcept, {^int}))); static_assert(!is_type_alias(substitute(^TConcept, {^int}))); static_assert(!is_namespace_alias(substitute(^TConcept, {^int}))); static_assert(!is_function(substitute(^TConcept, {^int}))); @@ -309,7 +309,7 @@ static_assert(!is_enumerator(substitute(^TConcept, {^int}))); static_assert(!is_data_member_spec(substitute(^TConcept, {^int}))); static_assert(!is_type(^TVar)); -static_assert(is_complete_type(^TVar)); +static_assert(!is_complete_type(^TVar)); static_assert(!is_type_alias(^TVar)); static_assert(!is_namespace_alias(^TVar)); static_assert(!is_function(^TVar)); @@ -328,7 +328,7 @@ static_assert(!is_enumerator(^TVar)); static_assert(!is_data_member_spec(^TVar)); static_assert(!is_type(^TVar)); -static_assert(is_complete_type(^TVar)); +static_assert(!is_complete_type(^TVar)); static_assert(!is_type_alias(^TVar)); static_assert(!is_namespace_alias(^TVar)); static_assert(!is_function(^TVar)); @@ -347,7 +347,7 @@ static_assert(!is_enumerator(^TVar)); static_assert(!is_data_member_spec(^TVar)); static_assert(!is_type(^TClsAlias)); -static_assert(is_complete_type(^TClsAlias)); +static_assert(!is_complete_type(^TClsAlias)); static_assert(!is_type_alias(^TClsAlias)); static_assert(!is_namespace_alias(^TClsAlias)); static_assert(!is_function(^TClsAlias)); @@ -385,7 +385,7 @@ static_assert(!is_enumerator(^TClsAlias)); static_assert(!is_data_member_spec(^TClsAlias)); static_assert(!is_type(^::)); -static_assert(is_complete_type(^::)); +static_assert(!is_complete_type(^::)); static_assert(!is_type_alias(^::)); static_assert(!is_namespace_alias(^::)); static_assert(!is_function(^::)); @@ -404,7 +404,7 @@ static_assert(!is_enumerator(^::)); static_assert(!is_data_member_spec(^::)); static_assert(!is_type(^ns)); -static_assert(is_complete_type(^ns)); +static_assert(!is_complete_type(^ns)); static_assert(!is_type_alias(^ns)); static_assert(!is_namespace_alias(^ns)); static_assert(!is_function(^ns)); @@ -423,7 +423,7 @@ static_assert(!is_enumerator(^ns)); static_assert(!is_data_member_spec(^ns)); static_assert(!is_type(^ns_alias)); -static_assert(is_complete_type(^ns_alias)); +static_assert(!is_complete_type(^ns_alias)); static_assert(!is_type_alias(^ns_alias)); static_assert(is_namespace_alias(^ns_alias)); static_assert(!is_function(^ns_alias)); @@ -461,7 +461,7 @@ static_assert(!is_enumerator(^Enum)); static_assert(!is_data_member_spec(^Enum)); static_assert(!is_type(^Enum::A)); -static_assert(is_complete_type(^Enum::A)); +static_assert(!is_complete_type(^Enum::A)); static_assert(!is_type_alias(^Enum::A)); static_assert(!is_namespace_alias(^Enum::A)); static_assert(!is_function(^Enum::A)); @@ -499,7 +499,7 @@ static_assert(!is_enumerator(^EnumCls)); static_assert(!is_data_member_spec(^EnumCls)); static_assert(!is_type(^EnumCls::A)); -static_assert(is_complete_type(^EnumCls::A)); +static_assert(!is_complete_type(^EnumCls::A)); static_assert(!is_type_alias(^EnumCls::A)); static_assert(!is_namespace_alias(^EnumCls::A)); static_assert(!is_function(^EnumCls::A)); @@ -519,7 +519,7 @@ static_assert(!is_data_member_spec(^EnumCls::A)); constexpr auto dms = data_member_spec(^int, {}); static_assert(!is_type(dms)); -static_assert(is_complete_type(dms)); +static_assert(!is_complete_type(dms)); static_assert(!is_type_alias(dms)); static_assert(!is_namespace_alias(dms)); static_assert(!is_function(dms)); From 957d5b18d0e408251c7feec0add70dfe0da6d88c Mon Sep 17 00:00:00 2001 From: delimbetov <1starfall1@gmail.com> Date: Fri, 23 Aug 2024 16:38:33 +0100 Subject: [PATCH 3/3] reapply changes post-merge Signed-off-by: delimbetov <1starfall1@gmail.com> --- .../reflection/define-class.pass.cpp | 32 ++++----- .../reflection/entity-classification.pass.cpp | 68 +++++++++---------- ...96-ex-compile-time-ticket-counter.pass.cpp | 2 +- .../reflection/substitute.pass.cpp | 4 +- 4 files changed, 53 insertions(+), 53 deletions(-) diff --git a/libcxx/test/std/experimental/reflection/define-class.pass.cpp b/libcxx/test/std/experimental/reflection/define-class.pass.cpp index bd08c85af0ac77..eda9f415488d38 100644 --- a/libcxx/test/std/experimental/reflection/define-class.pass.cpp +++ b/libcxx/test/std/experimental/reflection/define-class.pass.cpp @@ -33,15 +33,15 @@ namespace completion_with_no_fields { struct S; class C; union U; -static_assert(is_incomplete_type(^^S)); -static_assert(is_incomplete_type(^^C)); -static_assert(is_incomplete_type(^^U)); +static_assert(!is_complete_type(^^S)); +static_assert(!is_complete_type(^^C)); +static_assert(!is_complete_type(^^U)); static_assert(is_type(define_class(^^S, {}))); static_assert(is_type(define_class(^^C, {}))); static_assert(is_type(define_class(^^U, {}))); -static_assert(!is_incomplete_type(^^S)); -static_assert(!is_incomplete_type(^^C)); -static_assert(!is_incomplete_type(^^U)); +static_assert(is_complete_type(^^S)); +static_assert(is_complete_type(^^C)); +static_assert(is_complete_type(^^U)); static_assert(nonstatic_data_members_of(^^S).size() == 0); static_assert(nonstatic_data_members_of(^^C).size() == 0); static_assert(nonstatic_data_members_of(^^U).size() == 0); @@ -57,14 +57,14 @@ U u; namespace test_all_flags { struct S; -static_assert(is_incomplete_type(^^S)); +static_assert(!is_complete_type(^^S)); static_assert(is_type(define_class(^^S, { data_member_spec(^^int, {.name="count", .alignment=16}), data_member_spec(^^bool, {.name="flag"}), data_member_spec(^^int, {.width=0}), data_member_spec(^^int, {.width=5}), }))); -static_assert(!is_incomplete_type(^^S)); +static_assert(is_complete_type(^^S)); // unnamed bitfields are not nonstatic data members. static_assert(nonstatic_data_members_of(^^S).size() == 3); static_assert(alignment_of(^^S::count) == 16); @@ -92,12 +92,12 @@ static_assert(sizeof(WithEmpty) == sizeof(int)); // ================ namespace class_completion { class C; -static_assert(is_incomplete_type(^^C)); +static_assert(!is_complete_type(^^C)); static_assert(is_type(define_class(^^C, { data_member_spec(^^int, {.name="count"}), data_member_spec(^^bool, {.name="flag"}), }))); -static_assert(!is_incomplete_type(^^C)); +static_assert(is_complete_type(^^C)); static_assert(nonstatic_data_members_of(^^C).size() == 2); static_assert( (members_of(^^C) | @@ -113,12 +113,12 @@ C c; namespace union_completion { union U; -static_assert(is_incomplete_type(^^U)); +static_assert(!is_complete_type(^^U)); static_assert(is_type(define_class(^^U, { data_member_spec(^^int, {.name="count"}), data_member_spec(^^bool, {.name="flag"}), }))); -static_assert(!is_incomplete_type(^^U)); +static_assert(is_complete_type(^^U)); static_assert(size_of(^^U) == size_of(^^U::count)); static_assert(nonstatic_data_members_of(^^U).size() == 2); static_assert( @@ -140,7 +140,7 @@ template <> struct S<2> {}; consteval int nextIncompleteIdx() { for (int Idx = 0;; ++Idx) - if (is_incomplete_type(substitute(^^S, {std::meta::reflect_value(Idx)}))) + if (!is_complete_type(substitute(^^S, {std::meta::reflect_value(Idx)}))) return Idx; } static_assert(is_type(define_class(^^S, { @@ -156,7 +156,7 @@ static_assert(type_of(^^S<1>::mem) == ^^int); static_assert(nonstatic_data_members_of(^^S<2>).size() == 0); static_assert(nonstatic_data_members_of(^^S<3>).size() == 1); static_assert(type_of(^^S<3>::mem) == ^^bool); -static_assert(is_incomplete_type(^^S<4>)); +static_assert(!is_complete_type(^^S<4>)); } // namespace template_specialization_completion // ============================ @@ -170,11 +170,11 @@ consteval bool completeDefn() { } struct S; -static_assert(is_incomplete_type(^^S)); +static_assert(!is_complete_type(^^S)); static_assert(completeDefn()); -static_assert(!is_incomplete_type(^^S)); +static_assert(is_complete_type(^^S)); static_assert(nonstatic_data_members_of(^^S).size() == 2); S s; diff --git a/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp b/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp index f8a13f574a96e2..581e83c728494f 100644 --- a/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp +++ b/libcxx/test/std/experimental/reflection/entity-classification.pass.cpp @@ -41,7 +41,7 @@ enum class EnumCls { A }; constexpr std::meta::info null_reflection; static_assert(!is_type(null_reflection)); -static_assert(!is_incomplete_type(null_reflection)); +static_assert(!is_complete_type(null_reflection)); static_assert(!is_type_alias(null_reflection)); static_assert(!is_namespace_alias(null_reflection)); static_assert(!is_function(null_reflection)); @@ -61,7 +61,7 @@ static_assert(!is_user_provided(null_reflection)); static_assert(!is_data_member_spec(null_reflection)); static_assert(!is_type(std::meta::reflect_value(3))); -static_assert(!is_incomplete_type(std::meta::reflect_value(3))); +static_assert(!is_complete_type(std::meta::reflect_value(3))); static_assert(!is_type_alias(std::meta::reflect_value(3))); static_assert(!is_namespace_alias(std::meta::reflect_value(3))); static_assert(!is_function(std::meta::reflect_value(3))); @@ -80,7 +80,7 @@ static_assert(!is_enumerator(std::meta::reflect_value(3))); static_assert(!is_data_member_spec(std::meta::reflect_value(3))); static_assert(is_type(^^type)); -static_assert(!is_incomplete_type(^^type)); +static_assert(is_complete_type(^^type)); static_assert(!is_type_alias(^^type)); static_assert(!is_namespace_alias(^^type)); static_assert(!is_function(^^type)); @@ -99,7 +99,7 @@ static_assert(!is_enumerator(^^type)); static_assert(!is_data_member_spec(^^type)); static_assert(!is_type(^^func)); -static_assert(!is_incomplete_type(^^func)); +static_assert(!is_complete_type(^^func)); static_assert(!is_type_alias(^^func)); static_assert(!is_namespace_alias(^^func)); static_assert(is_function(^^func)); @@ -119,7 +119,7 @@ static_assert(is_user_provided(^^func)); static_assert(!is_data_member_spec(^^func)); static_assert(is_type(^^alias)); -static_assert(!is_incomplete_type(^^alias)); +static_assert(is_complete_type(^^alias)); static_assert(is_type_alias(^^alias)); static_assert(!is_namespace_alias(^^alias)); static_assert(!is_function(^^alias)); @@ -138,7 +138,7 @@ static_assert(!is_enumerator(^^alias)); static_assert(!is_data_member_spec(^^alias)); static_assert(!is_type(^^var)); -static_assert(!is_incomplete_type(^^var)); +static_assert(!is_complete_type(^^var)); static_assert(!is_type_alias(^^var)); static_assert(!is_namespace_alias(^^var)); static_assert(!is_function(^^var)); @@ -157,7 +157,7 @@ static_assert(!is_enumerator(^^var)); static_assert(!is_data_member_spec(^^var)); static_assert(!is_type(^^ref)); -static_assert(!is_incomplete_type(^^ref)); +static_assert(!is_complete_type(^^ref)); static_assert(!is_type_alias(^^ref)); static_assert(!is_namespace_alias(^^ref)); static_assert(!is_function(^^ref)); @@ -176,7 +176,7 @@ static_assert(!is_enumerator(^^ref)); static_assert(!is_data_member_spec(^^ref)); static_assert(!is_type(^^TCls)); -static_assert(!is_incomplete_type(^^TCls)); +static_assert(!is_complete_type(^^TCls)); static_assert(!is_type_alias(^^TCls)); static_assert(!is_namespace_alias(^^TCls)); static_assert(!is_function(^^TCls)); @@ -195,7 +195,7 @@ static_assert(!is_enumerator(^^TCls)); static_assert(!is_data_member_spec(^^TCls)); static_assert(is_type(^^IncompleteTCls)); -static_assert(is_incomplete_type(^^IncompleteTCls)); +static_assert(!is_complete_type(^^IncompleteTCls)); static_assert(!is_type_alias(^^IncompleteTCls)); static_assert(!is_namespace_alias(^^IncompleteTCls)); static_assert(!is_function(^^IncompleteTCls)); @@ -214,7 +214,7 @@ static_assert(!is_enumerator(^^IncompleteTCls)); static_assert(!is_data_member_spec(^^IncompleteTCls)); static_assert(is_type(^^TCls)); -static_assert(!is_incomplete_type(^^TCls)); +static_assert(is_complete_type(^^TCls)); static_assert(!is_type_alias(^^TCls)); static_assert(!is_namespace_alias(^^TCls)); static_assert(!is_function(^^TCls)); @@ -233,7 +233,7 @@ static_assert(!is_enumerator(^^TCls)); static_assert(!is_data_member_spec(^^TCls)); static_assert(!is_type(^^TFn)); -static_assert(!is_incomplete_type(^^TFn)); +static_assert(!is_complete_type(^^TFn)); static_assert(!is_type_alias(^^TFn)); static_assert(!is_namespace_alias(^^TFn)); static_assert(!is_function(^^TFn)); @@ -252,7 +252,7 @@ static_assert(!is_enumerator(^^TFn)); static_assert(!is_data_member_spec(^^TFn)); static_assert(!is_type(^^TFn)); -static_assert(!is_incomplete_type(^^TFn)); +static_assert(!is_complete_type(^^TFn)); static_assert(!is_type_alias(^^TFn)); static_assert(!is_namespace_alias(^^TFn)); static_assert(is_function(^^TFn)); @@ -272,7 +272,7 @@ static_assert(!is_enumerator(^^TFn)); static_assert(!is_data_member_spec(^^TFn)); static_assert(!is_type(^^TConcept)); -static_assert(!is_incomplete_type(^^TConcept)); +static_assert(!is_complete_type(^^TConcept)); static_assert(!is_type_alias(^^TConcept)); static_assert(!is_namespace_alias(^^TConcept)); static_assert(!is_function(^^TConcept)); @@ -291,7 +291,7 @@ static_assert(!is_enumerator(^^TConcept)); static_assert(!is_data_member_spec(^^TConcept)); static_assert(!is_type(substitute(^^TConcept,{^^int}))); -static_assert(!is_incomplete_type(substitute(^^TConcept, {^^int}))); +static_assert(!is_complete_type(substitute(^^TConcept, {^^int}))); static_assert(!is_type_alias(substitute(^^TConcept, {^^int}))); static_assert(!is_namespace_alias(substitute(^^TConcept, {^^int}))); static_assert(!is_function(substitute(^^TConcept, {^^int}))); @@ -310,7 +310,7 @@ static_assert(!is_enumerator(substitute(^^TConcept, {^^int}))); static_assert(!is_data_member_spec(substitute(^^TConcept, {^^int}))); static_assert(!is_type(^^TVar)); -static_assert(!is_incomplete_type(^^TVar)); +static_assert(!is_complete_type(^^TVar)); static_assert(!is_type_alias(^^TVar)); static_assert(!is_namespace_alias(^^TVar)); static_assert(!is_function(^^TVar)); @@ -329,7 +329,7 @@ static_assert(!is_enumerator(^^TVar)); static_assert(!is_data_member_spec(^^TVar)); static_assert(!is_type(^^TVar)); -static_assert(!is_incomplete_type(^^TVar)); +static_assert(!is_complete_type(^^TVar)); static_assert(!is_type_alias(^^TVar)); static_assert(!is_namespace_alias(^^TVar)); static_assert(!is_function(^^TVar)); @@ -348,7 +348,7 @@ static_assert(!is_enumerator(^^TVar)); static_assert(!is_data_member_spec(^^TVar)); static_assert(!is_type(^^TClsAlias)); -static_assert(!is_incomplete_type(^^TClsAlias)); +static_assert(!is_complete_type(^^TClsAlias)); static_assert(!is_type_alias(^^TClsAlias)); static_assert(!is_namespace_alias(^^TClsAlias)); static_assert(!is_function(^^TClsAlias)); @@ -367,7 +367,7 @@ static_assert(!is_enumerator(^^TClsAlias)); static_assert(!is_data_member_spec(^^TClsAlias)); static_assert(is_type(^^TClsAlias)); -static_assert(!is_incomplete_type(^^TClsAlias)); +static_assert(is_complete_type(^^TClsAlias)); static_assert(is_type_alias(^^TClsAlias)); static_assert(!is_namespace_alias(^^TClsAlias)); static_assert(!is_function(^^TClsAlias)); @@ -386,7 +386,7 @@ static_assert(!is_enumerator(^^TClsAlias)); static_assert(!is_data_member_spec(^^TClsAlias)); static_assert(!is_type(^^::)); -static_assert(!is_incomplete_type(^^::)); +static_assert(!is_complete_type(^^::)); static_assert(!is_type_alias(^^::)); static_assert(!is_namespace_alias(^^::)); static_assert(!is_function(^^::)); @@ -405,7 +405,7 @@ static_assert(!is_enumerator(^^::)); static_assert(!is_data_member_spec(^^::)); static_assert(!is_type(^^ns)); -static_assert(!is_incomplete_type(^^ns)); +static_assert(!is_complete_type(^^ns)); static_assert(!is_type_alias(^^ns)); static_assert(!is_namespace_alias(^^ns)); static_assert(!is_function(^^ns)); @@ -424,7 +424,7 @@ static_assert(!is_enumerator(^^ns)); static_assert(!is_data_member_spec(^^ns)); static_assert(!is_type(^^ns_alias)); -static_assert(!is_incomplete_type(^^ns_alias)); +static_assert(!is_complete_type(^^ns_alias)); static_assert(!is_type_alias(^^ns_alias)); static_assert(is_namespace_alias(^^ns_alias)); static_assert(!is_function(^^ns_alias)); @@ -443,7 +443,7 @@ static_assert(!is_enumerator(^^ns_alias)); static_assert(!is_data_member_spec(^^ns_alias)); static_assert(is_type(^^Enum)); -static_assert(!is_incomplete_type(^^Enum)); +static_assert(is_complete_type(^^Enum)); static_assert(!is_type_alias(^^Enum)); static_assert(!is_namespace_alias(^^Enum)); static_assert(!is_function(^^Enum)); @@ -462,7 +462,7 @@ static_assert(!is_enumerator(^^Enum)); static_assert(!is_data_member_spec(^^Enum)); static_assert(!is_type(^^Enum::A)); -static_assert(!is_incomplete_type(^^Enum::A)); +static_assert(!is_complete_type(^^Enum::A)); static_assert(!is_type_alias(^^Enum::A)); static_assert(!is_namespace_alias(^^Enum::A)); static_assert(!is_function(^^Enum::A)); @@ -481,7 +481,7 @@ static_assert(is_enumerator(^^Enum::A)); static_assert(!is_data_member_spec(^^Enum::A)); static_assert(is_type(^^EnumCls)); -static_assert(!is_incomplete_type(^^EnumCls)); +static_assert(is_complete_type(^^EnumCls)); static_assert(!is_type_alias(^^EnumCls)); static_assert(!is_namespace_alias(^^EnumCls)); static_assert(!is_function(^^EnumCls)); @@ -500,7 +500,7 @@ static_assert(!is_enumerator(^^EnumCls)); static_assert(!is_data_member_spec(^^EnumCls)); static_assert(!is_type(^^EnumCls::A)); -static_assert(!is_incomplete_type(^^EnumCls::A)); +static_assert(!is_complete_type(^^EnumCls::A)); static_assert(!is_type_alias(^^EnumCls::A)); static_assert(!is_namespace_alias(^^EnumCls::A)); static_assert(!is_function(^^EnumCls::A)); @@ -520,7 +520,7 @@ static_assert(!is_data_member_spec(^^EnumCls::A)); constexpr auto dms = data_member_spec(^^int, {}); static_assert(!is_type(dms)); -static_assert(!is_incomplete_type(dms)); +static_assert(!is_complete_type(dms)); static_assert(!is_type_alias(dms)); static_assert(!is_namespace_alias(dms)); static_assert(!is_function(dms)); @@ -540,18 +540,18 @@ static_assert(is_data_member_spec(dms)); struct incomplete_type; using incomplete_alias = incomplete_type; -static_assert(is_incomplete_type(^^incomplete_type)); -static_assert(is_incomplete_type(^^incomplete_alias)); +static_assert(!is_complete_type(^^incomplete_type)); +static_assert(!is_complete_type(^^incomplete_alias)); struct incomplete_type {}; -static_assert(!is_incomplete_type(^^incomplete_type)); -static_assert(!is_incomplete_type(^^incomplete_alias)); +static_assert(is_complete_type(^^incomplete_type)); +static_assert(is_complete_type(^^incomplete_alias)); template using IncompleteTClsAlias = IncompleteTCls; -static_assert(is_incomplete_type(^^IncompleteTCls)); -static_assert(is_incomplete_type(^^IncompleteTClsAlias)); +static_assert(!is_complete_type(^^IncompleteTCls)); +static_assert(!is_complete_type(^^IncompleteTClsAlias)); template struct IncompleteTCls {}; -static_assert(!is_incomplete_type(^^IncompleteTCls)); -static_assert(!is_incomplete_type(^^IncompleteTClsAlias)); +static_assert(is_complete_type(^^IncompleteTCls)); +static_assert(is_complete_type(^^IncompleteTClsAlias)); struct Base {}; struct Derived : Base {}; diff --git a/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp b/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp index b3f69e45b88ea0..a921d620c61ef9 100644 --- a/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp +++ b/libcxx/test/std/experimental/reflection/p2996-ex-compile-time-ticket-counter.pass.cpp @@ -32,7 +32,7 @@ class TU_Ticket { // Search for the next incomplete 'Helper'. std::meta::info r; - while (!is_incomplete_type(r = substitute(^^Helper, + while (is_complete_type(r = substitute(^^Helper, { std::meta::reflect_value(k) }))) ++k; diff --git a/libcxx/test/std/experimental/reflection/substitute.pass.cpp b/libcxx/test/std/experimental/reflection/substitute.pass.cpp index 3b9b2446e4e730..722946f1080e16 100644 --- a/libcxx/test/std/experimental/reflection/substitute.pass.cpp +++ b/libcxx/test/std/experimental/reflection/substitute.pass.cpp @@ -40,11 +40,11 @@ static_assert(can_substitute(^^Cls, {^^int, RVal<1>, ^^std::array})); [[maybe_unused]] constexpr auto obj1 = substitute(^^Cls, {^^int, RVal<1>, ^^std::array}); -static_assert(is_incomplete_type(^^Cls)); +static_assert(!is_complete_type(^^Cls)); template class C> struct Cls {}; -static_assert(!is_incomplete_type(^^Cls)); +static_assert(is_complete_type(^^Cls)); // Template arguments are dependent. template class C>