test: cleanup entity

test/entt/entity/entity.cpp

@@ -41,7 +41,7 @@ using EntityTypes = ::testing::Types<entt::entity, test::entity, test::other_ent
 TYPED_TEST_SUITE(Entity, EntityTypes, );
 
 TYPED_TEST(Entity, Traits) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using traits_type = entt::entt_traits<entity_type>;
 
     constexpr entity_type tombstone{entt::tombstone};
@@ -117,7 +117,7 @@ TYPED_TEST(Entity, Traits) {
 }
 
 TYPED_TEST(Entity, Null) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using traits_type = entt::entt_traits<entity_type>;
 
     constexpr entity_type null{entt::null};
@@ -140,7 +140,7 @@ TYPED_TEST(Entity, Null) {
 }
 
 TYPED_TEST(Entity, Tombstone) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using traits_type = entt::entt_traits<entity_type>;
 
     constexpr entity_type tombstone{entt::tombstone};

test/entt/entity/handle.cpp

@@ -26,19 +26,19 @@ TYPED_TEST_SUITE(BasicHandle, BasicHandleTypes, );
 TYPED_TEST_SUITE(BasicHandleDeathTest, BasicHandleTypes, );
 
 TYPED_TEST(BasicHandle, Assumptions) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     static_assert(std::is_trivially_copyable_v<handle_type>, "Trivially copyable type required");
     static_assert((std::is_trivially_assignable_v<handle_type, handle_type>), "Trivially assignable type required");
     static_assert(std::is_trivially_destructible_v<handle_type>, "Trivially destructible type required");
 }
 
 TYPED_TEST(BasicHandle, DeductionGuide) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     testing::StaticAssertTypeEq<decltype(entt::basic_handle{std::declval<typename handle_type::registry_type &>(), {}}), handle_type>();
 }
 
 TYPED_TEST(BasicHandle, Construction) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     entt::registry registry;
     const auto entity = registry.create();
@@ -78,13 +78,13 @@ TYPED_TEST(BasicHandle, Construction) {
 }
 
 TYPED_TEST(BasicHandle, Storage) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     entt::registry registry;
     const auto entity = registry.create();
     const handle_type handle{registry, entity};
 
-    testing::StaticAssertTypeEq<decltype(*handle.storage().begin()), std::pair<entt::id_type, entt::constness_as_t<entt::sparse_set, typename handle_type::registry_type> &>>();
+    testing::StaticAssertTypeEq<decltype(*handle.storage().begin()), std::pair<entt::id_type, entt::constness_as_t<entt::sparse_set, handle_type::registry_type> &>>();
 
     ASSERT_EQ(handle.storage().begin(), handle.storage().end());
 
@@ -97,14 +97,14 @@ TYPED_TEST(BasicHandle, Storage) {
 }
 
 ENTT_DEBUG_TYPED_TEST(BasicHandleDeathTest, Storage) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     const handle_type handle{};
 
     ASSERT_DEATH([[maybe_unused]] auto iterable = handle.storage(), "");
 }
 
 TYPED_TEST(BasicHandle, HandleStorageIterator) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     entt::registry registry;
     const auto entity = registry.create();
@@ -134,7 +134,7 @@ TYPED_TEST(BasicHandle, HandleStorageIterator) {
 }
 
 TYPED_TEST(BasicHandle, Entity) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     entt::registry registry;
     const auto entity = registry.create();
@@ -334,7 +334,7 @@ TYPED_TEST(BasicHandle, AllAnyOf) {
 }
 
 ENTT_DEBUG_TYPED_TEST(BasicHandleDeathTest, AllAnyOf) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     const handle_type handle{};
 
     ASSERT_DEATH([[maybe_unused]] const auto all_of = handle.template all_of<int>(), "");
@@ -360,7 +360,7 @@ TYPED_TEST(BasicHandle, Get) {
 }
 
 ENTT_DEBUG_TYPED_TEST(BasicHandleDeathTest, Get) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     const handle_type handle{};
 
     ASSERT_DEATH([[maybe_unused]] const auto &elem = handle.template get<int>(), "");
@@ -408,7 +408,7 @@ TYPED_TEST(BasicHandle, TryGet) {
 }
 
 ENTT_DEBUG_TYPED_TEST(BasicHandleDeathTest, TryGet) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     const handle_type handle{};
 
     ASSERT_DEATH([[maybe_unused]] const auto *elem = handle.template try_get<int>(), "");
@@ -436,7 +436,7 @@ TYPED_TEST(BasicHandle, Orphan) {
 }
 
 ENTT_DEBUG_TYPED_TEST(BasicHandleDeathTest, Orphan) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
     const handle_type handle{};
 
     ASSERT_DEATH([[maybe_unused]] const auto result = handle.orphan(), "");
@@ -502,7 +502,7 @@ TEST(BasicHandle, ImplicitConversion) {
 }
 
 TYPED_TEST(BasicHandle, Comparison) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     handle_type handle{};
 
@@ -548,7 +548,7 @@ TYPED_TEST(BasicHandle, Comparison) {
 }
 
 TYPED_TEST(BasicHandle, Null) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     handle_type handle{};
 
