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

ProgramBuilder: Migrate any remaining types to typ::*

Browse Source 
Used as a stepping stone to emitting the ast::Types instead.

Bug: tint:724
Change-Id: Ib2d6c150fe8aa7c1e2c502676922b14b1518a4be
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/48686
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Ben Clayton
2021-04-22 14:40:23 +00:00
committed by Commit Bot service account
parent 7241a504f0
commit e204f27f86
58 changed files with 1256 additions and 1255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/sem/alias_type_test.cc
View File

@@ -23,13 +23,13 @@ namespace {
using AliasTest = TestHelper;
TEST_F(AliasTest, Create) {
auto* a = ty.alias("a_type", ty.u32());
auto* a = create<Alias>(Sym("a_type"), ty.u32());
EXPECT_EQ(a->symbol(), Symbol(1, ID()));
EXPECT_EQ(a->type(), ty.u32());
}
TEST_F(AliasTest, Is) {
auto* at = ty.alias("a", ty.i32());
auto* at = create<Alias>(Sym("a"), ty.i32());
sem::Type* ty = at;
EXPECT_FALSE(ty->Is<AccessControl>());
EXPECT_TRUE(ty->Is<Alias>());
@@ -47,17 +47,17 @@ TEST_F(AliasTest, Is) {
}
TEST_F(AliasTest, TypeName) {
auto* at = ty.alias("Particle", ty.i32());
auto* at = create<Alias>(Sym("Particle"), ty.i32());
EXPECT_EQ(at->type_name(), "__alias_$1__i32");
}
TEST_F(AliasTest, FriendlyName) {
auto* at = ty.alias("Particle", ty.i32());
auto* at = create<Alias>(Sym("Particle"), ty.i32());
EXPECT_EQ(at->FriendlyName(Symbols()), "Particle");
}
TEST_F(AliasTest, UnwrapIfNeeded_Alias) {
auto* a = ty.alias("a_type", ty.u32());
auto* a = create<Alias>(Sym("a_type"), ty.u32());
EXPECT_EQ(a->symbol(), Symbol(1, ID()));
EXPECT_EQ(a->type(), ty.u32());
EXPECT_EQ(a->UnwrapIfNeeded(), ty.u32());
@@ -65,14 +65,14 @@ TEST_F(AliasTest, UnwrapIfNeeded_Alias) {
}
TEST_F(AliasTest, UnwrapIfNeeded_AccessControl) {
AccessControl a{ast::AccessControl::kReadOnly, ty.u32()};
EXPECT_EQ(a.type(), ty.u32());
EXPECT_EQ(a.UnwrapIfNeeded(), ty.u32());
auto* a = create<AccessControl>(ast::AccessControl::kReadOnly, ty.u32());
EXPECT_EQ(a->type(), ty.u32());
EXPECT_EQ(a->UnwrapIfNeeded(), ty.u32());
}
TEST_F(AliasTest, UnwrapIfNeeded_MultiLevel) {
auto* a = ty.alias("a_type", ty.u32());
auto* aa = ty.alias("aa_type", a);
auto* a = create<Alias>(Sym("a_type"), ty.u32());
auto* aa = create<Alias>(Sym("aa_type"), a);
EXPECT_EQ(aa->symbol(), Symbol(2, ID()));
EXPECT_EQ(aa->type(), a);
@@ -80,19 +80,19 @@ TEST_F(AliasTest, UnwrapIfNeeded_MultiLevel) {
}
TEST_F(AliasTest, UnwrapIfNeeded_MultiLevel_AliasAccessControl) {
auto* a = ty.alias("a_type", ty.u32());
AccessControl aa{ast::AccessControl::kReadWrite, a};
EXPECT_EQ(aa.type(), a);
EXPECT_EQ(aa.UnwrapIfNeeded(), ty.u32());
auto* a = create<Alias>(Sym("a_type"), ty.u32());
auto* aa = create<AccessControl>(ast::AccessControl::kReadWrite, a);
EXPECT_EQ(aa->type(), a);
EXPECT_EQ(aa->UnwrapIfNeeded(), ty.u32());
}
TEST_F(AliasTest, UnwrapAll_TwiceAliasPointerTwiceAlias) {
auto* a = ty.alias("a_type", ty.u32());
auto* aa = ty.alias("aa_type", a);
Pointer paa{aa, ast::StorageClass::kUniform};
auto* apaa = ty.alias("paa_type", &paa);
auto* aapaa = ty.alias("aapaa_type", apaa);
auto* u32 = create<U32>();
auto* a = create<Alias>(Sym(Sym("a_type")), u32);
auto* aa = create<Alias>(Sym("aa_type"), a);
auto* paa = create<Pointer>(aa, ast::StorageClass::kUniform);
auto* apaa = create<Alias>(Sym("paa_type"), paa);
auto* aapaa = create<Alias>(Sym("aapaa_type"), apaa);
EXPECT_EQ(aapaa->symbol(), Symbol(4, ID()));
EXPECT_EQ(aapaa->type(), apaa);
@@ -100,47 +100,47 @@ TEST_F(AliasTest, UnwrapAll_TwiceAliasPointerTwiceAlias) {
}
TEST_F(AliasTest, UnwrapAll_SecondConsecutivePointerBlocksUnrapping) {
auto* a = ty.alias("a_type", ty.u32());
auto* aa = ty.alias("aa_type", a);
auto* a = create<Alias>(Sym("a_type"), ty.u32());
auto* aa = create<Alias>(Sym("aa_type"), a);
Pointer paa{aa, ast::StorageClass::kUniform};
Pointer ppaa{&paa, ast::StorageClass::kUniform};
auto* appaa = ty.alias("appaa_type", &ppaa);
EXPECT_EQ(appaa->UnwrapAll(), &paa);
auto* paa = create<Pointer>(aa, ast::StorageClass::kUniform);
auto* ppaa = create<Pointer>(paa, ast::StorageClass::kUniform);
auto* appaa = create<Alias>(Sym("appaa_type"), ppaa);
EXPECT_EQ(appaa->UnwrapAll(), paa);
}
TEST_F(AliasTest, UnwrapAll_SecondNonConsecutivePointerBlocksUnrapping) {
auto* a = ty.alias("a_type", ty.u32());
auto* aa = ty.alias("aa_type", a);
Pointer paa{aa, ast::StorageClass::kUniform};
auto* a = create<Alias>(Sym("a_type"), ty.u32());
auto* aa = create<Alias>(Sym("aa_type"), a);
auto* paa = create<Pointer>(aa, ast::StorageClass::kUniform);
auto* apaa = ty.alias("apaa_type", &paa);
auto* aapaa = ty.alias("aapaa_type", apaa);
Pointer paapaa{aapaa, ast::StorageClass::kUniform};
auto* apaapaa = ty.alias("apaapaa_type", &paapaa);
auto* apaa = create<Alias>(Sym("apaa_type"), paa);
auto* aapaa = create<Alias>(Sym("aapaa_type"), apaa);
auto* paapaa = create<Pointer>(aapaa, ast::StorageClass::kUniform);
auto* apaapaa = create<Alias>(Sym("apaapaa_type"), paapaa);
EXPECT_EQ(apaapaa->UnwrapAll(), &paa);
EXPECT_EQ(apaapaa->UnwrapAll(), paa);
}
TEST_F(AliasTest, UnwrapAll_AccessControlPointer) {
AccessControl a{ast::AccessControl::kReadOnly, ty.u32()};
Pointer pa{&a, ast::StorageClass::kUniform};
EXPECT_EQ(pa.type(), &a);
EXPECT_EQ(pa.UnwrapAll(), ty.u32());
auto* a = create<AccessControl>(ast::AccessControl::kReadOnly, ty.u32());
auto* pa = create<Pointer>(a, ast::StorageClass::kUniform);
EXPECT_EQ(pa->type(), a);
EXPECT_EQ(pa->UnwrapAll(), ty.u32());
}
TEST_F(AliasTest, UnwrapAll_PointerAccessControl) {
Pointer p{ty.u32(), ast::StorageClass::kUniform};
AccessControl a{ast::AccessControl::kReadOnly, &p};
auto* p = create<Pointer>(ty.u32(), ast::StorageClass::kUniform);
auto* a = create<AccessControl>(ast::AccessControl::kReadOnly, p);
EXPECT_EQ(a.type(), &p);
EXPECT_EQ(a.UnwrapAll(), ty.u32());
EXPECT_EQ(a->type(), p);
EXPECT_EQ(a->UnwrapAll(), ty.u32());
}
TEST_F(AliasTest, UnwrapAliasIfNeeded) {
auto* alias1 = ty.alias("alias1", ty.f32());
auto* alias2 = ty.alias("alias2", alias1);
auto* alias3 = ty.alias("alias3", alias2);
auto* alias1 = create<Alias>(Sym("alias1"), ty.f32());
auto* alias2 = create<Alias>(Sym("alias2"), alias1);
auto* alias3 = create<Alias>(Sym("alias3"), alias2);
EXPECT_EQ(alias3->UnwrapAliasIfNeeded(), ty.f32());
}

8
src/sem/struct_type_test.cc
View File

@@ -27,7 +27,7 @@ TEST_F(StructTypeTest, Creation) {
auto* impl =
create<ast::Struct>(name, ast::StructMemberList{}, ast::DecorationList{});
auto* ptr = impl;
auto* s = ty.struct_(impl);
auto s = ty.struct_(impl);
EXPECT_EQ(s->impl(), ptr);
}
@@ -35,7 +35,7 @@ TEST_F(StructTypeTest, Is) {
auto name = Sym("S");
auto* impl =
create<ast::Struct>(name, ast::StructMemberList{}, ast::DecorationList{});
auto* s = ty.struct_(impl);
auto s = ty.struct_(impl);
sem::Type* ty = s;
EXPECT_FALSE(ty->Is<AccessControl>());
EXPECT_FALSE(ty->Is<Alias>());
@@ -56,7 +56,7 @@ TEST_F(StructTypeTest, TypeName) {
auto name = Sym("my_struct");
auto* impl =
create<ast::Struct>(name, ast::StructMemberList{}, ast::DecorationList{});
auto* s = ty.struct_(impl);
auto s = ty.struct_(impl);
EXPECT_EQ(s->type_name(), "__struct_$1");
}
@@ -64,7 +64,7 @@ TEST_F(StructTypeTest, FriendlyName) {
auto name = Sym("my_struct");
auto* impl =
create<ast::Struct>(name, ast::StructMemberList{}, ast::DecorationList{});
auto* s = ty.struct_(impl);
auto s = ty.struct_(impl);
EXPECT_EQ(s->FriendlyName(Symbols()), "my_struct");
}