encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-08-11 06:29:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove ShareableCloneable

Browse Source 
This functionality is no longer needed, so just remove it.

Change-Id: Iebb4e4105b9e3b4a6a700594298503ad6cb68d31
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/51484
Auto-Submit: Ben Clayton <bclayton@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Ben Clayton 2021-05-19 13:25:08 +00:00 committed by Commit Bot service account
parent 05743afb56
commit 40ac15f157
3 changed files with 67 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/clone_context.cc
View File

@ -20,7 +20,6 @@
#include "src/utils/get_or_create.h" #include "src/utils/get_or_create.h"
TINT_INSTANTIATE_TYPEINFO(tint::Cloneable); TINT_INSTANTIATE_TYPEINFO(tint::Cloneable);
TINT_INSTANTIATE_TYPEINFO(tint::ShareableCloneable);
namespace tint { namespace tint {

33
src/clone_context.h
View File

@ -56,12 +56,7 @@ inline ProgramID ProgramIDOf(const Cloneable*) {
return ProgramID(); return ProgramID();
} }
/// ShareableCloneable is the base class for Cloneable objects which will only /// CloneContext holds the state used while cloning AST nodes.
/// be cloned once when CloneContext::Clone() is called with the same object
/// pointer.
class ShareableCloneable : public Castable<ShareableCloneable, Cloneable> {};
/// CloneContext holds the state used while cloning AST nodes and types.
class CloneContext { class CloneContext {
/// ParamTypeIsPtrOf<F, T>::value is true iff the first parameter of /// ParamTypeIsPtrOf<F, T>::value is true iff the first parameter of
/// F is a pointer of (or derives from) type T. /// F is a pointer of (or derives from) type T.
@ -114,10 +109,9 @@ class CloneContext {
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(src, a); TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(src, a);
} }
// Have we cloned this object already, or was Replace() called for this // Was Replace() called for this object?
// object? auto it = replacements_.find(a);
auto it = cloned_.find(a); if (it != replacements_.end()) {
if (it != cloned_.end()) {
return CheckedCast<T>(it->second); return CheckedCast<T>(it->second);
} }
@ -139,13 +133,6 @@ class CloneContext {
cloned = a->Clone(this); cloned = a->Clone(this);
} }
// Does the type derive from ShareableCloneable?
if (Is<ShareableCloneable, kDontErrorOnImpossibleCast>(a)) {
// Yes. Record this clone mapping so that future calls to Clone()
// return the same cloned object.
cloned_.emplace(a, cloned);
}
auto* out = CheckedCast<T>(cloned); auto* out = CheckedCast<T>(cloned);
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(dst, out); TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(dst, out);
@ -179,15 +166,15 @@ class CloneContext {
// Have we seen this object before? If so, return the previously cloned // Have we seen this object before? If so, return the previously cloned
// version instead of making yet another copy. // version instead of making yet another copy.
auto it = cloned_.find(a); auto it = replacements_.find(a);
if (it != cloned_.end()) { if (it != replacements_.end()) {
return CheckedCast<T>(it->second); return CheckedCast<T>(it->second);
} }
// First time clone and no replacer transforms matched. // First time clone and no replacer transforms matched.
// Clone with T::Clone(). // Clone with T::Clone().
auto* c = a->Clone(this); auto* c = a->Clone(this);
cloned_.emplace(a, c); replacements_.emplace(a, c);
return CheckedCast<T>(c); return CheckedCast<T>(c);
} }
@ -374,7 +361,7 @@ class CloneContext {
CloneContext& Replace(WHAT* what, WITH* with) { CloneContext& Replace(WHAT* what, WITH* with) {
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(src, what); TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(src, what);
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(dst, with); TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(dst, with);
cloned_[what] = with; replacements_[what] = with;
return *this; return *this;
} }
@ -514,8 +501,8 @@ class CloneContext {
std::unordered_map<const Cloneable*, CloneableList> insert_after_; std::unordered_map<const Cloneable*, CloneableList> insert_after_;
}; };
/// A map of object in #src to their cloned equivalent in #dst /// A map of object in #src to their replacement in #dst
std::unordered_map<const Cloneable*, Cloneable*> cloned_; std::unordered_map<const Cloneable*, Cloneable*> replacements_;
/// A map of symbol in #src to their cloned equivalent in #dst /// A map of symbol in #src to their cloned equivalent in #dst
std::unordered_map<Symbol, Symbol> cloned_symbols_; std::unordered_map<Symbol, Symbol> cloned_symbols_;