@@ -569,7 +569,7 @@ TYPED_TEST(BasicHandle, Null) {
     ASSERT_TRUE(handle != entt::null);
     ASSERT_TRUE(entt::null != handle);
 
-    if constexpr(!std::is_const_v<typename handle_type::registry_type>) {
+    if constexpr(!std::is_const_v<handle_type::registry_type>) {
         handle.destroy();
 
         ASSERT_TRUE(handle == entt::null);
@@ -581,7 +581,7 @@ TYPED_TEST(BasicHandle, Null) {
 }
 
 TYPED_TEST(BasicHandle, FromEntity) {
-    using handle_type = typename TestFixture::type;
+    using handle_type = TestFixture::type;
 
     entt::registry registry;
     const auto entity = registry.create();

test/entt/entity/helper.cpp

@@ -66,7 +66,7 @@ TEST(Invoke, Functionalities) {
 }
 
 TYPED_TEST(ToEntity, Functionalities) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::registry registry;

test/entt/entity/organizer.cpp

@@ -92,7 +92,7 @@ TEST(Organizer, EmplaceFreeFunction) {
     ASSERT_EQ(graph[2u].out_edges()[0u], 3u);
 
     for(auto &&vertex: graph) {
-        typename entt::organizer::function_type *cb = vertex.callback();
+        entt::organizer::function_type *cb = vertex.callback();
         ASSERT_NO_THROW(cb(vertex.data(), registry));
     }
 
@@ -158,7 +158,7 @@ TEST(Organizer, EmplaceMemberFunction) {
     ASSERT_EQ(graph[2u].out_edges()[0u], 3u);
 
     for(auto &&vertex: graph) {
-        typename entt::organizer::function_type *cb = vertex.callback();
+        entt::organizer::function_type *cb = vertex.callback();
         ASSERT_NO_THROW(cb(vertex.data(), registry));
     }
 
@@ -231,7 +231,7 @@ TEST(Organizer, EmplaceFreeFunctionWithPayload) {
     ASSERT_EQ(graph[3u].out_edges()[0u], 4u);
 
     for(auto &&vertex: graph) {
-        typename entt::organizer::function_type *cb = vertex.callback();
+        entt::organizer::function_type *cb = vertex.callback();
         ASSERT_NO_THROW(cb(vertex.data(), registry));
     }
 
@@ -313,7 +313,7 @@ TEST(Organizer, EmplaceDirectFunction) {
     ASSERT_EQ(graph[2u].out_edges()[0u], 3u);
 
     for(auto &&vertex: graph) {
-        typename entt::organizer::function_type *cb = vertex.callback();
+        entt::organizer::function_type *cb = vertex.callback();
         ASSERT_NO_THROW(cb(vertex.data(), registry));
     }
 
@@ -380,7 +380,7 @@ TEST(Organizer, SyncPoint) {
     ASSERT_EQ(graph[4u].out_edges()[0u], 5u);
 
     for(auto &&vertex: graph) {
-        typename entt::organizer::function_type *cb = vertex.callback();
+        entt::organizer::function_type *cb = vertex.callback();
         ASSERT_NO_THROW(cb(vertex.data(), registry));
     }
 }
@@ -409,7 +409,7 @@ TEST(Organizer, ConstRegistry) {
     ASSERT_EQ(graph[1u].out_edges().size(), 0u);
 
     for(auto &&vertex: graph) {
-        typename entt::organizer::function_type *cb = vertex.callback();
+        entt::organizer::function_type *cb = vertex.callback();
         ASSERT_NO_THROW(cb(vertex.data(), registry));
     }
 }

test/entt/entity/reactive_mixin.cpp

@@ -49,7 +49,7 @@ TYPED_TEST_SUITE(ReactiveMixin, ReactiveMixinTypes, );
 TYPED_TEST_SUITE(ReactiveMixinDeathTest, ReactiveMixinTypes, );
 
 TYPED_TEST(ReactiveMixin, Constructors) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -66,7 +66,7 @@ TYPED_TEST(ReactiveMixin, Constructors) {
 }
 
 TYPED_TEST(ReactiveMixin, Move) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -126,7 +126,7 @@ TYPED_TEST(ReactiveMixin, Move) {
 }
 
 TYPED_TEST(ReactiveMixin, Swap) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -160,7 +160,7 @@ TYPED_TEST(ReactiveMixin, Swap) {
 }
 
 TYPED_TEST(ReactiveMixin, OnConstruct) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -199,7 +199,7 @@ TYPED_TEST(ReactiveMixin, OnConstruct) {
 }
 
 TYPED_TEST(ReactiveMixin, OnConstructCallback) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -228,13 +228,13 @@ TYPED_TEST(ReactiveMixin, OnConstructCallback) {
 }
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, OnConstruct) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     entt::reactive_mixin<entt::storage<value_type>> pool;
     ASSERT_DEATH(pool.template on_construct<test::empty>(), "");
 }
 
 TYPED_TEST(ReactiveMixin, OnUpdate) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -272,7 +272,7 @@ TYPED_TEST(ReactiveMixin, OnUpdate) {
 }
 
 TYPED_TEST(ReactiveMixin, OnUpdateCallback) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -304,13 +304,13 @@ TYPED_TEST(ReactiveMixin, OnUpdateCallback) {
 }
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, OnUpdate) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     entt::reactive_mixin<entt::storage<value_type>> pool;
     ASSERT_DEATH(pool.template on_update<test::empty>(), "");
 }
 
 TYPED_TEST(ReactiveMixin, OnDestroy) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -350,7 +350,7 @@ TYPED_TEST(ReactiveMixin, OnDestroy) {
 }
 
 TYPED_TEST(ReactiveMixin, OnDestroyCallback) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -380,13 +380,13 @@ TYPED_TEST(ReactiveMixin, OnDestroyCallback) {
 }
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, OnDestroy) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     entt::reactive_mixin<entt::storage<value_type>> pool;
     ASSERT_DEATH(pool.template on_destroy<test::empty>(), "");
 }
 
 TYPED_TEST(ReactiveMixin, EntityLifecycle) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -432,7 +432,7 @@ TYPED_TEST(ReactiveMixin, ManagedStorage) {
 }
 
 TYPED_TEST(ReactiveMixin, Registry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -447,14 +447,14 @@ TYPED_TEST(ReactiveMixin, Registry) {
 }
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, Registry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     entt::reactive_mixin<entt::storage<value_type>> pool;
     ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
     ASSERT_DEATH([[maybe_unused]] const auto &registry = std::as_const(pool).registry(), "");
 }
 
 TYPED_TEST(ReactiveMixin, CustomRegistry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using registry_type = test::custom_registry<test::entity>;
 
     registry_type registry;
@@ -476,7 +476,7 @@ TYPED_TEST(ReactiveMixin, CustomRegistry) {
 }
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, CustomRegistry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using registry_type = test::custom_registry<test::entity>;
     entt::basic_reactive_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
     ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
@@ -484,7 +484,7 @@ ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, CustomRegistry) {
 }
 
 TYPED_TEST(ReactiveMixin, View) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -529,14 +529,14 @@ TYPED_TEST(ReactiveMixin, View) {
 }
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, View) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     entt::reactive_mixin<entt::storage<value_type>> pool;
     ASSERT_DEATH([[maybe_unused]] const auto view = pool.view(), "");
     ASSERT_DEATH([[maybe_unused]] const auto cview = std::as_const(pool).view(), "");
 }
 
 TYPED_TEST(ReactiveMixin, AutoDisconnection) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::reactive_mixin<entt::storage<value_type>> pool;
@@ -570,9 +570,9 @@ TYPED_TEST(ReactiveMixin, AutoDisconnection) {
 }
 
 TYPED_TEST(ReactiveMixin, CustomAllocator) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using storage_type = entt::reactive_mixin<entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>>>;
-    using registry_type = typename storage_type::registry_type;
+    using registry_type = storage_type::registry_type;
 
     const test::throwing_allocator<entt::entity> allocator{};
     storage_type pool{allocator};
@@ -623,9 +623,9 @@ TYPED_TEST(ReactiveMixin, CustomAllocator) {
 }
 
 TYPED_TEST(ReactiveMixin, ThrowingAllocator) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using storage_type = entt::reactive_mixin<entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>>>;
-    using registry_type = typename storage_type::registry_type;
+    using registry_type = storage_type::registry_type;
 
     storage_type pool{};
     registry_type registry;

test/entt/entity/registry.cpp

