// Copyright 2020 The Tint Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include <unordered_set> #include "gtest/gtest-spi.h" #include "src/program_builder.h" namespace tint { namespace { struct Allocator { template <typename T, typename... ARGS> T* Create(ARGS&&... args) { return alloc.Create<T>(this, std::forward<ARGS>(args)...); } private: BlockAllocator<Cloneable> alloc; }; struct Node : public Castable<Node, Cloneable> { Node(Allocator* alloc, Symbol n) : allocator(alloc), name(n) {} Allocator* const allocator; Symbol name; Node* a = nullptr; Node* b = nullptr; Node* c = nullptr; std::vector<Node*> vec; Node* Clone(CloneContext* ctx) const override { auto* out = allocator->Create<Node>(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 Replaceable : public Castable<Replaceable, Node> { Replaceable(Allocator* alloc, Symbol n) : Base(alloc, n) {} }; struct Replacement : public Castable<Replacement, Replaceable> { Replacement(Allocator* alloc, Symbol n) : Base(alloc, n) {} }; struct NotANode : public Castable<NotANode, Cloneable> { explicit NotANode(Allocator* alloc) : allocator(alloc) {} Allocator* const allocator; NotANode* Clone(CloneContext*) const override { return allocator->Create<NotANode>(); } }; struct ProgramNode : public Castable<ProgramNode, Cloneable> { ProgramNode(Allocator* alloc, ProgramID id, ProgramID cloned_id) : allocator(alloc), program_id(id), cloned_program_id(cloned_id) {} Allocator* const allocator; ProgramID const program_id; ProgramID const cloned_program_id; ProgramNode* Clone(CloneContext*) const override { return allocator->Create<ProgramNode>(cloned_program_id, cloned_program_id); } }; ProgramID ProgramIDOf(const ProgramNode* node) { return node->program_id; } using CloneContextNodeTest = ::testing::Test; TEST_F(CloneContextNodeTest, Clone) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().New("root")); original_root->a = a.Create<Node>(builder.Symbols().New("a")); original_root->a->b = a.Create<Node>(builder.Symbols().New("a->b")); original_root->b = a.Create<Node>(builder.Symbols().New("b")); original_root->b->a = original_root->a; // Aliased original_root->b->b = a.Create<Node>(builder.Symbols().New("b->b")); original_root->c = original_root->b; // Aliased Program original(std::move(builder)); // root // ╭──────────────────┼──────────────────╮ // (a) (b) (c) // N <──────┐ N <───────────────┘ // ╭────┼────╮ │ ╭────┼────╮ // (a) (b) (c) │ (a) (b) (c) // N └───┘ N // // N: Node ProgramBuilder cloned; auto* cloned_root = CloneContext(&cloned, &original).Clone(original_root); EXPECT_NE(cloned_root->a, nullptr); EXPECT_EQ(cloned_root->a->a, nullptr); EXPECT_NE(cloned_root->a->b, nullptr); EXPECT_EQ(cloned_root->a->c, nullptr); EXPECT_NE(cloned_root->b, nullptr); EXPECT_NE(cloned_root->b->a, nullptr); EXPECT_NE(cloned_root->b->b, nullptr); EXPECT_EQ(cloned_root->b->c, nullptr); EXPECT_NE(cloned_root->c, nullptr); EXPECT_NE(cloned_root->a, original_root->a); EXPECT_NE(cloned_root->a->b, original_root->a->b); EXPECT_NE(cloned_root->b, original_root->b); EXPECT_NE(cloned_root->b->a, original_root->b->a); EXPECT_NE(cloned_root->b->b, original_root->b->b); EXPECT_NE(cloned_root->c, original_root->c); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->a->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->a->b->name, cloned.Symbols().Get("a->b")); EXPECT_EQ(cloned_root->b->name, cloned.Symbols().Get("b")); EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("b->b")); EXPECT_NE(cloned_root->b->a, cloned_root->a); // De-aliased EXPECT_NE(cloned_root->c, cloned_root->b); // De-aliased EXPECT_EQ(cloned_root->b->a->name, cloned_root->a->name); EXPECT_EQ(cloned_root->c->name, cloned_root->b->name); } TEST_F(CloneContextNodeTest, CloneWithReplaceAll_Cloneable) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().New("root")); original_root->a = a.Create<Node>(builder.Symbols().New("a")); original_root->a->b = a.Create<Replaceable>(builder.Symbols().New("a->b")); original_root->b = a.Create<Replaceable>(builder.Symbols().New("b")); original_root->b->a = original_root->a; // Aliased original_root->c = original_root->b; // Aliased Program original(std::move(builder)); // root // ╭──────────────────┼──────────────────╮ // (a) (b) (c) // N <──────┐ R <───────────────┘ // ╭────┼────╮ │ ╭────┼────╮ // (a) (b) (c) │ (a) (b) (c) // R └───┘ // // N: Node // R: Replaceable ProgramBuilder cloned; CloneContext ctx(&cloned, &original); ctx.ReplaceAll([&](Replaceable* in) { auto out_name = cloned.Symbols().Register( "replacement:" + original.Symbols().NameFor(in->name)); auto b_name = cloned.Symbols().Register( "replacement-child:" + original.Symbols().NameFor(in->name)); auto* out = a.Create<Replacement>(out_name); out->b = a.Create<Node>(b_name); out->c = ctx.Clone(in->a); return out; }); auto* cloned_root = ctx.Clone(original_root); // root // ╭─────────────────┼──────────────────╮ // (a) (b) (c) // N <──────┐ R <───────────────┘ // ╭────┼────╮ │ ╭────┼────╮ // (a) (b) (c) │ (a) (b) (c) // R │ N | // ╭────┼────╮ └────────────┘ // (a) (b) (c) // N // // N: Node // R: Replacement EXPECT_NE(cloned_root->a, nullptr); EXPECT_EQ(cloned_root->a->a, nullptr); EXPECT_NE(cloned_root->a->b, nullptr); // Replaced EXPECT_EQ(cloned_root->a->b->a, nullptr); // From replacement EXPECT_NE(cloned_root->a->b->b, nullptr); // From replacement EXPECT_EQ(cloned_root->a->b->c, nullptr); // From replacement EXPECT_EQ(cloned_root->a->c, nullptr); EXPECT_NE(cloned_root->b, nullptr); EXPECT_EQ(cloned_root->b->a, nullptr); // From replacement EXPECT_NE(cloned_root->b->b, nullptr); // From replacement EXPECT_NE(cloned_root->b->c, nullptr); // From replacement EXPECT_NE(cloned_root->c, nullptr); EXPECT_NE(cloned_root->a, original_root->a); EXPECT_NE(cloned_root->a->b, original_root->a->b); EXPECT_NE(cloned_root->b, original_root->b); EXPECT_NE(cloned_root->b->a, original_root->b->a); EXPECT_NE(cloned_root->c, original_root->c); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->a->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->a->b->name, cloned.Symbols().Get("replacement:a->b")); EXPECT_EQ(cloned_root->a->b->b->name, cloned.Symbols().Get("replacement-child:a->b")); EXPECT_EQ(cloned_root->b->name, cloned.Symbols().Get("replacement:b")); EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("replacement-child:b")); EXPECT_NE(cloned_root->b->c, cloned_root->a); // De-aliased EXPECT_NE(cloned_root->c, cloned_root->b); // De-aliased EXPECT_EQ(cloned_root->b->c->name, cloned_root->a->name); EXPECT_EQ(cloned_root->c->name, cloned_root->b->name); EXPECT_FALSE(Is<Replacement>(cloned_root->a)); EXPECT_TRUE(Is<Replacement>(cloned_root->a->b)); EXPECT_FALSE(Is<Replacement>(cloned_root->a->b->b)); EXPECT_TRUE(Is<Replacement>(cloned_root->b)); EXPECT_FALSE(Is<Replacement>(cloned_root->b->b)); } TEST_F(CloneContextNodeTest, CloneWithReplaceAll_Symbols) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().New("root")); original_root->a = a.Create<Node>(builder.Symbols().New("a")); original_root->a->b = a.Create<Node>(builder.Symbols().New("a->b")); original_root->b = a.Create<Node>(builder.Symbols().New("b")); original_root->b->a = original_root->a; // Aliased original_root->b->b = a.Create<Node>(builder.Symbols().New("b->b")); original_root->c = original_root->b; // Aliased Program original(std::move(builder)); // root // ╭──────────────────┼──────────────────╮ // (a) (b) (c) // N <──────┐ N <───────────────┘ // ╭────┼────╮ │ ╭────┼────╮ // (a) (b) (c) │ (a) (b) (c) // N └───┘ N // // N: Node ProgramBuilder cloned; auto* cloned_root = CloneContext(&cloned, &original, false) .ReplaceAll([&](Symbol sym) { auto in = original.Symbols().NameFor(sym); auto out = "transformed<" + in + ">"; return cloned.Symbols().New(out); }) .Clone(original_root); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("transformed<root>")); EXPECT_EQ(cloned_root->a->name, cloned.Symbols().Get("transformed<a>")); EXPECT_EQ(cloned_root->a->b->name, cloned.Symbols().Get("transformed<a->b>")); EXPECT_EQ(cloned_root->b->name, cloned.Symbols().Get("transformed<b>")); EXPECT_EQ(cloned_root->b->b->name, cloned.Symbols().Get("transformed<b->b>")); } TEST_F(CloneContextNodeTest, CloneWithoutTransform) { Allocator a; ProgramBuilder builder; auto* original_node = a.Create<Node>(builder.Symbols().New("root")); Program original(std::move(builder)); ProgramBuilder cloned; CloneContext ctx(&cloned, &original); ctx.ReplaceAll([&](Node*) { return a.Create<Replacement>(builder.Symbols().New("<unexpected-node>")); }); auto* cloned_node = ctx.CloneWithoutTransform(original_node); EXPECT_NE(cloned_node, original_node); EXPECT_EQ(cloned_node->name, cloned.Symbols().Get("root")); } TEST_F(CloneContextNodeTest, CloneWithReplace) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().New("root")); original_root->a = a.Create<Node>(builder.Symbols().New("a")); original_root->b = a.Create<Node>(builder.Symbols().New("b")); original_root->c = a.Create<Node>(builder.Symbols().New("c")); Program original(std::move(builder)); // root // ╭──────────────────┼──────────────────╮ // (a) (b) (c) // Replaced ProgramBuilder cloned; auto* replacement = a.Create<Node>(cloned.Symbols().New("replacement")); auto* cloned_root = CloneContext(&cloned, &original) .Replace(original_root->b, replacement) .Clone(original_root); EXPECT_NE(cloned_root->a, replacement); EXPECT_EQ(cloned_root->b, replacement); EXPECT_NE(cloned_root->c, replacement); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->a->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->b->name, cloned.Symbols().Get("replacement")); EXPECT_EQ(cloned_root->c->name, cloned.Symbols().Get("c")); } TEST_F(CloneContextNodeTest, CloneWithRemove) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->a = a.Create<Node>(builder.Symbols().Register("a")); original_root->b = a.Create<Node>(builder.Symbols().Register("b")); original_root->c = a.Create<Node>(builder.Symbols().Register("c")); original_root->vec = {original_root->a, original_root->b, original_root->c}; Program original(std::move(builder)); ProgramBuilder cloned; auto* cloned_root = CloneContext(&cloned, &original) .Remove(original_root->vec, original_root->b) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 2u); EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[1], cloned_root->c); 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[1]->name, cloned.Symbols().Get("c")); } TEST_F(CloneContextNodeTest, CloneWithInsertFront) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->a = a.Create<Node>(builder.Symbols().Register("a")); original_root->b = a.Create<Node>(builder.Symbols().Register("b")); original_root->c = a.Create<Node>(builder.Symbols().Register("c")); original_root->vec = {original_root->a, original_root->b, original_root->c}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion = a.Create<Node>(cloned.Symbols().New("insertion")); auto* cloned_root = CloneContext(&cloned, &original) .InsertFront(original_root->vec, insertion) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[1], cloned_root->b); EXPECT_NE(cloned_root->vec[2], cloned_root->c); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("insertion")); EXPECT_EQ(cloned_root->vec[1]->name, cloned.Symbols().Get("a")); EXPECT_EQ(cloned_root->vec[2]->name, cloned.Symbols().Get("b")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); } TEST_F(CloneContextNodeTest, CloneWithInsertFront_Empty) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->vec = {}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion = a.Create<Node>(cloned.Symbols().New("insertion")); auto* cloned_root = CloneContext(&cloned, &original) .InsertFront(original_root->vec, insertion) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 1u); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("insertion")); } TEST_F(CloneContextNodeTest, CloneWithInsertBack) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->a = a.Create<Node>(builder.Symbols().Register("a")); original_root->b = a.Create<Node>(builder.Symbols().Register("b")); original_root->c = a.Create<Node>(builder.Symbols().Register("c")); original_root->vec = {original_root->a, original_root->b, original_root->c}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion = a.Create<Node>(cloned.Symbols().New("insertion")); auto* cloned_root = CloneContext(&cloned, &original) .InsertBack(original_root->vec, insertion) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 4u); 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[1]->name, cloned.Symbols().Get("b")); EXPECT_EQ(cloned_root->vec[2]->name, cloned.Symbols().Get("c")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("insertion")); } TEST_F(CloneContextNodeTest, CloneWithInsertBack_Empty) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->vec = {}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion = a.Create<Node>(cloned.Symbols().New("insertion")); auto* cloned_root = CloneContext(&cloned, &original) .InsertBack(original_root->vec, insertion) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 1u); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("insertion")); } TEST_F(CloneContextNodeTest, CloneWithInsertFrontAndBack_Empty) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->vec = {}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion_front = a.Create<Node>(cloned.Symbols().New("insertion_front")); auto* insertion_back = a.Create<Node>(cloned.Symbols().New("insertion_back")); auto* cloned_root = CloneContext(&cloned, &original) .InsertBack(original_root->vec, insertion_back) .InsertFront(original_root->vec, insertion_front) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 2u); EXPECT_EQ(cloned_root->name, cloned.Symbols().Get("root")); EXPECT_EQ(cloned_root->vec[0]->name, cloned.Symbols().Get("insertion_front")); EXPECT_EQ(cloned_root->vec[1]->name, cloned.Symbols().Get("insertion_back")); } TEST_F(CloneContextNodeTest, CloneWithInsertBefore) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->a = a.Create<Node>(builder.Symbols().Register("a")); original_root->b = a.Create<Node>(builder.Symbols().Register("b")); original_root->c = a.Create<Node>(builder.Symbols().Register("c")); original_root->vec = {original_root->a, original_root->b, original_root->c}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion = a.Create<Node>(cloned.Symbols().New("insertion")); auto* cloned_root = CloneContext(&cloned, &original) .InsertBefore(original_root->vec, original_root->b, insertion) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[2], cloned_root->b); EXPECT_NE(cloned_root->vec[3], cloned_root->c); 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[1]->name, cloned.Symbols().Get("insertion")); EXPECT_EQ(cloned_root->vec[2]->name, cloned.Symbols().Get("b")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); } TEST_F(CloneContextNodeTest, CloneWithInsertAfter) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->a = a.Create<Node>(builder.Symbols().Register("a")); original_root->b = a.Create<Node>(builder.Symbols().Register("b")); original_root->c = a.Create<Node>(builder.Symbols().Register("c")); original_root->vec = {original_root->a, original_root->b, original_root->c}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion = a.Create<Node>(cloned.Symbols().New("insertion")); auto* cloned_root = CloneContext(&cloned, &original) .InsertAfter(original_root->vec, original_root->b, insertion) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[1], cloned_root->b); EXPECT_NE(cloned_root->vec[3], cloned_root->c); 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[1]->name, cloned.Symbols().Get("b")); EXPECT_EQ(cloned_root->vec[2]->name, cloned.Symbols().Get("insertion")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); } TEST_F(CloneContextNodeTest, CloneWithInsertBeforeAndAfterRemoved) { Allocator a; ProgramBuilder builder; auto* original_root = a.Create<Node>(builder.Symbols().Register("root")); original_root->a = a.Create<Node>(builder.Symbols().Register("a")); original_root->b = a.Create<Node>(builder.Symbols().Register("b")); original_root->c = a.Create<Node>(builder.Symbols().Register("c")); original_root->vec = {original_root->a, original_root->b, original_root->c}; Program original(std::move(builder)); ProgramBuilder cloned; auto* insertion_before = a.Create<Node>(cloned.Symbols().New("insertion_before")); auto* insertion_after = a.Create<Node>(cloned.Symbols().New("insertion_after")); auto* cloned_root = CloneContext(&cloned, &original) .InsertBefore(original_root->vec, original_root->b, insertion_before) .InsertAfter(original_root->vec, original_root->b, insertion_after) .Remove(original_root->vec, original_root->b) .Clone(original_root); EXPECT_EQ(cloned_root->vec.size(), 4u); EXPECT_NE(cloned_root->vec[0], cloned_root->a); EXPECT_NE(cloned_root->vec[3], cloned_root->c); 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[1]->name, cloned.Symbols().Get("insertion_before")); EXPECT_EQ(cloned_root->vec[2]->name, cloned.Symbols().Get("insertion_after")); EXPECT_EQ(cloned_root->vec[3]->name, cloned.Symbols().Get("c")); } TEST_F(CloneContextNodeTest, CloneIntoSameBuilder) { ProgramBuilder builder; CloneContext ctx(&builder); Allocator allocator; auto* original = allocator.Create<Node>(builder.Symbols().New()); auto* cloned_a = ctx.Clone(original); auto* cloned_b = ctx.Clone(original); EXPECT_NE(original, cloned_a); EXPECT_NE(original, cloned_b); EXPECT_NE(cloned_a, cloned_b); } TEST_F(CloneContextNodeTest, CloneWithReplaceAll_SameTypeTwice) { std::string node_name = TypeInfo::Of<Node>().name; EXPECT_FATAL_FAILURE( { ProgramBuilder cloned; Program original; CloneContext ctx(&cloned, &original); ctx.ReplaceAll([](Node*) { return nullptr; }); ctx.ReplaceAll([](Node*) { return nullptr; }); }, "internal compiler error: ReplaceAll() called with a handler for type " + node_name + " that is already handled by a handler for type " + node_name); } TEST_F(CloneContextNodeTest, CloneWithReplaceAll_BaseThenDerived) { std::string node_name = TypeInfo::Of<Node>().name; std::string replaceable_name = TypeInfo::Of<Replaceable>().name; EXPECT_FATAL_FAILURE( { ProgramBuilder cloned; Program original; CloneContext ctx(&cloned, &original); ctx.ReplaceAll([](Node*) { return nullptr; }); ctx.ReplaceAll([](Replaceable*) { return nullptr; }); }, "internal compiler error: ReplaceAll() called with a handler for type " + replaceable_name + " that is already handled by a handler for type " + node_name); } TEST_F(CloneContextNodeTest, CloneWithReplaceAll_DerivedThenBase) { std::string node_name = TypeInfo::Of<Node>().name; std::string replaceable_name = TypeInfo::Of<Replaceable>().name; EXPECT_FATAL_FAILURE( { ProgramBuilder cloned; Program original; CloneContext ctx(&cloned, &original); ctx.ReplaceAll([](Replaceable*) { return nullptr; }); ctx.ReplaceAll([](Node*) { return nullptr; }); }, "internal compiler error: ReplaceAll() called with a handler for type " + node_name + " that is already handled by a handler for type " + replaceable_name); } TEST_F(CloneContextNodeTest, CloneWithReplace_WithNotANode) { EXPECT_FATAL_FAILURE( { Allocator allocator; ProgramBuilder builder; auto* original_root = allocator.Create<Node>(builder.Symbols().New("root")); original_root->a = allocator.Create<Node>(builder.Symbols().New("a")); original_root->b = allocator.Create<Node>(builder.Symbols().New("b")); original_root->c = allocator.Create<Node>(builder.Symbols().New("c")); Program original(std::move(builder)); // root // ╭──────────────────┼──────────────────╮ // (a) (b) (c) // Replaced ProgramBuilder cloned; auto* replacement = allocator.Create<NotANode>(); CloneContext ctx(&cloned, &original); ctx.Replace(original_root->b, replacement); ctx.Clone(original_root); }, "internal compiler error"); } using CloneContextTest = ::testing::Test; TEST_F(CloneContextTest, CloneWithReplaceAll_SymbolsTwice) { EXPECT_FATAL_FAILURE( { ProgramBuilder cloned; Program original; CloneContext ctx(&cloned, &original); ctx.ReplaceAll([](Symbol s) { return s; }); ctx.ReplaceAll([](Symbol s) { return s; }); }, "internal compiler error: ReplaceAll(const SymbolTransform&) called " "multiple times on the same CloneContext"); } TEST_F(CloneContextTest, CloneNewUnnamedSymbols) { ProgramBuilder builder; Symbol old_a = builder.Symbols().New(); Symbol old_b = builder.Symbols().New(); Symbol old_c = builder.Symbols().New(); EXPECT_EQ(builder.Symbols().NameFor(old_a), "tint_symbol"); EXPECT_EQ(builder.Symbols().NameFor(old_b), "tint_symbol_1"); EXPECT_EQ(builder.Symbols().NameFor(old_c), "tint_symbol_2"); Program original(std::move(builder)); ProgramBuilder cloned; CloneContext ctx(&cloned, &original, false); Symbol new_x = cloned.Symbols().New(); Symbol new_a = ctx.Clone(old_a); Symbol new_y = cloned.Symbols().New(); Symbol new_b = ctx.Clone(old_b); Symbol new_z = cloned.Symbols().New(); Symbol new_c = ctx.Clone(old_c); EXPECT_EQ(cloned.Symbols().NameFor(new_x), "tint_symbol"); EXPECT_EQ(cloned.Symbols().NameFor(new_a), "tint_symbol_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_y), "tint_symbol_2"); EXPECT_EQ(cloned.Symbols().NameFor(new_b), "tint_symbol_1_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_z), "tint_symbol_3"); EXPECT_EQ(cloned.Symbols().NameFor(new_c), "tint_symbol_2_1"); } TEST_F(CloneContextTest, CloneNewSymbols) { ProgramBuilder builder; Symbol old_a = builder.Symbols().New("a"); Symbol old_b = builder.Symbols().New("b"); Symbol old_c = builder.Symbols().New("c"); EXPECT_EQ(builder.Symbols().NameFor(old_a), "a"); EXPECT_EQ(builder.Symbols().NameFor(old_b), "b"); EXPECT_EQ(builder.Symbols().NameFor(old_c), "c"); Program original(std::move(builder)); ProgramBuilder cloned; CloneContext ctx(&cloned, &original, false); Symbol new_x = cloned.Symbols().New("a"); Symbol new_a = ctx.Clone(old_a); Symbol new_y = cloned.Symbols().New("b"); Symbol new_b = ctx.Clone(old_b); Symbol new_z = cloned.Symbols().New("c"); Symbol new_c = ctx.Clone(old_c); EXPECT_EQ(cloned.Symbols().NameFor(new_x), "a"); EXPECT_EQ(cloned.Symbols().NameFor(new_a), "a_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_y), "b"); EXPECT_EQ(cloned.Symbols().NameFor(new_b), "b_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_z), "c"); EXPECT_EQ(cloned.Symbols().NameFor(new_c), "c_1"); } TEST_F(CloneContextTest, CloneNewSymbols_AfterCloneSymbols) { ProgramBuilder builder; Symbol old_a = builder.Symbols().New("a"); Symbol old_b = builder.Symbols().New("b"); Symbol old_c = builder.Symbols().New("c"); EXPECT_EQ(builder.Symbols().NameFor(old_a), "a"); EXPECT_EQ(builder.Symbols().NameFor(old_b), "b"); EXPECT_EQ(builder.Symbols().NameFor(old_c), "c"); Program original(std::move(builder)); ProgramBuilder cloned; CloneContext ctx(&cloned, &original); Symbol new_x = cloned.Symbols().New("a"); Symbol new_a = ctx.Clone(old_a); Symbol new_y = cloned.Symbols().New("b"); Symbol new_b = ctx.Clone(old_b); Symbol new_z = cloned.Symbols().New("c"); Symbol new_c = ctx.Clone(old_c); EXPECT_EQ(cloned.Symbols().NameFor(new_x), "a_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_a), "a"); EXPECT_EQ(cloned.Symbols().NameFor(new_y), "b_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_b), "b"); EXPECT_EQ(cloned.Symbols().NameFor(new_z), "c_1"); EXPECT_EQ(cloned.Symbols().NameFor(new_c), "c"); } TEST_F(CloneContextTest, ProgramIDs) { ProgramBuilder dst; Program src(ProgramBuilder{}); CloneContext ctx(&dst, &src); Allocator allocator; auto* cloned = ctx.Clone(allocator.Create<ProgramNode>(src.ID(), dst.ID())); EXPECT_EQ(cloned->program_id, dst.ID()); } TEST_F(CloneContextTest, ProgramIDs_Clone_ObjectNotOwnedBySrc) { EXPECT_FATAL_FAILURE( { ProgramBuilder dst; Program src(ProgramBuilder{}); CloneContext ctx(&dst, &src); Allocator allocator; ctx.Clone(allocator.Create<ProgramNode>(ProgramID::New(), dst.ID())); }, R"(internal compiler error: TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(src, a))"); } TEST_F(CloneContextTest, ProgramIDs_Clone_ObjectNotOwnedByDst) { EXPECT_FATAL_FAILURE( { ProgramBuilder dst; Program src(ProgramBuilder{}); CloneContext ctx(&dst, &src); Allocator allocator; ctx.Clone(allocator.Create<ProgramNode>(src.ID(), ProgramID::New())); }, R"(internal compiler error: TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(dst, out))"); } } // namespace TINT_INSTANTIATE_TYPEINFO(Node); TINT_INSTANTIATE_TYPEINFO(Replaceable); TINT_INSTANTIATE_TYPEINFO(Replacement); TINT_INSTANTIATE_TYPEINFO(NotANode); TINT_INSTANTIATE_TYPEINFO(ProgramNode); } // namespace tint