206
src/clone_context_test.cc
View File

@ -30,17 +30,17 @@ struct Allocator {
BlockAllocator<Cloneable> alloc; BlockAllocator<Cloneable> alloc;
}; };
struct UniqueNode : public Castable<UniqueNode, Cloneable> { struct Node : public Castable<Node, Cloneable> {
UniqueNode(Allocator* alloc, Symbol n) : allocator(alloc), name(n) {} Node(Allocator* alloc, Symbol n) : allocator(alloc), name(n) {}
Allocator* const allocator; Allocator* const allocator;
Symbol name; Symbol name;
UniqueNode* a = nullptr; Node* a = nullptr;
UniqueNode* b = nullptr; Node* b = nullptr;
UniqueNode* c = nullptr; Node* c = nullptr;
std::vector<UniqueNode*> vec; std::vector<Node*> vec;
UniqueNode* Clone(CloneContext* ctx) const override { Node* Clone(CloneContext* ctx) const override {
auto* out = allocator->Create<UniqueNode>(ctx->Clone(name)); auto* out = allocator->Create<Node>(ctx->Clone(name));
out->a = ctx->Clone(a); out->a = ctx->Clone(a);
out->b = ctx->Clone(b); out->b = ctx->Clone(b);
out->c = ctx->Clone(c); out->c = ctx->Clone(c);
@ -49,43 +49,12 @@ struct UniqueNode : public Castable<UniqueNode, Cloneable> {
} }
}; };
struct UniqueReplaceable : public Castable<UniqueReplaceable, UniqueNode> { struct Replaceable : public Castable<Replaceable, Node> {
UniqueReplaceable(Allocator* alloc, Symbol n) : Base(alloc, n) {} Replaceable(Allocator* alloc, Symbol n) : Base(alloc, n) {}
}; };
struct UniqueReplacement struct Replacement : public Castable<Replacement, Replaceable> {
: public Castable<UniqueReplacement, UniqueReplaceable> { Replacement(Allocator* alloc, Symbol n) : Base(alloc, n) {}
UniqueReplacement(Allocator* alloc, Symbol n) : Base(alloc, n) {}
};
struct ShareableNode : public Castable<ShareableNode, ShareableCloneable> {
ShareableNode(Allocator* alloc, Symbol n) : allocator(alloc), name(n) {}
Allocator* const allocator;
Symbol name;
ShareableNode* a = nullptr;
ShareableNode* b = nullptr;
ShareableNode* c = nullptr;
std::vector<ShareableNode*> vec;
ShareableNode* Clone(CloneContext* ctx) const override {
auto* out = allocator->Create<ShareableNode>(ctx->Clone(name));
out->a = ctx->Clone(a);
out->b = ctx->Clone(b);
out->c = ctx->Clone(c);
out->vec = ctx->Clone(vec);
return out;
}
};
struct ShareableReplaceable
: public Castable<ShareableReplaceable, ShareableNode> {
ShareableReplaceable(Allocator* alloc, Symbol n) : Base(alloc, n) {}
};
struct ShareableReplacement
: public Castable<ShareableReplacement, ShareableReplaceable> {
ShareableReplacement(Allocator* alloc, Symbol n) : Base(alloc, n) {}
}; };
struct NotANode : public Castable<NotANode, Cloneable> { struct NotANode : public Castable<NotANode, Cloneable> {
@ -114,32 +83,9 @@ ProgramID ProgramIDOf(const ProgramNode* node) {
return node->program_id; return node->program_id;
} }
struct UniqueTypes { using CloneContextNodeTest = ::testing::Test;
using Node = UniqueNode;
using Replaceable = UniqueReplaceable;
using Replacement = UniqueReplacement;
};
struct ShareableTypes {
using Node = ShareableNode;
using Replaceable = ShareableReplaceable;
using Replacement = ShareableReplacement;
};
template <typename T>
struct CloneContextNodeTest : public ::testing::Test {
using Node = typename T::Node;
using Replaceable = typename T::Replaceable;
using Replacement = typename T::Replacement;
static constexpr bool is_unique = std::is_same<Node, UniqueNode>::value;
};
using CloneContextTestNodeTypes = ::testing::Types<UniqueTypes, ShareableTypes>;
TYPED_TEST_SUITE(CloneContextNodeTest, CloneContextTestNodeTypes, /**/);
TYPED_TEST(CloneContextNodeTest, Clone) {
using Node = typename TestFixture::Node;
constexpr bool is_unique = TestFixture::is_unique;
TEST_F(CloneContextNodeTest, Clone) {
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -188,23 +134,14 @@ TYPED_TEST(CloneContextNodeTest, Clone) {
EXPECT_EQ(cloned_root->b->name, cloned.Symbols().Get("b")); EXPECT_EQ(cloned_root->b->name, cloned.Symbols().Get("b"));
EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("b->b")); EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("b->b"));
if (is_unique) {
EXPECT_NE(cloned_root->b->a, cloned_root->a); // De-aliased EXPECT_NE(cloned_root->b->a, cloned_root->a); // De-aliased
EXPECT_NE(cloned_root->c, cloned_root->b); // De-aliased EXPECT_NE(cloned_root->c, cloned_root->b); // De-aliased
} else {
EXPECT_EQ(cloned_root->b->a, cloned_root->a); // Aliased
EXPECT_EQ(cloned_root->c, cloned_root->b); // Aliased
}
EXPECT_EQ(cloned_root->b->a->name, cloned_root->a->name); EXPECT_EQ(cloned_root->b->a->name, cloned_root->a->name);
EXPECT_EQ(cloned_root->c->name, cloned_root->b->name); EXPECT_EQ(cloned_root->c->name, cloned_root->b->name);
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_Cloneable) { TEST_F(CloneContextNodeTest, CloneWithReplaceAll_Cloneable) {
using Node = typename TestFixture::Node;
using Replaceable = typename TestFixture::Replaceable;
using Replacement = typename TestFixture::Replacement;
constexpr bool is_unique = TestFixture::is_unique;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -284,13 +221,9 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_Cloneable) {
EXPECT_EQ(cloned_root->b->b->name, EXPECT_EQ(cloned_root->b->b->name,
cloned.Symbols().Get("replacement-child:b")); cloned.Symbols().Get("replacement-child:b"));
if (is_unique) {
EXPECT_NE(cloned_root->b->c, cloned_root->a); // De-aliased EXPECT_NE(cloned_root->b->c, cloned_root->a); // De-aliased
EXPECT_NE(cloned_root->c, cloned_root->b); // De-aliased EXPECT_NE(cloned_root->c, cloned_root->b); // De-aliased
} else {
EXPECT_EQ(cloned_root->b->c, cloned_root->a); // Aliased
EXPECT_EQ(cloned_root->c, cloned_root->b); // Aliased
}
EXPECT_EQ(cloned_root->b->c->name, cloned_root->a->name); EXPECT_EQ(cloned_root->b->c->name, cloned_root->a->name);
EXPECT_EQ(cloned_root->c->name, cloned_root->b->name); EXPECT_EQ(cloned_root->c->name, cloned_root->b->name);
@ -301,9 +234,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_Cloneable) {
EXPECT_FALSE(Is<Replacement>(cloned_root->b->b)); EXPECT_FALSE(Is<Replacement>(cloned_root->b->b));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_Symbols) { TEST_F(CloneContextNodeTest, CloneWithReplaceAll_Symbols) {
using Node = typename TestFixture::Node;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -342,10 +273,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_Symbols) {
EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("transformed<b->b>")); EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("transformed<b->b>"));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithoutTransform) { TEST_F(CloneContextNodeTest, CloneWithoutTransform) {
using Node = typename TestFixture::Node;
using Replacement = typename TestFixture::Replacement;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -363,9 +291,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithoutTransform) {
EXPECT_EQ(cloned_node->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_node->name, cloned.Symbols().Get("root"));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplace) { TEST_F(CloneContextNodeTest, CloneWithReplace) {
using Node = typename TestFixture::Node;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -397,10 +323,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplace) {
EXPECT_EQ(cloned_root->c->name, cloned.Symbols().Get("c")); EXPECT_EQ(cloned_root->c->name, cloned.Symbols().Get("c"));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithRemove) { TEST_F(CloneContextNodeTest, CloneWithRemove) {
using Node = typename TestFixture::Node;
constexpr bool is_unique = TestFixture::is_unique;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -417,23 +340,16 @@ TYPED_TEST(CloneContextNodeTest, CloneWithRemove) {
.Clone(original_root); .Clone(original_root);
EXPECT_EQ(cloned_root->vec.size(), 2u); EXPECT_EQ(cloned_root->vec.size(), 2u);
if (is_unique) {
EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[0], cloned_root->a);
EXPECT_NE(cloned_root->vec[1], cloned_root->c); EXPECT_NE(cloned_root->vec[1], cloned_root->c);
} else {
EXPECT_EQ(cloned_root->vec[0], cloned_root->a);
EXPECT_EQ(cloned_root->vec[1], cloned_root->c);
}
EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root"));
EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a"));
EXPECT_EQ(cloned_root->vec[1]->name, cloned.Symbols().Get("c")); EXPECT_EQ(cloned_root->vec[1]->name, cloned.Symbols().Get("c"));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithInsertBefore) { TEST_F(CloneContextNodeTest, CloneWithInsertBefore) {
using Node = typename TestFixture::Node;
constexpr bool is_unique = TestFixture::is_unique;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -453,15 +369,10 @@ TYPED_TEST(CloneContextNodeTest, CloneWithInsertBefore) {
.Clone(original_root); .Clone(original_root);
EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_EQ(cloned_root->vec.size(), 4u);
if (is_unique) {
EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[0], cloned_root->a);
EXPECT_NE(cloned_root->vec[2], cloned_root->b); EXPECT_NE(cloned_root->vec[2], cloned_root->b);
EXPECT_NE(cloned_root->vec[3], cloned_root->c); EXPECT_NE(cloned_root->vec[3], cloned_root->c);
} else {
EXPECT_EQ(cloned_root->vec[0], cloned_root->a);
EXPECT_EQ(cloned_root->vec[2], cloned_root->b);
EXPECT_EQ(cloned_root->vec[3], cloned_root->c);
}
EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root"));
EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a"));
@ -470,10 +381,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithInsertBefore) {
EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c"));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithInsertAfter) { TEST_F(CloneContextNodeTest, CloneWithInsertAfter) {
using Node = typename TestFixture::Node;
constexpr bool is_unique = TestFixture::is_unique;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -493,15 +401,10 @@ TYPED_TEST(CloneContextNodeTest, CloneWithInsertAfter) {
.Clone(original_root); .Clone(original_root);
EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_EQ(cloned_root->vec.size(), 4u);
if (is_unique) {
EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[0], cloned_root->a);
EXPECT_NE(cloned_root->vec[1], cloned_root->b); EXPECT_NE(cloned_root->vec[1], cloned_root->b);
EXPECT_NE(cloned_root->vec[3], cloned_root->c); EXPECT_NE(cloned_root->vec[3], cloned_root->c);
} else {
EXPECT_EQ(cloned_root->vec[0], cloned_root->a);
EXPECT_EQ(cloned_root->vec[1], cloned_root->b);
EXPECT_EQ(cloned_root->vec[3], cloned_root->c);
}
EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root"));
EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a"));
@ -510,10 +413,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithInsertAfter) {
EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c"));
} }
TYPED_TEST(CloneContextNodeTest, CloneWithInsertBeforeAndAfterRemoved) { TEST_F(CloneContextNodeTest, CloneWithInsertBeforeAndAfterRemoved) {
using Node = typename TestFixture::Node;
constexpr bool is_unique = TestFixture::is_unique;
Allocator a; Allocator a;
ProgramBuilder builder; ProgramBuilder builder;
@ -538,13 +438,9 @@ TYPED_TEST(CloneContextNodeTest, CloneWithInsertBeforeAndAfterRemoved) {
.Clone(original_root); .Clone(original_root);
EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_EQ(cloned_root->vec.size(), 4u);
if (is_unique) {
EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[0], cloned_root->a);
EXPECT_NE(cloned_root->vec[3], cloned_root->c); EXPECT_NE(cloned_root->vec[3], cloned_root->c);
} else {
EXPECT_EQ(cloned_root->vec[0], cloned_root->a);
EXPECT_EQ(cloned_root->vec[3], cloned_root->c);
}
EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root"));
EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("a"));
@ -554,10 +450,7 @@ TYPED_TEST(CloneContextNodeTest, CloneWithInsertBeforeAndAfterRemoved) {
EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c"));
} }
TYPED_TEST(CloneContextNodeTest, CloneIntoSameBuilder) { TEST_F(CloneContextNodeTest, CloneIntoSameBuilder) {
using Node = typename TestFixture::Node;
constexpr bool is_unique = TestFixture::is_unique;
ProgramBuilder builder; ProgramBuilder builder;
CloneContext ctx(&builder); CloneContext ctx(&builder);
Allocator allocator; Allocator allocator;
@ -566,19 +459,15 @@ TYPED_TEST(CloneContextNodeTest, CloneIntoSameBuilder) {
auto* cloned_b = ctx.Clone(original); auto* cloned_b = ctx.Clone(original);
EXPECT_NE(original, cloned_a); EXPECT_NE(original, cloned_a);
EXPECT_NE(original, cloned_b); EXPECT_NE(original, cloned_b);
if (is_unique) {
EXPECT_NE(cloned_a, cloned_b); EXPECT_NE(cloned_a, cloned_b);
} else {
EXPECT_EQ(cloned_a, cloned_b);
}
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_SameTypeTwice) { TEST_F(CloneContextNodeTest, CloneWithReplaceAll_SameTypeTwice) {
std::string node_name = TypeInfo::Of<typename TestFixture::Node>().name; std::string node_name = TypeInfo::Of<Node>().name;
EXPECT_FATAL_FAILURE( EXPECT_FATAL_FAILURE(
{ {
using Node = typename TestFixture::Node;
ProgramBuilder cloned; ProgramBuilder cloned;
Program original; Program original;
CloneContext ctx(&cloned, &original); CloneContext ctx(&cloned, &original);
@ -590,16 +479,12 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_SameTypeTwice) {
node_name); node_name);
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_BaseThenDerived) { TEST_F(CloneContextNodeTest, CloneWithReplaceAll_BaseThenDerived) {
std::string node_name = TypeInfo::Of<typename TestFixture::Node>().name; std::string node_name = TypeInfo::Of<Node>().name;
std::string replaceable_name = std::string replaceable_name = TypeInfo::Of<Replaceable>().name;
TypeInfo::Of<typename TestFixture::Replaceable>().name;
EXPECT_FATAL_FAILURE( EXPECT_FATAL_FAILURE(
{ {
using Node = typename TestFixture::Node;
using Replaceable = typename TestFixture::Replaceable;
ProgramBuilder cloned; ProgramBuilder cloned;
Program original; Program original;
CloneContext ctx(&cloned, &original); CloneContext ctx(&cloned, &original);
@ -611,15 +496,12 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_BaseThenDerived) {
node_name); node_name);
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_DerivedThenBase) { TEST_F(CloneContextNodeTest, CloneWithReplaceAll_DerivedThenBase) {
std::string node_name = TypeInfo::Of<typename TestFixture::Node>().name; std::string node_name = TypeInfo::Of<Node>().name;
std::string replaceable_name = std::string replaceable_name = TypeInfo::Of<Replaceable>().name;
TypeInfo::Of<typename TestFixture::Replaceable>().name;
EXPECT_FATAL_FAILURE( EXPECT_FATAL_FAILURE(
{ {
using Node = typename TestFixture::Node;
using Replaceable = typename TestFixture::Replaceable;
ProgramBuilder cloned; ProgramBuilder cloned;
Program original; Program original;
CloneContext ctx(&cloned, &original); CloneContext ctx(&cloned, &original);
@ -631,10 +513,9 @@ TYPED_TEST(CloneContextNodeTest, CloneWithReplaceAll_DerivedThenBase) {
replaceable_name); replaceable_name);
} }
TYPED_TEST(CloneContextNodeTest, CloneWithReplace_WithNotANode) { TEST_F(CloneContextNodeTest, CloneWithReplace_WithNotANode) {
EXPECT_FATAL_FAILURE( EXPECT_FATAL_FAILURE(
{ {
using Node = typename TestFixture::Node;
Allocator allocator; Allocator allocator;
ProgramBuilder builder; ProgramBuilder builder;
auto* original_root = auto* original_root =
@ -794,12 +675,9 @@ TEST_F(CloneContextTest, ProgramIDs_Clone_ObjectNotOwnedByDst) {
} // namespace } // namespace
TINT_INSTANTIATE_TYPEINFO(UniqueNode); TINT_INSTANTIATE_TYPEINFO(Node);
TINT_INSTANTIATE_TYPEINFO(UniqueReplaceable); TINT_INSTANTIATE_TYPEINFO(Replaceable);
TINT_INSTANTIATE_TYPEINFO(UniqueReplacement); TINT_INSTANTIATE_TYPEINFO(Replacement);
TINT_INSTANTIATE_TYPEINFO(ShareableNode);
TINT_INSTANTIATE_TYPEINFO(ShareableReplaceable);
TINT_INSTANTIATE_TYPEINFO(ShareableReplacement);
TINT_INSTANTIATE_TYPEINFO(NotANode); TINT_INSTANTIATE_TYPEINFO(NotANode);
TINT_INSTANTIATE_TYPEINFO(ProgramNode); TINT_INSTANTIATE_TYPEINFO(ProgramNode);