@@ -461,8 +461,8 @@ TEST(Registry, RegistryStorageIteratorConversion) {
     auto proxy = registry.storage();
     [[maybe_unused]] auto cproxy = std::as_const(registry).storage();
 
-    const typename decltype(proxy)::iterator it = proxy.begin();
-    typename decltype(cproxy)::iterator cit = it;
+    const decltype(proxy)::iterator it = proxy.begin();
+    decltype(cproxy)::iterator cit = it;
 
     testing::StaticAssertTypeEq<decltype(*it), std::pair<entt::id_type, entt::sparse_set &>>();
     testing::StaticAssertTypeEq<decltype(*cit), std::pair<entt::id_type, const entt::sparse_set &>>();
@@ -592,7 +592,7 @@ TEST(Registry, Identifiers) {
 
     const auto invalid = traits_type::combine(traits_type::to_entity(post) + 1u, {});
 
-    ASSERT_EQ(traits_type::to_version(invalid), typename traits_type::version_type{});
+    ASSERT_EQ(traits_type::to_version(invalid), traits_type::version_type{});
     ASSERT_EQ(registry.current(invalid), traits_type::to_version(entt::tombstone));
 }
 
@@ -626,13 +626,13 @@ TEST(Registry, VersionOverflow) {
     registry.destroy(entity);
 
     ASSERT_NE(registry.current(entity), traits_type::to_version(entity));
-    ASSERT_NE(registry.current(entity), typename traits_type::version_type{});
+    ASSERT_NE(registry.current(entity), traits_type::version_type{});
 
     registry.destroy(registry.create(), traits_type::to_version(entt::tombstone) - 1u);
     registry.destroy(registry.create());
 
     ASSERT_EQ(registry.current(entity), traits_type::to_version(entity));
-    ASSERT_EQ(registry.current(entity), typename traits_type::version_type{});
+    ASSERT_EQ(registry.current(entity), traits_type::version_type{});
 }
 
 TEST(Registry, NullEntity) {
@@ -2447,7 +2447,7 @@ TEST(Registry, ContextPoolMemberDestructionOrder) {
     const auto entity = registry->create();
     bool ctx_check = false;
 
-    registry->ctx().emplace<typename destruction_order::ctx_check_type>();
+    registry->ctx().emplace<destruction_order::ctx_check_type>();
     registry->emplace<destruction_order>(entity, *registry, ctx_check);
     registry.reset();
 

test/entt/entity/runtime_view.cpp

@@ -21,7 +21,7 @@ using RuntimeViewTypes = ::testing::Types<entt::runtime_view, entt::const_runtim
 TYPED_TEST_SUITE(RuntimeView, RuntimeViewTypes, );
 
 TYPED_TEST(RuntimeView, Functionalities) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -75,7 +75,7 @@ TYPED_TEST(RuntimeView, Functionalities) {
 }
 
 TYPED_TEST(RuntimeView, InvalidView) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     runtime_view_type view{};
 
@@ -98,7 +98,7 @@ TYPED_TEST(RuntimeView, InvalidView) {
 }
 
 TYPED_TEST(RuntimeView, Constructors) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     entt::storage<int> storage{};
     const entt::entity entity{0};
@@ -127,7 +127,7 @@ TYPED_TEST(RuntimeView, Constructors) {
 }
 
 TYPED_TEST(RuntimeView, Copy) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::entity entity{0};
@@ -163,7 +163,7 @@ TYPED_TEST(RuntimeView, Copy) {
 }
 
 TYPED_TEST(RuntimeView, Move) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::entity entity{0};
@@ -204,7 +204,7 @@ TYPED_TEST(RuntimeView, Move) {
 }
 
 TYPED_TEST(RuntimeView, Swap) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     entt::storage<int> storage{};
     const entt::entity entity{0};
@@ -241,8 +241,8 @@ TYPED_TEST(RuntimeView, Swap) {
 }
 
 TYPED_TEST(RuntimeView, Iterator) {
-    using runtime_view_type = typename TestFixture::type;
-    using iterator = typename runtime_view_type::iterator;
+    using runtime_view_type = TestFixture::type;
+    using iterator = runtime_view_type::iterator;
 
     entt::storage<int> storage{};
     const entt::entity entity{0};
@@ -271,7 +271,7 @@ TYPED_TEST(RuntimeView, Iterator) {
 }
 
 TYPED_TEST(RuntimeView, Contains) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     entt::storage<int> storage{};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -289,7 +289,7 @@ TYPED_TEST(RuntimeView, Contains) {
 }
 
 TYPED_TEST(RuntimeView, Empty) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     entt::storage<int> storage{};
     const entt::entity entity{0};
@@ -309,7 +309,7 @@ TYPED_TEST(RuntimeView, Empty) {
 }
 
 TYPED_TEST(RuntimeView, Each) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -327,7 +327,7 @@ TYPED_TEST(RuntimeView, Each) {
 }
 
 TYPED_TEST(RuntimeView, EachWithHoles) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{3}};
@@ -347,7 +347,7 @@ TYPED_TEST(RuntimeView, EachWithHoles) {
 }
 
 TYPED_TEST(RuntimeView, Exclude) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -369,7 +369,7 @@ TYPED_TEST(RuntimeView, Exclude) {
 }
 
 TYPED_TEST(RuntimeView, StableType) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<test::pointer_stable>> storage{};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{3}};
@@ -408,7 +408,7 @@ TYPED_TEST(RuntimeView, StableType) {
 }
 
 TYPED_TEST(RuntimeView, StableTypeWithExclude) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     constexpr entt::entity tombstone = entt::tombstone;
     std::tuple<entt::storage<int>, entt::storage<test::pointer_stable>> storage{};
@@ -444,7 +444,7 @@ TYPED_TEST(RuntimeView, StableTypeWithExclude) {
 }
 
 TYPED_TEST(RuntimeView, SameStorageTypes) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<int>, entt::storage<int>> storage{};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -470,7 +470,7 @@ TYPED_TEST(RuntimeView, SameStorageTypes) {
 }
 
 TYPED_TEST(RuntimeView, StorageEntity) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<entt::entity>, entt::storage<char>> storage{};
     const std::array entity{std::get<0>(storage).generate(), std::get<0>(storage).generate()};
@@ -504,7 +504,7 @@ TYPED_TEST(RuntimeView, StorageEntity) {
 }
 
 TYPED_TEST(RuntimeView, StorageEntityWithExclude) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<entt::entity>, entt::storage<int>, entt::storage<char>> storage{};
     const std::array entity{std::get<0>(storage).generate(), std::get<0>(storage).generate(), std::get<0>(storage).generate()};
@@ -542,7 +542,7 @@ TYPED_TEST(RuntimeView, StorageEntityWithExclude) {
 }
 
 TYPED_TEST(RuntimeView, StorageEntityExcludeOnly) {
-    using runtime_view_type = typename TestFixture::type;
+    using runtime_view_type = TestFixture::type;
 
     std::tuple<entt::storage<entt::entity>, entt::storage<int>> storage{};
     const std::array entity{std::get<0>(storage).generate(), std::get<0>(storage).generate(), std::get<0>(storage).generate()};

test/entt/entity/sigh_mixin.cpp

@@ -63,7 +63,7 @@ TYPED_TEST_SUITE(SighMixin, SighMixinTypes, );
 TYPED_TEST_SUITE(SighMixinDeathTest, SighMixinTypes, );
 
 TYPED_TEST(SighMixin, Functionalities) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::registry registry;
@@ -139,7 +139,7 @@ TYPED_TEST(SighMixin, Functionalities) {
 }
 
 TYPED_TEST(SighMixin, InsertWeakRange) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     auto &pool = registry.storage<value_type>();
@@ -319,7 +319,7 @@ TEST(SighMixin, StorageEntity) {
 }
 
 TYPED_TEST(SighMixin, Move) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::sigh_mixin<entt::storage<value_type>> pool;
     entt::registry registry;
@@ -379,7 +379,7 @@ TYPED_TEST(SighMixin, Move) {
 }
 
 TYPED_TEST(SighMixin, Swap) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::sigh_mixin<entt::storage<value_type>> pool;
@@ -461,7 +461,7 @@ TEST(SighMixin, AutoSignal) {
 }
 
 TYPED_TEST(SighMixin, Registry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::registry registry;
     entt::sigh_mixin<entt::storage<value_type>> pool;
@@ -476,14 +476,14 @@ TYPED_TEST(SighMixin, Registry) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, Registry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     entt::sigh_mixin<entt::storage<value_type>> pool;
     ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
     ASSERT_DEATH([[maybe_unused]] const auto &registry = std::as_const(pool).registry(), "");
 }
 
 TYPED_TEST(SighMixin, CustomRegistry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using registry_type = test::custom_registry<test::entity>;
 
     registry_type registry;
@@ -515,7 +515,7 @@ TYPED_TEST(SighMixin, CustomRegistry) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, CustomRegistry) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using registry_type = test::custom_registry<test::entity>;
     entt::basic_sigh_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
     ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
@@ -523,9 +523,9 @@ ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, CustomRegistry) {
 }
 
 TYPED_TEST(SighMixin, CustomAllocator) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using storage_type = entt::sigh_mixin<entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>>>;
-    using registry_type = typename storage_type::registry_type;
+    using registry_type = storage_type::registry_type;
 
     const test::throwing_allocator<entt::entity> allocator{};
     storage_type pool{allocator};
@@ -582,9 +582,9 @@ TYPED_TEST(SighMixin, CustomAllocator) {
 }
 
 TYPED_TEST(SighMixin, ThrowingAllocator) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using storage_type = entt::sigh_mixin<entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>>>;
-    using registry_type = typename storage_type::registry_type;
+    using registry_type = storage_type::registry_type;
 
     storage_type pool{};
     typename storage_type::base_type &base = pool;
@@ -656,7 +656,7 @@ TYPED_TEST(SighMixin, ThrowingAllocator) {
 
 TEST(SighMixin, ThrowingComponent) {
     using storage_type = entt::sigh_mixin<entt::storage<test::throwing_type>>;
-    using registry_type = typename storage_type::registry_type;
+    using registry_type = storage_type::registry_type;
 
     storage_type pool;
     registry_type registry;

test/entt/entity/snapshot.cpp

@@ -52,11 +52,11 @@ TEST(BasicSnapshot, GetEntityType) {
 
     ASSERT_EQ(data.size(), 2u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), storage.size());
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(&data[1u]), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[1u]), storage.free_list());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(&data[1u]), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[1u]), storage.free_list());
 
     constexpr auto number_of_entities = 3u;
     std::array<entt::entity, number_of_entities> entity{};
@@ -69,11 +69,11 @@ TEST(BasicSnapshot, GetEntityType) {
 
     ASSERT_EQ(data.size(), 5u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), storage.size());
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(&data[1u]), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[1u]), storage.free_list());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(&data[1u]), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[1u]), storage.free_list());
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[2u]), nullptr);
     ASSERT_EQ(entt::any_cast<entt::entity>(data[2u]), storage.data()[0u]);
@@ -108,16 +108,16 @@ TEST(BasicSnapshot, GetType) {
 
     ASSERT_EQ(data.size(), 1u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), 0u);
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), 0u);
 
     data.clear();
     snapshot.get<int>(archive);
 
     ASSERT_EQ(data.size(), 5u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), storage.size());
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
     ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
@@ -155,16 +155,16 @@ TEST(BasicSnapshot, GetPointerStableType) {
 
     ASSERT_EQ(data.size(), 1u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), 0u);
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), 0u);
 
     data.clear();
     snapshot.get<test::pointer_stable>(archive);
 
     ASSERT_EQ(data.size(), 6u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), storage.size());
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
     ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
@@ -204,16 +204,16 @@ TEST(BasicSnapshot, GetEmptyType) {
 
     ASSERT_EQ(data.size(), 1u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), 0u);
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), 0u);
 
     data.clear();
     snapshot.get<test::empty>(archive);
 
     ASSERT_EQ(data.size(), 3u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), storage.size());
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), storage.size());
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
     ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
@@ -244,16 +244,16 @@ TEST(BasicSnapshot, GetTypeSparse) {
 
     ASSERT_EQ(data.size(), 1u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), 0u);
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), 0u);
 
     data.clear();
     snapshot.get<int>(archive, entity.begin(), entity.end());
 
     ASSERT_EQ(data.size(), 6u);
 
-    ASSERT_NE(entt::any_cast<typename traits_type::entity_type>(data.data()), nullptr);
-    ASSERT_EQ(entt::any_cast<typename traits_type::entity_type>(data[0u]), static_cast<typename traits_type::entity_type>(std::distance(entity.begin(), entity.end())));
+    ASSERT_NE(entt::any_cast<traits_type::entity_type>(data.data()), nullptr);
+    ASSERT_EQ(entt::any_cast<traits_type::entity_type>(data[0u]), static_cast<traits_type::entity_type>(std::distance(entity.begin(), entity.end())));
 
     ASSERT_NE(entt::any_cast<entt::entity>(&data[1u]), nullptr);
     ASSERT_EQ(entt::any_cast<entt::entity>(data[1u]), entity[0u]);
@@ -313,8 +313,8 @@ TEST(BasicSnapshotLoader, GetEntityType) {
     ASSERT_FALSE(registry.valid(entity[1u]));
     ASSERT_FALSE(registry.valid(entity[2u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
+    data.emplace_back(static_cast<traits_type::entity_type>(0u));
+    data.emplace_back(static_cast<traits_type::entity_type>(0u));
 
     loader.get<entt::entity>(archive);
 
@@ -325,8 +325,8 @@ TEST(BasicSnapshotLoader, GetEntityType) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(storage.free_list(), 0u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
@@ -364,7 +364,7 @@ TEST(BasicSnapshotLoader, GetType) {
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
 
@@ -376,7 +376,7 @@ TEST(BasicSnapshotLoader, GetType) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
@@ -411,7 +411,7 @@ TEST(BasicSnapshotLoader, GetEmptyType) {
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[0u]);
 
     loader.get<test::empty>(archive, "other"_hs);
@@ -422,7 +422,7 @@ TEST(BasicSnapshotLoader, GetEmptyType) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<test::empty>("other"_hs).size(), 1u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
@@ -453,7 +453,7 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
     data.emplace_back(static_cast<entt::entity>(entt::null));
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
@@ -466,7 +466,7 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
@@ -505,7 +505,7 @@ TEST(BasicSnapshotLoader, GetTypeWithListener) {
 
     registry.on_construct<shadow>().connect<&shadow::listener>(check);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity);
     data.emplace_back(value);
 
@@ -530,13 +530,13 @@ TEST(BasicSnapshotLoader, Orphans) {
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[0u]);
     data.emplace_back(value);
 
@@ -582,8 +582,8 @@ TEST(BasicContinuousLoader, GetEntityType) {
     ASSERT_FALSE(registry.valid(entity[1u]));
     ASSERT_FALSE(registry.valid(entity[2u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
+    data.emplace_back(static_cast<traits_type::entity_type>(0u));
+    data.emplace_back(static_cast<traits_type::entity_type>(0u));
 
     loader.get<entt::entity>(archive);
 
@@ -602,8 +602,8 @@ TEST(BasicContinuousLoader, GetEntityType) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(storage.free_list(), 0u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
@@ -630,8 +630,8 @@ TEST(BasicContinuousLoader, GetEntityType) {
 
     ASSERT_EQ(registry.create(), entity[2u]);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
@@ -664,8 +664,8 @@ TEST(BasicContinuousLoader, GetEntityType) {
     ASSERT_NE(loader.map(entity[1u]), static_cast<entt::entity>(entt::null));
     ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
 
     data.emplace_back(entity[1u]);
 
@@ -676,8 +676,8 @@ TEST(BasicContinuousLoader, GetEntityType) {
     ASSERT_TRUE(registry.valid(loader.map(entity[1u])));
     ASSERT_EQ(storage[3u], loader.map(entity[1u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
 
     data.emplace_back(entity[1u]);
     data.emplace_back(entity[2u]);
@@ -720,7 +720,7 @@ TEST(BasicContinuousLoader, GetType) {
     ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
     ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
 
@@ -735,7 +735,7 @@ TEST(BasicContinuousLoader, GetType) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
@@ -784,13 +784,13 @@ TEST(BasicContinuousLoader, GetTypeExtended) {
     ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
     ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[1u]);
     data.emplace_back(value);
 
@@ -829,7 +829,7 @@ TEST(BasicContinuousLoader, GetEmptyType) {
     ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
     ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[0u]);
 
     loader.get<test::empty>(archive, "other"_hs);
@@ -843,7 +843,7 @@ TEST(BasicContinuousLoader, GetEmptyType) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<test::empty>("other"_hs).size(), 1u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
@@ -880,7 +880,7 @@ TEST(BasicContinuousLoader, GetTypeSparse) {
     ASSERT_FALSE(registry.valid(loader.map(entity[0u])));
     ASSERT_FALSE(registry.valid(loader.map(entity[1u])));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
     data.emplace_back(static_cast<entt::entity>(entt::null));
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
@@ -896,7 +896,7 @@ TEST(BasicContinuousLoader, GetTypeSparse) {
     ASSERT_EQ(storage.size(), 0u);
     ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<traits_type::entity_type>(3u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(value[0u]);
@@ -938,7 +938,7 @@ TEST(BasicContinuousLoader, GetTypeWithListener) {
 
     registry.on_construct<shadow>().connect<&shadow::listener>(check);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity);
     data.emplace_back(value);
 
@@ -963,13 +963,13 @@ TEST(BasicContinuousLoader, Orphans) {
     ASSERT_FALSE(registry.valid(entity[0u]));
     ASSERT_FALSE(registry.valid(entity[1u]));
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
-    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<traits_type::entity_type>(2u));
 
     data.emplace_back(entity[0u]);
     data.emplace_back(entity[1u]);
 
-    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<traits_type::entity_type>(1u));
     data.emplace_back(entity[0u]);
     data.emplace_back(value);
 

test/entt/entity/sparse_set.cpp

@@ -49,9 +49,9 @@ TYPED_TEST_SUITE(SparseSet, SparseSetTypes, );
 TYPED_TEST_SUITE(SparseSetDeathTest, SparseSetTypes, );
 
 TYPED_TEST(SparseSet, Constructors) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
-    using allocator_type = typename sparse_set_type::allocator_type;
+    using allocator_type = sparse_set_type::allocator_type;
 
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{};
@@ -81,9 +81,9 @@ TYPED_TEST(SparseSet, Constructors) {
 }
 
 TYPED_TEST(SparseSet, Move) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
-    using allocator_type = typename sparse_set_type::allocator_type;
+    using allocator_type = sparse_set_type::allocator_type;
 
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
@@ -137,7 +137,7 @@ TYPED_TEST(SparseSet, Move) {
 }
 
 TYPED_TEST(SparseSet, Swap) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -170,7 +170,7 @@ TYPED_TEST(SparseSet, Swap) {
 }
 
 TYPED_TEST(SparseSet, FreeList) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -244,7 +244,7 @@ TYPED_TEST(SparseSet, FreeList) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, FreeList) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -267,7 +267,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, FreeList) {
 }
 
 TYPED_TEST(SparseSet, Capacity) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -286,7 +286,7 @@ TYPED_TEST(SparseSet, Capacity) {
 }
 
 TYPED_TEST(SparseSet, ShrinkToFit) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -425,7 +425,7 @@ TYPED_TEST(SparseSet, ShrinkToFit) {
 }
 
 TYPED_TEST(SparseSet, Pagination) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -474,7 +474,7 @@ TYPED_TEST(SparseSet, Pagination) {
 }
 
 TYPED_TEST(SparseSet, Contiguous) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -522,7 +522,7 @@ TYPED_TEST(SparseSet, Contiguous) {
 }
 
 TYPED_TEST(SparseSet, Data) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -576,7 +576,7 @@ TYPED_TEST(SparseSet, Data) {
 }
 
 TYPED_TEST(SparseSet, Bind) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -587,9 +587,9 @@ TYPED_TEST(SparseSet, Bind) {
 }
 
 TYPED_TEST(SparseSet, Iterator) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
-    using iterator = typename sparse_set_type::iterator;
+    using iterator = sparse_set_type::iterator;
 
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
@@ -663,9 +663,9 @@ TYPED_TEST(SparseSet, Iterator) {
 }
 
 TYPED_TEST(SparseSet, ReverseIterator) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
-    using reverse_iterator = typename sparse_set_type::reverse_iterator;
+    using reverse_iterator = sparse_set_type::reverse_iterator;
 
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
@@ -732,7 +732,7 @@ TYPED_TEST(SparseSet, ReverseIterator) {
 }
 
 TYPED_TEST(SparseSet, Find) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -758,7 +758,7 @@ TYPED_TEST(SparseSet, Find) {
 }
 
 TYPED_TEST(SparseSet, FindErased) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -785,7 +785,7 @@ TYPED_TEST(SparseSet, FindErased) {
 }
 
 TYPED_TEST(SparseSet, Contains) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -847,7 +847,7 @@ TYPED_TEST(SparseSet, Contains) {
 }
 
 TYPED_TEST(SparseSet, ContainsErased) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -880,7 +880,7 @@ TYPED_TEST(SparseSet, ContainsErased) {
 }
 
 TYPED_TEST(SparseSet, Current) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -908,7 +908,7 @@ TYPED_TEST(SparseSet, Current) {
 }
 
 TYPED_TEST(SparseSet, CurrentErased) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -938,7 +938,7 @@ TYPED_TEST(SparseSet, CurrentErased) {
 }
 
 TYPED_TEST(SparseSet, Index) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -978,7 +978,7 @@ TYPED_TEST(SparseSet, Index) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Index) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -998,7 +998,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Index) {
 }
 
 TYPED_TEST(SparseSet, Indexing) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1014,7 +1014,7 @@ TYPED_TEST(SparseSet, Indexing) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Indexing) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1034,7 +1034,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Indexing) {
 }
 
 TYPED_TEST(SparseSet, Value) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1050,7 +1050,7 @@ TYPED_TEST(SparseSet, Value) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Value) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1070,7 +1070,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Value) {
 }
 
 TYPED_TEST(SparseSet, Push) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1207,7 +1207,7 @@ TYPED_TEST(SparseSet, Push) {
 }
 
 TYPED_TEST(SparseSet, PushOutOfBounds) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1229,7 +1229,7 @@ TYPED_TEST(SparseSet, PushOutOfBounds) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Push) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1245,7 +1245,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Push) {
 }
 
 TYPED_TEST(SparseSet, Bump) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1271,7 +1271,7 @@ TYPED_TEST(SparseSet, Bump) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Bump) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1293,7 +1293,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Bump) {
 }
 
 TYPED_TEST(SparseSet, Erase) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1394,7 +1394,7 @@ TYPED_TEST(SparseSet, Erase) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Erase) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1409,7 +1409,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Erase) {
 }
 
 TYPED_TEST(SparseSet, CrossErase) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1429,7 +1429,7 @@ TYPED_TEST(SparseSet, CrossErase) {
 }
 
 TYPED_TEST(SparseSet, Remove) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1561,7 +1561,7 @@ TYPED_TEST(SparseSet, Remove) {
 }
 
 TYPED_TEST(SparseSet, CrossRemove) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1581,7 +1581,7 @@ TYPED_TEST(SparseSet, CrossRemove) {
 }
 
 TYPED_TEST(SparseSet, Compact) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1681,7 +1681,7 @@ TYPED_TEST(SparseSet, Compact) {
 }
 
 TYPED_TEST(SparseSet, SwapElements) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1705,7 +1705,7 @@ TYPED_TEST(SparseSet, SwapElements) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SwapElements) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -1734,7 +1734,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SwapElements) {
 }
 
 TYPED_TEST(SparseSet, Clear) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1751,7 +1751,7 @@ TYPED_TEST(SparseSet, Clear) {
 }
 
 TYPED_TEST(SparseSet, SortOrdered) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1767,7 +1767,7 @@ TYPED_TEST(SparseSet, SortOrdered) {
 }
 
 TYPED_TEST(SparseSet, SortReverse) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1783,7 +1783,7 @@ TYPED_TEST(SparseSet, SortReverse) {
 }
 
 TYPED_TEST(SparseSet, SortUnordered) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1808,7 +1808,7 @@ TYPED_TEST(SparseSet, SortUnordered) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Sort) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1834,7 +1834,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Sort) {
 }
 
 TYPED_TEST(SparseSet, SortN) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1869,7 +1869,7 @@ TYPED_TEST(SparseSet, SortN) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortN) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1902,7 +1902,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortN) {
 }
 
 TYPED_TEST(SparseSet, SortAsDisjoint) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1923,7 +1923,7 @@ TYPED_TEST(SparseSet, SortAsDisjoint) {
 }
 
 TYPED_TEST(SparseSet, SortAsOverlap) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1954,7 +1954,7 @@ TYPED_TEST(SparseSet, SortAsOverlap) {
 }
 
 TYPED_TEST(SparseSet, SortAsOrdered) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -1978,7 +1978,7 @@ TYPED_TEST(SparseSet, SortAsOrdered) {
 }
 
 TYPED_TEST(SparseSet, SortAsReverse) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -2012,7 +2012,7 @@ TYPED_TEST(SparseSet, SortAsReverse) {
 }
 
 TYPED_TEST(SparseSet, SortAsUnordered) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -2046,7 +2046,7 @@ TYPED_TEST(SparseSet, SortAsUnordered) {
 }
 
 TYPED_TEST(SparseSet, SortAsInvalid) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
     using traits_type = entt::entt_traits<entity_type>;
 
@@ -2081,7 +2081,7 @@ TYPED_TEST(SparseSet, SortAsInvalid) {
 }
 
 ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -2115,7 +2115,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) {
 }
 
 TYPED_TEST(SparseSet, CanModifyDuringIteration) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using sparse_set_type = entt::basic_sparse_set<entity_type>;
 
     for(const auto policy: this->deletion_policy) {
@@ -2135,7 +2135,7 @@ TYPED_TEST(SparseSet, CanModifyDuringIteration) {
 }
 
 TYPED_TEST(SparseSet, CustomAllocator) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
 
     for(const auto policy: this->deletion_policy) {
         const test::throwing_allocator<entity_type> allocator{};
@@ -2189,7 +2189,7 @@ TYPED_TEST(SparseSet, CustomAllocator) {
 }
 
 TYPED_TEST(SparseSet, ThrowingAllocator) {
-    using entity_type = typename TestFixture::type;
+    using entity_type = TestFixture::type;
     using traits_type = entt::entt_traits<entity_type>;
 
     for(const auto policy: this->deletion_policy) {

test/entt/entity/storage.cpp

@@ -89,7 +89,7 @@ TYPED_TEST_SUITE(Storage, StorageTypes, );
 TYPED_TEST_SUITE(StorageDeathTest, StorageTypes, );
 
 TYPED_TEST(Storage, Constructors) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -106,7 +106,7 @@ TYPED_TEST(Storage, Constructors) {
 }
 
 TYPED_TEST(Storage, Move) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{3}, entt::entity{2}};
@@ -163,7 +163,7 @@ TYPED_TEST(Storage, Move) {
 }
 
 TYPED_TEST(Storage, Swap) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -197,7 +197,7 @@ TYPED_TEST(Storage, Swap) {
 }
 
 TYPED_TEST(Storage, Capacity) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -214,7 +214,7 @@ TYPED_TEST(Storage, Capacity) {
 }
 
 TYPED_TEST(Storage, ShrinkToFit) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -247,7 +247,7 @@ TYPED_TEST(Storage, ShrinkToFit) {
 }
 
 TYPED_TEST(Storage, Raw) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -259,8 +259,8 @@ TYPED_TEST(Storage, Raw) {
 }
 
 TYPED_TEST(Storage, Iterator) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, value_type>();
     testing::StaticAssertTypeEq<typename iterator::pointer, value_type *>();
@@ -322,8 +322,8 @@ TYPED_TEST(Storage, Iterator) {
 }
 
 TYPED_TEST(Storage, ConstIterator) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::const_iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::const_iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, value_type>();
     testing::StaticAssertTypeEq<typename iterator::pointer, const value_type *>();
@@ -387,8 +387,8 @@ TYPED_TEST(Storage, ConstIterator) {
 }
 
 TYPED_TEST(Storage, ReverseIterator) {
-    using value_type = typename TestFixture::type;
-    using reverse_iterator = typename entt::storage<value_type>::reverse_iterator;
+    using value_type = TestFixture::type;
+    using reverse_iterator = entt::storage<value_type>::reverse_iterator;
 
     testing::StaticAssertTypeEq<typename reverse_iterator::value_type, value_type>();
     testing::StaticAssertTypeEq<typename reverse_iterator::pointer, value_type *>();
@@ -451,8 +451,8 @@ TYPED_TEST(Storage, ReverseIterator) {
 }
 
 TYPED_TEST(Storage, ConstReverseIterator) {
-    using value_type = typename TestFixture::type;
-    using const_reverse_iterator = typename entt::storage<value_type>::const_reverse_iterator;
+    using value_type = TestFixture::type;
+    using const_reverse_iterator = entt::storage<value_type>::const_reverse_iterator;
 
     testing::StaticAssertTypeEq<typename const_reverse_iterator::value_type, value_type>();
     testing::StaticAssertTypeEq<typename const_reverse_iterator::pointer, const value_type *>();
@@ -517,7 +517,7 @@ TYPED_TEST(Storage, ConstReverseIterator) {
 }
 
 TYPED_TEST(Storage, IteratorConversion) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -543,7 +543,7 @@ TYPED_TEST(Storage, IteratorConversion) {
 }
 
 TYPED_TEST(Storage, IteratorPageSizeAwareness) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -562,7 +562,7 @@ TYPED_TEST(Storage, IteratorPageSizeAwareness) {
 }
 
 TYPED_TEST(Storage, Getters) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{1};
@@ -583,7 +583,7 @@ TYPED_TEST(Storage, Getters) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Getters) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{4};
@@ -596,7 +596,7 @@ ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Getters) {
 }
 
 TYPED_TEST(Storage, Value) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{2};
@@ -607,7 +607,7 @@ TYPED_TEST(Storage, Value) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Value) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -615,7 +615,7 @@ ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Value) {
 }
 
 TYPED_TEST(Storage, Emplace) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -663,7 +663,7 @@ TEST(Storage, EmplaceSelfMoveSupportInPlaceDelete) {
 }
 
 TYPED_TEST(Storage, TryEmplace) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -799,7 +799,7 @@ TEST(Storage, TryEmplaceNonCopyConstructible) {
 }
 
 TYPED_TEST(Storage, Patch) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{2};
@@ -824,7 +824,7 @@ TYPED_TEST(Storage, Patch) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Patch) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -832,7 +832,7 @@ ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Patch) {
 }
 
 TYPED_TEST(Storage, Insert) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -877,7 +877,7 @@ TYPED_TEST(Storage, Insert) {
 }
 
 TYPED_TEST(Storage, Erase) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -917,7 +917,7 @@ TYPED_TEST(Storage, Erase) {
 }
 
 TYPED_TEST(Storage, CrossErase) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     entt::sparse_set set;
@@ -934,7 +934,7 @@ TYPED_TEST(Storage, CrossErase) {
 }
 
 TYPED_TEST(Storage, Remove) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -977,7 +977,7 @@ TYPED_TEST(Storage, Remove) {
 }
 
 TYPED_TEST(Storage, CrossRemove) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     entt::sparse_set set;
@@ -994,7 +994,7 @@ TYPED_TEST(Storage, CrossRemove) {
 }
 
 TYPED_TEST(Storage, Clear) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -1019,7 +1019,7 @@ TYPED_TEST(Storage, Clear) {
 }
 
 TYPED_TEST(Storage, Compact) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -1065,7 +1065,7 @@ TYPED_TEST(Storage, Compact) {
 }
 
 TYPED_TEST(Storage, SwapElements) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -1090,8 +1090,8 @@ TYPED_TEST(Storage, SwapElements) {
 }
 
 TYPED_TEST(Storage, Iterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity, value_type &>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, value_type &>>>();
@@ -1137,8 +1137,8 @@ TYPED_TEST(Storage, Iterable) {
 }
 
 TYPED_TEST(Storage, ConstIterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::const_iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::const_iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity, const value_type &>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, const value_type &>>>();
@@ -1184,7 +1184,7 @@ TYPED_TEST(Storage, ConstIterable) {
 }
 
 TYPED_TEST(Storage, IterableIteratorConversion) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -1201,7 +1201,7 @@ TYPED_TEST(Storage, IterableIteratorConversion) {
 }
 
 TYPED_TEST(Storage, IterableAlgorithmCompatibility) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -1214,8 +1214,8 @@ TYPED_TEST(Storage, IterableAlgorithmCompatibility) {
 }
 
 TYPED_TEST(Storage, ReverseIterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::reverse_iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity, value_type &>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, value_type &>>>();
@@ -1261,8 +1261,8 @@ TYPED_TEST(Storage, ReverseIterable) {
 }
 
 TYPED_TEST(Storage, ConstReverseIterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::const_reverse_iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::const_reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity, const value_type &>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, const value_type &>>>();
@@ -1308,7 +1308,7 @@ TYPED_TEST(Storage, ConstReverseIterable) {
 }
 
 TYPED_TEST(Storage, ReverseIterableIteratorConversion) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -1325,7 +1325,7 @@ TYPED_TEST(Storage, ReverseIterableIteratorConversion) {
 }
 
 TYPED_TEST(Storage, ReverseIterableAlgorithmCompatibility) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -1338,7 +1338,7 @@ TYPED_TEST(Storage, ReverseIterableAlgorithmCompatibility) {
 }
 
 TYPED_TEST(Storage, SortOrdered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
@@ -1352,7 +1352,7 @@ TYPED_TEST(Storage, SortOrdered) {
 }
 
 TYPED_TEST(Storage, SortReverse) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
@@ -1366,7 +1366,7 @@ TYPED_TEST(Storage, SortReverse) {
 }
 
 TYPED_TEST(Storage, SortUnordered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
@@ -1393,7 +1393,7 @@ TYPED_TEST(Storage, SortUnordered) {
 }
 
 TYPED_TEST(Storage, SortN) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
@@ -1436,7 +1436,7 @@ TYPED_TEST(Storage, SortN) {
 }
 
 TYPED_TEST(Storage, SortAsDisjoint) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     const entt::storage<value_type> rhs;
@@ -1455,7 +1455,7 @@ TYPED_TEST(Storage, SortAsDisjoint) {
 }
 
 TYPED_TEST(Storage, SortAsOverlap) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -1491,7 +1491,7 @@ TYPED_TEST(Storage, SortAsOverlap) {
 }
 
 TYPED_TEST(Storage, SortAsOrdered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -1518,7 +1518,7 @@ TYPED_TEST(Storage, SortAsOrdered) {
 }
 
 TYPED_TEST(Storage, SortAsReverse) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -1560,7 +1560,7 @@ TYPED_TEST(Storage, SortAsReverse) {
 }
 
 TYPED_TEST(Storage, SortAsUnordered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -1634,7 +1634,7 @@ ENTT_DEBUG_TEST(StorageDeathTest, NonMovableComponent) {
 }
 
 TYPED_TEST(Storage, CanModifyDuringIteration) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
 
     entt::storage<value_type> pool;
@@ -1653,7 +1653,7 @@ TYPED_TEST(Storage, CanModifyDuringIteration) {
 }
 
 TYPED_TEST(Storage, ReferencesGuaranteed) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -1732,7 +1732,7 @@ TEST(Storage, ClassLevelNewDelete) {
 }
 
 TYPED_TEST(Storage, CustomAllocator) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     const test::throwing_allocator<entt::entity> allocator{};
     entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>> pool{allocator};
@@ -1778,7 +1778,7 @@ TYPED_TEST(Storage, CustomAllocator) {
 }
 
 TYPED_TEST(Storage, ThrowingAllocator) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>> pool{};
     typename std::decay_t<decltype(pool)>::base_type &base = pool;
@@ -1890,7 +1890,7 @@ TEST(Storage, ThrowingComponent) {
 #if defined(ENTT_HAS_TRACKED_MEMORY_RESOURCE)
 
 TYPED_TEST(Storage, NoUsesAllocatorConstruction) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     test::tracked_memory_resource memory_resource{};
     entt::basic_storage<value_type, entt::entity, std::pmr::polymorphic_allocator<value_type>> pool{&memory_resource};
@@ -1907,7 +1907,7 @@ TYPED_TEST(Storage, NoUsesAllocatorConstruction) {
 }
 
 TEST(Storage, UsesAllocatorConstruction) {
-    using string_type = typename test::tracked_memory_resource::string_type;
+    using string_type = test::tracked_memory_resource::string_type;
 
     test::tracked_memory_resource memory_resource{};
     entt::basic_storage<string_type, entt::entity, std::pmr::polymorphic_allocator<string_type>> pool{&memory_resource};

test/entt/entity/storage_entity.cpp

@@ -379,11 +379,11 @@ ENTT_DEBUG_TEST(StorageEntityDeathTest, FreeList) {
 }
 
 TEST(StorageEntity, Iterable) {
-    using iterator = typename entt::storage<entt::entity>::iterable::iterator;
+    using iterator = entt::storage<entt::entity>::iterable::iterator;
 
-    testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
-    testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
-    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
+    testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<iterator::reference, iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -405,7 +405,7 @@ TEST(StorageEntity, Iterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_NE(begin.base(), pool.begin());
-    ASSERT_EQ(begin.base(), pool.end() - static_cast<typename iterator::difference_type>(pool.free_list()));
+    ASSERT_EQ(begin.base(), pool.end() - static_cast<iterator::difference_type>(pool.free_list()));
     ASSERT_EQ(end.base(), pool.end());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{4});
@@ -423,11 +423,11 @@ TEST(StorageEntity, Iterable) {
 }
 
 TEST(StorageEntity, ConstIterable) {
-    using iterator = typename entt::storage<entt::entity>::const_iterable::iterator;
+    using iterator = entt::storage<entt::entity>::const_iterable::iterator;
 
-    testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
-    testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
-    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
+    testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<iterator::reference, iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -449,7 +449,7 @@ TEST(StorageEntity, ConstIterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_NE(begin.base(), pool.begin());
-    ASSERT_EQ(begin.base(), pool.end() - static_cast<typename iterator::difference_type>(pool.free_list()));
+    ASSERT_EQ(begin.base(), pool.end() - static_cast<iterator::difference_type>(pool.free_list()));
     ASSERT_EQ(end.base(), pool.end());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{4});
@@ -470,8 +470,8 @@ TEST(StorageEntity, IterableIteratorConversion) {
     entt::storage<entt::entity> pool;
     pool.generate(entt::entity{3});
 
-    const typename entt::storage<entt::entity>::iterable::iterator it = pool.each().begin();
-    typename entt::storage<entt::entity>::const_iterable::iterator cit = it;
+    const entt::storage<entt::entity>::iterable::iterator it = pool.each().begin();
+    entt::storage<entt::entity>::const_iterable::iterator cit = it;
 
     testing::StaticAssertTypeEq<decltype(*it), std::tuple<entt::entity>>();
     testing::StaticAssertTypeEq<decltype(*cit), std::tuple<entt::entity>>();
@@ -491,11 +491,11 @@ TEST(StorageEntity, IterableAlgorithmCompatibility) {
 }
 
 TEST(StorageEntity, ReverseIterable) {
-    using iterator = typename entt::storage<entt::entity>::reverse_iterable::iterator;
+    using iterator = entt::storage<entt::entity>::reverse_iterable::iterator;
 
-    testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
-    testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
-    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
+    testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<iterator::reference, iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -517,7 +517,7 @@ TEST(StorageEntity, ReverseIterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_EQ(begin.base(), pool.rbegin());
-    ASSERT_EQ(end.base(), pool.rbegin() + static_cast<typename iterator::difference_type>(pool.free_list()));
+    ASSERT_EQ(end.base(), pool.rbegin() + static_cast<iterator::difference_type>(pool.free_list()));
     ASSERT_NE(end.base(), pool.rend());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{1});
@@ -535,11 +535,11 @@ TEST(StorageEntity, ReverseIterable) {
 }
 
 TEST(StorageEntity, ReverseConstIterable) {
-    using iterator = typename entt::storage<entt::entity>::const_reverse_iterable::iterator;
+    using iterator = entt::storage<entt::entity>::const_reverse_iterable::iterator;
 
-    testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
-    testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
-    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
+    testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<iterator::reference, iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -561,7 +561,7 @@ TEST(StorageEntity, ReverseConstIterable) {
     ASSERT_NE(begin, end);
 
     ASSERT_EQ(begin.base(), pool.rbegin());
-    ASSERT_EQ(end.base(), pool.rbegin() + static_cast<typename iterator::difference_type>(pool.free_list()));
+    ASSERT_EQ(end.base(), pool.rbegin() + static_cast<iterator::difference_type>(pool.free_list()));
     ASSERT_NE(end.base(), pool.rend());
 
     ASSERT_EQ(std::get<0>(*begin.operator->().operator->()), entt::entity{1});
@@ -582,8 +582,8 @@ TEST(StorageEntity, ReverseIterableIteratorConversion) {
     entt::storage<entt::entity> pool;
     pool.generate(entt::entity{3});
 
-    const typename entt::storage<entt::entity>::reverse_iterable::iterator it = pool.reach().begin();
-    typename entt::storage<entt::entity>::const_reverse_iterable::iterator cit = it;
+    const entt::storage<entt::entity>::reverse_iterable::iterator it = pool.reach().begin();
+    entt::storage<entt::entity>::const_reverse_iterable::iterator cit = it;
 
     testing::StaticAssertTypeEq<decltype(*it), std::tuple<entt::entity>>();
     testing::StaticAssertTypeEq<decltype(*cit), std::tuple<entt::entity>>();

test/entt/entity/storage_no_instance.cpp

@@ -49,7 +49,7 @@ TYPED_TEST_SUITE(StorageNoInstance, StorageNoInstanceTypes, );
 TYPED_TEST_SUITE(StorageNoInstanceDeathTest, StorageNoInstanceTypes, );
 
 TYPED_TEST(StorageNoInstance, Constructors) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -65,7 +65,7 @@ TYPED_TEST(StorageNoInstance, Constructors) {
 }
 
 TYPED_TEST(StorageNoInstance, Move) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{3}, entt::entity{2}};
@@ -118,7 +118,7 @@ TYPED_TEST(StorageNoInstance, Move) {
 }
 
 TYPED_TEST(StorageNoInstance, Swap) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     entt::storage<value_type> other;
@@ -148,7 +148,7 @@ TYPED_TEST(StorageNoInstance, Swap) {
 }
 
 TYPED_TEST(StorageNoInstance, Getters) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{4};
@@ -169,7 +169,7 @@ TYPED_TEST(StorageNoInstance, Getters) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Getters) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{4};
@@ -182,7 +182,7 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Getters) {
 }
 
 TYPED_TEST(StorageNoInstance, Value) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{4};
@@ -193,7 +193,7 @@ TYPED_TEST(StorageNoInstance, Value) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Value) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -201,7 +201,7 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Value) {
 }
 
 TYPED_TEST(StorageNoInstance, Emplace) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -213,7 +213,7 @@ TYPED_TEST(StorageNoInstance, Emplace) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Emplace) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{4};
@@ -227,7 +227,7 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Emplace) {
 }
 
 TYPED_TEST(StorageNoInstance, TryEmplace) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
@@ -256,7 +256,7 @@ TYPED_TEST(StorageNoInstance, TryEmplace) {
 }
 
 TYPED_TEST(StorageNoInstance, Patch) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{4};
@@ -276,7 +276,7 @@ TYPED_TEST(StorageNoInstance, Patch) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Patch) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -284,7 +284,7 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Patch) {
 }
 
 TYPED_TEST(StorageNoInstance, Insert) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -304,7 +304,7 @@ TYPED_TEST(StorageNoInstance, Insert) {
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Insert) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -316,8 +316,8 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Insert) {
 }
 
 TYPED_TEST(StorageNoInstance, Iterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
@@ -359,8 +359,8 @@ TYPED_TEST(StorageNoInstance, Iterable) {
 }
 
 TYPED_TEST(StorageNoInstance, ConstIterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::const_iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::const_iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
@@ -402,7 +402,7 @@ TYPED_TEST(StorageNoInstance, ConstIterable) {
 }
 
 TYPED_TEST(StorageNoInstance, IterableIteratorConversion) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -419,7 +419,7 @@ TYPED_TEST(StorageNoInstance, IterableIteratorConversion) {
 }
 
 TYPED_TEST(StorageNoInstance, IterableAlgorithmCompatibility) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{3};
@@ -433,8 +433,8 @@ TYPED_TEST(StorageNoInstance, IterableAlgorithmCompatibility) {
 }
 
 TYPED_TEST(StorageNoInstance, ReverseIterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::reverse_iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
@@ -476,8 +476,8 @@ TYPED_TEST(StorageNoInstance, ReverseIterable) {
 }
 
 TYPED_TEST(StorageNoInstance, ConstReverseIterable) {
-    using value_type = typename TestFixture::type;
-    using iterator = typename entt::storage<value_type>::const_reverse_iterable::iterator;
+    using value_type = TestFixture::type;
+    using iterator = entt::storage<value_type>::const_reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<typename iterator::value_type, std::tuple<entt::entity>>();
     testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
@@ -519,7 +519,7 @@ TYPED_TEST(StorageNoInstance, ConstReverseIterable) {
 }
 
 TYPED_TEST(StorageNoInstance, ReverseIterableIteratorConversion) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
 
@@ -536,7 +536,7 @@ TYPED_TEST(StorageNoInstance, ReverseIterableIteratorConversion) {
 }
 
 TYPED_TEST(StorageNoInstance, ReverseIterableAlgorithmCompatibility) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const entt::entity entity{3};
@@ -550,7 +550,7 @@ TYPED_TEST(StorageNoInstance, ReverseIterableAlgorithmCompatibility) {
 }
 
 TYPED_TEST(StorageNoInstance, SortOrdered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{16}, entt::entity{8}, entt::entity{4}, entt::entity{2}, entt::entity{1}};
@@ -562,7 +562,7 @@ TYPED_TEST(StorageNoInstance, SortOrdered) {
 }
 
 TYPED_TEST(StorageNoInstance, SortReverse) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
@@ -574,7 +574,7 @@ TYPED_TEST(StorageNoInstance, SortReverse) {
 }
 
 TYPED_TEST(StorageNoInstance, SortUnordered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{4}, entt::entity{2}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
@@ -590,7 +590,7 @@ TYPED_TEST(StorageNoInstance, SortUnordered) {
 }
 
 TYPED_TEST(StorageNoInstance, SortN) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> pool;
     const std::array entity{entt::entity{2}, entt::entity{4}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
@@ -617,7 +617,7 @@ TYPED_TEST(StorageNoInstance, SortN) {
 }
 
 TYPED_TEST(StorageNoInstance, SortAsDisjoint) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     const entt::storage<value_type> rhs;
@@ -633,7 +633,7 @@ TYPED_TEST(StorageNoInstance, SortAsDisjoint) {
 }
 
 TYPED_TEST(StorageNoInstance, SortAsOverlap) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -654,7 +654,7 @@ TYPED_TEST(StorageNoInstance, SortAsOverlap) {
 }
 
 TYPED_TEST(StorageNoInstance, SortAsOrdered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -673,7 +673,7 @@ TYPED_TEST(StorageNoInstance, SortAsOrdered) {
 }
 
 TYPED_TEST(StorageNoInstance, SortAsReverse) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
@@ -697,7 +697,7 @@ TYPED_TEST(StorageNoInstance, SortAsReverse) {
 }
 
 TYPED_TEST(StorageNoInstance, SortAsUnordered) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;

test/entt/entity/storage_utility.cpp

@@ -11,7 +11,7 @@ using StorageUtilityTypes = ::testing::Types<int, char, double, void>;
 TYPED_TEST_SUITE(StorageUtility, StorageUtilityTypes, );
 
 TYPED_TEST(StorageUtility, StorageType) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     // just a bunch of static asserts to avoid regressions
 #ifdef ENTT_NO_MIXIN
@@ -24,7 +24,7 @@ TYPED_TEST(StorageUtility, StorageType) {
 }
 
 TYPED_TEST(StorageUtility, StorageFor) {
-    using value_type = typename TestFixture::type;
+    using value_type = TestFixture::type;
 
     // just a bunch of static asserts to avoid regressions
 #ifdef ENTT_NO_MIXIN

test/entt/entity/view.cpp

@@ -765,7 +765,7 @@ TEST(MultiStorageView, Iterator) {
     std::get<0>(storage).insert(entity.begin(), entity.end());
     std::get<1>(storage).insert(entity.begin(), entity.end());
 
-    using iterator = typename decltype(view)::iterator;
+    using iterator = decltype(view)::iterator;
 
     iterator end{view.begin()};
     iterator begin{};