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

Move ast/address_space to type/

Browse Source 
This CL moves the ast/address_space to type/address_space. This breaks
the type dependency on ast for AddressSpace.

Change-Id: Icb48e7423e18904865ec735024eb3b9864c947c2
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/117604
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair 2023-01-21 19:56:49 +00:00 committed by Dawn LUCI CQ
parent 3cbf3fc4c5
commit 18b2158b4e
216 changed files with 1936 additions and 1935 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/tint/BUILD.gn
View File

@ -183,8 +183,6 @@ libtint_source_set("libtint_core_all_src") {
sources = [ sources = [
"ast/access.cc", "ast/access.cc",
"ast/access.h", "ast/access.h",
"ast/address_space.cc",
"ast/address_space.h",
"ast/alias.cc", "ast/alias.cc",
"ast/alias.h", "ast/alias.h",
"ast/array.cc", "ast/array.cc",
@ -563,6 +561,7 @@ libtint_source_set("libtint_core_all_src") {
"type/abstract_float.h", "type/abstract_float.h",
"type/abstract_int.h", "type/abstract_int.h",
"type/abstract_numeric.h", "type/abstract_numeric.h",
"type/address_space.h",
"type/array.h", "type/array.h",
"type/array_count.h", "type/array_count.h",
"type/atomic.h", "type/atomic.h",
@ -695,6 +694,8 @@ libtint_source_set("libtint_type_src") {
"type/abstract_int.h", "type/abstract_int.h",
"type/abstract_numeric.cc", "type/abstract_numeric.cc",
"type/abstract_numeric.h", "type/abstract_numeric.h",
"type/address_space.cc",
"type/address_space.h",
"type/array.cc", "type/array.cc",
"type/array.h", "type/array.h",
"type/array_count.cc", "type/array_count.cc",
@ -1124,7 +1125,6 @@ if (tint_build_unittests) {
tint_unittests_source_set("tint_unittests_ast_src") { tint_unittests_source_set("tint_unittests_ast_src") {
sources = [ sources = [
"ast/access_test.cc", "ast/access_test.cc",
"ast/address_space_test.cc",
"ast/alias_test.cc", "ast/alias_test.cc",
"ast/array_test.cc", "ast/array_test.cc",
"ast/assignment_statement_test.cc", "ast/assignment_statement_test.cc",
@ -1303,6 +1303,7 @@ if (tint_build_unittests) {
tint_unittests_source_set("tint_unittests_type_src") { tint_unittests_source_set("tint_unittests_type_src") {
sources = [ sources = [
"type/address_space_test.cc",
"type/array_test.cc", "type/array_test.cc",
"type/atomic_test.cc", "type/atomic_test.cc",
"type/bool_test.cc", "type/bool_test.cc",

2
src/tint/CMakeLists.txt
View File

@ -567,7 +567,6 @@ list(APPEND TINT_LIB_SRCS
) )
tint_generated(ast/access BENCH TEST) tint_generated(ast/access BENCH TEST)
tint_generated(ast/address_space BENCH TEST)
tint_generated(ast/builtin_value BENCH TEST) tint_generated(ast/builtin_value BENCH TEST)
tint_generated(ast/extension BENCH TEST) tint_generated(ast/extension BENCH TEST)
tint_generated(ast/interpolate_attribute BENCH TEST) tint_generated(ast/interpolate_attribute BENCH TEST)
@ -575,6 +574,7 @@ tint_generated(ast/texel_format BENCH TEST)
tint_generated(resolver/init_conv_intrinsic) tint_generated(resolver/init_conv_intrinsic)
tint_generated(sem/builtin_type) tint_generated(sem/builtin_type)
tint_generated(sem/parameter_usage) tint_generated(sem/parameter_usage)
tint_generated(type/address_space BENCH TEST)
tint_generated(type/short_name BENCH TEST) tint_generated(type/short_name BENCH TEST)
if(UNIX) if(UNIX)

4
src/tint/ast/module_test.cc
View File

@ -72,7 +72,7 @@ TEST_F(ModuleTest, Assert_DifferentProgramID_GlobalVariable) {
{ {
ProgramBuilder b1; ProgramBuilder b1;
ProgramBuilder b2; ProgramBuilder b2;
b1.AST().AddGlobalVariable(b2.Var("var", b2.ty.i32(), ast::AddressSpace::kPrivate)); b1.AST().AddGlobalVariable(b2.Var("var", b2.ty.i32(), type::AddressSpace::kPrivate));
}, },
"internal compiler error"); "internal compiler error");
} }
@ -92,7 +92,7 @@ TEST_F(ModuleTest, CloneOrder) {
ProgramBuilder b; ProgramBuilder b;
b.Func("F", {}, b.ty.void_(), {}); b.Func("F", {}, b.ty.void_(), {});
b.Alias("A", b.ty.u32()); b.Alias("A", b.ty.u32());
b.GlobalVar("V", b.ty.i32(), ast::AddressSpace::kPrivate); b.GlobalVar("V", b.ty.i32(), type::AddressSpace::kPrivate);
return Program(std::move(b)); return Program(std::move(b));
}(); }();

4
src/tint/ast/pointer.cc
View File

@ -24,14 +24,14 @@ Pointer::Pointer(ProgramID pid,
NodeID nid, NodeID nid,
const Source& src, const Source& src,
const Type* const subtype, const Type* const subtype,
ast::AddressSpace addr_space, type::AddressSpace addr_space,
ast::Access ac) ast::Access ac)
: Base(pid, nid, src), type(subtype), address_space(addr_space), access(ac) {} : Base(pid, nid, src), type(subtype), address_space(addr_space), access(ac) {}
std::string Pointer::FriendlyName(const SymbolTable& symbols) const { std::string Pointer::FriendlyName(const SymbolTable& symbols) const {
std::ostringstream out; std::ostringstream out;
out << "ptr<"; out << "ptr<";
if (address_space != ast::AddressSpace::kNone) { if (address_space != type::AddressSpace::kNone) {
out << address_space << ", "; out << address_space << ", ";
} }
out << type->FriendlyName(symbols); out << type->FriendlyName(symbols);

6
src/tint/ast/pointer.h
View File

@ -18,8 +18,8 @@
#include <string> #include <string>
#include "src/tint/ast/access.h" #include "src/tint/ast/access.h"
#include "src/tint/ast/address_space.h"
#include "src/tint/ast/type.h" #include "src/tint/ast/type.h"
#include "src/tint/type/address_space.h"
namespace tint::ast { namespace tint::ast {
@ -37,7 +37,7 @@ class Pointer final : public Castable<Pointer, Type> {
NodeID nid, NodeID nid,
const Source& src, const Source& src,
const Type* const subtype, const Type* const subtype,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access); ast::Access access);
/// Move constructor /// Move constructor
Pointer(Pointer&&); Pointer(Pointer&&);
@ -57,7 +57,7 @@ class Pointer final : public Castable<Pointer, Type> {
const Type* const type; const Type* const type;
/// The address space of the pointer /// The address space of the pointer
ast::AddressSpace const address_space; type::AddressSpace const address_space;
/// The access control of the pointer /// The access control of the pointer
ast::Access const access; ast::Access const access;

8
src/tint/ast/pointer_test.cc
View File

@ -24,21 +24,21 @@ using AstPointerTest = TestHelper;
TEST_F(AstPointerTest, Creation) { TEST_F(AstPointerTest, Creation) {
auto* i32 = create<I32>(); auto* i32 = create<I32>();
auto* p = create<Pointer>(i32, ast::AddressSpace::kStorage, Access::kRead); auto* p = create<Pointer>(i32, type::AddressSpace::kStorage, Access::kRead);
EXPECT_EQ(p->type, i32); EXPECT_EQ(p->type, i32);
EXPECT_EQ(p->address_space, ast::AddressSpace::kStorage); EXPECT_EQ(p->address_space, type::AddressSpace::kStorage);
EXPECT_EQ(p->access, Access::kRead); EXPECT_EQ(p->access, Access::kRead);
} }
TEST_F(AstPointerTest, FriendlyName) { TEST_F(AstPointerTest, FriendlyName) {
auto* i32 = create<I32>(); auto* i32 = create<I32>();
auto* p = create<Pointer>(i32, ast::AddressSpace::kWorkgroup, Access::kUndefined); auto* p = create<Pointer>(i32, type::AddressSpace::kWorkgroup, Access::kUndefined);
EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<workgroup, i32>"); EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<workgroup, i32>");
} }
TEST_F(AstPointerTest, FriendlyNameWithAccess) { TEST_F(AstPointerTest, FriendlyNameWithAccess) {
auto* i32 = create<I32>(); auto* i32 = create<I32>();
auto* p = create<Pointer>(i32, ast::AddressSpace::kStorage, Access::kReadWrite); auto* p = create<Pointer>(i32, type::AddressSpace::kStorage, Access::kReadWrite);
EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<storage, i32, read_write>"); EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<storage, i32, read_write>");
} }

2
src/tint/ast/var.cc
View File

@ -25,7 +25,7 @@ Var::Var(ProgramID pid,
const Source& src, const Source& src,
const Symbol& sym, const Symbol& sym,
const ast::Type* ty, const ast::Type* ty,
AddressSpace address_space, type::AddressSpace address_space,
Access access, Access access,
const Expression* init, const Expression* init,
utils::VectorRef<const Attribute*> attrs) utils::VectorRef<const Attribute*> attrs)

4
src/tint/ast/var.h
View File

@ -56,7 +56,7 @@ class Var final : public Castable<Var, Variable> {
const Source& source, const Source& source,
const Symbol& sym, const Symbol& sym,
const ast::Type* type, const ast::Type* type,
AddressSpace declared_address_space, type::AddressSpace declared_address_space,
Access declared_access, Access declared_access,
const Expression* initializer, const Expression* initializer,
utils::VectorRef<const Attribute*> attributes); utils::VectorRef<const Attribute*> attributes);
@ -77,7 +77,7 @@ class Var final : public Castable<Var, Variable> {
const Var* Clone(CloneContext* ctx) const override; const Var* Clone(CloneContext* ctx) const override;
/// The declared address space /// The declared address space
const AddressSpace declared_address_space; const type::AddressSpace declared_address_space;
/// The declared access control /// The declared access control
const Access declared_access; const Access declared_access;

2
src/tint/ast/variable.h
View File

@ -19,11 +19,11 @@
#include <vector> #include <vector>
#include "src/tint/ast/access.h" #include "src/tint/ast/access.h"
#include "src/tint/ast/address_space.h"
#include "src/tint/ast/attribute.h" #include "src/tint/ast/attribute.h"
#include "src/tint/ast/binding_attribute.h" #include "src/tint/ast/binding_attribute.h"
#include "src/tint/ast/expression.h" #include "src/tint/ast/expression.h"
#include "src/tint/ast/group_attribute.h" #include "src/tint/ast/group_attribute.h"
#include "src/tint/type/address_space.h"
// Forward declarations // Forward declarations
namespace tint::ast { namespace tint::ast {

22
src/tint/ast/variable_test.cc
View File

@ -25,10 +25,10 @@ namespace {
using VariableTest = TestHelper; using VariableTest = TestHelper;
TEST_F(VariableTest, Creation) { TEST_F(VariableTest, Creation) {
auto* v = Var("my_var", ty.i32(), AddressSpace::kFunction); auto* v = Var("my_var", ty.i32(), type::AddressSpace::kFunction);
EXPECT_EQ(v->symbol, Symbol(1, ID())); EXPECT_EQ(v->symbol, Symbol(1, ID()));
EXPECT_EQ(v->declared_address_space, AddressSpace::kFunction); EXPECT_EQ(v->declared_address_space, type::AddressSpace::kFunction);
EXPECT_TRUE(v->type->Is<ast::I32>()); EXPECT_TRUE(v->type->Is<ast::I32>());
EXPECT_EQ(v->source.range.begin.line, 0u); EXPECT_EQ(v->source.range.begin.line, 0u);
EXPECT_EQ(v->source.range.begin.column, 0u); EXPECT_EQ(v->source.range.begin.column, 0u);
@ -38,10 +38,10 @@ TEST_F(VariableTest, Creation) {
TEST_F(VariableTest, CreationWithSource) { TEST_F(VariableTest, CreationWithSource) {
auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 5}}}, "i", auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 5}}}, "i",
ty.f32(), AddressSpace::kPrivate, utils::Empty); ty.f32(), type::AddressSpace::kPrivate, utils::Empty);
EXPECT_EQ(v->symbol, Symbol(1, ID())); EXPECT_EQ(v->symbol, Symbol(1, ID()));
EXPECT_EQ(v->declared_address_space, AddressSpace::kPrivate); EXPECT_EQ(v->declared_address_space, type::AddressSpace::kPrivate);
EXPECT_TRUE(v->type->Is<ast::F32>()); EXPECT_TRUE(v->type->Is<ast::F32>());
EXPECT_EQ(v->source.range.begin.line, 27u); EXPECT_EQ(v->source.range.begin.line, 27u);
EXPECT_EQ(v->source.range.begin.column, 4u); EXPECT_EQ(v->source.range.begin.column, 4u);
@ -51,10 +51,10 @@ TEST_F(VariableTest, CreationWithSource) {
TEST_F(VariableTest, CreationEmpty) { TEST_F(VariableTest, CreationEmpty) {
auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 7}}}, "a_var", auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 7}}}, "a_var",
ty.i32(), AddressSpace::kWorkgroup, utils::Empty); ty.i32(), type::AddressSpace::kWorkgroup, utils::Empty);
EXPECT_EQ(v->symbol, Symbol(1, ID())); EXPECT_EQ(v->symbol, Symbol(1, ID()));
EXPECT_EQ(v->declared_address_space, AddressSpace::kWorkgroup); EXPECT_EQ(v->declared_address_space, type::AddressSpace::kWorkgroup);
EXPECT_TRUE(v->type->Is<ast::I32>()); EXPECT_TRUE(v->type->Is<ast::I32>());
EXPECT_EQ(v->source.range.begin.line, 27u); EXPECT_EQ(v->source.range.begin.line, 27u);
EXPECT_EQ(v->source.range.begin.column, 4u); EXPECT_EQ(v->source.range.begin.column, 4u);
@ -92,7 +92,7 @@ TEST_F(VariableTest, Assert_DifferentProgramID_Initializer) {
} }
TEST_F(VariableTest, WithAttributes) { TEST_F(VariableTest, WithAttributes) {
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Location(1_u), auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Location(1_u),
Builtin(BuiltinValue::kPosition), Id(1200_u)); Builtin(BuiltinValue::kPosition), Id(1200_u));
auto& attributes = var->attributes; auto& attributes = var->attributes;
@ -107,22 +107,22 @@ TEST_F(VariableTest, WithAttributes) {
} }
TEST_F(VariableTest, HasBindingPoint_BothProvided) { TEST_F(VariableTest, HasBindingPoint_BothProvided) {
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Binding(2_a), Group(1_a)); auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Binding(2_a), Group(1_a));
EXPECT_TRUE(var->HasBindingPoint()); EXPECT_TRUE(var->HasBindingPoint());
} }
TEST_F(VariableTest, HasBindingPoint_NeitherProvided) { TEST_F(VariableTest, HasBindingPoint_NeitherProvided) {
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, utils::Empty); auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, utils::Empty);
EXPECT_FALSE(var->HasBindingPoint()); EXPECT_FALSE(var->HasBindingPoint());
} }
TEST_F(VariableTest, HasBindingPoint_MissingGroupAttribute) { TEST_F(VariableTest, HasBindingPoint_MissingGroupAttribute) {
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Binding(2_a)); auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Binding(2_a));
EXPECT_FALSE(var->HasBindingPoint()); EXPECT_FALSE(var->HasBindingPoint());
} }
TEST_F(VariableTest, HasBindingPoint_MissingBindingAttribute) { TEST_F(VariableTest, HasBindingPoint_MissingBindingAttribute) {
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Group(1_a)); auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Group(1_a));
EXPECT_FALSE(var->HasBindingPoint()); EXPECT_FALSE(var->HasBindingPoint());
} }

2
src/tint/inspector/inspector.cc
View File

@ -586,7 +586,7 @@ uint32_t Inspector::GetWorkgroupStorageSize(const std::string& entry_point) {
uint32_t total_size = 0; uint32_t total_size = 0;
auto* func_sem = program_->Sem().Get(func); auto* func_sem = program_->Sem().Get(func);
for (const sem::Variable* var : func_sem->TransitivelyReferencedGlobals()) { for (const sem::Variable* var : func_sem->TransitivelyReferencedGlobals()) {
if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) { if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
auto* ty = var->Type()->UnwrapRef(); auto* ty = var->Type()->UnwrapRef();
uint32_t align = ty->Align(); uint32_t align = ty->Align();
uint32_t size = ty->Size(); uint32_t size = ty->Size();

8
src/tint/inspector/inspector_test.cc
View File

@ -743,7 +743,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly) {
TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly_ViaPrivateInitializer) { TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly_ViaPrivateInitializer) {
Override("foo", ty.f32()); Override("foo", ty.f32());
GlobalVar("bar", ast::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "foo")); GlobalVar("bar", type::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "foo"));
MakePlainGlobalReferenceBodyFunction("ep_func", "bar", ty.f32(), MakePlainGlobalReferenceBodyFunction("ep_func", "bar", ty.f32(),
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kCompute), Stage(ast::PipelineStage::kCompute),
@ -834,7 +834,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByAttributeIndirectly) {
TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) { TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) {
Override("size", ty.u32()); Override("size", ty.u32());
GlobalVar("v", ast::AddressSpace::kWorkgroup, ty.array(ty.f32(), "size")); GlobalVar("v", type::AddressSpace::kWorkgroup, ty.array(ty.f32(), "size"));
Func("ep", utils::Empty, ty.void_(), Func("ep", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Assign(Phony(), IndexAccessor("v", 0_a)), Assign(Phony(), IndexAccessor("v", 0_a)),
@ -857,7 +857,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) {
TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySizeIndirectly) { TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySizeIndirectly) {
Override("foo", ty.u32()); Override("foo", ty.u32());
Override("bar", ty.u32(), Mul(2_a, "foo")); Override("bar", ty.u32(), Mul(2_a, "foo"));
GlobalVar("v", ast::AddressSpace::kWorkgroup, ty.array(ty.f32(), Mul(2_a, Expr("bar")))); GlobalVar("v", type::AddressSpace::kWorkgroup, ty.array(ty.f32(), Mul(2_a, Expr("bar"))));
Func("ep", utils::Empty, ty.void_(), Func("ep", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Assign(Phony(), IndexAccessor("v", 0_a)), Assign(Phony(), IndexAccessor("v", 0_a)),
@ -885,7 +885,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySizeViaAlias) {
Alias("MyArray", ty.array(ty.f32(), Mul(2_a, Expr("bar")))); Alias("MyArray", ty.array(ty.f32(), Mul(2_a, Expr("bar"))));
Override("zoo", ty.u32()); Override("zoo", ty.u32());
Alias("MyArrayUnused", ty.array(ty.f32(), Mul(2_a, Expr("zoo")))); Alias("MyArrayUnused", ty.array(ty.f32(), Mul(2_a, Expr("zoo"))));
GlobalVar("v", ast::AddressSpace::kWorkgroup, ty.type_name("MyArray")); GlobalVar("v", type::AddressSpace::kWorkgroup, ty.type_name("MyArray"));
Func("ep", utils::Empty, ty.void_(), Func("ep", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Assign(Phony(), IndexAccessor("v", 0_a)), Assign(Phony(), IndexAccessor("v", 0_a)),

8
src/tint/inspector/test_inspector_builder.cc
View File

@ -126,11 +126,11 @@ void InspectorBuilder::AddUniformBuffer(const std::string& name,
const ast::Type* type, const ast::Type* type,
uint32_t group, uint32_t group,
uint32_t binding) { uint32_t binding) {
GlobalVar(name, type, ast::AddressSpace::kUniform, Binding(AInt(binding)), Group(AInt(group))); GlobalVar(name, type, type::AddressSpace::kUniform, Binding(AInt(binding)), Group(AInt(group)));
} }
void InspectorBuilder::AddWorkgroupStorage(const std::string& name, const ast::Type* type) { void InspectorBuilder::AddWorkgroupStorage(const std::string& name, const ast::Type* type) {
GlobalVar(name, type, ast::AddressSpace::kWorkgroup); GlobalVar(name, type, type::AddressSpace::kWorkgroup);
} }
void InspectorBuilder::AddStorageBuffer(const std::string& name, void InspectorBuilder::AddStorageBuffer(const std::string& name,
@ -138,7 +138,7 @@ void InspectorBuilder::AddStorageBuffer(const std::string& name,
ast::Access access, ast::Access access,
uint32_t group, uint32_t group,
uint32_t binding) { uint32_t binding) {
GlobalVar(name, type, ast::AddressSpace::kStorage, access, Binding(AInt(binding)), GlobalVar(name, type, type::AddressSpace::kStorage, access, Binding(AInt(binding)),
Group(AInt(group))); Group(AInt(group)));
} }
@ -188,7 +188,7 @@ void InspectorBuilder::AddResource(const std::string& name,
} }
void InspectorBuilder::AddGlobalVariable(const std::string& name, const ast::Type* type) { void InspectorBuilder::AddGlobalVariable(const std::string& name, const ast::Type* type) {
GlobalVar(name, type, ast::AddressSpace::kPrivate); GlobalVar(name, type, type::AddressSpace::kPrivate);
} }
const ast::Function* InspectorBuilder::MakeSamplerReferenceBodyFunction( const ast::Function* InspectorBuilder::MakeSamplerReferenceBodyFunction(

12
src/tint/ir/builder_impl_test.cc
View File

@ -1468,7 +1468,7 @@ FunctionEnd
TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) { TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) {
auto* expr = Expr(true); auto* expr = Expr(true);
GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate, expr); GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder(); auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr); auto r = b.EmitLiteral(expr);
@ -1482,7 +1482,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) {
TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) { TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) {
auto* expr = Expr(false); auto* expr = Expr(false);
GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate, expr); GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder(); auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr); auto r = b.EmitLiteral(expr);
@ -1496,7 +1496,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) {
TEST_F(IR_BuilderImplTest, EmitLiteral_F32) { TEST_F(IR_BuilderImplTest, EmitLiteral_F32) {
auto* expr = Expr(1.2_f); auto* expr = Expr(1.2_f);
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, expr); GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder(); auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr); auto r = b.EmitLiteral(expr);
@ -1511,7 +1511,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_F32) {
TEST_F(IR_BuilderImplTest, EmitLiteral_F16) { TEST_F(IR_BuilderImplTest, EmitLiteral_F16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
auto* expr = Expr(1.2_h); auto* expr = Expr(1.2_h);
GlobalVar("a", ty.f16(), ast::AddressSpace::kPrivate, expr); GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder(); auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr); auto r = b.EmitLiteral(expr);
@ -1525,7 +1525,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_F16) {
TEST_F(IR_BuilderImplTest, EmitLiteral_I32) { TEST_F(IR_BuilderImplTest, EmitLiteral_I32) {
auto* expr = Expr(-2_i); auto* expr = Expr(-2_i);
GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate, expr); GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder(); auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr); auto r = b.EmitLiteral(expr);
@ -1539,7 +1539,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_I32) {
TEST_F(IR_BuilderImplTest, EmitLiteral_U32) { TEST_F(IR_BuilderImplTest, EmitLiteral_U32) {
auto* expr = Expr(2_u); auto* expr = Expr(2_u);
GlobalVar("a", ty.u32(), ast::AddressSpace::kPrivate, expr); GlobalVar("a", ty.u32(), type::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder(); auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr); auto r = b.EmitLiteral(expr);

28
src/tint/program_builder.h
View File

@ -181,14 +181,14 @@ class ProgramBuilder {
~VarOptions(); ~VarOptions();
const ast::Type* type = nullptr; const ast::Type* type = nullptr;
ast::AddressSpace address_space = ast::AddressSpace::kNone; type::AddressSpace address_space = type::AddressSpace::kNone;
ast::Access access = ast::Access::kUndefined; ast::Access access = ast::Access::kUndefined;
const ast::Expression* initializer = nullptr; const ast::Expression* initializer = nullptr;
utils::Vector<const ast::Attribute*, 4> attributes; utils::Vector<const ast::Attribute*, 4> attributes;
private: private:
void Set(const ast::Type* t) { type = t; } void Set(const ast::Type* t) { type = t; }
void Set(ast::AddressSpace addr_space) { address_space = addr_space; } void Set(type::AddressSpace addr_space) { address_space = addr_space; }
void Set(ast::Access ac) { access = ac; } void Set(ast::Access ac) { access = ac; }
void Set(const ast::Expression* c) { initializer = c; } void Set(const ast::Expression* c) { initializer = c; }
void Set(utils::VectorRef<const ast::Attribute*> l) { attributes = std::move(l); } void Set(utils::VectorRef<const ast::Attribute*> l) { attributes = std::move(l); }
@ -940,9 +940,9 @@ class ProgramBuilder {
/// @param type the type of the pointer /// @param type the type of the pointer
/// @param address_space the address space of the pointer /// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer /// @param access the optional access control of the pointer
/// @return the pointer to `type` with the given ast::AddressSpace /// @return the pointer to `type` with the given type::AddressSpace
const ast::Pointer* pointer(const ast::Type* type, const ast::Pointer* pointer(const ast::Type* type,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access = ast::Access::kUndefined) const { ast::Access access = ast::Access::kUndefined) const {
return builder->create<ast::Pointer>(type, address_space, access); return builder->create<ast::Pointer>(type, address_space, access);
} }
@ -951,19 +951,19 @@ class ProgramBuilder {
/// @param type the type of the pointer /// @param type the type of the pointer
/// @param address_space the address space of the pointer /// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer /// @param access the optional access control of the pointer
/// @return the pointer to `type` with the given ast::AddressSpace /// @return the pointer to `type` with the given type::AddressSpace
const ast::Pointer* pointer(const Source& source, const ast::Pointer* pointer(const Source& source,
const ast::Type* type, const ast::Type* type,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access = ast::Access::kUndefined) const { ast::Access access = ast::Access::kUndefined) const {
return builder->create<ast::Pointer>(source, type, address_space, access); return builder->create<ast::Pointer>(source, type, address_space, access);
} }
/// @param address_space the address space of the pointer /// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer /// @param access the optional access control of the pointer
/// @return the pointer to type `T` with the given ast::AddressSpace. /// @return the pointer to type `T` with the given type::AddressSpace.
template <typename T> template <typename T>
const ast::Pointer* pointer(ast::AddressSpace address_space, const ast::Pointer* pointer(type::AddressSpace address_space,
ast::Access access = ast::Access::kUndefined) const { ast::Access access = ast::Access::kUndefined) const {
return pointer(Of<T>(), address_space, access); return pointer(Of<T>(), address_space, access);
} }
@ -971,10 +971,10 @@ class ProgramBuilder {
/// @param source the Source of the node /// @param source the Source of the node
/// @param address_space the address space of the pointer /// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer /// @param access the optional access control of the pointer
/// @return the pointer to type `T` with the given ast::AddressSpace. /// @return the pointer to type `T` with the given type::AddressSpace.
template <typename T> template <typename T>
const ast::Pointer* pointer(const Source& source, const ast::Pointer* pointer(const Source& source,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access = ast::Access::kUndefined) const { ast::Access access = ast::Access::kUndefined) const {
return pointer(source, Of<T>(), address_space, access); return pointer(source, Of<T>(), address_space, access);
} }
@ -1697,7 +1697,7 @@ class ProgramBuilder {
/// @param options the extra options passed to the ast::Var initializer /// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order: /// Can be any of the following, in any order:
/// * ast::Type* - specifies the variable type /// * ast::Type* - specifies the variable type
/// * ast::AddressSpace - specifies the variable address space /// * type::AddressSpace - specifies the variable address space
/// * ast::Access - specifies the variable's access control /// * ast::Access - specifies the variable's access control
/// * ast::Expression* - specifies the variable's initializer expression /// * ast::Expression* - specifies the variable's initializer expression
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
@ -1716,7 +1716,7 @@ class ProgramBuilder {
/// @param options the extra options passed to the ast::Var initializer /// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order: /// Can be any of the following, in any order:
/// * ast::Type* - specifies the variable type /// * ast::Type* - specifies the variable type
/// * ast::AddressSpace - specifies the variable address space /// * type::AddressSpace - specifies the variable address space
/// * ast::Access - specifies the variable's access control /// * ast::Access - specifies the variable's access control
/// * ast::Expression* - specifies the variable's initializer expression /// * ast::Expression* - specifies the variable's initializer expression
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
@ -1820,7 +1820,7 @@ class ProgramBuilder {
/// @param options the extra options passed to the ast::Var initializer /// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order: /// Can be any of the following, in any order:
/// * ast::Type* - specifies the variable type /// * ast::Type* - specifies the variable type
/// * ast::AddressSpace - specifies the variable address space /// * type::AddressSpace - specifies the variable address space
/// * ast::Access - specifies the variable's access control /// * ast::Access - specifies the variable's access control
/// * ast::Expression* - specifies the variable's initializer expression /// * ast::Expression* - specifies the variable's initializer expression
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
@ -1839,7 +1839,7 @@ class ProgramBuilder {
/// @param options the extra options passed to the ast::Var initializer /// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order: /// Can be any of the following, in any order:
/// * ast::Type* - specifies the variable type /// * ast::Type* - specifies the variable type
/// * ast::AddressSpace - specifies the variable address space /// * type::AddressSpace - specifies the variable address space
/// * ast::Access - specifies the variable's access control /// * ast::Access - specifies the variable's access control
/// * ast::Expression* - specifies the variable's initializer expression /// * ast::Expression* - specifies the variable's initializer expression
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)

2
src/tint/program_test.cc
View File

@ -46,7 +46,7 @@ TEST_F(ProgramTest, IDsAreUnique) {
} }
TEST_F(ProgramTest, Assert_GlobalVariable) { TEST_F(ProgramTest, Assert_GlobalVariable) {
GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
Program program(std::move(*this)); Program program(std::move(*this));
EXPECT_TRUE(program.IsValid()); EXPECT_TRUE(program.IsValid());

20
src/tint/reader/spirv/enum_converter.cc
View File

@ -38,30 +38,30 @@ ast::PipelineStage EnumConverter::ToPipelineStage(spv::ExecutionModel model) {
return ast::PipelineStage::kNone; return ast::PipelineStage::kNone;
} }
ast::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) { type::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) {
switch (sc) { switch (sc) {
case spv::StorageClass::Input: case spv::StorageClass::Input:
return ast::AddressSpace::kIn; return type::AddressSpace::kIn;
case spv::StorageClass::Output: case spv::StorageClass::Output:
return ast::AddressSpace::kOut; return type::AddressSpace::kOut;
case spv::StorageClass::Uniform: case spv::StorageClass::Uniform:
return ast::AddressSpace::kUniform; return type::AddressSpace::kUniform;
case spv::StorageClass::Workgroup: case spv::StorageClass::Workgroup:
return ast::AddressSpace::kWorkgroup; return type::AddressSpace::kWorkgroup;
case spv::StorageClass::UniformConstant: case spv::StorageClass::UniformConstant:
return ast::AddressSpace::kNone; return type::AddressSpace::kNone;
case spv::StorageClass::StorageBuffer: case spv::StorageClass::StorageBuffer:
return ast::AddressSpace::kStorage; return type::AddressSpace::kStorage;
case spv::StorageClass::Private: case spv::StorageClass::Private:
return ast::AddressSpace::kPrivate; return type::AddressSpace::kPrivate;
case spv::StorageClass::Function: case spv::StorageClass::Function:
return ast::AddressSpace::kFunction; return type::AddressSpace::kFunction;
default: default:
break; break;
} }
Fail() << "unknown SPIR-V storage class: " << uint32_t(sc); Fail() << "unknown SPIR-V storage class: " << uint32_t(sc);
return ast::AddressSpace::kUndefined; return type::AddressSpace::kUndefined;
} }
ast::BuiltinValue EnumConverter::ToBuiltin(spv::BuiltIn b) { ast::BuiltinValue EnumConverter::ToBuiltin(spv::BuiltIn b) {

4
src/tint/reader/spirv/enum_converter.h
View File

@ -17,10 +17,10 @@
#include "spirv/unified1/spirv.h" #include "spirv/unified1/spirv.h"
#include "spirv/unified1/spirv.hpp11" #include "spirv/unified1/spirv.hpp11"
#include "src/tint/ast/address_space.h"
#include "src/tint/ast/builtin_value.h" #include "src/tint/ast/builtin_value.h"
#include "src/tint/ast/pipeline_stage.h" #include "src/tint/ast/pipeline_stage.h"
#include "src/tint/reader/spirv/fail_stream.h" #include "src/tint/reader/spirv/fail_stream.h"
#include "src/tint/type/address_space.h"
#include "src/tint/type/storage_texture.h" #include "src/tint/type/storage_texture.h"
#include "src/tint/type/texture_dimension.h" #include "src/tint/type/texture_dimension.h"
@ -45,7 +45,7 @@ class EnumConverter {
/// On failure, logs an error and returns kNone /// On failure, logs an error and returns kNone
/// @param sc the SPIR-V storage class /// @param sc the SPIR-V storage class
/// @returns a Tint AST address space /// @returns a Tint AST address space
ast::AddressSpace ToAddressSpace(const spv::StorageClass sc); type::AddressSpace ToAddressSpace(const spv::StorageClass sc);
/// Converts a SPIR-V Builtin value a Tint Builtin. /// Converts a SPIR-V Builtin value a Tint Builtin.
/// On failure, logs an error and returns kNone /// On failure, logs an error and returns kNone

20
src/tint/reader/spirv/enum_converter_test.cc
View File

@ -85,7 +85,7 @@ INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
struct StorageClassCase { struct StorageClassCase {
spv::StorageClass sc; spv::StorageClass sc;
bool expect_success; bool expect_success;
ast::AddressSpace expected; type::AddressSpace expected;
}; };
inline std::ostream& operator<<(std::ostream& out, StorageClassCase scc) { inline std::ostream& operator<<(std::ostream& out, StorageClassCase scc) {
out << "StorageClassCase{ spv::StorageClass:::" << int(scc.sc) out << "StorageClassCase{ spv::StorageClass:::" << int(scc.sc)
@ -126,19 +126,19 @@ INSTANTIATE_TEST_SUITE_P(
EnumConverterGood, EnumConverterGood,
SpvStorageClassTest, SpvStorageClassTest,
testing::Values( testing::Values(
StorageClassCase{spv::StorageClass::Input, true, ast::AddressSpace::kIn}, StorageClassCase{spv::StorageClass::Input, true, type::AddressSpace::kIn},
StorageClassCase{spv::StorageClass::Output, true, ast::AddressSpace::kOut}, StorageClassCase{spv::StorageClass::Output, true, type::AddressSpace::kOut},
StorageClassCase{spv::StorageClass::Uniform, true, ast::AddressSpace::kUniform}, StorageClassCase{spv::StorageClass::Uniform, true, type::AddressSpace::kUniform},
StorageClassCase{spv::StorageClass::Workgroup, true, ast::AddressSpace::kWorkgroup}, StorageClassCase{spv::StorageClass::Workgroup, true, type::AddressSpace::kWorkgroup},
StorageClassCase{spv::StorageClass::UniformConstant, true, ast::AddressSpace::kNone}, StorageClassCase{spv::StorageClass::UniformConstant, true, type::AddressSpace::kNone},
StorageClassCase{spv::StorageClass::StorageBuffer, true, ast::AddressSpace::kStorage}, StorageClassCase{spv::StorageClass::StorageBuffer, true, type::AddressSpace::kStorage},
StorageClassCase{spv::StorageClass::Private, true, ast::AddressSpace::kPrivate}, StorageClassCase{spv::StorageClass::Private, true, type::AddressSpace::kPrivate},
StorageClassCase{spv::StorageClass::Function, true, ast::AddressSpace::kFunction})); StorageClassCase{spv::StorageClass::Function, true, type::AddressSpace::kFunction}));
INSTANTIATE_TEST_SUITE_P(EnumConverterBad, INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
SpvStorageClassTest, SpvStorageClassTest,
testing::Values(StorageClassCase{static_cast<spv::StorageClass>(9999), testing::Values(StorageClassCase{static_cast<spv::StorageClass>(9999),
false, ast::AddressSpace::kUndefined})); false, type::AddressSpace::kUndefined}));
// Builtin // Builtin

18
src/tint/reader/spirv/function.cc
View File

@ -2536,11 +2536,11 @@ bool FunctionEmitter::EmitFunctionVariables() {
return false; return false;
} }
} }
auto* var = parser_impl_.MakeVar(inst.result_id(), ast::AddressSpace::kNone, var_store_type, auto* var = parser_impl_.MakeVar(inst.result_id(), type::AddressSpace::kNone,
initializer, AttributeList{}); var_store_type, initializer, AttributeList{});
auto* var_decl_stmt = create<ast::VariableDeclStatement>(Source{}, var); auto* var_decl_stmt = create<ast::VariableDeclStatement>(Source{}, var);
AddStatement(var_decl_stmt); AddStatement(var_decl_stmt);
auto* var_type = ty_.Reference(var_store_type, ast::AddressSpace::kNone); auto* var_type = ty_.Reference(var_store_type, type::AddressSpace::kNone);
identifier_types_.emplace(inst.result_id(), var_type); identifier_types_.emplace(inst.result_id(), var_type);
} }
return success(); return success();
@ -3390,9 +3390,9 @@ bool FunctionEmitter::EmitStatementsInBasicBlock(const BlockInfo& block_info,
// no need to remap pointer properties. // no need to remap pointer properties.
auto* store_type = parser_impl_.ConvertType(def_inst->type_id()); auto* store_type = parser_impl_.ConvertType(def_inst->type_id());
AddStatement(create<ast::VariableDeclStatement>( AddStatement(create<ast::VariableDeclStatement>(
Source{}, parser_impl_.MakeVar(id, ast::AddressSpace::kNone, store_type, nullptr, Source{}, parser_impl_.MakeVar(id, type::AddressSpace::kNone, store_type, nullptr,
AttributeList{}))); AttributeList{})));
auto* type = ty_.Reference(store_type, ast::AddressSpace::kNone); auto* type = ty_.Reference(store_type, type::AddressSpace::kNone);
identifier_types_.emplace(id, type); identifier_types_.emplace(id, type);
} }
@ -4882,7 +4882,7 @@ DefInfo::Pointer FunctionEmitter::GetPointerInfo(uint32_t id) {
} }
// Local variables are always Function storage class, with default // Local variables are always Function storage class, with default
// access mode. // access mode.
return DefInfo::Pointer{ast::AddressSpace::kFunction, ast::Access::kUndefined}; return DefInfo::Pointer{type::AddressSpace::kFunction, ast::Access::kUndefined};
} }
case spv::Op::OpFunctionParameter: { case spv::Op::OpFunctionParameter: {
const auto* type = As<Pointer>(parser_impl_.ConvertType(inst.type_id())); const auto* type = As<Pointer>(parser_impl_.ConvertType(inst.type_id()));
@ -5117,7 +5117,7 @@ void FunctionEmitter::FindValuesNeedingNamedOrHoistedDefinition() {
// Avoid moving combinatorial values across constructs. This is a // Avoid moving combinatorial values across constructs. This is a
// simple heuristic to avoid changing the cost of an operation // simple heuristic to avoid changing the cost of an operation
// by moving it into or out of a loop, for example. // by moving it into or out of a loop, for example.
if ((def_info->pointer.address_space == ast::AddressSpace::kUndefined) && if ((def_info->pointer.address_space == type::AddressSpace::kUndefined) &&
local_def.used_in_another_construct) { local_def.used_in_another_construct) {
should_hoist_to_let = true; should_hoist_to_let = true;
} }
@ -6254,7 +6254,7 @@ bool FunctionEmitter::MakeVectorInsertDynamic(const spvtools::opt::Instruction&
// API in parser_impl_. // API in parser_impl_.
var_name = namer_.MakeDerivedName(original_value_name); var_name = namer_.MakeDerivedName(original_value_name);
auto* temp_var = builder_.Var(var_name, type->Build(builder_), ast::AddressSpace::kNone, auto* temp_var = builder_.Var(var_name, type->Build(builder_), type::AddressSpace::kNone,
src_vector.expr); src_vector.expr);
AddStatement(builder_.Decl({}, temp_var)); AddStatement(builder_.Decl({}, temp_var));
@ -6324,7 +6324,7 @@ bool FunctionEmitter::MakeCompositeInsert(const spvtools::opt::Instruction& inst
// It doesn't correspond to a SPIR-V ID, so we don't use the ordinary // It doesn't correspond to a SPIR-V ID, so we don't use the ordinary
// API in parser_impl_. // API in parser_impl_.
var_name = namer_.MakeDerivedName(original_value_name); var_name = namer_.MakeDerivedName(original_value_name);
auto* temp_var = builder_.Var(var_name, type->Build(builder_), ast::AddressSpace::kNone, auto* temp_var = builder_.Var(var_name, type->Build(builder_), type::AddressSpace::kNone,
src_composite.expr); src_composite.expr);
AddStatement(builder_.Decl({}, temp_var)); AddStatement(builder_.Decl({}, temp_var));
} }

4
src/tint/reader/spirv/function.h
View File

@ -331,7 +331,7 @@ struct DefInfo {
/// buffer expressed in the old style (with Uniform address space) /// buffer expressed in the old style (with Uniform address space)
/// that needs to be remapped to StorageBuffer address space. /// that needs to be remapped to StorageBuffer address space.
/// This is kInvalid for non-pointers. /// This is kInvalid for non-pointers.
ast::AddressSpace address_space = ast::AddressSpace::kUndefined; type::AddressSpace address_space = type::AddressSpace::kUndefined;
/// The declared access mode. /// The declared access mode.
ast::Access access = ast::Access::kUndefined; ast::Access access = ast::Access::kUndefined;
@ -368,7 +368,7 @@ inline std::ostream& operator<<(std::ostream& o, const DefInfo& di) {
} }
o << " requires_named_let_def: " << (di.requires_named_let_def ? "true" : "false") o << " requires_named_let_def: " << (di.requires_named_let_def ? "true" : "false")
<< " requires_hoisted_var_def: " << (di.requires_hoisted_var_def ? "true" : "false"); << " requires_hoisted_var_def: " << (di.requires_hoisted_var_def ? "true" : "false");
if (di.pointer.address_space != ast::AddressSpace::kNone) { if (di.pointer.address_space != type::AddressSpace::kNone) {
o << " sc:" << int(di.pointer.address_space); o << " sc:" << int(di.pointer.address_space);
} }
switch (di.skip) { switch (di.skip) {

40
src/tint/reader/spirv/parser_impl.cc
View File

@ -1222,21 +1222,21 @@ const Type* ParserImpl::ConvertType(uint32_t type_id,
} }
auto ast_address_space = enum_converter_.ToAddressSpace(storage_class); auto ast_address_space = enum_converter_.ToAddressSpace(storage_class);
if (ast_address_space == ast::AddressSpace::kUndefined) { if (ast_address_space == type::AddressSpace::kUndefined) {
Fail() << "SPIR-V pointer type with ID " << type_id << " has invalid storage class " Fail() << "SPIR-V pointer type with ID " << type_id << " has invalid storage class "
<< static_cast<uint32_t>(storage_class); << static_cast<uint32_t>(storage_class);
return nullptr; return nullptr;
} }
if (ast_address_space == ast::AddressSpace::kUniform && if (ast_address_space == type::AddressSpace::kUniform &&
remap_buffer_block_type_.count(pointee_type_id)) { remap_buffer_block_type_.count(pointee_type_id)) {
ast_address_space = ast::AddressSpace::kStorage; ast_address_space = type::AddressSpace::kStorage;
remap_buffer_block_type_.insert(type_id); remap_buffer_block_type_.insert(type_id);
} }
// Pipeline input and output variables map to private variables. // Pipeline input and output variables map to private variables.
if (ast_address_space == ast::AddressSpace::kIn || if (ast_address_space == type::AddressSpace::kIn ||
ast_address_space == ast::AddressSpace::kOut) { ast_address_space == type::AddressSpace::kOut) {
ast_address_space = ast::AddressSpace::kPrivate; ast_address_space = type::AddressSpace::kPrivate;
} }
switch (ptr_as) { switch (ptr_as) {
case PtrAs::Ref: case PtrAs::Ref:
@ -1460,14 +1460,14 @@ bool ParserImpl::EmitModuleScopeVariables() {
continue; continue;
} }
switch (enum_converter_.ToAddressSpace(spirv_storage_class)) { switch (enum_converter_.ToAddressSpace(spirv_storage_class)) {
case ast::AddressSpace::kNone: case type::AddressSpace::kNone:
case ast::AddressSpace::kIn: case type::AddressSpace::kIn:
case ast::AddressSpace::kOut: case type::AddressSpace::kOut:
case ast::AddressSpace::kUniform: case type::AddressSpace::kUniform:
case ast::AddressSpace::kHandle: case type::AddressSpace::kHandle:
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
case ast::AddressSpace::kWorkgroup: case type::AddressSpace::kWorkgroup:
case ast::AddressSpace::kPrivate: case type::AddressSpace::kPrivate:
break; break;
default: default:
return Fail() << "invalid SPIR-V storage class " << int(spirv_storage_class) return Fail() << "invalid SPIR-V storage class " << int(spirv_storage_class)
@ -1477,7 +1477,7 @@ bool ParserImpl::EmitModuleScopeVariables() {
return false; return false;
} }
const Type* ast_store_type = nullptr; const Type* ast_store_type = nullptr;
ast::AddressSpace ast_address_space = ast::AddressSpace::kNone; type::AddressSpace ast_address_space = type::AddressSpace::kNone;
if (spirv_storage_class == spv::StorageClass::UniformConstant) { if (spirv_storage_class == spv::StorageClass::UniformConstant) {
// These are opaque handles: samplers or textures // These are opaque handles: samplers or textures
ast_store_type = GetHandleTypeForSpirvHandle(var); ast_store_type = GetHandleTypeForSpirvHandle(var);
@ -1578,7 +1578,7 @@ const spvtools::opt::analysis::IntConstant* ParserImpl::GetArraySize(uint32_t va
} }
ast::Var* ParserImpl::MakeVar(uint32_t id, ast::Var* ParserImpl::MakeVar(uint32_t id,
ast::AddressSpace address_space, type::AddressSpace address_space,
const Type* storage_type, const Type* storage_type,
const ast::Expression* initializer, const ast::Expression* initializer,
AttributeList decorations) { AttributeList decorations) {
@ -1588,7 +1588,7 @@ ast::Var* ParserImpl::MakeVar(uint32_t id,
} }
ast::Access access = ast::Access::kUndefined; ast::Access access = ast::Access::kUndefined;
if (address_space == ast::AddressSpace::kStorage) { if (address_space == type::AddressSpace::kStorage) {
bool read_only = false; bool read_only = false;
if (auto* tn = storage_type->As<Named>()) { if (auto* tn = storage_type->As<Named>()) {
read_only = read_only_struct_types_.count(tn->name) > 0; read_only = read_only_struct_types_.count(tn->name) > 0;
@ -1600,12 +1600,12 @@ ast::Var* ParserImpl::MakeVar(uint32_t id,
// Handle variables (textures and samplers) are always in the handle // Handle variables (textures and samplers) are always in the handle
// address space, so we don't mention the address space. // address space, so we don't mention the address space.
if (address_space == ast::AddressSpace::kHandle) { if (address_space == type::AddressSpace::kHandle) {
address_space = ast::AddressSpace::kNone; address_space = type::AddressSpace::kNone;
} }
if (!ConvertDecorationsForVariable(id, &storage_type, &decorations, if (!ConvertDecorationsForVariable(id, &storage_type, &decorations,
address_space != ast::AddressSpace::kPrivate)) { address_space != type::AddressSpace::kPrivate)) {
return nullptr; return nullptr;
} }

4
src/tint/reader/spirv/parser_impl.h
View File

@ -423,14 +423,14 @@ class ParserImpl : Reader {
/// Creates an AST 'var' node for a SPIR-V ID, including any attached decorations, unless it's /// Creates an AST 'var' node for a SPIR-V ID, including any attached decorations, unless it's
/// an ignorable builtin variable. /// an ignorable builtin variable.
/// @param id the SPIR-V result ID /// @param id the SPIR-V result ID
/// @param address_space the address space, which cannot be ast::AddressSpace::kNone /// @param address_space the address space, which cannot be type::AddressSpace::kNone
/// @param storage_type the storage type of the variable /// @param storage_type the storage type of the variable
/// @param initializer the variable initializer /// @param initializer the variable initializer
/// @param decorations the variable decorations /// @param decorations the variable decorations
/// @returns a new Variable node, or null in the ignorable variable case and /// @returns a new Variable node, or null in the ignorable variable case and
/// in the error case /// in the error case
ast::Var* MakeVar(uint32_t id, ast::Var* MakeVar(uint32_t id,
ast::AddressSpace address_space, type::AddressSpace address_space,
const Type* storage_type, const Type* storage_type,
const ast::Expression* initializer, const ast::Expression* initializer,
AttributeList decorations); AttributeList decorations);

20
src/tint/reader/spirv/parser_impl_convert_type_test.cc
View File

@ -731,7 +731,7 @@ TEST_F(SpvParserTest, ConvertType_PointerInput) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -747,7 +747,7 @@ TEST_F(SpvParserTest, ConvertType_PointerOutput) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -763,7 +763,7 @@ TEST_F(SpvParserTest, ConvertType_PointerUniform) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kUniform); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kUniform);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -779,7 +779,7 @@ TEST_F(SpvParserTest, ConvertType_PointerWorkgroup) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kWorkgroup); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kWorkgroup);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -795,7 +795,7 @@ TEST_F(SpvParserTest, ConvertType_PointerUniformConstant) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kNone); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kNone);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -811,7 +811,7 @@ TEST_F(SpvParserTest, ConvertType_PointerStorageBuffer) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kStorage); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kStorage);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -827,7 +827,7 @@ TEST_F(SpvParserTest, ConvertType_PointerPrivate) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -843,7 +843,7 @@ TEST_F(SpvParserTest, ConvertType_PointerFunction) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ty->type->Is<F32>());
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kFunction); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kFunction);
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());
} }
@ -862,12 +862,12 @@ TEST_F(SpvParserTest, ConvertType_PointerToPointer) {
auto* ptr_ty = type->As<Pointer>(); auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr); EXPECT_NE(ptr_ty, nullptr);
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
EXPECT_TRUE(ptr_ty->type->Is<Pointer>()); EXPECT_TRUE(ptr_ty->type->Is<Pointer>());
auto* ptr_ptr_ty = ptr_ty->type->As<Pointer>(); auto* ptr_ptr_ty = ptr_ty->type->As<Pointer>();
EXPECT_NE(ptr_ptr_ty, nullptr); EXPECT_NE(ptr_ptr_ty, nullptr);
EXPECT_EQ(ptr_ptr_ty->address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(ptr_ptr_ty->address_space, type::AddressSpace::kPrivate);
EXPECT_TRUE(ptr_ptr_ty->type->Is<F32>()); EXPECT_TRUE(ptr_ptr_ty->type->Is<F32>());
EXPECT_TRUE(p->error().empty()); EXPECT_TRUE(p->error().empty());

8
src/tint/reader/spirv/parser_type.cc
View File

@ -175,7 +175,7 @@ Type::~Type() = default;
Texture::~Texture() = default; Texture::~Texture() = default;
Pointer::Pointer(const Type* t, ast::AddressSpace s, ast::Access a) Pointer::Pointer(const Type* t, type::AddressSpace s, ast::Access a)
: type(t), address_space(s), access(a) {} : type(t), address_space(s), access(a) {}
Pointer::Pointer(const Pointer&) = default; Pointer::Pointer(const Pointer&) = default;
@ -183,7 +183,7 @@ const ast::Type* Pointer::Build(ProgramBuilder& b) const {
return b.ty.pointer(type->Build(b), address_space, access); return b.ty.pointer(type->Build(b), address_space, access);
} }
Reference::Reference(const Type* t, ast::AddressSpace s, ast::Access a) Reference::Reference(const Type* t, type::AddressSpace s, ast::Access a)
: type(t), address_space(s), access(a) {} : type(t), address_space(s), access(a) {}
Reference::Reference(const Reference&) = default; Reference::Reference(const Reference&) = default;
@ -460,13 +460,13 @@ const Type* TypeManager::AsUnsigned(const Type* ty) {
} }
const spirv::Pointer* TypeManager::Pointer(const Type* el, const spirv::Pointer* TypeManager::Pointer(const Type* el,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access) { ast::Access access) {
return state->pointers_.Get(el, address_space, access); return state->pointers_.Get(el, address_space, access);
} }
const spirv::Reference* TypeManager::Reference(const Type* el, const spirv::Reference* TypeManager::Reference(const Type* el,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access) { ast::Access access) {
return state->references_.Get(el, address_space, access); return state->references_.Get(el, address_space, access);
} }

14
src/tint/reader/spirv/parser_type.h
View File

@ -20,10 +20,10 @@
#include <vector> #include <vector>
#include "src/tint/ast/access.h" #include "src/tint/ast/access.h"
#include "src/tint/ast/address_space.h"
#include "src/tint/ast/sampler.h" #include "src/tint/ast/sampler.h"
#include "src/tint/ast/storage_texture.h" #include "src/tint/ast/storage_texture.h"
#include "src/tint/castable.h" #include "src/tint/castable.h"
#include "src/tint/type/address_space.h"
#include "src/tint/type/texture_dimension.h" #include "src/tint/type/texture_dimension.h"
#include "src/tint/utils/block_allocator.h" #include "src/tint/utils/block_allocator.h"
@ -163,7 +163,7 @@ struct Pointer final : public Castable<Pointer, Type> {
/// @param ty the store type /// @param ty the store type
/// @param sc the pointer address space /// @param sc the pointer address space
/// @param access the declared access mode /// @param access the declared access mode
Pointer(const Type* ty, ast::AddressSpace sc, ast::Access access); Pointer(const Type* ty, type::AddressSpace sc, ast::Access access);
/// Copy constructor /// Copy constructor
/// @param other the other type to copy /// @param other the other type to copy
@ -181,7 +181,7 @@ struct Pointer final : public Castable<Pointer, Type> {
/// the store type /// the store type
Type const* const type; Type const* const type;
/// the pointer address space /// the pointer address space
ast::AddressSpace const address_space; type::AddressSpace const address_space;
/// the pointer declared access mode /// the pointer declared access mode
ast::Access const access; ast::Access const access;
}; };
@ -194,7 +194,7 @@ struct Reference final : public Castable<Reference, Type> {
/// @param ty the referenced type /// @param ty the referenced type
/// @param sc the reference address space /// @param sc the reference address space
/// @param access the reference declared access mode /// @param access the reference declared access mode
Reference(const Type* ty, ast::AddressSpace sc, ast::Access access); Reference(const Type* ty, type::AddressSpace sc, ast::Access access);
/// Copy constructor /// Copy constructor
/// @param other the other type to copy /// @param other the other type to copy
@ -212,7 +212,7 @@ struct Reference final : public Castable<Reference, Type> {
/// the store type /// the store type
Type const* const type; Type const* const type;
/// the pointer address space /// the pointer address space
ast::AddressSpace const address_space; type::AddressSpace const address_space;
/// the pointer declared access mode /// the pointer declared access mode
ast::Access const access; ast::Access const access;
}; };
@ -550,7 +550,7 @@ class TypeManager {
/// @return a Pointer type. Repeated calls with the same arguments will return /// @return a Pointer type. Repeated calls with the same arguments will return
/// the same pointer. /// the same pointer.
const spirv::Pointer* Pointer(const Type* ty, const spirv::Pointer* Pointer(const Type* ty,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access = ast::Access::kUndefined); ast::Access access = ast::Access::kUndefined);
/// @param ty the referenced type /// @param ty the referenced type
/// @param address_space the reference address space /// @param address_space the reference address space
@ -558,7 +558,7 @@ class TypeManager {
/// @return a Reference type. Repeated calls with the same arguments will /// @return a Reference type. Repeated calls with the same arguments will
/// return the same pointer. /// return the same pointer.
const spirv::Reference* Reference(const Type* ty, const spirv::Reference* Reference(const Type* ty,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access = ast::Access::kUndefined); ast::Access access = ast::Access::kUndefined);
/// @param ty the element type /// @param ty the element type
/// @param sz the number of elements in the vector /// @param sz the number of elements in the vector

12
src/tint/reader/spirv/parser_type_test.cc
View File

@ -29,8 +29,8 @@ TEST(SpvParserTypeTest, SameArgumentsGivesSamePointer) {
EXPECT_EQ(ty.U32(), ty.U32()); EXPECT_EQ(ty.U32(), ty.U32());
EXPECT_EQ(ty.F32(), ty.F32()); EXPECT_EQ(ty.F32(), ty.F32());
EXPECT_EQ(ty.I32(), ty.I32()); EXPECT_EQ(ty.I32(), ty.I32());
EXPECT_EQ(ty.Pointer(ty.I32(), ast::AddressSpace::kNone), EXPECT_EQ(ty.Pointer(ty.I32(), type::AddressSpace::kNone),
ty.Pointer(ty.I32(), ast::AddressSpace::kNone)); ty.Pointer(ty.I32(), type::AddressSpace::kNone));
EXPECT_EQ(ty.Vector(ty.I32(), 3), ty.Vector(ty.I32(), 3)); EXPECT_EQ(ty.Vector(ty.I32(), 3), ty.Vector(ty.I32(), 3));
EXPECT_EQ(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.I32(), 3, 2)); EXPECT_EQ(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.I32(), 3, 2));
EXPECT_EQ(ty.Array(ty.I32(), 3, 2), ty.Array(ty.I32(), 3, 2)); EXPECT_EQ(ty.Array(ty.I32(), 3, 2), ty.Array(ty.I32(), 3, 2));
@ -54,10 +54,10 @@ TEST(SpvParserTypeTest, DifferentArgumentsGivesDifferentPointer) {
Symbol sym_b(Symbol(2, {})); Symbol sym_b(Symbol(2, {}));
TypeManager ty; TypeManager ty;
EXPECT_NE(ty.Pointer(ty.I32(), ast::AddressSpace::kNone), EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kNone),
ty.Pointer(ty.U32(), ast::AddressSpace::kNone)); ty.Pointer(ty.U32(), type::AddressSpace::kNone));
EXPECT_NE(ty.Pointer(ty.I32(), ast::AddressSpace::kNone), EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kNone),
ty.Pointer(ty.I32(), ast::AddressSpace::kIn)); ty.Pointer(ty.I32(), type::AddressSpace::kIn));
EXPECT_NE(ty.Vector(ty.I32(), 3), ty.Vector(ty.U32(), 3)); EXPECT_NE(ty.Vector(ty.I32(), 3), ty.Vector(ty.U32(), 3));
EXPECT_NE(ty.Vector(ty.I32(), 3), ty.Vector(ty.I32(), 2)); EXPECT_NE(ty.Vector(ty.I32(), 3), ty.Vector(ty.I32(), 2));
EXPECT_NE(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.U32(), 3, 2)); EXPECT_NE(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.U32(), 3, 2));

8
src/tint/reader/wgsl/parser_impl.cc
View File

@ -213,7 +213,7 @@ ParserImpl::VarDeclInfo::VarDeclInfo(const VarDeclInfo&) = default;
ParserImpl::VarDeclInfo::VarDeclInfo(Source source_in, ParserImpl::VarDeclInfo::VarDeclInfo(Source source_in,
std::string name_in, std::string name_in,
ast::AddressSpace address_space_in, type::AddressSpace address_space_in,
ast::Access access_in, ast::Access access_in,
const ast::Type* type_in) const ast::Type* type_in)
: source(std::move(source_in)), : source(std::move(source_in)),
@ -1251,7 +1251,7 @@ Expect<const ast::Type*> ParserImpl::expect_type(std::string_view use) {
Expect<const ast::Type*> ParserImpl::expect_type_specifier_pointer(const Source& s) { Expect<const ast::Type*> ParserImpl::expect_type_specifier_pointer(const Source& s) {
const char* use = "ptr declaration"; const char* use = "ptr declaration";
auto address_space = ast::AddressSpace::kNone; auto address_space = type::AddressSpace::kNone;
auto access = ast::Access::kUndefined; auto access = ast::Access::kUndefined;
auto subtype = expect_lt_gt_block(use, [&]() -> Expect<const ast::Type*> { auto subtype = expect_lt_gt_block(use, [&]() -> Expect<const ast::Type*> {
@ -1372,8 +1372,8 @@ Expect<const ast::Type*> ParserImpl::expect_type_specifier_matrix(const Source&
// | 'storage' // | 'storage'
// //
// Note, we also parse `push_constant` from the experimental extension // Note, we also parse `push_constant` from the experimental extension
Expect<ast::AddressSpace> ParserImpl::expect_address_space(std::string_view use) { Expect<type::AddressSpace> ParserImpl::expect_address_space(std::string_view use) {
return expect_enum("address space", ast::ParseAddressSpace, ast::kAddressSpaceStrings, use); return expect_enum("address space", type::ParseAddressSpace, type::kAddressSpaceStrings, use);
} }
// struct_decl // struct_decl

10
src/tint/reader/wgsl/parser_impl.h
View File

@ -284,7 +284,7 @@ class ParserImpl {
/// @param type_in variable type /// @param type_in variable type
VarDeclInfo(Source source_in, VarDeclInfo(Source source_in,
std::string name_in, std::string name_in,
ast::AddressSpace address_space_in, type::AddressSpace address_space_in,
ast::Access access_in, ast::Access access_in,
const ast::Type* type_in); const ast::Type* type_in);
/// Destructor /// Destructor
@ -295,7 +295,7 @@ class ParserImpl {
/// Variable name /// Variable name
std::string name; std::string name;
/// Variable address space /// Variable address space
ast::AddressSpace address_space = ast::AddressSpace::kNone; type::AddressSpace address_space = type::AddressSpace::kNone;
/// Variable access control /// Variable access control
ast::Access access = ast::Access::kUndefined; ast::Access access = ast::Access::kUndefined;
/// Variable type /// Variable type
@ -305,7 +305,7 @@ class ParserImpl {
/// VariableQualifier contains the parsed information for a variable qualifier /// VariableQualifier contains the parsed information for a variable qualifier
struct VariableQualifier { struct VariableQualifier {
/// The variable's address space /// The variable's address space
ast::AddressSpace address_space = ast::AddressSpace::kNone; type::AddressSpace address_space = type::AddressSpace::kNone;
/// The variable's access control /// The variable's access control
ast::Access access = ast::Access::kUndefined; ast::Access access = ast::Access::kUndefined;
}; };
@ -461,8 +461,8 @@ class ParserImpl {
Maybe<const ast::Type*> type_specifier(); Maybe<const ast::Type*> type_specifier();
/// Parses an `address_space` grammar element, erroring on parse failure. /// Parses an `address_space` grammar element, erroring on parse failure.
/// @param use a description of what was being parsed if an error was raised. /// @param use a description of what was being parsed if an error was raised.
/// @returns the address space or ast::AddressSpace::kNone if none matched /// @returns the address space or type::AddressSpace::kNone if none matched
Expect<ast::AddressSpace> expect_address_space(std::string_view use); Expect<type::AddressSpace> expect_address_space(std::string_view use);
/// Parses a `struct_decl` grammar element. /// Parses a `struct_decl` grammar element.
/// @returns the struct type or nullptr on error /// @returns the struct type or nullptr on error
Maybe<const ast::Struct*> struct_decl(); Maybe<const ast::Struct*> struct_decl();

12
src/tint/reader/wgsl/parser_impl_address_space_test.cc
View File

@ -19,7 +19,7 @@ namespace {
struct AddressSpaceData { struct AddressSpaceData {
const char* input; const char* input;
ast::AddressSpace result; type::AddressSpace result;
}; };
inline std::ostream& operator<<(std::ostream& out, AddressSpaceData data) { inline std::ostream& operator<<(std::ostream& out, AddressSpaceData data) {
out << std::string(data.input); out << std::string(data.input);
@ -43,11 +43,11 @@ TEST_P(ParserAddressSpaceTest, Parses) {
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
ParserImplTest, ParserImplTest,
ParserAddressSpaceTest, ParserAddressSpaceTest,
testing::Values(AddressSpaceData{"uniform", ast::AddressSpace::kUniform}, testing::Values(AddressSpaceData{"uniform", type::AddressSpace::kUniform},
AddressSpaceData{"workgroup", ast::AddressSpace::kWorkgroup}, AddressSpaceData{"workgroup", type::AddressSpace::kWorkgroup},
AddressSpaceData{"storage", ast::AddressSpace::kStorage}, AddressSpaceData{"storage", type::AddressSpace::kStorage},
AddressSpaceData{"private", ast::AddressSpace::kPrivate}, AddressSpaceData{"private", type::AddressSpace::kPrivate},
AddressSpaceData{"function", ast::AddressSpace::kFunction})); AddressSpaceData{"function", type::AddressSpace::kFunction}));
TEST_F(ParserImplTest, AddressSpace_NoMatch) { TEST_F(ParserImplTest, AddressSpace_NoMatch) {
auto p = parser("not-a-address-space"); auto p = parser("not-a-address-space");

8
src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc
View File

@ -31,7 +31,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithoutInitializer) {
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
EXPECT_TRUE(var->type->Is<ast::F32>()); EXPECT_TRUE(var->type->Is<ast::F32>());
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(var->declared_address_space, type::AddressSpace::kPrivate);
EXPECT_EQ(var->source.range.begin.line, 1u); EXPECT_EQ(var->source.range.begin.line, 1u);
EXPECT_EQ(var->source.range.begin.column, 14u); EXPECT_EQ(var->source.range.begin.column, 14u);
@ -55,7 +55,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithInitializer) {
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
EXPECT_TRUE(var->type->Is<ast::F32>()); EXPECT_TRUE(var->type->Is<ast::F32>());
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(var->declared_address_space, type::AddressSpace::kPrivate);
EXPECT_EQ(var->source.range.begin.line, 1u); EXPECT_EQ(var->source.range.begin.line, 1u);
EXPECT_EQ(var->source.range.begin.column, 14u); EXPECT_EQ(var->source.range.begin.column, 14u);
@ -81,7 +81,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithAttribute) {
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
ASSERT_NE(var->type, nullptr); ASSERT_NE(var->type, nullptr);
EXPECT_TRUE(var->type->Is<ast::F32>()); EXPECT_TRUE(var->type->Is<ast::F32>());
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kUniform); EXPECT_EQ(var->declared_address_space, type::AddressSpace::kUniform);
EXPECT_EQ(var->source.range.begin.line, 1u); EXPECT_EQ(var->source.range.begin.line, 1u);
EXPECT_EQ(var->source.range.begin.column, 36u); EXPECT_EQ(var->source.range.begin.column, 36u);
@ -112,7 +112,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithAttribute_MulitpleGroups) {
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
ASSERT_NE(var->type, nullptr); ASSERT_NE(var->type, nullptr);
EXPECT_TRUE(var->type->Is<ast::F32>()); EXPECT_TRUE(var->type->Is<ast::F32>());
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kUniform); EXPECT_EQ(var->declared_address_space, type::AddressSpace::kUniform);
EXPECT_EQ(var->source.range.begin.line, 1u); EXPECT_EQ(var->source.range.begin.line, 1u);
EXPECT_EQ(var->source.range.begin.column, 36u); EXPECT_EQ(var->source.range.begin.column, 36u);

6
src/tint/reader/wgsl/parser_impl_type_decl_test.cc
View File

@ -176,7 +176,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr) {
auto* ptr = t.value->As<ast::Pointer>(); auto* ptr = t.value->As<ast::Pointer>();
ASSERT_TRUE(ptr->type->Is<ast::F32>()); ASSERT_TRUE(ptr->type->Is<ast::F32>());
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 19u}})); EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 19u}}));
} }
@ -191,7 +191,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_WithAccess) {
auto* ptr = t.value->As<ast::Pointer>(); auto* ptr = t.value->As<ast::Pointer>();
ASSERT_TRUE(ptr->type->Is<ast::F32>()); ASSERT_TRUE(ptr->type->Is<ast::F32>());
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
ASSERT_EQ(ptr->access, ast::Access::kRead); ASSERT_EQ(ptr->access, ast::Access::kRead);
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 25u}})); EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 25u}}));
} }
@ -207,7 +207,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_ToVec) {
auto* ptr = t.value->As<ast::Pointer>(); auto* ptr = t.value->As<ast::Pointer>();
ASSERT_TRUE(ptr->type->Is<ast::Vector>()); ASSERT_TRUE(ptr->type->Is<ast::Vector>());
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
auto* vec = ptr->type->As<ast::Vector>(); auto* vec = ptr->type->As<ast::Vector>();
ASSERT_EQ(vec->width, 2u); ASSERT_EQ(vec->width, 2u);

6
src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc
View File

@ -167,7 +167,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr) {
auto* ptr = t.value->As<ast::Pointer>(); auto* ptr = t.value->As<ast::Pointer>();
ASSERT_TRUE(ptr->type->Is<ast::F32>()); ASSERT_TRUE(ptr->type->Is<ast::F32>());
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 19u}})); EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 19u}}));
} }
@ -182,7 +182,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_WithAccess) {
auto* ptr = t.value->As<ast::Pointer>(); auto* ptr = t.value->As<ast::Pointer>();
ASSERT_TRUE(ptr->type->Is<ast::F32>()); ASSERT_TRUE(ptr->type->Is<ast::F32>());
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
ASSERT_EQ(ptr->access, ast::Access::kRead); ASSERT_EQ(ptr->access, ast::Access::kRead);
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 25u}})); EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 25u}}));
} }
@ -198,7 +198,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_ToVec) {
auto* ptr = t.value->As<ast::Pointer>(); auto* ptr = t.value->As<ast::Pointer>();
ASSERT_TRUE(ptr->type->Is<ast::Vector>()); ASSERT_TRUE(ptr->type->Is<ast::Vector>());
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
auto* vec = ptr->type->As<ast::Vector>(); auto* vec = ptr->type->As<ast::Vector>();
ASSERT_EQ(vec->width, 2u); ASSERT_EQ(vec->width, 2u);

4
src/tint/reader/wgsl/parser_impl_variable_decl_test.cc
View File

@ -80,7 +80,7 @@ TEST_F(ParserImplTest, VariableDecl_WithAddressSpace) {
EXPECT_FALSE(p->has_error()); EXPECT_FALSE(p->has_error());
EXPECT_EQ(v->name, "my_var"); EXPECT_EQ(v->name, "my_var");
EXPECT_TRUE(v->type->Is<ast::F32>()); EXPECT_TRUE(v->type->Is<ast::F32>());
EXPECT_EQ(v->address_space, ast::AddressSpace::kPrivate); EXPECT_EQ(v->address_space, type::AddressSpace::kPrivate);
EXPECT_EQ(v->source.range.begin.line, 1u); EXPECT_EQ(v->source.range.begin.line, 1u);
EXPECT_EQ(v->source.range.begin.column, 14u); EXPECT_EQ(v->source.range.begin.column, 14u);
@ -96,7 +96,7 @@ TEST_F(ParserImplTest, VariableDecl_WithPushConstant) {
EXPECT_FALSE(p->has_error()); EXPECT_FALSE(p->has_error());
EXPECT_EQ(v->name, "my_var"); EXPECT_EQ(v->name, "my_var");
EXPECT_TRUE(v->type->Is<ast::F32>()); EXPECT_TRUE(v->type->Is<ast::F32>());
EXPECT_EQ(v->address_space, ast::AddressSpace::kPushConstant); EXPECT_EQ(v->address_space, type::AddressSpace::kPushConstant);
} }
TEST_F(ParserImplTest, VariableDecl_InvalidAddressSpace) { TEST_F(ParserImplTest, VariableDecl_InvalidAddressSpace) {

18
src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
View File

@ -19,7 +19,7 @@ namespace {
struct VariableStorageData { struct VariableStorageData {
const char* input; const char* input;
ast::AddressSpace address_space; type::AddressSpace address_space;
ast::Access access; ast::Access access;
}; };
inline std::ostream& operator<<(std::ostream& out, VariableStorageData data) { inline std::ostream& operator<<(std::ostream& out, VariableStorageData data) {
@ -47,14 +47,14 @@ INSTANTIATE_TEST_SUITE_P(
ParserImplTest, ParserImplTest,
VariableQualifierTest, VariableQualifierTest,
testing::Values( testing::Values(
VariableStorageData{"uniform", ast::AddressSpace::kUniform, ast::Access::kUndefined}, VariableStorageData{"uniform", type::AddressSpace::kUniform, ast::Access::kUndefined},
VariableStorageData{"workgroup", ast::AddressSpace::kWorkgroup, ast::Access::kUndefined}, VariableStorageData{"workgroup", type::AddressSpace::kWorkgroup, ast::Access::kUndefined},
VariableStorageData{"storage", ast::AddressSpace::kStorage, ast::Access::kUndefined}, VariableStorageData{"storage", type::AddressSpace::kStorage, ast::Access::kUndefined},
VariableStorageData{"private", ast::AddressSpace::kPrivate, ast::Access::kUndefined}, VariableStorageData{"private", type::AddressSpace::kPrivate, ast::Access::kUndefined},
VariableStorageData{"function", ast::AddressSpace::kFunction, ast::Access::kUndefined}, VariableStorageData{"function", type::AddressSpace::kFunction, ast::Access::kUndefined},
VariableStorageData{"storage, read", ast::AddressSpace::kStorage, ast::Access::kRead}, VariableStorageData{"storage, read", type::AddressSpace::kStorage, ast::Access::kRead},
VariableStorageData{"storage, write", ast::AddressSpace::kStorage, ast::Access::kWrite}, VariableStorageData{"storage, write", type::AddressSpace::kStorage, ast::Access::kWrite},
VariableStorageData{"storage, read_write", ast::AddressSpace::kStorage, VariableStorageData{"storage, read_write", type::AddressSpace::kStorage,
ast::Access::kReadWrite})); ast::Access::kReadWrite}));
TEST_F(ParserImplTest, VariableQualifier_NoMatch) { TEST_F(ParserImplTest, VariableQualifier_NoMatch) {

62
src/tint/resolver/address_space_layout_validation_test.cc
View File

@ -39,7 +39,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, StorageBuffer_UnalignedMember)
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)}), Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)}),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::AddressSpace::kStorage, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), type::AddressSpace::kStorage, Group(0_a),
Binding(0_a)); Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -69,7 +69,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, StorageBuffer_UnalignedMember_S
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(4_i)}), Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(4_i)}),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::AddressSpace::kStorage, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), type::AddressSpace::kStorage, Group(0_a),
Binding(0_a)); Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -100,8 +100,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_S
Member(Source{{56, 78}}, "inner", ty.type_name("Inner")), Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -145,8 +145,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest,
utils::Vector{MemberAlign(16_i)}), utils::Vector{MemberAlign(16_i)}),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -170,8 +170,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_A
Member(Source{{56, 78}}, "inner", ty.type_name("Inner")), Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -204,8 +204,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_A
utils::Vector{MemberAlign(16_i)}), utils::Vector{MemberAlign(16_i)}),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -236,8 +236,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_MembersOffsetNotM
Member(Source{{78, 90}}, "scalar", ty.i32()), Member(Source{{78, 90}}, "scalar", ty.i32()),
}); });
GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -288,8 +288,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest,
Member(Source{{78, 90}}, "scalar", ty.i32()), Member(Source{{78, 90}}, "scalar", ty.i32()),
}); });
GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -336,8 +336,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest,
Member(Source{{78, 90}}, "scalar", ty.i32(), utils::Vector{MemberAlign(16_i)}), Member(Source{{78, 90}}, "scalar", ty.i32(), utils::Vector{MemberAlign(16_i)}),
}); });
GlobalVar(Source{{22, 34}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{22, 34}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -358,7 +358,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_Vec3MemberOffset_
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"), GlobalVar(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"),
ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -381,7 +381,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_Vec3F16MemberOffs
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"), GlobalVar(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"),
ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -406,8 +406,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
Member("scalar", ty.i32()), Member("scalar", ty.i32()),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -440,8 +440,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
Member("scalar", ty.i32()), Member("scalar", ty.i32()),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -483,8 +483,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
Member("scalar", ty.i32()), Member("scalar", ty.i32()),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -502,7 +502,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
// @group(0) @binding(0) // @group(0) @binding(0)
// var<uniform> a : array<f32, 4u>; // var<uniform> a : array<f32, 4u>;
GlobalVar(Source{{78, 90}}, "a", ty.array(Source{{34, 56}}, ty.f32(), 4_u), GlobalVar(Source{{78, 90}}, "a", ty.array(Source{{34, 56}}, ty.f32(), 4_u),
ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -523,8 +523,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
Member("inner", ty.array(Source{{34, 56}}, ty.array(ty.f32(), 4_u), 4_u)), Member("inner", ty.array(Source{{34, 56}}, ty.array(ty.f32(), 4_u), 4_u)),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -556,8 +556,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
Member("scalar", ty.i32()), Member("scalar", ty.i32()),
}); });
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -575,7 +575,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, PushConstant_UnalignedMember) {
Source{{12, 34}}, "S", Source{{12, 34}}, "S",
utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}), utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}),
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)})}); Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)})});
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::AddressSpace::kPushConstant); GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), type::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -600,7 +600,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, PushConstant_Aligned) {
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}), Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(4_i)})}); Member("b", ty.f32(), utils::Vector{MemberAlign(4_i)})});
GlobalVar("a", ty.type_name("S"), ast::AddressSpace::kPushConstant); GlobalVar("a", ty.type_name("S"), type::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }

190
src/tint/resolver/address_space_validation_test.cc
View File

@ -38,7 +38,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NoAddressSpace_Fail) {
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NoAddressSpace_Fail) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NoAddressSpace_Fail) {
// type g = ptr<f32>; // type g = ptr<f32>;
Alias("g", ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kUndefined)); Alias("g", ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kUndefined));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: ptr missing address space"); EXPECT_EQ(r()->error(), "12:34 error: ptr missing address space");
@ -46,7 +46,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NoAddressSpace_Fail) {
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_Fail) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_Fail) {
// var<private> g : f32; // var<private> g : f32;
GlobalVar(Source{{12, 34}}, "g", ty.f32(), ast::AddressSpace::kFunction); GlobalVar(Source{{12, 34}}, "g", ty.f32(), type::AddressSpace::kFunction);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -56,7 +56,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_F
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray) {
// var<private> v : array<i32>; // var<private> v : array<i32>;
GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()), GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -67,7 +67,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray)
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArray) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArray) {
// type t : ptr<private, array<i32>>; // type t : ptr<private, array<i32>>;
Alias("t", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()), Alias("t", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()),
ast::AddressSpace::kPrivate)); type::AddressSpace::kPrivate));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -79,7 +79,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArrayIn
// struct S { m : array<i32> }; // struct S { m : array<i32> };
// var<private> v : S; // var<private> v : S;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))}); Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
GlobalVar(Source{{56, 78}}, "v", ty.type_name("S"), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "v", ty.type_name("S"), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -92,7 +92,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArrayInSt
// struct S { m : array<i32> }; // struct S { m : array<i32> };
// type t = ptr<private, S>; // type t = ptr<private, S>;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))}); Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kPrivate)); Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kPrivate));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -104,7 +104,7 @@ note: while instantiating ptr<private, S, read_write>)");
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray) {
// var<workgroup> v : array<i32>; // var<workgroup> v : array<i32>;
GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()), GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()),
ast::AddressSpace::kWorkgroup); type::AddressSpace::kWorkgroup);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -114,7 +114,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArray) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArray) {
// type t = ptr<workgroup, array<i32>>; // type t = ptr<workgroup, array<i32>>;
Alias("t", ty.pointer(ty.array(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kWorkgroup)); Alias("t", ty.pointer(ty.array(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -126,7 +126,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray
// struct S { m : array<i32> }; // struct S { m : array<i32> };
// var<workgroup> v : S; // var<workgroup> v : S;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))}); Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
GlobalVar(Source{{56, 78}}, "v", ty.type_name("S"), ast::AddressSpace::kWorkgroup); GlobalVar(Source{{56, 78}}, "v", ty.type_name("S"), type::AddressSpace::kWorkgroup);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -139,7 +139,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArrayIn
// struct S { m : array<i32> }; // struct S { m : array<i32> };
// type t = ptr<workgroup, S>; // type t = ptr<workgroup, S>;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))}); Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
Alias(Source{{56, 78}}, "t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kWorkgroup)); Alias(Source{{56, 78}}, "t", ty.pointer(ty.type_name("S"), type::AddressSpace::kWorkgroup));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -150,7 +150,7 @@ note: while instantiating ptr<workgroup, S, read_write>)");
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) {
// var<storage> g : bool; // var<storage> g : bool;
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), ast::AddressSpace::kStorage, GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kStorage,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -164,7 +164,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) {
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Bool) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Bool) {
// type t = ptr<storage, bool>; // type t = ptr<storage, bool>;
Alias(Source{{56, 78}}, "t", Alias(Source{{56, 78}}, "t",
ty.pointer(ty.bool_(Source{{12, 34}}), ast::AddressSpace::kStorage)); ty.pointer(ty.bool_(Source{{12, 34}}), type::AddressSpace::kStorage));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -179,7 +179,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_BoolAlias) {
// @binding(0) @group(0) var<storage, read> g : a; // @binding(0) @group(0) var<storage, read> g : a;
Alias("a", ty.bool_()); Alias("a", ty.bool_());
GlobalVar(Source{{56, 78}}, "g", ty.type_name(Source{{12, 34}}, "a"), GlobalVar(Source{{56, 78}}, "g", ty.type_name(Source{{12, 34}}, "a"),
ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -194,7 +194,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_BoolAlias) {
// type t = ptr<storage, a>; // type t = ptr<storage, a>;
Alias("a", ty.bool_()); Alias("a", ty.bool_());
Alias(Source{{56, 78}}, "t", Alias(Source{{56, 78}}, "t",
ty.pointer(ty.type_name(Source{{12, 34}}, "a"), ast::AddressSpace::kStorage)); ty.pointer(ty.type_name(Source{{12, 34}}, "a"), type::AddressSpace::kStorage));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -207,8 +207,8 @@ note: while instantiating ptr<storage, bool, read>)");
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) {
// var<storage> g : ptr<private, f32>; // var<storage> g : ptr<private, f32>;
GlobalVar(Source{{56, 78}}, "g", GlobalVar(Source{{56, 78}}, "g",
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -221,8 +221,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) {
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) {
// type t = ptr<storage, ptr<private, f32>>; // type t = ptr<storage, ptr<private, f32>>;
Alias("t", ty.pointer(Source{{56, 78}}, Alias("t", ty.pointer(Source{{56, 78}},
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
ast::AddressSpace::kStorage)); type::AddressSpace::kStorage));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -234,14 +234,14 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) {
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_IntScalar) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_IntScalar) {
// var<storage> g : i32; // var<storage> g : i32;
GlobalVar("g", ty.i32(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); GlobalVar("g", ty.i32(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_IntScalar) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_IntScalar) {
// type t = ptr<storage, i32; // type t = ptr<storage, i32;
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kStorage)); Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -251,7 +251,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_F16) {
// var<storage> g : f16; // var<storage> g : f16;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("g", ty.f16(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); GlobalVar("g", ty.f16(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -261,7 +261,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_F16) {
// type t = ptr<storage, f16>; // type t = ptr<storage, f16>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Alias("t", ty.pointer(ty.f16(), ast::AddressSpace::kStorage)); Alias("t", ty.pointer(ty.f16(), type::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -273,7 +273,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_F16Alias) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Alias("a", ty.f16()); Alias("a", ty.f16());
GlobalVar("g", ty.type_name("a"), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); GlobalVar("g", ty.type_name("a"), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -285,21 +285,21 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_F16Alias) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Alias("a", ty.f16()); Alias("a", ty.f16());
Alias("t", ty.pointer(ty.type_name("a"), ast::AddressSpace::kStorage)); Alias("t", ty.pointer(ty.type_name("a"), type::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF32) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF32) {
// var<storage> g : vec4<f32>; // var<storage> g : vec4<f32>;
GlobalVar("g", ty.vec4<f32>(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) {
// type t = ptr<storage, vec4<f32>>; // type t = ptr<storage, vec4<f32>>;
Alias("t", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kStorage)); Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -307,7 +307,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) {
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) {
// var<storage> g : vec4<f16>; // var<storage> g : vec4<f16>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("g", ty.vec(ty.f16(), 4u), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); GlobalVar("g", ty.vec(ty.f16(), 4u), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -315,7 +315,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) {
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF16) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF16) {
// type t = ptr<storage, vec4<f16>>; // type t = ptr<storage, vec4<f16>>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Alias("t", ty.pointer(ty.vec(ty.f16(), 4u), ast::AddressSpace::kStorage)); Alias("t", ty.pointer(ty.vec(ty.f16(), 4u), type::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -324,7 +324,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ArrayF32) {
// struct S{ a : f32 }; // struct S{ a : f32 };
// var<storage, read> g : array<S, 3u>; // var<storage, read> g : array<S, 3u>;
Structure("S", utils::Vector{Member("a", ty.f32())}); Structure("S", utils::Vector{Member("a", ty.f32())});
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage, GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage,
ast::Access::kRead, Binding(0_a), Group(0_a)); ast::Access::kRead, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -334,7 +334,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ArrayF32) {
// struct S{ a : f32 }; // struct S{ a : f32 };
// type t = ptr<storage, array<S, 3u>>; // type t = ptr<storage, array<S, 3u>>;
Structure("S", utils::Vector{Member("a", ty.f32())}); Structure("S", utils::Vector{Member("a", ty.f32())});
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage)); Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -346,7 +346,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ArrayF16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16())}); Structure("S", utils::Vector{Member("a", ty.f16())});
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage, GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage,
ast::Access::kRead, Binding(0_a), Group(0_a)); ast::Access::kRead, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -359,7 +359,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ArrayF16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16())}); Structure("S", utils::Vector{Member("a", ty.f16())});
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage, Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage,
ast::Access::kRead)); ast::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -369,8 +369,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructI32) {
// struct S { x : i32 }; // struct S { x : i32 };
// var<storage, read> g : S; // var<storage, read> g : S;
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), GlobalVar("g", ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -379,7 +379,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructI32) {
// struct S { x : i32 }; // struct S { x : i32 };
// type t = ptr<storage, read, S>; // type t = ptr<storage, read, S>;
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead)); Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -391,7 +391,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructI32Alias
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
Alias("a2", ty.type_name("a1")); Alias("a2", ty.type_name("a1"));
GlobalVar("g", ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar("g", ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -404,7 +404,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructI32Aliases
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
Alias("a2", ty.type_name("a1")); Alias("a2", ty.type_name("a1"));
Alias("t", ty.pointer(ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead)); Alias("t", ty.pointer(ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -415,8 +415,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructF16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), GlobalVar("g", ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -427,7 +427,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructF16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead)); Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -441,7 +441,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructF16Alias
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
Alias("a2", ty.type_name("a1")); Alias("a2", ty.type_name("a1"));
GlobalVar("g", ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar("g", ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -456,14 +456,14 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructF16Aliases
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
Alias("a2", ty.type_name("a1")); Alias("a2", ty.type_name("a1"));
Alias("g", ty.pointer(ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead)); Alias("g", ty.pointer(ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode) {
// var<private, read> g : a; // var<private, read> g : a;
GlobalVar(Source{{12, 34}}, "g", ty.i32(), ast::AddressSpace::kPrivate, ast::Access::kRead); GlobalVar(Source{{12, 34}}, "g", ty.i32(), type::AddressSpace::kPrivate, ast::Access::kRead);
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -475,7 +475,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode)
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) {
// type t = ptr<private, read, a>; // type t = ptr<private, read, a>;
Alias("t", Alias("t",
ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kPrivate, ast::Access::kRead)); ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kPrivate, ast::Access::kRead));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -486,7 +486,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) {
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode) {
// @group(0) @binding(0) var<storage, read> a : i32; // @group(0) @binding(0) var<storage, read> a : i32;
GlobalVar("a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), GlobalVar("a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead, Group(0_a),
Binding(0_a)); Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -494,14 +494,14 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadAccessMode) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadAccessMode) {
// type t = ptr<storage, read, i32>; // type t = ptr<storage, read, i32>;
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead)); Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAccessMode) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAccessMode) {
// @group(0) @binding(0) var<storage, read_write> a : i32; // @group(0) @binding(0) var<storage, read_write> a : i32;
GlobalVar("a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), GlobalVar("a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a),
Binding(0_a)); Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -509,14 +509,14 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAcces
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadWriteAccessMode) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadWriteAccessMode) {
// type t = ptr<storage, read_write, i32>; // type t = ptr<storage, read_write, i32>;
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kStorage, ast::Access::kReadWrite)); Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage, ast::Access::kReadWrite));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMode) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMode) {
// @group(0) @binding(0) var<storage, read_write> a : i32; // @group(0) @binding(0) var<storage, read_write> a : i32;
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kWrite, GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kWrite,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -527,8 +527,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMod
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_WriteAccessMode) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_WriteAccessMode) {
// type t = ptr<storage, read_write, i32>; // type t = ptr<storage, read_write, i32>;
Alias("t", Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kStorage,
ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kStorage, ast::Access::kWrite)); ast::Access::kWrite));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -543,7 +543,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBuffer_Struct_R
Structure("S", Structure("S",
utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))}); utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))});
GlobalVar(Source{{90, 12}}, "svar", ty.type_name("S"), ast::AddressSpace::kUniform, GlobalVar(Source{{90, 12}}, "svar", ty.type_name("S"), type::AddressSpace::kUniform,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -560,7 +560,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBuffer_Struct_Run
Structure("S", Structure("S",
utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))}); utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))});
Alias("t", ty.pointer(Source{{90, 12}}, ty.type_name("S"), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(Source{{90, 12}}, ty.type_name("S"), type::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -575,7 +575,7 @@ note: see layout of struct:
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) {
// var<uniform> g : bool; // var<uniform> g : bool;
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), ast::AddressSpace::kUniform, GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kUniform,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -589,7 +589,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) {
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBool) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBool) {
// type t = ptr<uniform, bool>; // type t = ptr<uniform, bool>;
Alias("t", Alias("t",
ty.pointer(Source{{56, 78}}, ty.bool_(Source{{12, 34}}), ast::AddressSpace::kUniform)); ty.pointer(Source{{56, 78}}, ty.bool_(Source{{12, 34}}), type::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -604,7 +604,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBoolAlias
// var<uniform> g : a; // var<uniform> g : a;
Alias("a", ty.bool_()); Alias("a", ty.bool_());
GlobalVar(Source{{56, 78}}, "g", ty.type_name(Source{{12, 34}}, "a"), GlobalVar(Source{{56, 78}}, "g", ty.type_name(Source{{12, 34}}, "a"),
ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -619,7 +619,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBoolAlias)
// type t = ptr<uniform, a>; // type t = ptr<uniform, a>;
Alias("a", ty.bool_()); Alias("a", ty.bool_());
Alias("t", ty.pointer(Source{{56, 78}}, ty.type_name(Source{{12, 34}}, "a"), Alias("t", ty.pointer(Source{{56, 78}}, ty.type_name(Source{{12, 34}}, "a"),
ast::AddressSpace::kUniform)); type::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -632,8 +632,8 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBoolAlias)
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) {
// var<uniform> g : ptr<private, f32>; // var<uniform> g : ptr<private, f32>;
GlobalVar(Source{{56, 78}}, "g", GlobalVar(Source{{56, 78}}, "g",
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -646,8 +646,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) {
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) {
// type t = ptr<uniform, ptr<private, f32>>; // type t = ptr<uniform, ptr<private, f32>>;
Alias("t", ty.pointer(Source{{56, 78}}, Alias("t", ty.pointer(Source{{56, 78}},
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
ast::AddressSpace::kUniform)); type::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -659,7 +659,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) {
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar) {
// var<uniform> g : i32; // var<uniform> g : i32;
GlobalVar(Source{{56, 78}}, "g", ty.i32(), ast::AddressSpace::kUniform, Binding(0_a), GlobalVar(Source{{56, 78}}, "g", ty.i32(), type::AddressSpace::kUniform, Binding(0_a),
Group(0_a)); Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -667,7 +667,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferIntScalar) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferIntScalar) {
// type t = ptr<uniform, i32>; // type t = ptr<uniform, i32>;
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -677,7 +677,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferF16) {
// var<uniform> g : f16; // var<uniform> g : f16;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("g", ty.f16(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.f16(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -687,21 +687,21 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferF16) {
// type t = ptr<uniform, f16>; // type t = ptr<uniform, f16>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Alias("t", ty.pointer(ty.f16(), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.f16(), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF32) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF32) {
// var<uniform> g : vec4<f32>; // var<uniform> g : vec4<f32>;
GlobalVar("g", ty.vec4<f32>(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF32) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF32) {
// type t = ptr<uniform, vec4<f32>>; // type t = ptr<uniform, vec4<f32>>;
Alias("t", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -711,7 +711,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF16
// var<uniform> g : vec4<f16>; // var<uniform> g : vec4<f16>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("g", ty.vec4<f16>(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -721,7 +721,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF16)
// type t = ptr<uniform, vec4<f16>>; // type t = ptr<uniform, vec4<f16>>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Alias("t", ty.pointer(ty.vec4<f16>(), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.vec4<f16>(), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -732,7 +732,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferArrayF32)
// } // }
// var<uniform> g : array<S, 3u>; // var<uniform> g : array<S, 3u>;
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})}); Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})});
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform, Binding(0_a), GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform, Binding(0_a),
Group(0_a)); Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -744,7 +744,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferArrayF32) {
// } // }
// type t = ptr<uniform, array<S, 3u>>; // type t = ptr<uniform, array<S, 3u>>;
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})}); Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})});
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -758,7 +758,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferArrayF16)
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})}); Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})});
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform, Binding(0_a), GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform, Binding(0_a),
Group(0_a)); Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -773,7 +773,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferArrayF16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})}); Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})});
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -782,7 +782,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructI32
// struct S { x : i32 }; // struct S { x : i32 };
// var<uniform> g : S; // var<uniform> g : S;
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.type_name("S"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -791,7 +791,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructI32)
// struct S { x : i32 }; // struct S { x : i32 };
// type t = ptr<uniform, S>; // type t = ptr<uniform, S>;
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -802,7 +802,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructI32
// var<uniform> g : a1; // var<uniform> g : a1;
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
GlobalVar("g", ty.type_name("a1"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.type_name("a1"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -813,7 +813,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructI32Al
// type t = ptr<uniform, a1>; // type t = ptr<uniform, a1>;
Structure("S", utils::Vector{Member("x", ty.i32())}); Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
Alias("t", ty.pointer(ty.type_name("a1"), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.type_name("a1"), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -825,7 +825,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructF16
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.type_name("S"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -837,7 +837,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructF16)
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -851,7 +851,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructF16
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
GlobalVar("g", ty.type_name("a1"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("g", ty.type_name("a1"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -865,7 +865,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructF16Al
Structure("S", utils::Vector{Member("x", ty.f16())}); Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty.type_name("S")); Alias("a1", ty.type_name("S"));
Alias("t", ty.pointer(ty.type_name("a1"), ast::AddressSpace::kUniform)); Alias("t", ty.pointer(ty.type_name("a1"), type::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -874,7 +874,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantBool) {
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// var<push_constant> g : bool; // var<push_constant> g : bool;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), ast::AddressSpace::kPushConstant); GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -888,7 +888,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantBool) {
// type t = ptr<push_constant, bool>; // type t = ptr<push_constant, bool>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Alias(Source{{56, 78}}, "t", Alias(Source{{56, 78}}, "t",
ty.pointer(ty.bool_(Source{{12, 34}}), ast::AddressSpace::kPushConstant)); ty.pointer(ty.bool_(Source{{12, 34}}), type::AddressSpace::kPushConstant));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -903,7 +903,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantF16) {
// var<push_constant> g : f16; // var<push_constant> g : f16;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar("g", ty.f16(Source{{56, 78}}), ast::AddressSpace::kPushConstant); GlobalVar("g", ty.f16(Source{{56, 78}}), type::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -916,7 +916,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantF16) {
// type t = ptr<push_constant, f16>; // type t = ptr<push_constant, f16>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Alias("t", ty.pointer(ty.f16(Source{{56, 78}}), ast::AddressSpace::kPushConstant)); Alias("t", ty.pointer(ty.f16(Source{{56, 78}}), type::AddressSpace::kPushConstant));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -928,8 +928,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantPointer) {
// var<push_constant> g : ptr<private, f32>; // var<push_constant> g : ptr<private, f32>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar(Source{{56, 78}}, "g", GlobalVar(Source{{56, 78}}, "g",
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
ast::AddressSpace::kPushConstant); type::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -943,8 +943,8 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantPointer) {
// type t = ptr<push_constant, ptr<private, f32>>; // type t = ptr<push_constant, ptr<private, f32>>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Alias(Source{{56, 78}}, "t", Alias(Source{{56, 78}}, "t",
ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
ast::AddressSpace::kPushConstant)); type::AddressSpace::kPushConstant));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
@ -957,7 +957,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantIntScalar)
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// var<push_constant> g : i32; // var<push_constant> g : i32;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar("g", ty.i32(), ast::AddressSpace::kPushConstant); GlobalVar("g", ty.i32(), type::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -966,7 +966,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantIntScalar) {
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// type t = ptr<push_constant, i32>; // type t = ptr<push_constant, i32>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kPushConstant)); Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kPushConstant));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -975,7 +975,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantVectorF32)
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// var<push_constant> g : vec4<f32>; // var<push_constant> g : vec4<f32>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar("g", ty.vec4<f32>(), ast::AddressSpace::kPushConstant); GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -984,7 +984,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantVectorF32) {
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// var<push_constant> g : vec4<f32>; // var<push_constant> g : vec4<f32>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Alias("t", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kPushConstant)); Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kPushConstant));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -995,7 +995,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantArrayF32)
// var<push_constant> g : array<S, 3u>; // var<push_constant> g : array<S, 3u>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Structure("S", utils::Vector{Member("a", ty.f32())}); Structure("S", utils::Vector{Member("a", ty.f32())});
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kPushConstant); GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }
@ -1006,7 +1006,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantArrayF32) {
// type t = ptr<push_constant, array<S, 3u>>; // type t = ptr<push_constant, array<S, 3u>>;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
Structure("S", utils::Vector{Member("a", ty.f32())}); Structure("S", utils::Vector{Member("a", ty.f32())});
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kPushConstant)); Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kPushConstant));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
} }

78
src/tint/resolver/alias_analysis_test.cc
View File

@ -35,19 +35,19 @@ struct ResolverAliasAnalysisTest : public resolver::TestHelper, public testing::
// target(&v1, aliased ? &v1 : &v2); // target(&v1, aliased ? &v1 : &v2);
// } // }
struct TwoPointerConfig { struct TwoPointerConfig {
ast::AddressSpace address_space; // The address space for the pointers. type::AddressSpace address_space; // The address space for the pointers.
bool aliased; // Whether the pointers alias or not. bool aliased; // Whether the pointers alias or not.
}; };
class TwoPointers : public ResolverTestWithParam<TwoPointerConfig> { class TwoPointers : public ResolverTestWithParam<TwoPointerConfig> {
protected: protected:
void SetUp() override { void SetUp() override {
utils::Vector<const ast::Statement*, 4> body; utils::Vector<const ast::Statement*, 4> body;
if (GetParam().address_space == ast::AddressSpace::kFunction) { if (GetParam().address_space == type::AddressSpace::kFunction) {
body.Push(Decl(Var("v1", ty.i32()))); body.Push(Decl(Var("v1", ty.i32())));
body.Push(Decl(Var("v2", ty.i32()))); body.Push(Decl(Var("v2", ty.i32())));
} else { } else {
GlobalVar("v1", ast::AddressSpace::kPrivate, ty.i32()); GlobalVar("v1", type::AddressSpace::kPrivate, ty.i32());
GlobalVar("v2", ast::AddressSpace::kPrivate, ty.i32()); GlobalVar("v2", type::AddressSpace::kPrivate, ty.i32());
} }
body.Push(CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"), body.Push(CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"),
AddressOf(Source{{56, 78}}, GetParam().aliased ? "v1" : "v2")))); AddressOf(Source{{56, 78}}, GetParam().aliased ? "v1" : "v2"))));
@ -190,10 +190,10 @@ TEST_P(TwoPointers, ReadWriteAcrossDifferentFunctions) {
INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest,
TwoPointers, TwoPointers,
::testing::Values(TwoPointerConfig{ast::AddressSpace::kFunction, false}, ::testing::Values(TwoPointerConfig{type::AddressSpace::kFunction, false},
TwoPointerConfig{ast::AddressSpace::kFunction, true}, TwoPointerConfig{type::AddressSpace::kFunction, true},
TwoPointerConfig{ast::AddressSpace::kPrivate, false}, TwoPointerConfig{type::AddressSpace::kPrivate, false},
TwoPointerConfig{ast::AddressSpace::kPrivate, true}), TwoPointerConfig{type::AddressSpace::kPrivate, true}),
[](const ::testing::TestParamInfo<TwoPointers::ParamType>& p) { [](const ::testing::TestParamInfo<TwoPointers::ParamType>& p) {
std::stringstream ss; std::stringstream ss;
ss << (p.param.aliased ? "Aliased" : "Unaliased") << "_" ss << (p.param.aliased ? "Aliased" : "Unaliased") << "_"
@ -214,8 +214,8 @@ INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest,
class OnePointerOneModuleScope : public ResolverTestWithParam<bool> { class OnePointerOneModuleScope : public ResolverTestWithParam<bool> {
protected: protected:
void SetUp() override { void SetUp() override {
GlobalVar("global_1", ast::AddressSpace::kPrivate, ty.i32()); GlobalVar("global_1", type::AddressSpace::kPrivate, ty.i32());
GlobalVar("global_2", ast::AddressSpace::kPrivate, ty.i32()); GlobalVar("global_2", type::AddressSpace::kPrivate, ty.i32());
Func("caller", utils::Empty, ty.void_(), Func("caller", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
CallStmt(Call("target", CallStmt(Call("target",
@ -226,7 +226,7 @@ class OnePointerOneModuleScope : public ResolverTestWithParam<bool> {
void Run(utils::Vector<const ast::Statement*, 4>&& body, const char* err = nullptr) { void Run(utils::Vector<const ast::Statement*, 4>&& body, const char* err = nullptr) {
Func("target", Func("target",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), std::move(body)); ty.void_(), std::move(body));
if (GetParam() && err) { if (GetParam() && err) {
@ -295,7 +295,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) {
// f1(p1); // f1(p1);
Func("f2", Func("f2",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -303,7 +303,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) {
}); });
Func("f1", Func("f1",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -330,7 +330,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) {
// f1(p1); // f1(p1);
Func("f2", Func("f2",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -339,7 +339,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) {
}); });
Func("f1", Func("f1",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -365,7 +365,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) {
// f1(p1); // f1(p1);
Func("f2", Func("f2",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -373,7 +373,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) {
}); });
Func("f1", Func("f1",
utils::Vector<const ast::Parameter*, 4>{ utils::Vector<const ast::Parameter*, 4>{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -400,7 +400,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) {
// f1(p1); // f1(p1);
Func("f2", Func("f2",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -409,7 +409,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) {
}); });
Func("f1", Func("f1",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -435,7 +435,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteAcrossDifferentFunctions) {
// f2(); // f2();
Func("f1", Func("f1",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -487,8 +487,8 @@ class Use : public ResolverTestWithParam<bool> {
void Run(const ast::Statement* stmt, const char* err = nullptr) { void Run(const ast::Statement* stmt, const char* err = nullptr) {
Func("target", Func("target",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p1", ty.pointer<i32>(type::AddressSpace::kFunction)),
Param("p2", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p2", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -531,7 +531,7 @@ TEST_P(Use, Write_CompoundAssignment_LHS) {
TEST_P(Use, Read_CompoundAssignment_RHS) { TEST_P(Use, Read_CompoundAssignment_RHS) {
// var<private> global : i32; // var<private> global : i32;
// global += *p2; // global += *p2;
GlobalVar("global", ast::AddressSpace::kPrivate, ty.i32()); GlobalVar("global", type::AddressSpace::kPrivate, ty.i32());
Run(CompoundAssign("global", Deref("p2"), ast::BinaryOp::kAdd), Run(CompoundAssign("global", Deref("p2"), ast::BinaryOp::kAdd),
R"(56:78 warning: invalid aliased pointer argument R"(56:78 warning: invalid aliased pointer argument
12:34 note: aliases with another argument passed here)"); 12:34 note: aliases with another argument passed here)");
@ -578,7 +578,7 @@ TEST_P(Use, Read_Convert) {
TEST_P(Use, Read_IndexAccessor) { TEST_P(Use, Read_IndexAccessor) {
// var<private> data : array<f32, 4>; // var<private> data : array<f32, 4>;
// _ = data[*p2]; // _ = data[*p2];
GlobalVar("data", ast::AddressSpace::kPrivate, ty.array<f32, 4>()); GlobalVar("data", type::AddressSpace::kPrivate, ty.array<f32, 4>());
Run(Assign(Phony(), IndexAccessor("data", Deref("p2"))), Run(Assign(Phony(), IndexAccessor("data", Deref("p2"))),
R"(56:78 warning: invalid aliased pointer argument R"(56:78 warning: invalid aliased pointer argument
12:34 note: aliases with another argument passed here)"); 12:34 note: aliases with another argument passed here)");
@ -592,7 +592,7 @@ TEST_P(Use, Read_LetInitializer) {
TEST_P(Use, Read_VarInitializer) { TEST_P(Use, Read_VarInitializer) {
// var x = *p2; // var x = *p2;
Run(Decl(Var("x", ast::AddressSpace::kFunction, Deref("p2"))), Run(Decl(Var("x", type::AddressSpace::kFunction, Deref("p2"))),
R"(56:78 warning: invalid aliased pointer argument R"(56:78 warning: invalid aliased pointer argument
12:34 note: aliases with another argument passed here)"); 12:34 note: aliases with another argument passed here)");
} }
@ -602,7 +602,7 @@ TEST_P(Use, Read_ReturnValue) {
// foo(p2); // foo(p2);
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.i32(), ty.i32(),
utils::Vector{ utils::Vector{
@ -659,8 +659,8 @@ class UseBool : public ResolverTestWithParam<bool> {
void Run(const ast::Statement* stmt, const char* err = nullptr) { void Run(const ast::Statement* stmt, const char* err = nullptr) {
Func("target", Func("target",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer<bool>(ast::AddressSpace::kFunction)), Param("p1", ty.pointer<bool>(type::AddressSpace::kFunction)),
Param("p2", ty.pointer<bool>(ast::AddressSpace::kFunction)), Param("p2", ty.pointer<bool>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -724,8 +724,8 @@ TEST_F(ResolverAliasAnalysisTest, NoAccess_MemberAccessor) {
Structure("S", utils::Vector{Member("a", ty.i32())}); Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2", Func("f2",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), Param("p1", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
Param("p2", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), Param("p2", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -753,8 +753,8 @@ TEST_F(ResolverAliasAnalysisTest, Read_MemberAccessor) {
Structure("S", utils::Vector{Member("a", ty.i32())}); Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2", Func("f2",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), Param("p1", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
Param("p2", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), Param("p2", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -785,8 +785,8 @@ TEST_F(ResolverAliasAnalysisTest, Write_MemberAccessor) {
Structure("S", utils::Vector{Member("a", ty.i32())}); Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2", Func("f2",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), Param("p1", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
Param("p2", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), Param("p2", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -816,8 +816,8 @@ TEST_F(ResolverAliasAnalysisTest, Read_MultiComponentSwizzle) {
Structure("S", utils::Vector{Member("a", ty.i32())}); Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2", Func("f2",
utils::Vector{ utils::Vector{
Param("p1", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)), Param("p1", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction)),
Param("p2", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)), Param("p2", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -848,7 +848,7 @@ TEST_F(ResolverAliasAnalysisTest, SinglePointerReadWrite) {
// } // }
Func("f1", Func("f1",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -901,7 +901,7 @@ TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) {
// } // }
Func("f2", Func("f2",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -909,7 +909,7 @@ TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) {
}); });
Func("f3", Func("f3",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{

28
src/tint/resolver/array_accessor_test.cc
View File

@ -27,7 +27,7 @@ namespace {
using ResolverIndexAccessorTest = ResolverTest; using ResolverIndexAccessorTest = ResolverTest;
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) { TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) {
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1_f)); auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1_f));
WrapInFunction(acc); WrapInFunction(acc);
@ -36,7 +36,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) {
} }
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) { TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) {
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
auto* idx = Var("idx", ty.i32(), Construct(ty.i32())); auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
auto* acc = IndexAccessor("my_var", idx); auto* acc = IndexAccessor("my_var", idx);
WrapInFunction(Decl(idx), acc); WrapInFunction(Decl(idx), acc);
@ -50,7 +50,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) {
} }
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) { TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) {
GlobalVar("my_var", ty.mat4x4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.mat4x4<f32>(), type::AddressSpace::kPrivate);
auto* idx = Var("idx", ty.u32(), Expr(3_u)); auto* idx = Var("idx", ty.u32(), Expr(3_u));
auto* idy = Var("idy", ty.u32(), Expr(2_u)); auto* idy = Var("idy", ty.u32(), Expr(2_u));
auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy); auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy);
@ -100,7 +100,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_BothDimension_Dynamic) {
} }
TEST_F(ResolverIndexAccessorTest, Matrix) { TEST_F(ResolverIndexAccessorTest, Matrix) {
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 1_i); auto* acc = IndexAccessor("my_var", 1_i);
WrapInFunction(acc); WrapInFunction(acc);
@ -118,7 +118,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix) {
} }
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) { TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor(IndexAccessor("my_var", 0_i), 1_i); auto* acc = IndexAccessor(IndexAccessor("my_var", 0_i), 1_i);
WrapInFunction(acc); WrapInFunction(acc);
@ -135,7 +135,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
} }
TEST_F(ResolverIndexAccessorTest, Vector_F32) { TEST_F(ResolverIndexAccessorTest, Vector_F32) {
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2_f)); auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2_f));
WrapInFunction(acc); WrapInFunction(acc);
@ -144,7 +144,7 @@ TEST_F(ResolverIndexAccessorTest, Vector_F32) {
} }
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) { TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) {
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
auto* idx = Var("idx", ty.i32(), Expr(2_i)); auto* idx = Var("idx", ty.i32(), Expr(2_i));
auto* acc = IndexAccessor("my_var", idx); auto* acc = IndexAccessor("my_var", idx);
WrapInFunction(Decl(idx), acc); WrapInFunction(Decl(idx), acc);
@ -167,7 +167,7 @@ TEST_F(ResolverIndexAccessorTest, Vector_Dynamic) {
} }
TEST_F(ResolverIndexAccessorTest, Vector) { TEST_F(ResolverIndexAccessorTest, Vector) {
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_i); auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc); WrapInFunction(acc);
@ -184,7 +184,7 @@ TEST_F(ResolverIndexAccessorTest, Vector) {
} }
TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) { TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) {
GlobalVar("my_var", ty.array<f32, 3>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_i); auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc); WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -197,7 +197,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) {
} }
TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) { TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) {
GlobalVar("my_var", ty.array<f32, 3>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_u); auto* acc = IndexAccessor("my_var", 2_u);
WrapInFunction(acc); WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -210,7 +210,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) {
} }
TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) { TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) {
GlobalVar("my_var", ty.array<f32, 3>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_a); auto* acc = IndexAccessor("my_var", 2_a);
WrapInFunction(acc); WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -225,7 +225,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) {
TEST_F(ResolverIndexAccessorTest, Alias_Array) { TEST_F(ResolverIndexAccessorTest, Alias_Array) {
auto* aary = Alias("myarrty", ty.array<f32, 3>()); auto* aary = Alias("myarrty", ty.array<f32, 3>());
GlobalVar("my_var", ty.Of(aary), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.Of(aary), type::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_i); auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc); WrapInFunction(acc);
@ -316,7 +316,7 @@ TEST_F(ResolverIndexAccessorTest, Expr_Deref_FuncGoodParent) {
// let x: f32 = (*p)[idx]; // let x: f32 = (*p)[idx];
// return x; // return x;
// } // }
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)); auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
auto* idx = Let("idx", ty.u32(), Construct(ty.u32())); auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
auto* star_p = Deref(p); auto* star_p = Deref(p);
auto* acc = IndexAccessor(Source{{12, 34}}, star_p, idx); auto* acc = IndexAccessor(Source{{12, 34}}, star_p, idx);
@ -337,7 +337,7 @@ TEST_F(ResolverIndexAccessorTest, Expr_Deref_FuncBadParent) {
// let x: f32 = *p[idx]; // let x: f32 = *p[idx];
// return x; // return x;
// } // }
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)); auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
auto* idx = Let("idx", ty.u32(), Construct(ty.u32())); auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
auto* accessor_expr = IndexAccessor(Source{{12, 34}}, p, idx); auto* accessor_expr = IndexAccessor(Source{{12, 34}}, p, idx);
auto* star_p = Deref(accessor_expr); auto* star_p = Deref(accessor_expr);

24
src/tint/resolver/assignment_validation_test.cc
View File

@ -33,7 +33,7 @@ TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("m", ty.i32()), Member("m", ty.i32()),
}); });
GlobalVar(Source{{12, 34}}, "a", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{12, 34}}, "a", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i)); WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i));
@ -193,7 +193,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
// var a : i32; // var a : i32;
// let b : ptr<function,i32> = &a; // let b : ptr<function,i32> = &a;
// *b = 2i; // *b = 2i;
const auto func = ast::AddressSpace::kFunction; const auto func = type::AddressSpace::kFunction;
WrapInFunction(Var("a", ty.i32(), func, Expr(2_i)), // WrapInFunction(Var("a", ty.i32(), func, Expr(2_i)), //
Let("b", ty.pointer<i32>(func), AddressOf(Expr("a"))), // Let("b", ty.pointer<i32>(func), AddressOf(Expr("a"))), //
Assign(Deref("b"), 2_i)); Assign(Deref("b"), 2_i));
@ -205,7 +205,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignMaterializedThroughPointer_Pass)
// var a : i32; // var a : i32;
// let b : ptr<function,i32> = &a; // let b : ptr<function,i32> = &a;
// *b = 2; // *b = 2;
const auto func = ast::AddressSpace::kFunction; const auto func = type::AddressSpace::kFunction;
auto* var_a = Var("a", ty.i32(), func, Expr(2_i)); auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a"))); auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b, Assign(Deref("b"), 2_a)); WrapInFunction(var_a, var_b, Assign(Deref("b"), 2_a));
@ -252,8 +252,8 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Atomic) {
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("a", ty.atomic(ty.i32())), Member("a", ty.atomic(ty.i32())),
}); });
GlobalVar(Source{{12, 34}}, "v", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage,
Binding(0_a), Group(0_a)); ast::Access::kReadWrite, Binding(0_a), Group(0_a));
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a"))); WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));
@ -269,8 +269,8 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_RuntimeArray) {
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("a", ty.array(ty.f32())), Member("a", ty.array(ty.f32())),
}); });
GlobalVar(Source{{12, 34}}, "v", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage,
Binding(0_a), Group(0_a)); ast::Access::kReadWrite, Binding(0_a), Group(0_a));
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a"))); WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));
@ -289,7 +289,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_NonConstructibleStruct_Fa
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("arr", ty.array<i32>()), Member("arr", ty.array<i32>()),
}); });
GlobalVar("s", ty.Of(s), ast::AddressSpace::kStorage, Group(0_a), Binding(0_a)); GlobalVar("s", ty.Of(s), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s"))); WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s")));
@ -311,7 +311,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("arr", ty.array<i32>()), Member("arr", ty.array<i32>()),
}); });
GlobalVar("s", ty.Of(s), ast::AddressSpace::kStorage, Group(0_a), Binding(0_a)); GlobalVar("s", ty.Of(s), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr"))); WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr")));
@ -364,9 +364,9 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) {
GlobalVar("tex", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a), GlobalVar("tex", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
Binding(0_a)); Binding(0_a));
GlobalVar("smp", ty.sampler(ast::SamplerKind::kSampler), Group(0_a), Binding(1_a)); GlobalVar("smp", ty.sampler(ast::SamplerKind::kSampler), Group(0_a), Binding(1_a));
GlobalVar("u", ty.Of(U), ast::AddressSpace::kUniform, Group(0_a), Binding(2_a)); GlobalVar("u", ty.Of(U), type::AddressSpace::kUniform, Group(0_a), Binding(2_a));
GlobalVar("s", ty.Of(S), ast::AddressSpace::kStorage, Group(0_a), Binding(3_a)); GlobalVar("s", ty.Of(S), type::AddressSpace::kStorage, Group(0_a), Binding(3_a));
GlobalVar("wg", ty.array<f32, 10>(), ast::AddressSpace::kWorkgroup); GlobalVar("wg", ty.array<f32, 10>(), type::AddressSpace::kWorkgroup);
WrapInFunction(Assign(Phony(), 1_i), // WrapInFunction(Assign(Phony(), 1_i), //
Assign(Phony(), 2_u), // Assign(Phony(), 2_u), //

6
src/tint/resolver/atomics_test.cc
View File

@ -27,7 +27,7 @@ using namespace tint::number_suffixes; // NOLINT
struct ResolverAtomicTest : public resolver::TestHelper, public testing::Test {}; struct ResolverAtomicTest : public resolver::TestHelper, public testing::Test {};
TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) { TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) {
auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kWorkgroup); auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(g)->Is<type::Reference>()); ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
@ -37,7 +37,7 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) {
} }
TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) { TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), ast::AddressSpace::kWorkgroup); auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(g)->Is<type::Reference>()); ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
@ -48,7 +48,7 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
TEST_F(ResolverAtomicTest, GlobalStorageStruct) { TEST_F(ResolverAtomicTest, GlobalStorageStruct) {
auto* s = Structure("s", utils::Vector{Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))}); auto* s = Structure("s", utils::Vector{Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))});
auto* g = GlobalVar("g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, auto* g = GlobalVar("g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();

36
src/tint/resolver/atomics_validation_test.cc
View File

@ -27,13 +27,13 @@ namespace {
struct ResolverAtomicValidationTest : public resolver::TestHelper, public testing::Test {}; struct ResolverAtomicValidationTest : public resolver::TestHelper, public testing::Test {};
TEST_F(ResolverAtomicValidationTest, AddressSpace_WorkGroup) { TEST_F(ResolverAtomicValidationTest, AddressSpace_WorkGroup) {
GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kWorkgroup); GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()); EXPECT_TRUE(r()->Resolve());
} }
TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) { TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) {
GlobalVar("g", ty.atomic(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kStorage, GlobalVar("g", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kStorage,
ast::Access::kReadWrite, Group(0_a), Binding(0_a)); ast::Access::kReadWrite, Group(0_a), Binding(0_a));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -41,21 +41,21 @@ TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) {
TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage_Struct) { TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage_Struct) {
auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))}); auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))});
GlobalVar("g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), GlobalVar("g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a),
Binding(0_a)); Binding(0_a));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverAtomicValidationTest, InvalidType) { TEST_F(ResolverAtomicValidationTest, InvalidType) {
GlobalVar("a", ty.atomic(ty.f32(Source{{12, 34}})), ast::AddressSpace::kWorkgroup); GlobalVar("a", ty.atomic(ty.f32(Source{{12, 34}})), type::AddressSpace::kWorkgroup);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: atomic only supports i32 or u32 types"); EXPECT_EQ(r()->error(), "12:34 error: atomic only supports i32 or u32 types");
} }
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Simple) { TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Simple) {
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -63,7 +63,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Simple) {
} }
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) { TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) {
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -72,7 +72,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) {
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Struct) { TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Struct) {
auto* s = Structure("s", utils::Vector{Member("a", ty.atomic(ty.i32()))}); auto* s = Structure("s", utils::Vector{Member("a", ty.atomic(ty.i32()))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -88,7 +88,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_StructOfStruct) {
auto* Inner = auto* Inner =
Structure("Inner", utils::Vector{Member("m", ty.atomic(Source{{12, 34}}, ty.i32()))}); Structure("Inner", utils::Vector{Member("m", ty.atomic(Source{{12, 34}}, ty.i32()))});
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))}); auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -104,7 +104,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_StructOfStructOfArray)
auto* Inner = auto* Inner =
Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))}); Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))}); auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -118,7 +118,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfArray) {
auto* atomic_array = auto* atomic_array =
Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32())); Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32()));
GlobalVar(Source{{56, 78}}, "v", ty.Of(atomic_array), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "v", ty.Of(atomic_array), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -132,7 +132,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfStruct) {
// var<private> v: array<S, 5u>; // var<private> v: array<S, 5u>;
auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic<u32>())}); auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic<u32>())});
GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -149,7 +149,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfStructOfArray) {
auto* atomic_array = Alias("AtomicArray", ty.atomic(ty.i32())); auto* atomic_array = Alias("AtomicArray", ty.atomic(ty.i32()));
auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.Of(atomic_array))}); auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.Of(atomic_array))});
GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -188,7 +188,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Complex) {
auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))}); auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))});
auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))}); auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))});
auto* s0 = Structure("S0", utils::Vector{Member("x", ty.Of(s1))}); auto* s0 = Structure("S0", utils::Vector{Member("x", ty.Of(s1))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(s0), ast::AddressSpace::kPrivate); GlobalVar(Source{{56, 78}}, "g", ty.Of(s0), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -198,7 +198,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Complex) {
TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) { TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) {
auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))}); auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -210,7 +210,7 @@ TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) {
TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Struct) { TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Struct) {
auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))}); auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -228,7 +228,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStruct) {
auto* Inner = auto* Inner =
Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))}); Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))}); auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -246,7 +246,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStructOfArray) {
auto* Inner = auto* Inner =
Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))}); Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))}); auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -287,7 +287,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Complex) {
auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))}); auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))});
auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))}); auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))});
auto* s0 = Structure("S0", utils::Vector{Member("x", ty.Of(s1))}); auto* s0 = Structure("S0", utils::Vector{Member("x", ty.Of(s1))});
GlobalVar(Source{{12, 34}}, "g", ty.Of(s0), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{12, 34}}, "g", ty.Of(s0), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());

20
src/tint/resolver/attribute_validation_test.cc
View File

@ -722,8 +722,8 @@ TEST_F(StructMemberAttributeTest, Align_Attribute_ConstAFloat) {
} }
TEST_F(StructMemberAttributeTest, Align_Attribute_Var) { TEST_F(StructMemberAttributeTest, Align_Attribute_Var) {
GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined, GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate,
Expr(1.23_f)); ast::Access::kUndefined, Expr(1.23_f));
Structure(Source{{6, 4}}, "mystruct", Structure(Source{{6, 4}}, "mystruct",
utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(), utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(),
@ -796,8 +796,8 @@ TEST_F(StructMemberAttributeTest, Size_Attribute_ConstAFloat) {
} }
TEST_F(StructMemberAttributeTest, Size_Attribute_Var) { TEST_F(StructMemberAttributeTest, Size_Attribute_Var) {
GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined, GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate,
Expr(1.23_f)); ast::Access::kUndefined, Expr(1.23_f));
Structure(Source{{6, 4}}, "mystruct", Structure(Source{{6, 4}}, "mystruct",
utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(), utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(),
@ -875,7 +875,7 @@ TEST_P(VariableAttributeTest, IsValid) {
if (IsBindingAttribute(params.kind)) { if (IsBindingAttribute(params.kind)) {
GlobalVar("a", ty.sampler(ast::SamplerKind::kSampler), attrs); GlobalVar("a", ty.sampler(ast::SamplerKind::kSampler), attrs);
} else { } else {
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, attrs); GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, attrs);
} }
if (params.should_pass) { if (params.should_pass) {
@ -1046,7 +1046,7 @@ TEST_P(ArrayStrideTest, All) {
create<ast::StrideAttribute>(Source{{12, 34}}, params.stride), create<ast::StrideAttribute>(Source{{12, 34}}, params.stride),
}); });
GlobalVar("myarray", arr, ast::AddressSpace::kPrivate); GlobalVar("myarray", arr, type::AddressSpace::kPrivate);
if (params.should_pass) { if (params.should_pass) {
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -1129,7 +1129,7 @@ TEST_F(ArrayStrideTest, DuplicateAttribute) {
create<ast::StrideAttribute>(Source{{56, 78}}, 4u), create<ast::StrideAttribute>(Source{{56, 78}}, 4u),
}); });
GlobalVar("myarray", arr, ast::AddressSpace::kPrivate); GlobalVar("myarray", arr, type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -1148,7 +1148,7 @@ TEST_F(ResourceAttributeTest, UniformBufferMissingBinding) {
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("x", ty.i32()), Member("x", ty.i32()),
}); });
GlobalVar(Source{{12, 34}}, "G", ty.Of(s), ast::AddressSpace::kUniform); GlobalVar(Source{{12, 34}}, "G", ty.Of(s), type::AddressSpace::kUniform);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -1159,7 +1159,7 @@ TEST_F(ResourceAttributeTest, StorageBufferMissingBinding) {
auto* s = Structure("S", utils::Vector{ auto* s = Structure("S", utils::Vector{
Member("x", ty.i32()), Member("x", ty.i32()),
}); });
GlobalVar(Source{{12, 34}}, "G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead); GlobalVar(Source{{12, 34}}, "G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -1245,7 +1245,7 @@ TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByDifferentEntryPoints) {
} }
TEST_F(ResourceAttributeTest, BindingPointOnNonResource) { TEST_F(ResourceAttributeTest, BindingPointOnNonResource) {
GlobalVar(Source{{12, 34}}, "G", ty.f32(), ast::AddressSpace::kPrivate, Binding(1_a), GlobalVar(Source{{12, 34}}, "G", ty.f32(), type::AddressSpace::kPrivate, Binding(1_a),
Group(2_a)); Group(2_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());

50
src/tint/resolver/builtin_test.cc
View File

@ -80,7 +80,7 @@ using ResolverBuiltinTest_BoolMethod = ResolverTestWithParam<std::string>;
TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) { TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) {
auto name = GetParam(); auto name = GetParam();
GlobalVar("my_var", ty.bool_(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.bool_(), type::AddressSpace::kPrivate);
auto* expr = Call(name, "my_var"); auto* expr = Call(name, "my_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -93,7 +93,7 @@ TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) {
TEST_P(ResolverBuiltinTest_BoolMethod, Vector) { TEST_P(ResolverBuiltinTest_BoolMethod, Vector) {
auto name = GetParam(); auto name = GetParam();
GlobalVar("my_var", ty.vec3<bool>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec3<bool>(), type::AddressSpace::kPrivate);
auto* expr = Call(name, "my_var"); auto* expr = Call(name, "my_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -108,9 +108,9 @@ INSTANTIATE_TEST_SUITE_P(ResolverTest,
testing::Values("any", "all")); testing::Values("any", "all"));
TEST_F(ResolverBuiltinTest, Select) { TEST_F(ResolverBuiltinTest, Select) {
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
GlobalVar("bool_var", ty.vec3<bool>(), ast::AddressSpace::kPrivate); GlobalVar("bool_var", ty.vec3<bool>(), type::AddressSpace::kPrivate);
auto* expr = Call("select", "my_var", "my_var", "bool_var"); auto* expr = Call("select", "my_var", "my_var", "bool_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -214,7 +214,7 @@ using ResolverBuiltinArrayTest = ResolverTest;
TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) { TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) {
auto* ary = ty.array<i32>(); auto* ary = ty.array<i32>();
auto* str = Structure("S", utils::Vector{Member("x", ary)}); auto* str = Structure("S", utils::Vector{Member("x", ary)});
GlobalVar("a", ty.Of(str), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), GlobalVar("a", ty.Of(str), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a),
Group(0_a)); Group(0_a));
auto* call = Call("arrayLength", AddressOf(MemberAccessor("a", "x"))); auto* call = Call("arrayLength", AddressOf(MemberAccessor("a", "x")));
@ -227,7 +227,7 @@ TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) {
} }
TEST_F(ResolverBuiltinArrayTest, ArrayLength_Error_ArraySized) { TEST_F(ResolverBuiltinArrayTest, ArrayLength_Error_ArraySized) {
GlobalVar("arr", ty.array<i32, 4>(), ast::AddressSpace::kPrivate); GlobalVar("arr", ty.array<i32, 4>(), type::AddressSpace::kPrivate);
auto* call = Call("arrayLength", AddressOf("arr")); auto* call = Call("arrayLength", AddressOf("arr"));
WrapInFunction(call); WrapInFunction(call);
@ -1070,7 +1070,7 @@ TEST_F(ResolverBuiltinFloatTest, FrexpVector_sig) {
} }
TEST_F(ResolverBuiltinFloatTest, Frexp_Error_FirstParamInt) { TEST_F(ResolverBuiltinFloatTest, Frexp_Error_FirstParamInt) {
GlobalVar("v", ty.i32(), ast::AddressSpace::kWorkgroup); GlobalVar("v", ty.i32(), type::AddressSpace::kWorkgroup);
auto* call = Call("frexp", 1_i, AddressOf("v")); auto* call = Call("frexp", 1_i, AddressOf("v"));
WrapInFunction(call); WrapInFunction(call);
@ -1319,7 +1319,7 @@ TEST_F(ResolverBuiltinFloatTest, ModfVector_f16) {
} }
TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) { TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) {
GlobalVar("whole", ty.f32(), ast::AddressSpace::kWorkgroup); GlobalVar("whole", ty.f32(), type::AddressSpace::kWorkgroup);
auto* call = Call("modf", 1_i, AddressOf("whole")); auto* call = Call("modf", 1_i, AddressOf("whole"));
WrapInFunction(call); WrapInFunction(call);
@ -1335,7 +1335,7 @@ TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) {
} }
TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamIntPtr) { TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamIntPtr) {
GlobalVar("whole", ty.i32(), ast::AddressSpace::kWorkgroup); GlobalVar("whole", ty.i32(), type::AddressSpace::kWorkgroup);
auto* call = Call("modf", 1_f, AddressOf("whole")); auto* call = Call("modf", 1_f, AddressOf("whole"));
WrapInFunction(call); WrapInFunction(call);
@ -1365,7 +1365,7 @@ TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamNotAPointer) {
} }
TEST_F(ResolverBuiltinFloatTest, Modf_Error_VectorSizesDontMatch) { TEST_F(ResolverBuiltinFloatTest, Modf_Error_VectorSizesDontMatch) {
GlobalVar("whole", ty.vec4<f32>(), ast::AddressSpace::kWorkgroup); GlobalVar("whole", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
auto* call = Call("modf", vec2<f32>(1_f, 2_f), AddressOf("whole")); auto* call = Call("modf", vec2<f32>(1_f, 2_f), AddressOf("whole"));
WrapInFunction(call); WrapInFunction(call);
@ -1845,7 +1845,7 @@ INSTANTIATE_TEST_SUITE_P(
namespace matrix_builtin_tests { namespace matrix_builtin_tests {
TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) { TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) {
GlobalVar("var", ty.mat2x2<f32>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat2x2<f32>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1859,7 +1859,7 @@ TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) {
TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) { TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("var", ty.mat2x2<f16>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat2x2<f16>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1871,7 +1871,7 @@ TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) {
} }
TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) { TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) {
GlobalVar("var", ty.mat3x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1885,7 +1885,7 @@ TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) {
TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) { TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("var", ty.mat3x3<f16>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1897,7 +1897,7 @@ TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) {
} }
TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) { TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) {
GlobalVar("var", ty.mat4x4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat4x4<f32>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1911,7 +1911,7 @@ TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) {
TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) { TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("var", ty.mat4x4<f16>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat4x4<f16>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1923,7 +1923,7 @@ TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) {
} }
TEST_F(ResolverBuiltinTest, Determinant_NotSquare) { TEST_F(ResolverBuiltinTest, Determinant_NotSquare) {
GlobalVar("var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1938,7 +1938,7 @@ TEST_F(ResolverBuiltinTest, Determinant_NotSquare) {
} }
TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) { TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) {
GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
auto* call = Call("determinant", "var"); auto* call = Call("determinant", "var");
WrapInFunction(call); WrapInFunction(call);
@ -1958,7 +1958,7 @@ TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) {
namespace vector_builtin_tests { namespace vector_builtin_tests {
TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) { TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) {
GlobalVar("my_var", ty.vec2<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec2<f32>(), type::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var"); auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -1972,7 +1972,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) {
TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) { TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("my_var", ty.vec2<f16>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec2<f16>(), type::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var"); auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -1984,7 +1984,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) {
} }
TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) { TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) {
GlobalVar("my_var", ty.vec3<i32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec3<i32>(), type::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var"); auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -1996,7 +1996,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) {
} }
TEST_F(ResolverBuiltinTest, Dot_Vec4_u32) { TEST_F(ResolverBuiltinTest, Dot_Vec4_u32) {
GlobalVar("my_var", ty.vec4<u32>(), ast::AddressSpace::kPrivate); GlobalVar("my_var", ty.vec4<u32>(), type::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var"); auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr); WrapInFunction(expr);
@ -2031,7 +2031,7 @@ using ResolverBuiltinDerivativeTest = ResolverTestWithParam<std::string>;
TEST_P(ResolverBuiltinDerivativeTest, Scalar) { TEST_P(ResolverBuiltinDerivativeTest, Scalar) {
auto name = GetParam(); auto name = GetParam();
GlobalVar("ident", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.f32(), type::AddressSpace::kPrivate);
auto* expr = Call(name, "ident"); auto* expr = Call(name, "ident");
Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)}, Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
@ -2045,7 +2045,7 @@ TEST_P(ResolverBuiltinDerivativeTest, Scalar) {
TEST_P(ResolverBuiltinDerivativeTest, Vector) { TEST_P(ResolverBuiltinDerivativeTest, Vector) {
auto name = GetParam(); auto name = GetParam();
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* expr = Call(name, "ident"); auto* expr = Call(name, "ident");
Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)}, Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
@ -2141,7 +2141,7 @@ class ResolverBuiltinTest_TextureOperation : public ResolverTestWithParam<Textur
GlobalVar(name, type, Binding(0_a), Group(0_a)); GlobalVar(name, type, Binding(0_a), Group(0_a));
} else { } else {
GlobalVar(name, type, ast::AddressSpace::kPrivate); GlobalVar(name, type, type::AddressSpace::kPrivate);
} }
call_params->Push(Expr(name)); call_params->Push(Expr(name));

16
src/tint/resolver/builtin_validation_test.cc
View File

@ -166,7 +166,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalConstUsedAsType)
} }
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsFunction) { TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsFunction) {
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
WrapInFunction(Call(Expr(Source{{56, 78}}, "mix"), 1_f, 2_f, 3_f)); WrapInFunction(Call(Expr(Source{{56, 78}}, "mix"), 1_f, 2_f, 3_f));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -176,7 +176,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsFunction
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable) { TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable) {
auto* mix = auto* mix =
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
auto* use = Expr("mix"); auto* use = Expr("mix");
WrapInFunction(Decl(Var("v", use))); WrapInFunction(Decl(Var("v", use)));
@ -187,7 +187,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable
} }
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsType) { TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsType) {
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
WrapInFunction(Construct(ty.type_name(Source{{56, 78}}, "mix"))); WrapInFunction(Construct(ty.type_name(Source{{56, 78}}, "mix")));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -481,7 +481,7 @@ TEST_P(BuiltinTextureConstExprArgValidationTest, GlobalVar) {
overload.BuildSamplerVariable(this); overload.BuildSamplerVariable(this);
// Build the module-scope var 'G' with the offset value // Build the module-scope var 'G' with the offset value
GlobalVar("G", expr({}, *this), ast::AddressSpace::kPrivate); GlobalVar("G", expr({}, *this), type::AddressSpace::kPrivate);
auto args = overload.args(this); auto args = overload.args(this);
auto*& arg_to_replace = (param.position == Position::kFirst) ? args.Front() : args.Back(); auto*& arg_to_replace = (param.position == Position::kFirst) ? args.Front() : args.Back();
@ -652,7 +652,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_WrongAddressSpace) {
// fn foo() { // fn foo() {
// workgroupUniformLoad(&v); // workgroupUniformLoad(&v);
// } // }
GlobalVar("v", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kReadWrite, GlobalVar("v", ty.i32(), type::AddressSpace::kStorage, ast::Access::kReadWrite,
utils::Vector{Group(0_a), Binding(0_a)}); utils::Vector{Group(0_a), Binding(0_a)});
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v")))); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
@ -670,7 +670,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_Atomic) {
// fn foo() { // fn foo() {
// workgroupUniformLoad(&v); // workgroupUniformLoad(&v);
// } // }
GlobalVar("v", ty.atomic<i32>(), ast::AddressSpace::kWorkgroup); GlobalVar("v", ty.atomic<i32>(), type::AddressSpace::kWorkgroup);
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v")))); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -684,7 +684,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_AtomicInArray) {
// fn foo() { // fn foo() {
// workgroupUniformLoad(&v); // workgroupUniformLoad(&v);
// } // }
GlobalVar("v", ty.array(ty.atomic<i32>(), 4_a), ast::AddressSpace::kWorkgroup); GlobalVar("v", ty.array(ty.atomic<i32>(), 4_a), type::AddressSpace::kWorkgroup);
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v")))); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -703,7 +703,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_AtomicInStruct) {
Structure("Inner", utils::Vector{Member("a", ty.array(ty.atomic<i32>(), 4_a))}); Structure("Inner", utils::Vector{Member("a", ty.array(ty.atomic<i32>(), 4_a))});
Structure("S", utils::Vector{Member("i", ty.type_name("Inner"))}); Structure("S", utils::Vector{Member("i", ty.type_name("Inner"))});
GlobalVar(Source{{12, 34}}, "v", ty.array(ty.type_name("S"), 4_a), GlobalVar(Source{{12, 34}}, "v", ty.array(ty.type_name("S"), 4_a),
ast::AddressSpace::kWorkgroup); type::AddressSpace::kWorkgroup);
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf("v")))); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf("v"))));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());

2
src/tint/resolver/builtins_validation_test.cc
View File

@ -100,7 +100,7 @@ using ResolverBuiltinsStageTest = ResolverTestWithParam<Params>;
TEST_P(ResolverBuiltinsStageTest, All_input) { TEST_P(ResolverBuiltinsStageTest, All_input) {
const Params& params = GetParam(); const Params& params = GetParam();
auto* p = GlobalVar("p", ty.vec4<f32>(), ast::AddressSpace::kPrivate); auto* p = GlobalVar("p", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* input = Param("input", params.type(*this), auto* input = Param("input", params.type(*this),
utils::Vector{Builtin(Source{{12, 34}}, params.builtin)}); utils::Vector{Builtin(Source{{12, 34}}, params.builtin)});
switch (params.stage) { switch (params.stage) {

44
src/tint/resolver/call_validation_test.cc
View File

@ -103,7 +103,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_VariableIdentExpr) {
// var z: i32 = 1i; // var z: i32 = 1i;
// foo(&z); // foo(&z);
// } // }
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)); auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -120,7 +120,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_LetIdentExpr) {
// let z: i32 = 1i; // let z: i32 = 1i;
// foo(&z); // foo(&z);
// } // }
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)); auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -142,7 +142,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfFunctionMember) {
auto* S = Structure("S", utils::Vector{ auto* S = Structure("S", utils::Vector{
Member("m", ty.i32()), Member("m", ty.i32()),
}); });
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)); auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -169,7 +169,7 @@ TEST_F(ResolverCallValidationTest,
auto* S = Structure("S", utils::Vector{ auto* S = Structure("S", utils::Vector{
Member("m", ty.i32()), Member("m", ty.i32()),
}); });
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)); auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -189,7 +189,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfLetMember) {
auto* S = Structure("S", utils::Vector{ auto* S = Structure("S", utils::Vector{
Member("m", ty.i32()), Member("m", ty.i32()),
}); });
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)); auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -208,12 +208,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParam) {
// } // }
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("bar", Func("bar",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -235,12 +235,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParamWithMain) {
// } // }
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("bar", Func("bar",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -268,13 +268,13 @@ TEST_F(ResolverCallValidationTest, LetPointer) {
// } // }
Func("x", Func("x",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Decl(Var("v", ty.i32())), Decl(Var("v", ty.i32())),
Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), AddressOf("v"))), Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction), AddressOf("v"))),
CallStmt(Call("x", "p")), CallStmt(Call("x", "p")),
}, },
utils::Vector{ utils::Vector{
@ -293,13 +293,13 @@ TEST_F(ResolverCallValidationTest, LetPointerPrivate) {
// } // }
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Param("p", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kPrivate), AddressOf("v"))), Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kPrivate), AddressOf("v"))),
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))), CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
}, },
utils::Vector{ utils::Vector{
@ -318,13 +318,13 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar) {
// } // }
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Decl(Var("v", ty.array<i32, 4>())), Decl(Var("v", ty.array<i32, 4>())),
Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction),
AddressOf(IndexAccessor("v", 0_a)))), AddressOf(IndexAccessor("v", 0_a)))),
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))), CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
}, },
@ -349,13 +349,13 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar_WithFullPtrParametersE
Enable(ast::Extension::kChromiumExperimentalFullPtrParameters); Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Decl(Var("v", ty.array<i32, 4>())), Decl(Var("v", ty.array<i32, 4>())),
Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction),
AddressOf(IndexAccessor("v", 0_a)))), AddressOf(IndexAccessor("v", 0_a)))),
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))), CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
}, },
@ -377,7 +377,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain) {
// } // }
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer(ty.array<i32, 4>(), ast::AddressSpace::kFunction)), Param("p", ty.pointer(ty.array<i32, 4>(), type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
@ -406,7 +406,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar) {
// } // }
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
@ -440,7 +440,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar_WithFullPtrPa
Enable(ast::Extension::kChromiumExperimentalFullPtrParameters); Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
Func("foo", Func("foo",
utils::Vector{ utils::Vector{
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)), Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
}, },
ty.void_(), utils::Empty); ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(), Func("main", utils::Empty, ty.void_(),
@ -462,7 +462,7 @@ TEST_F(ResolverCallValidationTest, CallVariable) {
// fn f() { // fn f() {
// v(); // v();
// } // }
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
Func("f", utils::Empty, ty.void_(), Func("f", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
CallStmt(Call(Source{{12, 34}}, "v")), CallStmt(Call(Source{{12, 34}}, "v")),

6
src/tint/resolver/compound_assignment_validation_test.cc
View File

@ -51,7 +51,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, CompatibleTypesAssignThroughPoi
// var a : i32; // var a : i32;
// let b : ptr<function,i32> = &a; // let b : ptr<function,i32> = &a;
// *b += 2; // *b += 2;
const auto func = ast::AddressSpace::kFunction; const auto func = type::AddressSpace::kFunction;
auto* var_a = Var("a", ty.i32(), func, Expr(2_i)); auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a"))); auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b, WrapInFunction(var_a, var_b,
@ -233,7 +233,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, ReadOnlyBuffer) {
// { // {
// a += 1i; // a += 1i;
// } // }
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1_i, ast::BinaryOp::kAdd)); WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1_i, ast::BinaryOp::kAdd));
@ -264,7 +264,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, LhsLiteral) {
TEST_F(ResolverCompoundAssignmentValidationTest, LhsAtomic) { TEST_F(ResolverCompoundAssignmentValidationTest, LhsAtomic) {
// var<workgroup> a : atomic<i32>; // var<workgroup> a : atomic<i32>;
// a += a; // a += a;
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kWorkgroup); GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", "a", ast::BinaryOp::kAdd)); WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", "a", ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());

2
src/tint/resolver/const_eval_indexing_test.cc
View File

@ -279,7 +279,7 @@ TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index_OOB_Low) {
TEST_F(ResolverConstEvalTest, RuntimeArray_vec3_f32_Index_OOB_Low) { TEST_F(ResolverConstEvalTest, RuntimeArray_vec3_f32_Index_OOB_Low) {
auto* sb = GlobalVar("sb", ty.array(ty.vec3<f32>()), Group(0_a), Binding(0_a), auto* sb = GlobalVar("sb", ty.array(ty.vec3<f32>()), Group(0_a), Binding(0_a),
ast::AddressSpace::kStorage); type::AddressSpace::kStorage);
auto* expr = IndexAccessor(sb, Expr(Source{{12, 34}}, -2_i)); auto* expr = IndexAccessor(sb, Expr(Source{{12, 34}}, -2_i));
WrapInFunction(expr); WrapInFunction(expr);

20
src/tint/resolver/dependency_graph_test.cc
View File

@ -426,7 +426,7 @@ const ast::Node* SymbolTestHelper::Add(SymbolDeclKind kind, Symbol symbol, Sourc
auto& b = *builder; auto& b = *builder;
switch (kind) { switch (kind) {
case SymbolDeclKind::GlobalVar: case SymbolDeclKind::GlobalVar:
return b.GlobalVar(source, symbol, b.ty.i32(), ast::AddressSpace::kPrivate); return b.GlobalVar(source, symbol, b.ty.i32(), type::AddressSpace::kPrivate);
case SymbolDeclKind::GlobalConst: case SymbolDeclKind::GlobalConst:
return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1_i)); return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1_i));
case SymbolDeclKind::Alias: case SymbolDeclKind::Alias:
@ -469,27 +469,27 @@ const ast::Node* SymbolTestHelper::Add(SymbolUseKind kind, Symbol symbol, Source
switch (kind) { switch (kind) {
case SymbolUseKind::GlobalVarType: { case SymbolUseKind::GlobalVarType: {
auto* node = b.ty.type_name(source, symbol); auto* node = b.ty.type_name(source, symbol);
b.GlobalVar(b.Sym(), node, ast::AddressSpace::kPrivate); b.GlobalVar(b.Sym(), node, type::AddressSpace::kPrivate);
return node; return node;
} }
case SymbolUseKind::GlobalVarArrayElemType: { case SymbolUseKind::GlobalVarArrayElemType: {
auto* node = b.ty.type_name(source, symbol); auto* node = b.ty.type_name(source, symbol);
b.GlobalVar(b.Sym(), b.ty.array(node, 4_i), ast::AddressSpace::kPrivate); b.GlobalVar(b.Sym(), b.ty.array(node, 4_i), type::AddressSpace::kPrivate);
return node; return node;
} }
case SymbolUseKind::GlobalVarArraySizeValue: { case SymbolUseKind::GlobalVarArraySizeValue: {
auto* node = b.Expr(source, symbol); auto* node = b.Expr(source, symbol);
b.GlobalVar(b.Sym(), b.ty.array(b.ty.i32(), node), ast::AddressSpace::kPrivate); b.GlobalVar(b.Sym(), b.ty.array(b.ty.i32(), node), type::AddressSpace::kPrivate);
return node; return node;
} }
case SymbolUseKind::GlobalVarVectorElemType: { case SymbolUseKind::GlobalVarVectorElemType: {
auto* node = b.ty.type_name(source, symbol); auto* node = b.ty.type_name(source, symbol);
b.GlobalVar(b.Sym(), b.ty.vec3(node), ast::AddressSpace::kPrivate); b.GlobalVar(b.Sym(), b.ty.vec3(node), type::AddressSpace::kPrivate);
return node; return node;
} }
case SymbolUseKind::GlobalVarMatrixElemType: { case SymbolUseKind::GlobalVarMatrixElemType: {
auto* node = b.ty.type_name(source, symbol); auto* node = b.ty.type_name(source, symbol);
b.GlobalVar(b.Sym(), b.ty.mat3x4(node), ast::AddressSpace::kPrivate); b.GlobalVar(b.Sym(), b.ty.mat3x4(node), type::AddressSpace::kPrivate);
return node; return node;
} }
case SymbolUseKind::GlobalVarSampledTexElemType: { case SymbolUseKind::GlobalVarSampledTexElemType: {
@ -504,7 +504,7 @@ const ast::Node* SymbolTestHelper::Add(SymbolUseKind kind, Symbol symbol, Source
} }
case SymbolUseKind::GlobalVarValue: { case SymbolUseKind::GlobalVarValue: {
auto* node = b.Expr(source, symbol); auto* node = b.Expr(source, symbol);
b.GlobalVar(b.Sym(), b.ty.i32(), ast::AddressSpace::kPrivate, node); b.GlobalVar(b.Sym(), b.ty.i32(), type::AddressSpace::kPrivate, node);
return node; return node;
} }
case SymbolUseKind::GlobalConstType: { case SymbolUseKind::GlobalConstType: {
@ -725,7 +725,7 @@ TEST_F(ResolverDependencyGraphUsedBeforeDeclTest, VarUsed) {
Block(Assign(Expr(Source{{12, 34}}, "G"), 3.14_f)), Block(Assign(Expr(Source{{12, 34}}, "G"), 3.14_f)),
}); });
GlobalVar(Source{{56, 78}}, "G", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f)); GlobalVar(Source{{56, 78}}, "G", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
Build(); Build();
} }
@ -1212,7 +1212,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) {
const auto type_sym = Sym("TYPE"); const auto type_sym = Sym("TYPE");
const auto func_sym = Sym("FUNC"); const auto func_sym = Sym("FUNC");
const auto* value_decl = GlobalVar(value_sym, ty.i32(), ast::AddressSpace::kPrivate); const auto* value_decl = GlobalVar(value_sym, ty.i32(), type::AddressSpace::kPrivate);
const auto* type_decl = Alias(type_sym, ty.i32()); const auto* type_decl = Alias(type_sym, ty.i32());
const auto* func_decl = Func(func_sym, utils::Empty, ty.void_(), utils::Empty); const auto* func_decl = Func(func_sym, utils::Empty, ty.void_(), utils::Empty);
@ -1290,7 +1290,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) {
GlobalVar(Sym(), ty.array(T, V, 4)); GlobalVar(Sym(), ty.array(T, V, 4));
GlobalVar(Sym(), ty.vec3(T)); GlobalVar(Sym(), ty.vec3(T));
GlobalVar(Sym(), ty.mat3x2(T)); GlobalVar(Sym(), ty.mat3x2(T));
GlobalVar(Sym(), ty.pointer(T, ast::AddressSpace::kPrivate)); GlobalVar(Sym(), ty.pointer(T, type::AddressSpace::kPrivate));
GlobalVar(Sym(), ty.sampled_texture(type::TextureDimension::k2d, T)); GlobalVar(Sym(), ty.sampled_texture(type::TextureDimension::k2d, T));
GlobalVar(Sym(), ty.depth_texture(type::TextureDimension::k2d)); GlobalVar(Sym(), ty.depth_texture(type::TextureDimension::k2d));
GlobalVar(Sym(), ty.depth_multisampled_texture(type::TextureDimension::k2d)); GlobalVar(Sym(), ty.depth_multisampled_texture(type::TextureDimension::k2d));

20
src/tint/resolver/entry_point_validation_test.cc
View File

@ -453,14 +453,14 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithEnable) {
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// var<push_constant> a : u32; // var<push_constant> a : u32;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
EXPECT_TRUE(r()->Resolve()); EXPECT_TRUE(r()->Resolve());
} }
TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) { TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) {
// var<push_constant> a : u32; // var<push_constant> a : u32;
GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -470,7 +470,7 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) {
TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithIgnoreAddressSpaceAttribute) { TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithIgnoreAddressSpaceAttribute) {
// var<push_constant> a : u32; // With ast::DisabledValidation::kIgnoreAddressSpace // var<push_constant> a : u32; // With ast::DisabledValidation::kIgnoreAddressSpace
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant, GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant,
utils::Vector{Disable(ast::DisabledValidation::kIgnoreAddressSpace)}); utils::Vector{Disable(ast::DisabledValidation::kIgnoreAddressSpace)});
EXPECT_TRUE(r()->Resolve()); EXPECT_TRUE(r()->Resolve());
@ -483,7 +483,7 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantOneVariableUsedInEntryPoint
// _ = a; // _ = a;
// } // }
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
Func("main", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")}, Func("main", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")},
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),
@ -501,8 +501,8 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantTwoVariablesUsedInEntryPoin
// _ = b; // _ = b;
// } // }
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
GlobalVar(Source{{3, 4}}, "b", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant);
Func(Source{{5, 6}}, "main", {}, ty.void_(), Func(Source{{5, 6}}, "main", {}, ty.void_(),
utils::Vector{Assign(Phony(), "a"), Assign(Phony(), "b")}, utils::Vector{Assign(Phony(), "a"), Assign(Phony(), "b")},
@ -532,8 +532,8 @@ TEST_F(ResolverEntryPointValidationTest,
// uses_b(); // uses_b();
// } // }
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
GlobalVar(Source{{3, 4}}, "b", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant);
Func(Source{{5, 6}}, "uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")}); Func(Source{{5, 6}}, "uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")});
Func(Source{{7, 8}}, "uses_b", {}, ty.void_(), utils::Vector{Assign(Phony(), "b")}); Func(Source{{7, 8}}, "uses_b", {}, ty.void_(), utils::Vector{Assign(Phony(), "b")});
@ -565,8 +565,8 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantTwoVariablesUsedInDifferent
// _ = a; // _ = a;
// } // }
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
GlobalVar("b", ty.u32(), ast::AddressSpace::kPushConstant); GlobalVar("b", ty.u32(), type::AddressSpace::kPushConstant);
Func("uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")}, Func("uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")},
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),

24
src/tint/resolver/f16_extension_test.cc
View File

@ -29,14 +29,14 @@ TEST_F(ResolverF16ExtensionTest, TypeUsedWithExtension) {
// var<private> v : f16; // var<private> v : f16;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("v", ty.f16(), ast::AddressSpace::kPrivate); GlobalVar("v", ty.f16(), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverF16ExtensionTest, TypeUsedWithoutExtension) { TEST_F(ResolverF16ExtensionTest, TypeUsedWithoutExtension) {
// var<private> v : f16; // var<private> v : f16;
GlobalVar("v", ty.f16(Source{{12, 34}}), ast::AddressSpace::kPrivate); GlobalVar("v", ty.f16(Source{{12, 34}}), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@ -47,14 +47,14 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithExtension) {
// var<private> v : vec2<f16>; // var<private> v : vec2<f16>;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("v", ty.vec2<f16>(), ast::AddressSpace::kPrivate); GlobalVar("v", ty.vec2<f16>(), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithoutExtension) { TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithoutExtension) {
// var<private> v : vec2<f16>; // var<private> v : vec2<f16>;
GlobalVar("v", ty.vec2(ty.f16(Source{{12, 34}})), ast::AddressSpace::kPrivate); GlobalVar("v", ty.vec2(ty.f16(Source{{12, 34}})), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@ -65,14 +65,14 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithExtension) {
// var<private> v = vec2<f16>(); // var<private> v = vec2<f16>();
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("v", Construct(ty.vec2<f16>()), ast::AddressSpace::kPrivate); GlobalVar("v", Construct(ty.vec2<f16>()), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithoutExtension) { TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithoutExtension) {
// var<private> v = vec2<f16>(); // var<private> v = vec2<f16>();
GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}}))), ast::AddressSpace::kPrivate); GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}}))), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@ -84,7 +84,7 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithExtension) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("v", Construct(ty.vec2<f16>(), Construct(ty.vec2<f32>())), GlobalVar("v", Construct(ty.vec2<f16>(), Construct(ty.vec2<f32>())),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -92,7 +92,7 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithExtension) {
TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithoutExtension) { TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithoutExtension) {
// var<private> v = vec2<f16>(vec2<f32>()); // var<private> v = vec2<f16>(vec2<f32>());
GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}})), Construct(ty.vec2<f32>())), GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}})), Construct(ty.vec2<f32>())),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@ -103,14 +103,14 @@ TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithExtension) {
// var<private> v = 16h; // var<private> v = 16h;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("v", Expr(16_h), ast::AddressSpace::kPrivate); GlobalVar("v", Expr(16_h), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithoutExtension) { TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithoutExtension) {
// var<private> v = 16h; // var<private> v = 16h;
GlobalVar("v", Expr(Source{{12, 34}}, 16_h), ast::AddressSpace::kPrivate); GlobalVar("v", Expr(Source{{12, 34}}, 16_h), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@ -123,14 +123,14 @@ TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithExtension) {
// var<private> v : vec2h; // var<private> v : vec2h;
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), ast::AddressSpace::kPrivate); GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithoutExtension) { TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithoutExtension) {
// var<private> v : vec2h; // var<private> v : vec2h;
GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), ast::AddressSpace::kPrivate); GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");

34
src/tint/resolver/function_validation_test.cc
View File

@ -39,7 +39,7 @@ TEST_F(ResolverFunctionValidationTest, DuplicateParameterName) {
TEST_F(ResolverFunctionValidationTest, ParameterMayShadowGlobal) { TEST_F(ResolverFunctionValidationTest, ParameterMayShadowGlobal) {
// var<private> common_name : f32; // var<private> common_name : f32;
// fn func(common_name : f32) { } // fn func(common_name : f32) { }
GlobalVar("common_name", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("common_name", ty.f32(), type::AddressSpace::kPrivate);
Func("func", utils::Vector{Param("common_name", ty.f32())}, ty.void_(), utils::Empty); Func("func", utils::Vector{Param("common_name", ty.f32())}, ty.void_(), utils::Empty);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -420,7 +420,7 @@ TEST_F(ResolverFunctionValidationTest, CannotCallFunctionAtModuleScope) {
utils::Vector{ utils::Vector{
Return(1_i), Return(1_i),
}); });
GlobalVar("x", Call(Source{{12, 34}}, "F"), ast::AddressSpace::kPrivate); GlobalVar("x", Call(Source{{12, 34}}, "F"), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(12:34 error: functions cannot be called at module-scope)"); EXPECT_EQ(r()->error(), R"(12:34 error: functions cannot be called at module-scope)");
@ -874,7 +874,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) {
// var<private> x = 64i; // var<private> x = 64i;
// @compute @workgroup_size(x) // @compute @workgroup_size(x)
// fn main() {} // fn main() {}
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(64_i)); GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(64_i));
Func("main", utils::Empty, ty.void_(), utils::Empty, Func("main", utils::Empty, ty.void_(), utils::Empty,
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kCompute), Stage(ast::PipelineStage::kCompute),
@ -890,7 +890,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) {
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) { TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) {
// @compute @workgroup_size(1 << 2 + 4) // @compute @workgroup_size(1 << 2 + 4)
// fn main() {} // fn main() {}
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(0_i)); GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
Func("main", utils::Empty, ty.void_(), utils::Empty, Func("main", utils::Empty, ty.void_(), utils::Empty,
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kCompute), Stage(ast::PipelineStage::kCompute),
@ -906,7 +906,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) {
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) { TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) {
// @compute @workgroup_size(1, 1 << 2 + 4) // @compute @workgroup_size(1, 1 << 2 + 4)
// fn main() {} // fn main() {}
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(0_i)); GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
Func("main", utils::Empty, ty.void_(), utils::Empty, Func("main", utils::Empty, ty.void_(), utils::Empty,
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kCompute), Stage(ast::PipelineStage::kCompute),
@ -922,7 +922,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) {
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) { TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) {
// @compute @workgroup_size(1, 1, 1 << 2 + 4) // @compute @workgroup_size(1, 1, 1 << 2 + 4)
// fn main() {} // fn main() {}
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(0_i)); GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
Func("main", utils::Empty, ty.void_(), utils::Empty, Func("main", utils::Empty, ty.void_(), utils::Empty,
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kCompute), Stage(ast::PipelineStage::kCompute),
@ -936,7 +936,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) {
} }
TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_NonPlain) { TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_NonPlain) {
auto* ret_type = ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kFunction); auto* ret_type = ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kFunction);
Func("f", utils::Empty, ret_type, utils::Empty); Func("f", utils::Empty, ret_type, utils::Empty);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -1050,7 +1050,7 @@ enum class Expectation {
kAlwaysFail, kAlwaysFail,
}; };
struct TestParams { struct TestParams {
ast::AddressSpace address_space; type::AddressSpace address_space;
Expectation expectation; Expectation expectation;
}; };
@ -1094,15 +1094,15 @@ INSTANTIATE_TEST_SUITE_P(
ResolverTest, ResolverTest,
ResolverFunctionParameterValidationTest, ResolverFunctionParameterValidationTest,
testing::Values( testing::Values(
TestParams{ast::AddressSpace::kNone, Expectation::kAlwaysFail}, TestParams{type::AddressSpace::kNone, Expectation::kAlwaysFail},
TestParams{ast::AddressSpace::kIn, Expectation::kAlwaysFail}, TestParams{type::AddressSpace::kIn, Expectation::kAlwaysFail},
TestParams{ast::AddressSpace::kOut, Expectation::kAlwaysFail}, TestParams{type::AddressSpace::kOut, Expectation::kAlwaysFail},
TestParams{ast::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension}, TestParams{type::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension},
TestParams{ast::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension}, TestParams{type::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension},
TestParams{ast::AddressSpace::kHandle, Expectation::kAlwaysFail}, TestParams{type::AddressSpace::kHandle, Expectation::kAlwaysFail},
TestParams{ast::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension}, TestParams{type::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension},
TestParams{ast::AddressSpace::kPrivate, Expectation::kAlwaysPass}, TestParams{type::AddressSpace::kPrivate, Expectation::kAlwaysPass},
TestParams{ast::AddressSpace::kFunction, Expectation::kAlwaysPass})); TestParams{type::AddressSpace::kFunction, Expectation::kAlwaysPass}));
} // namespace } // namespace
} // namespace tint::resolver } // namespace tint::resolver

10
src/tint/resolver/host_shareable_validation_test.cc
View File

@ -29,7 +29,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolMember) {
auto* s = auto* s =
Structure("S", utils::Vector{Member(Source{{56, 78}}, "x", ty.bool_(Source{{12, 34}}))}); Structure("S", utils::Vector{Member(Source{{56, 78}}, "x", ty.bool_(Source{{12, 34}}))});
GlobalVar(Source{{90, 12}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{90, 12}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -45,7 +45,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolVectorMember) {
auto* s = Structure( auto* s = Structure(
"S", utils::Vector{Member(Source{{56, 78}}, "x", ty.vec3<bool>(Source{{12, 34}}))}); "S", utils::Vector{Member(Source{{56, 78}}, "x", ty.vec3<bool>(Source{{12, 34}}))});
GlobalVar(Source{{90, 12}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{90, 12}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -62,7 +62,7 @@ TEST_F(ResolverHostShareableValidationTest, Aliases) {
auto* s = Structure( auto* s = Structure(
"S", utils::Vector{Member(Source{{56, 78}}, "x", ty.type_name(Source{{12, 34}}, "a1"))}); "S", utils::Vector{Member(Source{{56, 78}}, "x", ty.type_name(Source{{12, 34}}, "a1"))});
auto* a2 = Alias("a2", ty.Of(s)); auto* a2 = Alias("a2", ty.Of(s));
GlobalVar(Source{{90, 12}}, "g", ty.Of(a2), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{90, 12}}, "g", ty.Of(a2), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -81,7 +81,7 @@ TEST_F(ResolverHostShareableValidationTest, NestedStructures) {
auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))}); auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))});
GlobalVar(Source{{9, 10}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{9, 10}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -120,7 +120,7 @@ TEST_F(ResolverHostShareableValidationTest, NoError) {
auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))}); auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))});
GlobalVar(Source{{9, 10}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{9, 10}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();

8
src/tint/resolver/increment_decrement_validation_test.cc
View File

@ -64,8 +64,8 @@ TEST_F(ResolverIncrementDecrementValidationTest, ThroughPointer) {
// var a : i32; // var a : i32;
// let b : ptr<function,i32> = &a; // let b : ptr<function,i32> = &a;
// *b++; // *b++;
auto* var_a = Var("a", ty.i32(), ast::AddressSpace::kFunction); auto* var_a = Var("a", ty.i32(), type::AddressSpace::kFunction);
auto* var_b = Let("b", ty.pointer<i32>(ast::AddressSpace::kFunction), AddressOf(Expr("a"))); auto* var_b = Let("b", ty.pointer<i32>(type::AddressSpace::kFunction), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b, Increment(Source{{12, 34}}, Deref("b"))); WrapInFunction(var_a, var_b, Increment(Source{{12, 34}}, Deref("b")));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -127,7 +127,7 @@ TEST_F(ResolverIncrementDecrementValidationTest, Vector) {
TEST_F(ResolverIncrementDecrementValidationTest, Atomic) { TEST_F(ResolverIncrementDecrementValidationTest, Atomic) {
// var<workgroup> a : atomic<i32>; // var<workgroup> a : atomic<i32>;
// a++; // a++;
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kWorkgroup); GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
WrapInFunction(Increment(Expr(Source{{56, 78}}, "a"))); WrapInFunction(Increment(Expr(Source{{56, 78}}, "a")));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -193,7 +193,7 @@ TEST_F(ResolverIncrementDecrementValidationTest, ReadOnlyBuffer) {
// { // {
// a++; // a++;
// } // }
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead, GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead,
Group(0_a), Binding(0_a)); Group(0_a), Binding(0_a));
WrapInFunction(Increment(Source{{56, 78}}, "a")); WrapInFunction(Increment(Source{{56, 78}}, "a"));

8
src/tint/resolver/inferred_type_test.cc
View File

@ -97,7 +97,7 @@ TEST_P(ResolverInferredTypeParamTest, GlobalVar_Pass) {
// var a = <type initializer>; // var a = <type initializer>;
auto* ctor_expr = params.create_value(*this, 0); auto* ctor_expr = params.create_value(*this, 0);
auto* var = GlobalVar("a", ast::AddressSpace::kPrivate, ctor_expr); auto* var = GlobalVar("a", type::AddressSpace::kPrivate, ctor_expr);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_EQ(TypeOf(var)->UnwrapRef(), expected_type); EXPECT_EQ(TypeOf(var)->UnwrapRef(), expected_type);
@ -124,7 +124,7 @@ TEST_P(ResolverInferredTypeParamTest, LocalVar_Pass) {
// var a = <type initializer>; // var a = <type initializer>;
auto* ctor_expr = params.create_value(*this, 0); auto* ctor_expr = params.create_value(*this, 0);
auto* var = Var("a", ast::AddressSpace::kFunction, ctor_expr); auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
WrapInFunction(var); WrapInFunction(var);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -139,7 +139,7 @@ TEST_F(ResolverInferredTypeTest, InferArray_Pass) {
create<type::U32>(), create<type::ConstantArrayCount>(10u), 4u, 4u * 10u, 4u, 4u); create<type::U32>(), create<type::ConstantArrayCount>(10u), 4u, 4u * 10u, 4u, 4u);
auto* ctor_expr = Construct(type); auto* ctor_expr = Construct(type);
auto* var = Var("a", ast::AddressSpace::kFunction, ctor_expr); auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
WrapInFunction(var); WrapInFunction(var);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -158,7 +158,7 @@ TEST_F(ResolverInferredTypeTest, InferStruct_Pass) {
auto* ctor_expr = Construct(ty.Of(str)); auto* ctor_expr = Construct(ty.Of(str));
auto* var = Var("a", ast::AddressSpace::kFunction, ctor_expr); auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
WrapInFunction(var); WrapInFunction(var);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();

10
src/tint/resolver/intrinsic_table.cc
View File

@ -330,7 +330,7 @@ class TemplateNumberMatcher : public NumberMatcher {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
using TexelFormat = ast::TexelFormat; using TexelFormat = ast::TexelFormat;
using Access = ast::Access; using Access = ast::Access;
using AddressSpace = ast::AddressSpace; using AddressSpace = type::AddressSpace;
using ParameterUsage = sem::ParameterUsage; using ParameterUsage = sem::ParameterUsage;
using PipelineStage = ast::PipelineStage; using PipelineStage = ast::PipelineStage;
@ -560,7 +560,7 @@ bool match_ptr(MatchState&, const type::Type* ty, Number& S, const type::Type*&
} }
const type::Pointer* build_ptr(MatchState& state, Number S, const type::Type* T, Number& A) { const type::Pointer* build_ptr(MatchState& state, Number S, const type::Type* T, Number& A) {
return state.builder.create<type::Pointer>(T, static_cast<ast::AddressSpace>(S.Value()), return state.builder.create<type::Pointer>(T, static_cast<type::AddressSpace>(S.Value()),
static_cast<ast::Access>(A.Value())); static_cast<ast::Access>(A.Value()));
} }
@ -1275,7 +1275,7 @@ Impl::Builtin Impl::Lookup(sem::BuiltinType builtin_type,
params.Reserve(match.parameters.Length()); params.Reserve(match.parameters.Length());
for (auto& p : match.parameters) { for (auto& p : match.parameters) {
params.Push(builder.create<sem::Parameter>( params.Push(builder.create<sem::Parameter>(
nullptr, static_cast<uint32_t>(params.Length()), p.type, ast::AddressSpace::kNone, nullptr, static_cast<uint32_t>(params.Length()), p.type, type::AddressSpace::kNone,
ast::Access::kUndefined, p.usage)); ast::Access::kUndefined, p.usage));
} }
sem::PipelineStageSet supported_stages; sem::PipelineStageSet supported_stages;
@ -1476,7 +1476,7 @@ IntrinsicTable::InitOrConv Impl::Lookup(InitConvIntrinsic type,
params.Reserve(match.parameters.Length()); params.Reserve(match.parameters.Length());
for (auto& p : match.parameters) { for (auto& p : match.parameters) {
params.Push(builder.create<sem::Parameter>( params.Push(builder.create<sem::Parameter>(
nullptr, static_cast<uint32_t>(params.Length()), p.type, ast::AddressSpace::kNone, nullptr, static_cast<uint32_t>(params.Length()), p.type, type::AddressSpace::kNone,
ast::Access::kUndefined, p.usage)); ast::Access::kUndefined, p.usage));
} }
auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
@ -1491,7 +1491,7 @@ IntrinsicTable::InitOrConv Impl::Lookup(InitConvIntrinsic type,
// Conversion. // Conversion.
auto* target = converters.GetOrCreate(match, [&]() { auto* target = converters.GetOrCreate(match, [&]() {
auto param = builder.create<sem::Parameter>( auto param = builder.create<sem::Parameter>(
nullptr, 0u, match.parameters[0].type, ast::AddressSpace::kNone, nullptr, 0u, match.parameters[0].type, type::AddressSpace::kNone,
ast::Access::kUndefined, match.parameters[0].usage); ast::Access::kUndefined, match.parameters[0].usage);
auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
: sem::EvaluationStage::kRuntime; : sem::EvaluationStage::kRuntime;

8
src/tint/resolver/intrinsic_table_test.cc
View File

@ -232,7 +232,7 @@ TEST_F(IntrinsicTableTest, MatchPointer) {
auto* i32 = create<type::I32>(); auto* i32 = create<type::I32>();
auto* atomicI32 = create<type::Atomic>(i32); auto* atomicI32 = create<type::Atomic>(i32);
auto* ptr = auto* ptr =
create<type::Pointer>(atomicI32, ast::AddressSpace::kWorkgroup, ast::Access::kReadWrite); create<type::Pointer>(atomicI32, type::AddressSpace::kWorkgroup, ast::Access::kReadWrite);
auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr}, auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr},
sem::EvaluationStage::kConstant, Source{}); sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str(); ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
@ -256,7 +256,7 @@ TEST_F(IntrinsicTableTest, MatchArray) {
auto* arr = auto* arr =
create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u); create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
auto* arr_ptr = auto* arr_ptr =
create<type::Pointer>(arr, ast::AddressSpace::kStorage, ast::Access::kReadWrite); create<type::Pointer>(arr, type::AddressSpace::kStorage, ast::Access::kReadWrite);
auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{arr_ptr}, auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{arr_ptr},
sem::EvaluationStage::kConstant, Source{}); sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str(); ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
@ -448,7 +448,7 @@ TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) {
auto result = table->Lookup( auto result = table->Lookup(
BuiltinType::kCos, BuiltinType::kCos,
utils::Vector{ utils::Vector{
create<type::Reference>(f32, ast::AddressSpace::kFunction, ast::Access::kReadWrite), create<type::Reference>(f32, type::AddressSpace::kFunction, ast::Access::kReadWrite),
}, },
sem::EvaluationStage::kConstant, Source{}); sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str(); ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
@ -548,7 +548,7 @@ TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) {
TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_RuntimeEval) { TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_RuntimeEval) {
auto* af = create<type::AbstractFloat>(); auto* af = create<type::AbstractFloat>();
auto* bool_ref = create<type::Reference>(create<type::Bool>(), ast::AddressSpace::kFunction, auto* bool_ref = create<type::Reference>(create<type::Bool>(), type::AddressSpace::kFunction,
ast::Access::kReadWrite); ast::Access::kReadWrite);
auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_ref}, auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_ref},
sem::EvaluationStage::kRuntime, Source{}); sem::EvaluationStage::kRuntime, Source{});

2
src/tint/resolver/is_host_shareable_test.cc
View File

@ -95,7 +95,7 @@ TEST_F(ResolverIsHostShareable, Matrix) {
} }
TEST_F(ResolverIsHostShareable, Pointer) { TEST_F(ResolverIsHostShareable, Pointer) {
auto* ptr = create<type::Pointer>(create<type::I32>(), ast::AddressSpace::kPrivate, auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
ast::Access::kReadWrite); ast::Access::kReadWrite);
EXPECT_FALSE(r()->IsHostShareable(ptr)); EXPECT_FALSE(r()->IsHostShareable(ptr));
} }

6
src/tint/resolver/is_storeable_test.cc
View File

@ -78,7 +78,7 @@ TEST_F(ResolverIsStorableTest, Matrix) {
} }
TEST_F(ResolverIsStorableTest, Pointer) { TEST_F(ResolverIsStorableTest, Pointer) {
auto* ptr = create<type::Pointer>(create<type::I32>(), ast::AddressSpace::kPrivate, auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
ast::Access::kReadWrite); ast::Access::kReadWrite);
EXPECT_FALSE(r()->IsStorable(ptr)); EXPECT_FALSE(r()->IsStorable(ptr));
} }
@ -112,7 +112,7 @@ TEST_F(ResolverIsStorableTest, Struct_AllMembersStorable) {
TEST_F(ResolverIsStorableTest, Struct_SomeMembersNonStorable) { TEST_F(ResolverIsStorableTest, Struct_SomeMembersNonStorable) {
Structure("S", utils::Vector{ Structure("S", utils::Vector{
Member("a", ty.i32()), Member("a", ty.i32()),
Member("b", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Member("b", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}); });
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -138,7 +138,7 @@ TEST_F(ResolverIsStorableTest, Struct_NestedNonStorable) {
auto* non_storable = auto* non_storable =
Structure("nonstorable", utils::Vector{ Structure("nonstorable", utils::Vector{
Member("a", ty.i32()), Member("a", ty.i32()),
Member("b", ty.pointer<i32>(ast::AddressSpace::kPrivate)), Member("b", ty.pointer<i32>(type::AddressSpace::kPrivate)),
}); });
Structure("S", utils::Vector{ Structure("S", utils::Vector{
Member("a", ty.i32()), Member("a", ty.i32()),

2
src/tint/resolver/materialize_test.cc
View File

@ -929,7 +929,7 @@ TEST_P(MaterializeAbstractNumericToDefaultType, Test) {
break; break;
} }
case Method::kIndex: { case Method::kIndex: {
GlobalVar("arr", ty.array<i32, 4>(), ast::AddressSpace::kPrivate); GlobalVar("arr", ty.array<i32, 4>(), type::AddressSpace::kPrivate);
WrapInFunction(IndexAccessor("arr", abstract_expr())); WrapInFunction(IndexAccessor("arr", abstract_expr()));
break; break;
} }

10
src/tint/resolver/override_test.cc
View File

@ -159,7 +159,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaOverrideInit) {
TEST_F(ResolverOverrideTest, TransitiveReferences_ViaPrivateInit) { TEST_F(ResolverOverrideTest, TransitiveReferences_ViaPrivateInit) {
auto* a = Override("a", ty.f32()); auto* a = Override("a", ty.f32());
auto* b = GlobalVar("b", ast::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "a")); auto* b = GlobalVar("b", type::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "a"));
Override("unused", ty.f32(), Expr(1_f)); Override("unused", ty.f32(), Expr(1_f));
auto* func = Func("foo", utils::Empty, ty.void_(), auto* func = Func("foo", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -209,7 +209,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize) {
auto* a = Override("a", ty.i32()); auto* a = Override("a", ty.i32());
auto* b = Override("b", ty.i32(), Mul(2_a, "a")); auto* b = Override("b", ty.i32(), Mul(2_a, "a"));
auto* arr_ty = ty.array(ty.i32(), Mul(2_a, "b")); auto* arr_ty = ty.array(ty.i32(), Mul(2_a, "b"));
auto* arr = GlobalVar("arr", ast::AddressSpace::kWorkgroup, arr_ty); auto* arr = GlobalVar("arr", type::AddressSpace::kWorkgroup, arr_ty);
Override("unused", ty.i32(), Expr(1_a)); Override("unused", ty.i32(), Expr(1_a));
auto* func = Func("foo", utils::Empty, ty.void_(), auto* func = Func("foo", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -249,7 +249,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize_Alias) {
auto* a = Override("a", ty.i32()); auto* a = Override("a", ty.i32());
auto* b = Override("b", ty.i32(), Mul(2_a, "a")); auto* b = Override("b", ty.i32(), Mul(2_a, "a"));
auto* arr_ty = Alias("arr_ty", ty.array(ty.i32(), Mul(2_a, "b"))); auto* arr_ty = Alias("arr_ty", ty.array(ty.i32(), Mul(2_a, "b")));
auto* arr = GlobalVar("arr", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty")); auto* arr = GlobalVar("arr", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty"));
Override("unused", ty.i32(), Expr(1_a)); Override("unused", ty.i32(), Expr(1_a));
auto* func = Func("foo", utils::Empty, ty.void_(), auto* func = Func("foo", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -294,8 +294,8 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_MultipleEntryPoints) {
auto* d = Override("d", ty.i32()); auto* d = Override("d", ty.i32());
Alias("arr_ty1", ty.array(ty.i32(), Mul("b1", "c1"))); Alias("arr_ty1", ty.array(ty.i32(), Mul("b1", "c1")));
Alias("arr_ty2", ty.array(ty.i32(), Mul("b2", "c2"))); Alias("arr_ty2", ty.array(ty.i32(), Mul("b2", "c2")));
auto* arr1 = GlobalVar("arr1", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty1")); auto* arr1 = GlobalVar("arr1", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty1"));
auto* arr2 = GlobalVar("arr2", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty2")); auto* arr2 = GlobalVar("arr2", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty2"));
Override("unused", ty.i32(), Expr(1_a)); Override("unused", ty.i32(), Expr(1_a));
auto* func1 = Func("foo1", utils::Empty, ty.void_(), auto* func1 = Func("foo1", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{

20
src/tint/resolver/ptr_ref_test.cc
View File

@ -39,7 +39,7 @@ TEST_F(ResolverPtrRefTest, AddressOf) {
ASSERT_TRUE(TypeOf(expr)->Is<type::Pointer>()); ASSERT_TRUE(TypeOf(expr)->Is<type::Pointer>());
EXPECT_TRUE(TypeOf(expr)->As<type::Pointer>()->StoreType()->Is<type::I32>()); EXPECT_TRUE(TypeOf(expr)->As<type::Pointer>()->StoreType()->Is<type::I32>());
EXPECT_EQ(TypeOf(expr)->As<type::Pointer>()->AddressSpace(), ast::AddressSpace::kFunction); EXPECT_EQ(TypeOf(expr)->As<type::Pointer>()->AddressSpace(), type::AddressSpace::kFunction);
} }
TEST_F(ResolverPtrRefTest, AddressOfThenDeref) { TEST_F(ResolverPtrRefTest, AddressOfThenDeref) {
@ -68,23 +68,23 @@ TEST_F(ResolverPtrRefTest, DefaultPtrAddressSpace) {
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())}); auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
auto* function = Var("f", ty.i32()); auto* function = Var("f", ty.i32());
auto* private_ = GlobalVar("p", ty.i32(), ast::AddressSpace::kPrivate); auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate);
auto* workgroup = GlobalVar("w", ty.i32(), ast::AddressSpace::kWorkgroup); auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup);
auto* uniform = auto* uniform =
GlobalVar("ub", ty.Of(buf), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("ub", ty.Of(buf), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
auto* storage = auto* storage =
GlobalVar("sb", ty.Of(buf), ast::AddressSpace::kStorage, Binding(1_a), Group(0_a)); GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage, Binding(1_a), Group(0_a));
auto* function_ptr = auto* function_ptr =
Let("f_ptr", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), AddressOf(function)); Let("f_ptr", ty.pointer(ty.i32(), type::AddressSpace::kFunction), AddressOf(function));
auto* private_ptr = auto* private_ptr =
Let("p_ptr", ty.pointer(ty.i32(), ast::AddressSpace::kPrivate), AddressOf(private_)); Let("p_ptr", ty.pointer(ty.i32(), type::AddressSpace::kPrivate), AddressOf(private_));
auto* workgroup_ptr = auto* workgroup_ptr =
Let("w_ptr", ty.pointer(ty.i32(), ast::AddressSpace::kWorkgroup), AddressOf(workgroup)); Let("w_ptr", ty.pointer(ty.i32(), type::AddressSpace::kWorkgroup), AddressOf(workgroup));
auto* uniform_ptr = auto* uniform_ptr =
Let("ub_ptr", ty.pointer(ty.Of(buf), ast::AddressSpace::kUniform), AddressOf(uniform)); Let("ub_ptr", ty.pointer(ty.Of(buf), type::AddressSpace::kUniform), AddressOf(uniform));
auto* storage_ptr = auto* storage_ptr =
Let("sb_ptr", ty.pointer(ty.Of(buf), ast::AddressSpace::kStorage), AddressOf(storage)); Let("sb_ptr", ty.pointer(ty.Of(buf), type::AddressSpace::kStorage), AddressOf(storage));
WrapInFunction(function, function_ptr, private_ptr, workgroup_ptr, uniform_ptr, storage_ptr); WrapInFunction(function, function_ptr, private_ptr, workgroup_ptr, uniform_ptr, storage_ptr);

6
src/tint/resolver/ptr_ref_validation_test.cc
View File

@ -143,12 +143,12 @@ TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) {
// } // }
auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())}); auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))}); auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))});
auto* storage = GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, ast::Access::kReadWrite, auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage,
Binding(0_a), Group(0_a)); ast::Access::kReadWrite, Binding(0_a), Group(0_a));
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i); auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i);
auto* ptr = auto* ptr =
Let(Source{{12, 34}}, "p", ty.pointer<i32>(ast::AddressSpace::kStorage), AddressOf(expr)); Let(Source{{12, 34}}, "p", ty.pointer<i32>(type::AddressSpace::kStorage), AddressOf(expr));
WrapInFunction(ptr); WrapInFunction(ptr);

60
src/tint/resolver/resolver.cc
View File

@ -391,11 +391,11 @@ sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) {
ty = rhs->Type()->UnwrapRef(); // Implicit load of RHS ty = rhs->Type()->UnwrapRef(); // Implicit load of RHS
} }
if (rhs && !validator_.VariableInitializer(v, ast::AddressSpace::kNone, ty, rhs)) { if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kNone, ty, rhs)) {
return nullptr; return nullptr;
} }
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast<type::Type*>(ty), if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast<type::Type*>(ty),
v->source)) { v->source)) {
AddNote("while instantiating 'let' " + builder_->Symbols().NameFor(v->symbol), v->source); AddNote("while instantiating 'let' " + builder_->Symbols().NameFor(v->symbol), v->source);
return nullptr; return nullptr;
@ -404,12 +404,12 @@ sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) {
sem::Variable* sem = nullptr; sem::Variable* sem = nullptr;
if (is_global) { if (is_global) {
sem = builder_->create<sem::GlobalVariable>( sem = builder_->create<sem::GlobalVariable>(
v, ty, sem::EvaluationStage::kRuntime, ast::AddressSpace::kNone, v, ty, sem::EvaluationStage::kRuntime, type::AddressSpace::kNone,
ast::Access::kUndefined, ast::Access::kUndefined,
/* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt); /* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
} else { } else {
sem = builder_->create<sem::LocalVariable>(v, ty, sem::EvaluationStage::kRuntime, sem = builder_->create<sem::LocalVariable>(v, ty, sem::EvaluationStage::kRuntime,
ast::AddressSpace::kNone, type::AddressSpace::kNone,
ast::Access::kUndefined, current_statement_, ast::Access::kUndefined, current_statement_,
/* constant_value */ nullptr); /* constant_value */ nullptr);
} }
@ -453,11 +453,11 @@ sem::Variable* Resolver::Override(const ast::Override* v) {
return nullptr; return nullptr;
} }
if (rhs && !validator_.VariableInitializer(v, ast::AddressSpace::kNone, ty, rhs)) { if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kNone, ty, rhs)) {
return nullptr; return nullptr;
} }
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast<type::Type*>(ty), if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast<type::Type*>(ty),
v->source)) { v->source)) {
AddNote("while instantiating 'override' " + builder_->Symbols().NameFor(v->symbol), AddNote("while instantiating 'override' " + builder_->Symbols().NameFor(v->symbol),
v->source); v->source);
@ -465,7 +465,7 @@ sem::Variable* Resolver::Override(const ast::Override* v) {
} }
auto* sem = builder_->create<sem::GlobalVariable>( auto* sem = builder_->create<sem::GlobalVariable>(
v, ty, sem::EvaluationStage::kOverride, ast::AddressSpace::kNone, ast::Access::kUndefined, v, ty, sem::EvaluationStage::kOverride, type::AddressSpace::kNone, ast::Access::kUndefined,
/* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt); /* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
sem->SetInitializer(rhs); sem->SetInitializer(rhs);
@ -546,11 +546,11 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) {
ty = rhs->Type(); ty = rhs->Type();
} }
if (!validator_.VariableInitializer(c, ast::AddressSpace::kNone, ty, rhs)) { if (!validator_.VariableInitializer(c, type::AddressSpace::kNone, ty, rhs)) {
return nullptr; return nullptr;
} }
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast<type::Type*>(ty), if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast<type::Type*>(ty),
c->source)) { c->source)) {
AddNote("while instantiating 'const' " + builder_->Symbols().NameFor(c->symbol), c->source); AddNote("while instantiating 'const' " + builder_->Symbols().NameFor(c->symbol), c->source);
return nullptr; return nullptr;
@ -558,10 +558,10 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) {
const auto value = rhs->ConstantValue(); const auto value = rhs->ConstantValue();
auto* sem = is_global ? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>( auto* sem = is_global ? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>(
c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone, c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kNone,
ast::Access::kUndefined, value, sem::BindingPoint{}, std::nullopt)) ast::Access::kUndefined, value, sem::BindingPoint{}, std::nullopt))
: static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>( : static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>(
c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone, c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kNone,
ast::Access::kUndefined, current_statement_, value)); ast::Access::kUndefined, current_statement_, value));
sem->SetInitializer(rhs); sem->SetInitializer(rhs);
@ -606,20 +606,20 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) {
} }
auto address_space = var->declared_address_space; auto address_space = var->declared_address_space;
if (address_space == ast::AddressSpace::kNone) { if (address_space == type::AddressSpace::kNone) {
// No declared address space. Infer from usage / type. // No declared address space. Infer from usage / type.
if (!is_global) { if (!is_global) {
address_space = ast::AddressSpace::kFunction; address_space = type::AddressSpace::kFunction;
} else if (storage_ty->UnwrapRef()->is_handle()) { } else if (storage_ty->UnwrapRef()->is_handle()) {
// https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables // https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
// If the store type is a texture type or a sampler type, then the // If the store type is a texture type or a sampler type, then the
// variable declaration must not have a address space attribute. The // variable declaration must not have a address space attribute. The
// address space will always be handle. // address space will always be handle.
address_space = ast::AddressSpace::kHandle; address_space = type::AddressSpace::kHandle;
} }
} }
if (!is_global && address_space != ast::AddressSpace::kFunction && if (!is_global && address_space != type::AddressSpace::kFunction &&
validator_.IsValidationEnabled(var->attributes, validator_.IsValidationEnabled(var->attributes,
ast::DisabledValidation::kIgnoreAddressSpace)) { ast::DisabledValidation::kIgnoreAddressSpace)) {
AddError("function-scope 'var' declaration must use 'function' address space", var->source); AddError("function-scope 'var' declaration must use 'function' address space", var->source);
@ -740,7 +740,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, uint32_t index)
return nullptr; return nullptr;
} }
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, ty, param->type->source)) { if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, ty, param->type->source)) {
add_note(); add_note();
return nullptr; return nullptr;
} }
@ -791,7 +791,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, uint32_t index)
} }
auto* sem = builder_->create<sem::Parameter>( auto* sem = builder_->create<sem::Parameter>(
param, index, ty, ast::AddressSpace::kNone, ast::Access::kUndefined, param, index, ty, type::AddressSpace::kNone, ast::Access::kUndefined,
sem::ParameterUsage::kNone, binding_point, location); sem::ParameterUsage::kNone, binding_point, location);
builder_->Sem().Add(param, sem); builder_->Sem().Add(param, sem);
return sem; return sem;
@ -821,12 +821,12 @@ utils::Result<uint32_t> Resolver::LocationAttribute(const ast::LocationAttribute
return static_cast<uint32_t>(value); return static_cast<uint32_t>(value);
} }
ast::Access Resolver::DefaultAccessForAddressSpace(ast::AddressSpace address_space) { ast::Access Resolver::DefaultAccessForAddressSpace(type::AddressSpace address_space) {
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class // https://gpuweb.github.io/gpuweb/wgsl/#storage-class
switch (address_space) { switch (address_space) {
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
case ast::AddressSpace::kUniform: case type::AddressSpace::kUniform:
case ast::AddressSpace::kHandle: case type::AddressSpace::kHandle:
return ast::Access::kRead; return ast::Access::kRead;
default: default:
break; break;
@ -1036,7 +1036,7 @@ sem::Function* Resolver::Function(const ast::Function* decl) {
} }
if (auto* str = return_type->As<sem::Struct>()) { if (auto* str = return_type->As<sem::Struct>()) {
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, str, decl->source)) { if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, str, decl->source)) {
AddNote( AddNote(
"while instantiating return type for " + builder_->Symbols().NameFor(decl->symbol), "while instantiating return type for " + builder_->Symbols().NameFor(decl->symbol),
decl->source); decl->source);
@ -2099,10 +2099,10 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
[&]() -> sem::TypeInitializer* { [&]() -> sem::TypeInitializer* {
auto params = utils::Transform(args, [&](auto, size_t i) { auto params = utils::Transform(args, [&](auto, size_t i) {
return builder_->create<sem::Parameter>( return builder_->create<sem::Parameter>(
nullptr, // declaration nullptr, // declaration
static_cast<uint32_t>(i), // index static_cast<uint32_t>(i), // index
arr->ElemType(), // type arr->ElemType(), // type
ast::AddressSpace::kNone, // address_space type::AddressSpace::kNone, // address_space
ast::Access::kUndefined); ast::Access::kUndefined);
}); });
return builder_->create<sem::TypeInitializer>(arr, std::move(params), return builder_->create<sem::TypeInitializer>(arr, std::move(params),
@ -2131,7 +2131,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
nullptr, // declaration nullptr, // declaration
static_cast<uint32_t>(i), // index static_cast<uint32_t>(i), // index
str->Members()[i]->Type(), // type str->Members()[i]->Type(), // type
ast::AddressSpace::kNone, // address_space type::AddressSpace::kNone, // address_space
ast::Access::kUndefined); // access ast::Access::kUndefined); // access
} }
return builder_->create<sem::TypeInitializer>(str, std::move(params), return builder_->create<sem::TypeInitializer>(str, std::move(params),
@ -3759,7 +3759,7 @@ sem::Statement* Resolver::IncrementDecrementStatement(
}); });
} }
bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space, bool Resolver::ApplyAddressSpaceUsageToType(type::AddressSpace address_space,
type::Type* ty, type::Type* ty,
const Source& usage) { const Source& usage) {
ty = const_cast<type::Type*>(ty->UnwrapRef()); ty = const_cast<type::Type*>(ty->UnwrapRef());
@ -3787,7 +3787,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space,
} }
if (auto* arr = ty->As<type::Array>()) { if (auto* arr = ty->As<type::Array>()) {
if (address_space != ast::AddressSpace::kStorage) { if (address_space != type::AddressSpace::kStorage) {
if (arr->Count()->Is<type::RuntimeArrayCount>()) { if (arr->Count()->Is<type::RuntimeArrayCount>()) {
AddError("runtime-sized arrays can only be used in the <storage> address space", AddError("runtime-sized arrays can only be used in the <storage> address space",
usage); usage);
@ -3806,7 +3806,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space,
usage); usage);
} }
if (ast::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) { if (type::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) {
std::stringstream err; std::stringstream err;
err << "Type '" << sem_.TypeNameOf(ty) << "' cannot be used in address space '" err << "Type '" << sem_.TypeNameOf(ty) << "' cannot be used in address space '"
<< address_space << "' as it is non-host-shareable"; << address_space << "' as it is non-host-shareable";

4
src/tint/resolver/resolver.h
View File

@ -378,11 +378,11 @@ class Resolver {
/// given type and address space. Used for generating sensible error /// given type and address space. Used for generating sensible error
/// messages. /// messages.
/// @returns true on success, false on error /// @returns true on success, false on error
bool ApplyAddressSpaceUsageToType(ast::AddressSpace sc, type::Type* ty, const Source& usage); bool ApplyAddressSpaceUsageToType(type::AddressSpace sc, type::Type* ty, const Source& usage);
/// @param address_space the address space /// @param address_space the address space
/// @returns the default access control for the given address space /// @returns the default access control for the given address space
ast::Access DefaultAccessForAddressSpace(ast::AddressSpace address_space); ast::Access DefaultAccessForAddressSpace(type::AddressSpace address_space);
/// Allocate constant IDs for pipeline-overridable constants. /// Allocate constant IDs for pipeline-overridable constants.
/// @returns true on success, false on error /// @returns true on success, false on error

130
src/tint/resolver/resolver_test.cc
View File

@ -325,7 +325,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_Alias) {
TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) { TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) {
auto* init = Expr(2_i); auto* init = Expr(2_i);
GlobalVar("my_var", ty.i32(), ast::AddressSpace::kPrivate, init); GlobalVar("my_var", ty.i32(), type::AddressSpace::kPrivate, init);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -405,7 +405,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) {
Func("func_i32", utils::Empty, ty.void_(), utils::Vector{fn_i32_decl}); Func("func_i32", utils::Empty, ty.void_(), utils::Vector{fn_i32_decl});
// Declare f32 "foo" at module scope // Declare f32 "foo" at module scope
auto* mod_f32 = Var("foo", ty.f32(), ast::AddressSpace::kPrivate, Expr(2_f)); auto* mod_f32 = Var("foo", ty.f32(), type::AddressSpace::kPrivate, Expr(2_f));
auto* mod_init = mod_f32->initializer; auto* mod_init = mod_f32->initializer;
AST().AddGlobalVariable(mod_f32); AST().AddGlobalVariable(mod_f32);
@ -433,7 +433,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) {
TEST_F(ResolverTest, ArraySize_UnsignedLiteral) { TEST_F(ResolverTest, ArraySize_UnsignedLiteral) {
// var<private> a : array<f32, 10u>; // var<private> a : array<f32, 10u>;
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_u)), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_u)), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -446,7 +446,7 @@ TEST_F(ResolverTest, ArraySize_UnsignedLiteral) {
TEST_F(ResolverTest, ArraySize_SignedLiteral) { TEST_F(ResolverTest, ArraySize_SignedLiteral) {
// var<private> a : array<f32, 10i>; // var<private> a : array<f32, 10i>;
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_i)), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_i)), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -461,7 +461,7 @@ TEST_F(ResolverTest, ArraySize_UnsignedConst) {
// const size = 10u; // const size = 10u;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(10_u)); GlobalConst("size", Expr(10_u));
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -476,7 +476,7 @@ TEST_F(ResolverTest, ArraySize_SignedConst) {
// const size = 0; // const size = 0;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(10_i)); GlobalConst("size", Expr(10_i));
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -491,7 +491,7 @@ TEST_F(ResolverTest, ArraySize_NamedOverride) {
// override size = 10i; // override size = 10i;
// var<workgroup> a : array<f32, size>; // var<workgroup> a : array<f32, size>;
auto* override = Override("size", Expr(10_i)); auto* override = Override("size", Expr(10_i));
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kWorkgroup); auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -509,8 +509,8 @@ TEST_F(ResolverTest, ArraySize_NamedOverride_Equivalence) {
// var<workgroup> a : array<f32, size>; // var<workgroup> a : array<f32, size>;
// var<workgroup> b : array<f32, size>; // var<workgroup> b : array<f32, size>;
auto* override = Override("size", Expr(10_i)); auto* override = Override("size", Expr(10_i));
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kWorkgroup); auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
auto* b = GlobalVar("b", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kWorkgroup); auto* b = GlobalVar("b", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -536,7 +536,7 @@ TEST_F(ResolverTest, ArraySize_UnnamedOverride) {
// var<workgroup> a : array<f32, size*2>; // var<workgroup> a : array<f32, size*2>;
auto* override = Override("size", Expr(10_i)); auto* override = Override("size", Expr(10_i));
auto* cnt = Mul("size", 2_a); auto* cnt = Mul("size", 2_a);
auto* a = GlobalVar("a", ty.array(ty.f32(), cnt), ast::AddressSpace::kWorkgroup); auto* a = GlobalVar("a", ty.array(ty.f32(), cnt), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -556,8 +556,8 @@ TEST_F(ResolverTest, ArraySize_UnamedOverride_Equivalence) {
auto* override = Override("size", Expr(10_i)); auto* override = Override("size", Expr(10_i));
auto* a_cnt = Mul("size", 2_a); auto* a_cnt = Mul("size", 2_a);
auto* b_cnt = Mul("size", 2_a); auto* b_cnt = Mul("size", 2_a);
auto* a = GlobalVar("a", ty.array(ty.f32(), a_cnt), ast::AddressSpace::kWorkgroup); auto* a = GlobalVar("a", ty.array(ty.f32(), a_cnt), type::AddressSpace::kWorkgroup);
auto* b = GlobalVar("b", ty.array(ty.f32(), b_cnt), ast::AddressSpace::kWorkgroup); auto* b = GlobalVar("b", ty.array(ty.f32(), b_cnt), type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -579,7 +579,7 @@ TEST_F(ResolverTest, ArraySize_UnamedOverride_Equivalence) {
} }
TEST_F(ResolverTest, Expr_Bitcast) { TEST_F(ResolverTest, Expr_Bitcast) {
GlobalVar("name", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate);
auto* bitcast = create<ast::BitcastExpression>(ty.f32(), Expr("name")); auto* bitcast = create<ast::BitcastExpression>(ty.f32(), Expr("name"));
WrapInFunction(bitcast); WrapInFunction(bitcast);
@ -642,7 +642,7 @@ TEST_F(ResolverTest, Expr_Call_Builtin) {
} }
TEST_F(ResolverTest, Expr_Cast) { TEST_F(ResolverTest, Expr_Cast) {
GlobalVar("name", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate);
auto* cast = Construct(ty.f32(), "name"); auto* cast = Construct(ty.f32(), "name");
WrapInFunction(cast); WrapInFunction(cast);
@ -700,7 +700,7 @@ TEST_F(ResolverTest, Expr_Initializer_Type_Vec4) {
} }
TEST_F(ResolverTest, Expr_Identifier_GlobalVariable) { TEST_F(ResolverTest, Expr_Identifier_GlobalVariable) {
auto* my_var = GlobalVar("my_var", ty.f32(), ast::AddressSpace::kPrivate); auto* my_var = GlobalVar("my_var", ty.f32(), type::AddressSpace::kPrivate);
auto* ident = Expr("my_var"); auto* ident = Expr("my_var");
WrapInFunction(ident); WrapInFunction(ident);
@ -801,7 +801,7 @@ TEST_F(ResolverTest, Expr_Identifier_Function_Ptr) {
auto* v = Expr("v"); auto* v = Expr("v");
auto* p = Expr("p"); auto* p = Expr("p");
auto* v_decl = Decl(Var("v", ty.f32())); auto* v_decl = Decl(Var("v", ty.f32()));
auto* p_decl = Decl(Let("p", ty.pointer<f32>(ast::AddressSpace::kFunction), AddressOf(v))); auto* p_decl = Decl(Let("p", ty.pointer<f32>(type::AddressSpace::kFunction), AddressOf(v)));
auto* assign = Assign(Deref(p), 1.23_f); auto* assign = Assign(Deref(p), 1.23_f);
Func("my_func", utils::Empty, ty.void_(), Func("my_func", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -876,7 +876,7 @@ TEST_F(ResolverTest, Function_Parameters_Locations) {
auto* param_b = Param("b", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kVertexIndex)}); auto* param_b = Param("b", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kVertexIndex)});
auto* param_c = Param("c", ty.u32(), utils::Vector{Location(1_a)}); auto* param_c = Param("c", ty.u32(), utils::Vector{Location(1_a)});
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* func = Func("my_func", auto* func = Func("my_func",
utils::Vector{ utils::Vector{
param_a, param_a,
@ -906,7 +906,7 @@ TEST_F(ResolverTest, Function_Parameters_Locations) {
TEST_F(ResolverTest, Function_GlobalVariable_Location) { TEST_F(ResolverTest, Function_GlobalVariable_Location) {
auto* var = GlobalVar( auto* var = GlobalVar(
"my_vec", ty.vec4<f32>(), ast::AddressSpace::kIn, "my_vec", ty.vec4<f32>(), type::AddressSpace::kIn,
utils::Vector{Location(3_a), Disable(ast::DisabledValidation::kIgnoreAddressSpace)}); utils::Vector{Location(3_a), Disable(ast::DisabledValidation::kIgnoreAddressSpace)});
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -919,10 +919,10 @@ TEST_F(ResolverTest, Function_GlobalVariable_Location) {
TEST_F(ResolverTest, Function_RegisterInputOutputVariables) { TEST_F(ResolverTest, Function_RegisterInputOutputVariables) {
auto* s = Structure("S", utils::Vector{Member("m", ty.u32())}); auto* s = Structure("S", utils::Vector{Member("m", ty.u32())});
auto* sb_var = GlobalVar("sb_var", ty.Of(s), ast::AddressSpace::kStorage, auto* sb_var = GlobalVar("sb_var", ty.Of(s), type::AddressSpace::kStorage,
ast::Access::kReadWrite, Binding(0_a), Group(0_a)); ast::Access::kReadWrite, Binding(0_a), Group(0_a));
auto* wg_var = GlobalVar("wg_var", ty.f32(), ast::AddressSpace::kWorkgroup); auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup);
auto* priv_var = GlobalVar("priv_var", ty.f32(), ast::AddressSpace::kPrivate); auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate);
auto* func = Func("my_func", utils::Empty, ty.void_(), auto* func = Func("my_func", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -965,7 +965,7 @@ TEST_F(ResolverTest, Function_ReturnType_Location) {
} }
TEST_F(ResolverTest, Function_ReturnType_NoLocation) { TEST_F(ResolverTest, Function_ReturnType_NoLocation) {
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* func = Func("my_func", utils::Empty, ty.vec4<f32>(), auto* func = Func("my_func", utils::Empty, ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Return("my_vec"), Return("my_vec"),
@ -987,10 +987,10 @@ TEST_F(ResolverTest, Function_ReturnType_NoLocation) {
TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) { TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) {
auto* s = Structure("S", utils::Vector{Member("m", ty.u32())}); auto* s = Structure("S", utils::Vector{Member("m", ty.u32())});
auto* sb_var = GlobalVar("sb_var", ty.Of(s), ast::AddressSpace::kStorage, auto* sb_var = GlobalVar("sb_var", ty.Of(s), type::AddressSpace::kStorage,
ast::Access::kReadWrite, Binding(0_a), Group(0_a)); ast::Access::kReadWrite, Binding(0_a), Group(0_a));
auto* wg_var = GlobalVar("wg_var", ty.f32(), ast::AddressSpace::kWorkgroup); auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup);
auto* priv_var = GlobalVar("priv_var", ty.f32(), ast::AddressSpace::kPrivate); auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate);
Func("my_func", utils::Empty, ty.f32(), Func("my_func", utils::Empty, ty.f32(),
utils::Vector{Assign("wg_var", "wg_var"), Assign("sb_var", "sb_var"), utils::Vector{Assign("wg_var", "wg_var"), Assign("sb_var", "sb_var"),
@ -1241,7 +1241,7 @@ TEST_F(ResolverTest, Function_WorkgroupSize_Mixed) {
TEST_F(ResolverTest, Expr_MemberAccessor_Struct) { TEST_F(ResolverTest, Expr_MemberAccessor_Struct) {
auto* st = Structure( auto* st = Structure(
"S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())}); "S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())});
GlobalVar("my_struct", ty.Of(st), ast::AddressSpace::kPrivate); GlobalVar("my_struct", ty.Of(st), type::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_struct", "second_member"); auto* mem = MemberAccessor("my_struct", "second_member");
WrapInFunction(mem); WrapInFunction(mem);
@ -1262,7 +1262,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) {
auto* st = Structure( auto* st = Structure(
"S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())}); "S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())});
auto* alias = Alias("alias", ty.Of(st)); auto* alias = Alias("alias", ty.Of(st));
GlobalVar("my_struct", ty.Of(alias), ast::AddressSpace::kPrivate); GlobalVar("my_struct", ty.Of(alias), type::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_struct", "second_member"); auto* mem = MemberAccessor("my_struct", "second_member");
WrapInFunction(mem); WrapInFunction(mem);
@ -1279,7 +1279,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) {
} }
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) { TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", "xzyw"); auto* mem = MemberAccessor("my_vec", "xzyw");
WrapInFunction(mem); WrapInFunction(mem);
@ -1297,7 +1297,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
} }
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle_SingleElement) { TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle_SingleElement) {
GlobalVar("my_vec", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", "b"); auto* mem = MemberAccessor("my_vec", "b");
WrapInFunction(mem); WrapInFunction(mem);
@ -1330,7 +1330,7 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
auto* stB = Structure("B", utils::Vector{Member("foo", ty.vec4<f32>())}); auto* stB = Structure("B", utils::Vector{Member("foo", ty.vec4<f32>())});
auto* stA = Structure("A", utils::Vector{Member("mem", ty.array(ty.Of(stB), 3_i))}); auto* stA = Structure("A", utils::Vector{Member("mem", ty.array(ty.Of(stB), 3_i))});
GlobalVar("c", ty.Of(stA), ast::AddressSpace::kPrivate); GlobalVar("c", ty.Of(stA), type::AddressSpace::kPrivate);
auto* mem = auto* mem =
MemberAccessor(MemberAccessor(IndexAccessor(MemberAccessor("c", "mem"), 0_i), "foo"), "yx"); MemberAccessor(MemberAccessor(IndexAccessor(MemberAccessor("c", "mem"), 0_i), "foo"), "yx");
@ -1348,7 +1348,7 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
TEST_F(ResolverTest, Expr_MemberAccessor_InBinaryOp) { TEST_F(ResolverTest, Expr_MemberAccessor_InBinaryOp) {
auto* st = Structure( auto* st = Structure(
"S", utils::Vector{Member("first_member", ty.f32()), Member("second_member", ty.f32())}); "S", utils::Vector{Member("first_member", ty.f32()), Member("second_member", ty.f32())});
GlobalVar("my_struct", ty.Of(st), ast::AddressSpace::kPrivate); GlobalVar("my_struct", ty.Of(st), type::AddressSpace::kPrivate);
auto* expr = Add(MemberAccessor("my_struct", "first_member"), auto* expr = Add(MemberAccessor("my_struct", "first_member"),
MemberAccessor("my_struct", "second_member")); MemberAccessor("my_struct", "second_member"));
@ -1651,8 +1651,8 @@ TEST_P(Expr_Binary_Test_Valid, All) {
ss << FriendlyName(lhs_type) << " " << params.op << " " << FriendlyName(rhs_type); ss << FriendlyName(lhs_type) << " " << params.op << " " << FriendlyName(rhs_type);
SCOPED_TRACE(ss.str()); SCOPED_TRACE(ss.str());
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs")); auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr); WrapInFunction(expr);
@ -1686,8 +1686,8 @@ TEST_P(Expr_Binary_Test_WithAlias_Valid, All) {
<< FriendlyName(rhs_type); << FriendlyName(rhs_type);
SCOPED_TRACE(ss.str()); SCOPED_TRACE(ss.str());
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs")); auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr); WrapInFunction(expr);
@ -1732,8 +1732,8 @@ TEST_P(Expr_Binary_Test_Invalid, All) {
ss << FriendlyName(lhs_type) << " " << op << " " << FriendlyName(rhs_type); ss << FriendlyName(lhs_type) << " " << op << " " << FriendlyName(rhs_type);
SCOPED_TRACE(ss.str()); SCOPED_TRACE(ss.str());
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(Source{{12, 34}}, op, Expr("lhs"), Expr("rhs")); auto* expr = create<ast::BinaryExpression>(Source{{12, 34}}, op, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr); WrapInFunction(expr);
@ -1772,8 +1772,8 @@ TEST_P(Expr_Binary_Test_Invalid_VectorMatrixMultiply, All) {
is_valid_expr = vec_size == mat_cols; is_valid_expr = vec_size == mat_cols;
} }
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs")); auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr); WrapInFunction(expr);
@ -1809,8 +1809,8 @@ TEST_P(Expr_Binary_Test_Invalid_MatrixMatrixMultiply, All) {
auto* col = create<type::Vector>(f32, lhs_mat_rows); auto* col = create<type::Vector>(f32, lhs_mat_rows);
auto* result_type = create<type::Matrix>(col, rhs_mat_cols); auto* result_type = create<type::Matrix>(col, rhs_mat_cols);
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs")); auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr); WrapInFunction(expr);
@ -1838,11 +1838,11 @@ TEST_P(UnaryOpExpressionTest, Expr_UnaryOp) {
auto op = GetParam(); auto op = GetParam();
if (op == ast::UnaryOp::kNot) { if (op == ast::UnaryOp::kNot) {
GlobalVar("ident", ty.vec4<bool>(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.vec4<bool>(), type::AddressSpace::kPrivate);
} else if (op == ast::UnaryOp::kNegation || op == ast::UnaryOp::kComplement) { } else if (op == ast::UnaryOp::kNegation || op == ast::UnaryOp::kComplement) {
GlobalVar("ident", ty.vec4<i32>(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.vec4<i32>(), type::AddressSpace::kPrivate);
} else { } else {
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
} }
auto* der = create<ast::UnaryOpExpression>(op, Expr("ident")); auto* der = create<ast::UnaryOpExpression>(op, Expr("ident"));
WrapInFunction(der); WrapInFunction(der);
@ -1874,7 +1874,7 @@ TEST_F(ResolverTest, AddressSpace_SetsIfMissing) {
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kFunction); EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kFunction);
} }
TEST_F(ResolverTest, AddressSpace_SetForSampler) { TEST_F(ResolverTest, AddressSpace_SetForSampler) {
@ -1883,7 +1883,7 @@ TEST_F(ResolverTest, AddressSpace_SetForSampler) {
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kHandle); EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kHandle);
} }
TEST_F(ResolverTest, AddressSpace_SetForTexture) { TEST_F(ResolverTest, AddressSpace_SetForTexture) {
@ -1892,7 +1892,7 @@ TEST_F(ResolverTest, AddressSpace_SetForTexture) {
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kHandle); EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kHandle);
} }
TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) { TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) {
@ -1902,14 +1902,14 @@ TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) {
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kNone); EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kNone);
} }
TEST_F(ResolverTest, Access_SetForStorageBuffer) { TEST_F(ResolverTest, Access_SetForStorageBuffer) {
// struct S { x : i32 }; // struct S { x : i32 };
// var<storage> g : S; // var<storage> g : S;
auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "x", ty.i32())}); auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "x", ty.i32())});
auto* var = GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kStorage, auto* var = GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kStorage,
Binding(0_a), Group(0_a)); Binding(0_a), Group(0_a));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -1942,11 +1942,11 @@ TEST_F(ResolverTest, Function_EntryPoints_StageAttribute) {
// ep_1 -> {} // ep_1 -> {}
// ep_2 -> {} // ep_2 -> {}
GlobalVar("first", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("first", ty.f32(), type::AddressSpace::kPrivate);
GlobalVar("second", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("second", ty.f32(), type::AddressSpace::kPrivate);
GlobalVar("call_a", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("call_a", ty.f32(), type::AddressSpace::kPrivate);
GlobalVar("call_b", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("call_b", ty.f32(), type::AddressSpace::kPrivate);
GlobalVar("call_c", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("call_c", ty.f32(), type::AddressSpace::kPrivate);
auto* func_b = Func("b", utils::Empty, ty.f32(), auto* func_b = Func("b", utils::Empty, ty.f32(),
utils::Vector{ utils::Vector{
@ -2086,8 +2086,8 @@ TEST_F(ResolverTest, ASTNodeReachedTwice) {
{ {
ProgramBuilder b; ProgramBuilder b;
auto* expr = b.Expr(1_i); auto* expr = b.Expr(1_i);
b.GlobalVar("a", b.ty.i32(), ast::AddressSpace::kPrivate, expr); b.GlobalVar("a", b.ty.i32(), type::AddressSpace::kPrivate, expr);
b.GlobalVar("b", b.ty.i32(), ast::AddressSpace::kPrivate, expr); b.GlobalVar("b", b.ty.i32(), type::AddressSpace::kPrivate, expr);
Resolver(&b).Resolve(); Resolver(&b).Resolve();
}, },
"internal compiler error: AST node 'tint::ast::IntLiteralExpression' was encountered twice " "internal compiler error: AST node 'tint::ast::IntLiteralExpression' was encountered twice "
@ -2095,7 +2095,7 @@ TEST_F(ResolverTest, ASTNodeReachedTwice) {
} }
TEST_F(ResolverTest, UnaryOp_Not) { TEST_F(ResolverTest, UnaryOp_Not) {
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* der = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr(Source{{12, 34}}, "ident")); auto* der = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr(Source{{12, 34}}, "ident"));
WrapInFunction(der); WrapInFunction(der);
@ -2104,7 +2104,7 @@ TEST_F(ResolverTest, UnaryOp_Not) {
} }
TEST_F(ResolverTest, UnaryOp_Complement) { TEST_F(ResolverTest, UnaryOp_Complement) {
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* der = auto* der =
create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr(Source{{12, 34}}, "ident")); create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr(Source{{12, 34}}, "ident"));
WrapInFunction(der); WrapInFunction(der);
@ -2114,7 +2114,7 @@ TEST_F(ResolverTest, UnaryOp_Complement) {
} }
TEST_F(ResolverTest, UnaryOp_Negation) { TEST_F(ResolverTest, UnaryOp_Negation) {
GlobalVar("ident", ty.u32(), ast::AddressSpace::kPrivate); GlobalVar("ident", ty.u32(), type::AddressSpace::kPrivate);
auto* der = auto* der =
create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr(Source{{12, 34}}, "ident")); create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr(Source{{12, 34}}, "ident"));
WrapInFunction(der); WrapInFunction(der);
@ -2273,7 +2273,7 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715
GlobalVar("s", ty.sampler(ast::SamplerKind::kSampler), Group(0_a), Binding(0_a)); GlobalVar("s", ty.sampler(ast::SamplerKind::kSampler), Group(0_a), Binding(0_a));
GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a), GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
Binding(1_a)); Binding(1_a));
GlobalVar("c", ty.vec2<f32>(), ast::AddressSpace::kUniform, Group(0_a), Binding(2_a)); GlobalVar("c", ty.vec2<f32>(), type::AddressSpace::kUniform, Group(0_a), Binding(2_a));
Func("main", utils::Empty, ty.vec4<f32>(), Func("main", utils::Empty, ty.vec4<f32>(),
utils::Vector{ utils::Vector{
@ -2289,9 +2289,9 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715
Func("helper", Func("helper",
utils::Vector{ utils::Vector{
Param("sl", ty.pointer(ty.sampler(ast::SamplerKind::kSampler), Param("sl", ty.pointer(ty.sampler(ast::SamplerKind::kSampler),
ast::AddressSpace::kFunction)), type::AddressSpace::kFunction)),
Param("tl", ty.pointer(ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Param("tl", ty.pointer(ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
ast::AddressSpace::kFunction)), type::AddressSpace::kFunction)),
}, },
ty.vec4<f32>(), ty.vec4<f32>(),
utils::Vector{ utils::Vector{
@ -2304,15 +2304,15 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715
TEST_F(ResolverTest, ModuleDependencyOrderedDeclarations) { TEST_F(ResolverTest, ModuleDependencyOrderedDeclarations) {
auto* f0 = Func("f0", utils::Empty, ty.void_(), utils::Empty); auto* f0 = Func("f0", utils::Empty, ty.void_(), utils::Empty);
auto* v0 = GlobalVar("v0", ty.i32(), ast::AddressSpace::kPrivate); auto* v0 = GlobalVar("v0", ty.i32(), type::AddressSpace::kPrivate);
auto* a0 = Alias("a0", ty.i32()); auto* a0 = Alias("a0", ty.i32());
auto* s0 = Structure("s0", utils::Vector{Member("m", ty.i32())}); auto* s0 = Structure("s0", utils::Vector{Member("m", ty.i32())});
auto* f1 = Func("f1", utils::Empty, ty.void_(), utils::Empty); auto* f1 = Func("f1", utils::Empty, ty.void_(), utils::Empty);
auto* v1 = GlobalVar("v1", ty.i32(), ast::AddressSpace::kPrivate); auto* v1 = GlobalVar("v1", ty.i32(), type::AddressSpace::kPrivate);
auto* a1 = Alias("a1", ty.i32()); auto* a1 = Alias("a1", ty.i32());
auto* s1 = Structure("s1", utils::Vector{Member("m", ty.i32())}); auto* s1 = Structure("s1", utils::Vector{Member("m", ty.i32())});
auto* f2 = Func("f2", utils::Empty, ty.void_(), utils::Empty); auto* f2 = Func("f2", utils::Empty, ty.void_(), utils::Empty);
auto* v2 = GlobalVar("v2", ty.i32(), ast::AddressSpace::kPrivate); auto* v2 = GlobalVar("v2", ty.i32(), type::AddressSpace::kPrivate);
auto* a2 = Alias("a2", ty.i32()); auto* a2 = Alias("a2", ty.i32());
auto* s2 = Structure("s2", utils::Vector{Member("m", ty.i32())}); auto* s2 = Structure("s2", utils::Vector{Member("m", ty.i32())});

6
src/tint/resolver/resolver_test_helper.h
View File

@ -616,13 +616,13 @@ struct DataType<ptr<T>> {
/// @param b the ProgramBuilder /// @param b the ProgramBuilder
/// @return a new AST alias type /// @return a new AST alias type
static inline const ast::Type* AST(ProgramBuilder& b) { static inline const ast::Type* AST(ProgramBuilder& b) {
return b.create<ast::Pointer>(DataType<T>::AST(b), ast::AddressSpace::kPrivate, return b.create<ast::Pointer>(DataType<T>::AST(b), type::AddressSpace::kPrivate,
ast::Access::kUndefined); ast::Access::kUndefined);
} }
/// @param b the ProgramBuilder /// @param b the ProgramBuilder
/// @return the semantic aliased type /// @return the semantic aliased type
static inline const type::Type* Sem(ProgramBuilder& b) { static inline const type::Type* Sem(ProgramBuilder& b) {
return b.create<type::Pointer>(DataType<T>::Sem(b), ast::AddressSpace::kPrivate, return b.create<type::Pointer>(DataType<T>::Sem(b), type::AddressSpace::kPrivate,
ast::Access::kReadWrite); ast::Access::kReadWrite);
} }
@ -631,7 +631,7 @@ struct DataType<ptr<T>> {
static inline const ast::Expression* Expr(ProgramBuilder& b, static inline const ast::Expression* Expr(ProgramBuilder& b,
utils::VectorRef<Scalar> /*unused*/) { utils::VectorRef<Scalar> /*unused*/) {
auto sym = b.Symbols().New("global_for_ptr"); auto sym = b.Symbols().New("global_for_ptr");
b.GlobalVar(sym, DataType<T>::AST(b), ast::AddressSpace::kPrivate); b.GlobalVar(sym, DataType<T>::AST(b), type::AddressSpace::kPrivate);
return b.AddressOf(sym); return b.AddressOf(sym);
} }

18
src/tint/resolver/root_identifier_test.cc
View File

@ -27,7 +27,7 @@ namespace {
class ResolverRootIdentifierTest : public ResolverTest {}; class ResolverRootIdentifierTest : public ResolverTest {};
TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) { TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) {
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
auto* expr = Expr(a); auto* expr = Expr(a);
WrapInFunction(expr); WrapInFunction(expr);
@ -38,7 +38,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) {
} }
TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) { TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) {
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kWorkgroup); auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kWorkgroup);
auto* expr = Expr(a); auto* expr = Expr(a);
WrapInFunction(expr); WrapInFunction(expr);
@ -49,7 +49,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) {
} }
TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) { TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) {
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kStorage, Group(0_a), Binding(0_a)); auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
auto* expr = Expr(a); auto* expr = Expr(a);
WrapInFunction(expr); WrapInFunction(expr);
@ -60,7 +60,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) {
} }
TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) { TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) {
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
auto* expr = Expr(a); auto* expr = Expr(a);
WrapInFunction(expr); WrapInFunction(expr);
@ -72,7 +72,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) {
TEST_F(ResolverRootIdentifierTest, GlobalTextureVar) { TEST_F(ResolverRootIdentifierTest, GlobalTextureVar) {
auto* a = GlobalVar("a", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), auto* a = GlobalVar("a", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
ast::AddressSpace::kNone, Group(0_a), Binding(0_a)); type::AddressSpace::kNone, Group(0_a), Binding(0_a));
auto* expr = Expr(a); auto* expr = Expr(a);
WrapInFunction(Call("textureDimensions", expr)); WrapInFunction(Call("textureDimensions", expr));
@ -142,7 +142,7 @@ TEST_F(ResolverRootIdentifierTest, PointerParameter) {
// { // {
// let b = a; // let b = a;
// } // }
auto* param = Param("a", ty.pointer(ty.f32(), ast::AddressSpace::kFunction)); auto* param = Param("a", ty.pointer(ty.f32(), type::AddressSpace::kFunction));
auto* expr_param = Expr(param); auto* expr_param = Expr(param);
auto* let = Let("b", expr_param); auto* let = Let("b", expr_param);
auto* expr_let = Expr("b"); auto* expr_let = Expr("b");
@ -199,7 +199,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughIndexAccessor) {
// { // {
// a[2i] // a[2i]
// } // }
auto* a = GlobalVar("a", ty.array(ty.f32(), 4_u), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.array(ty.f32(), 4_u), type::AddressSpace::kPrivate);
auto* expr = IndexAccessor(a, 2_i); auto* expr = IndexAccessor(a, 2_i);
WrapInFunction(expr); WrapInFunction(expr);
@ -216,7 +216,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughMemberAccessor) {
// a.f // a.f
// } // }
auto* S = Structure("S", utils::Vector{Member("f", ty.f32())}); auto* S = Structure("S", utils::Vector{Member("f", ty.f32())});
auto* a = GlobalVar("a", ty.Of(S), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.Of(S), type::AddressSpace::kPrivate);
auto* expr = MemberAccessor(a, "f"); auto* expr = MemberAccessor(a, "f");
WrapInFunction(expr); WrapInFunction(expr);
@ -232,7 +232,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughPointers) {
// let a_ptr1 = &*&a; // let a_ptr1 = &*&a;
// let a_ptr2 = &*a_ptr1; // let a_ptr2 = &*a_ptr1;
// } // }
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
auto* address_of_1 = AddressOf(a); auto* address_of_1 = AddressOf(a);
auto* deref_1 = Deref(address_of_1); auto* deref_1 = Deref(address_of_1);
auto* address_of_2 = AddressOf(deref_1); auto* address_of_2 = AddressOf(deref_1);

36
src/tint/resolver/side_effects_test.cc
View File

@ -31,7 +31,7 @@ struct SideEffectsTest : ResolverTest {
template <typename T> template <typename T>
void MakeSideEffectFunc(const char* name) { void MakeSideEffectFunc(const char* name) {
auto global = Sym(); auto global = Sym();
GlobalVar(global, ty.Of<T>(), ast::AddressSpace::kPrivate); GlobalVar(global, ty.Of<T>(), type::AddressSpace::kPrivate);
auto local = Sym(); auto local = Sym();
Func(name, utils::Empty, ty.Of<T>(), Func(name, utils::Empty, ty.Of<T>(),
utils::Vector{ utils::Vector{
@ -44,7 +44,7 @@ struct SideEffectsTest : ResolverTest {
template <typename MAKE_TYPE_FUNC> template <typename MAKE_TYPE_FUNC>
void MakeSideEffectFunc(const char* name, MAKE_TYPE_FUNC make_type) { void MakeSideEffectFunc(const char* name, MAKE_TYPE_FUNC make_type) {
auto global = Sym(); auto global = Sym();
GlobalVar(global, make_type(), ast::AddressSpace::kPrivate); GlobalVar(global, make_type(), type::AddressSpace::kPrivate);
auto local = Sym(); auto local = Sym();
Func(name, utils::Empty, make_type(), Func(name, utils::Empty, make_type(),
utils::Vector{ utils::Vector{
@ -89,7 +89,7 @@ TEST_F(SideEffectsTest, VariableUser) {
} }
TEST_F(SideEffectsTest, Call_Builtin_NoSE) { TEST_F(SideEffectsTest, Call_Builtin_NoSE) {
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
auto* expr = Call("dpdx", "a"); auto* expr = Call("dpdx", "a");
Func("f", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)}, Func("f", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
utils::Vector{create<ast::StageAttribute>(ast::PipelineStage::kFragment)}); utils::Vector{create<ast::StageAttribute>(ast::PipelineStage::kFragment)});
@ -115,7 +115,7 @@ TEST_F(SideEffectsTest, Call_Builtin_NoSE_WithSEArg) {
} }
TEST_F(SideEffectsTest, Call_Builtin_SE) { TEST_F(SideEffectsTest, Call_Builtin_SE) {
GlobalVar("a", ty.atomic(ty.i32()), ast::AddressSpace::kWorkgroup); GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
auto* expr = Call("atomicAdd", AddressOf("a"), 1_i); auto* expr = Call("atomicAdd", AddressOf("a"), 1_i);
WrapInFunction(expr); WrapInFunction(expr);
@ -164,21 +164,21 @@ TEST_P(SideEffectsBuiltinTest, Test) {
auto& c = GetParam(); auto& c = GetParam();
uint32_t next_binding = 0; uint32_t next_binding = 0;
GlobalVar("f", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar("f", ty.f32(), type::AddressSpace::kPrivate);
GlobalVar("i", ty.i32(), ast::AddressSpace::kPrivate); GlobalVar("i", ty.i32(), type::AddressSpace::kPrivate);
GlobalVar("u", ty.u32(), ast::AddressSpace::kPrivate); GlobalVar("u", ty.u32(), type::AddressSpace::kPrivate);
GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
GlobalVar("vf", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("vf", ty.vec3<f32>(), type::AddressSpace::kPrivate);
GlobalVar("vf2", ty.vec2<f32>(), ast::AddressSpace::kPrivate); GlobalVar("vf2", ty.vec2<f32>(), type::AddressSpace::kPrivate);
GlobalVar("vi2", ty.vec2<i32>(), ast::AddressSpace::kPrivate); GlobalVar("vi2", ty.vec2<i32>(), type::AddressSpace::kPrivate);
GlobalVar("vf4", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("vf4", ty.vec4<f32>(), type::AddressSpace::kPrivate);
GlobalVar("vb", ty.vec3<bool>(), ast::AddressSpace::kPrivate); GlobalVar("vb", ty.vec3<bool>(), type::AddressSpace::kPrivate);
GlobalVar("m", ty.mat3x3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("m", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
GlobalVar("arr", ty.array<f32, 10>(), ast::AddressSpace::kPrivate); GlobalVar("arr", ty.array<f32, 10>(), type::AddressSpace::kPrivate);
GlobalVar("storage_arr", ty.array<f32>(), ast::AddressSpace::kStorage, Group(0_a), GlobalVar("storage_arr", ty.array<f32>(), type::AddressSpace::kStorage, Group(0_a),
Binding(AInt(next_binding++))); Binding(AInt(next_binding++)));
GlobalVar("workgroup_arr", ty.array<f32, 4>(), ast::AddressSpace::kWorkgroup); GlobalVar("workgroup_arr", ty.array<f32, 4>(), type::AddressSpace::kWorkgroup);
GlobalVar("a", ty.atomic(ty.i32()), ast::AddressSpace::kStorage, ast::Access::kReadWrite, GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kStorage, ast::Access::kReadWrite,
Group(0_a), Binding(AInt(next_binding++))); Group(0_a), Binding(AInt(next_binding++)));
if (c.pipeline_stage != ast::PipelineStage::kCompute) { if (c.pipeline_stage != ast::PipelineStage::kCompute) {
GlobalVar("t2d", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a), GlobalVar("t2d", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),

2
src/tint/resolver/static_assert_test.cc
View File

@ -84,7 +84,7 @@ TEST_F(ResolverStaticAssertTest, Local_Const_Fail) {
} }
TEST_F(ResolverStaticAssertTest, Local_NonConst) { TEST_F(ResolverStaticAssertTest, Local_NonConst) {
GlobalVar("V", ty.bool_(), Expr(true), ast::AddressSpace::kPrivate); GlobalVar("V", ty.bool_(), Expr(true), type::AddressSpace::kPrivate);
WrapInFunction(StaticAssert(Expr(Source{{12, 34}}, "V"))); WrapInFunction(StaticAssert(Expr(Source{{12, 34}}, "V")));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),

36
src/tint/resolver/struct_address_space_use_test.cc
View File

@ -46,7 +46,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromParameter) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kNone)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kNone));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) { TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) {
@ -58,55 +58,55 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kNone)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kNone));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromGlobal) { TEST_F(ResolverAddressSpaceUseTest, StructReachableFromGlobal) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalAlias) { TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalAlias) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
auto* a = Alias("A", ty.Of(s)); auto* a = Alias("A", ty.Of(s));
GlobalVar("g", ty.Of(a), ast::AddressSpace::kPrivate); GlobalVar("g", ty.Of(a), type::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalStruct) { TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalStruct) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
auto* o = Structure("O", utils::Vector{Member("a", ty.Of(s))}); auto* o = Structure("O", utils::Vector{Member("a", ty.Of(s))});
GlobalVar("g", ty.Of(o), ast::AddressSpace::kPrivate); GlobalVar("g", ty.Of(o), type::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalArray) { TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalArray) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
auto* a = ty.array(ty.Of(s), 3_u); auto* a = ty.array(ty.Of(s), 3_u);
GlobalVar("g", a, ast::AddressSpace::kPrivate); GlobalVar("g", a, type::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) { TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) {
@ -118,7 +118,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) { TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) {
@ -130,7 +130,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) { TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) {
@ -142,7 +142,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
} }
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) { TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) {
@ -154,13 +154,13 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
} }
TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) { TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
GlobalVar("x", ty.Of(s), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("x", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
GlobalVar("y", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), GlobalVar("y", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a),
Group(0_a)); Group(0_a));
WrapInFunction(Var("g", ty.Of(s))); WrapInFunction(Var("g", ty.Of(s)));
@ -169,8 +169,8 @@ TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) {
auto* sem = TypeOf(s)->As<sem::Struct>(); auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr); ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->AddressSpaceUsage(), EXPECT_THAT(sem->AddressSpaceUsage(),
UnorderedElementsAre(ast::AddressSpace::kUniform, ast::AddressSpace::kStorage, UnorderedElementsAre(type::AddressSpace::kUniform, type::AddressSpace::kStorage,
ast::AddressSpace::kFunction)); type::AddressSpace::kFunction));
} }
} // namespace } // namespace

24
src/tint/resolver/type_initializer_validation_test.cc
View File

@ -69,10 +69,12 @@ TEST_F(ResolverTypeInitializerValidationTest, InferTypeTest_Simple) {
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(a_ident)->Is<type::Reference>()); ASSERT_TRUE(TypeOf(a_ident)->Is<type::Reference>());
EXPECT_TRUE(TypeOf(a_ident)->As<type::Reference>()->StoreType()->Is<type::I32>()); EXPECT_TRUE(TypeOf(a_ident)->As<type::Reference>()->StoreType()->Is<type::I32>());
EXPECT_EQ(TypeOf(a_ident)->As<type::Reference>()->AddressSpace(), ast::AddressSpace::kFunction); EXPECT_EQ(TypeOf(a_ident)->As<type::Reference>()->AddressSpace(),
type::AddressSpace::kFunction);
ASSERT_TRUE(TypeOf(b_ident)->Is<type::Reference>()); ASSERT_TRUE(TypeOf(b_ident)->Is<type::Reference>());
EXPECT_TRUE(TypeOf(b_ident)->As<type::Reference>()->StoreType()->Is<type::I32>()); EXPECT_TRUE(TypeOf(b_ident)->As<type::Reference>()->StoreType()->Is<type::I32>());
EXPECT_EQ(TypeOf(b_ident)->As<type::Reference>()->AddressSpace(), ast::AddressSpace::kFunction); EXPECT_EQ(TypeOf(b_ident)->As<type::Reference>()->AddressSpace(),
type::AddressSpace::kFunction);
} }
using InferTypeTest_FromInitializerExpression = ResolverTestWithParam<Params>; using InferTypeTest_FromInitializerExpression = ResolverTestWithParam<Params>;
@ -95,8 +97,8 @@ TEST_P(InferTypeTest_FromInitializerExpression, All) {
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* got = TypeOf(a_ident); auto* got = TypeOf(a_ident);
auto* expected = create<type::Reference>(params.create_rhs_sem_type(*this), auto* expected = create<type::Reference>(
ast::AddressSpace::kFunction, ast::Access::kReadWrite); params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite);
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
<< "expected: " << FriendlyName(expected) << "\n"; << "expected: " << FriendlyName(expected) << "\n";
} }
@ -149,8 +151,8 @@ TEST_P(InferTypeTest_FromArithmeticExpression, All) {
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* got = TypeOf(a_ident); auto* got = TypeOf(a_ident);
auto* expected = create<type::Reference>(params.create_rhs_sem_type(*this), auto* expected = create<type::Reference>(
ast::AddressSpace::kFunction, ast::Access::kReadWrite); params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite);
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
<< "expected: " << FriendlyName(expected) << "\n"; << "expected: " << FriendlyName(expected) << "\n";
} }
@ -197,8 +199,8 @@ TEST_P(InferTypeTest_FromCallExpression, All) {
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* got = TypeOf(a_ident); auto* got = TypeOf(a_ident);
auto* expected = create<type::Reference>(params.create_rhs_sem_type(*this), auto* expected = create<type::Reference>(
ast::AddressSpace::kFunction, ast::Access::kReadWrite); params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite);
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
<< "expected: " << FriendlyName(expected) << "\n"; << "expected: " << FriendlyName(expected) << "\n";
} }
@ -1968,7 +1970,7 @@ TEST_F(ResolverTypeInitializerValidationTest, NestedVectorInitializers_Success)
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) { TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) {
auto* alias = Alias("UnsignedInt", ty.u32()); auto* alias = Alias("UnsignedInt", ty.u32());
GlobalVar("uint_var", ty.Of(alias), ast::AddressSpace::kPrivate); GlobalVar("uint_var", ty.Of(alias), type::AddressSpace::kPrivate);
auto* tc = vec2<f32>(Source{{12, 34}}, "uint_var"); auto* tc = vec2<f32>(Source{{12, 34}}, "uint_var");
WrapInFunction(tc); WrapInFunction(tc);
@ -1980,8 +1982,8 @@ TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) {
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Success) { TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Success) {
auto* f32_alias = Alias("Float32", ty.f32()); auto* f32_alias = Alias("Float32", ty.f32());
auto* vec2_alias = Alias("VectorFloat2", ty.vec2<f32>()); auto* vec2_alias = Alias("VectorFloat2", ty.vec2<f32>());
GlobalVar("my_f32", ty.Of(f32_alias), ast::AddressSpace::kPrivate); GlobalVar("my_f32", ty.Of(f32_alias), type::AddressSpace::kPrivate);
GlobalVar("my_vec2", ty.Of(vec2_alias), ast::AddressSpace::kPrivate); GlobalVar("my_vec2", ty.Of(vec2_alias), type::AddressSpace::kPrivate);
auto* tc = vec3<f32>("my_vec2", "my_f32"); auto* tc = vec3<f32>("my_vec2", "my_f32");
WrapInFunction(tc); WrapInFunction(tc);

108
src/tint/resolver/type_validation_test.cc
View File

@ -95,7 +95,7 @@ TEST_F(ResolverTypeValidationTest, GlobalOverrideNoInitializer_Pass) {
TEST_F(ResolverTypeValidationTest, GlobalVariableWithAddressSpace_Pass) { TEST_F(ResolverTypeValidationTest, GlobalVariableWithAddressSpace_Pass) {
// var<private> global_var: f32; // var<private> global_var: f32;
GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -111,9 +111,9 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableUnique_Pass) {
// var global_var0 : f32 = 0.1; // var global_var0 : f32 = 0.1;
// var global_var1 : i32 = 0; // var global_var1 : i32 = 0;
GlobalVar("global_var0", ty.f32(), ast::AddressSpace::kPrivate, Expr(0.1_f)); GlobalVar("global_var0", ty.f32(), type::AddressSpace::kPrivate, Expr(0.1_f));
GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), ast::AddressSpace::kPrivate, Expr(1_f)); GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), type::AddressSpace::kPrivate, Expr(1_f));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -129,7 +129,7 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Pass)
Decl(Var("a", ty.f32(), Expr(2_f))), Decl(Var("a", ty.f32(), Expr(2_f))),
}); });
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f)); GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -193,19 +193,19 @@ TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierDifferentFunctions_Pass)
TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Pass) { TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Pass) {
// var<private> a : array<f32, 4>; // var<private> a : array<f32, 4>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) { TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) {
// var<private> a : array<f32, 4u>; // var<private> a : array<f32, 4u>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) { TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) {
// var<private> a : array<f32, 4i>; // var<private> a : array<f32, 4i>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -213,7 +213,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Pass) {
// const size = 4u; // const size = 4u;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(4_u)); GlobalConst("size", Expr(4_u));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -221,34 +222,35 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Pass) {
// const size = 4i; // const size = 4i;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(4_i)); GlobalConst("size", Expr(4_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Zero) { TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Zero) {
// var<private> a : array<f32, 0>; // var<private> a : array<f32, 0>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
} }
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Zero) { TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Zero) {
// var<private> a : array<f32, 0u>; // var<private> a : array<f32, 0u>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
} }
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Zero) { TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Zero) {
// var<private> a : array<f32, 0i>; // var<private> a : array<f32, 0i>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
} }
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Negative) { TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Negative) {
// var<private> a : array<f32, -10i>; // var<private> a : array<f32, -10i>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10_i)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10_i)), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0");
} }
@ -257,7 +259,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Zero) {
// const size = 0u; // const size = 0u;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(0_u)); GlobalConst("size", Expr(0_u));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
} }
@ -266,7 +269,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Zero) {
// const size = 0i; // const size = 0i;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(0_i)); GlobalConst("size", Expr(0_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
} }
@ -275,14 +279,15 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Negative) {
// const size = -10i; // const size = -10i;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(-10_i)); GlobalConst("size", Expr(-10_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0"); EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0");
} }
TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) { TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) {
// var<private> a : array<f32, 10.0>; // var<private> a : array<f32, 10.0>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
r()->error(), r()->error(),
@ -293,7 +298,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) {
TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) { TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) {
// var<private> a : array<f32, vec2<i32>(10, 10)>; // var<private> a : array<f32, vec2<i32>(10, 10)>;
GlobalVar("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.vec2<i32>(), 10_i, 10_i)), GlobalVar("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.vec2<i32>(), 10_i, 10_i)),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
r()->error(), r()->error(),
@ -305,7 +310,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_FloatConst) {
// const size = 10.0; // const size = 10.0;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Expr(10_f)); GlobalConst("size", Expr(10_f));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
r()->error(), r()->error(),
@ -317,7 +323,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) {
// const size = vec2<i32>(100, 100); // const size = vec2<i32>(100, 100);
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalConst("size", Construct(ty.vec2<i32>(), 100_i, 100_i)); GlobalConst("size", Construct(ty.vec2<i32>(), 100_i, 100_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ( EXPECT_EQ(
r()->error(), r()->error(),
@ -328,14 +335,14 @@ TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) {
TEST_F(ResolverTypeValidationTest, ArraySize_UnderElementCountLimit) { TEST_F(ResolverTypeValidationTest, ArraySize_UnderElementCountLimit) {
// var<private> a : array<f32, 65535>; // var<private> a : array<f32, 65535>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a)), GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a)),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) { TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) {
// var<private> a : array<f32, 65536>; // var<private> a : array<f32, 65536>;
GlobalVar(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.f32(), Expr(65536_a)), GlobalVar(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.f32(), Expr(65536_a)),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(12:34 error: array count (65536) must be less than 65536 EXPECT_EQ(r()->error(), R"(12:34 error: array count (65536) must be less than 65536
56:78 note: while instantiating 'var' a)"); 56:78 note: while instantiating 'var' a)");
@ -343,8 +350,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) {
TEST_F(ResolverTypeValidationTest, ArraySize_StorageBufferLargeArray) { TEST_F(ResolverTypeValidationTest, ArraySize_StorageBufferLargeArray) {
// var<storage> a : array<f32, 65536>; // var<storage> a : array<f32, 65536>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)), ast::AddressSpace::kStorage, GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)),
utils::Vector{Binding(0_u), Group(0_u)}); type::AddressSpace::kStorage, utils::Vector{Binding(0_u), Group(0_u)});
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -355,7 +362,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NestedStorageBufferLargeArray) {
// var<storage> a : S; // var<storage> a : S;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", Structure("S", utils::Vector{Member(Source{{12, 34}}, "a",
ty.array(Source{{12, 20}}, ty.f32(), 65536_a))}); ty.array(Source{{12, 20}}, ty.f32(), 65536_a))});
GlobalVar("a", ty.type_name(Source{{12, 30}}, "S"), ast::AddressSpace::kStorage, GlobalVar("a", ty.type_name(Source{{12, 30}}, "S"), type::AddressSpace::kStorage,
utils::Vector{Binding(0_u), Group(0_u)}); utils::Vector{Binding(0_u), Group(0_u)});
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -368,7 +375,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ImplicitStride) {
Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", ty.f32(), Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", ty.f32(),
utils::Vector{MemberOffset(800000_a)})}); utils::Vector{MemberOffset(800000_a)})});
GlobalVar("a", ty.array(ty.type_name(Source{{12, 30}}, "S"), Expr(Source{{12, 34}}, 65535_a)), GlobalVar("a", ty.array(ty.type_name(Source{{12, 30}}, "S"), Expr(Source{{12, 34}}, 65535_a)),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
"12:34 error: array byte size (0xc34f7cafc) must not exceed 0xffffffff bytes"); "12:34 error: array byte size (0xc34f7cafc) must not exceed 0xffffffff bytes");
@ -377,7 +384,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ImplicitStride) {
TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ExplicitStride) { TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ExplicitStride) {
// var<private> a : @stride(8000000) array<f32, 65535>; // var<private> a : @stride(8000000) array<f32, 65535>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a), 8000000), GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a), 8000000),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
"12:34 error: array byte size (0x7a1185ee00) must not exceed 0xffffffff bytes"); "12:34 error: array byte size (0x7a1185ee00) must not exceed 0xffffffff bytes");
@ -387,7 +394,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_PrivateVar) {
// override size = 10i; // override size = 10i;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
Override("size", Expr(10_i)); Override("size", Expr(10_i));
GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
"12:34 error: array with an 'override' element count can only be used as the store " "12:34 error: array with an 'override' element count can only be used as the store "
@ -399,7 +406,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_InArray) {
// var<workgroup> a : array<array<f32, size>, 4>; // var<workgroup> a : array<array<f32, size>, 4>;
Override("size", Expr(10_i)); Override("size", Expr(10_i));
GlobalVar("a", ty.array(ty.array(Source{{12, 34}}, ty.f32(), "size"), 4_a), GlobalVar("a", ty.array(ty.array(Source{{12, 34}}, ty.f32(), "size"), 4_a),
ast::AddressSpace::kWorkgroup); type::AddressSpace::kWorkgroup);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
"12:34 error: array with an 'override' element count can only be used as the store " "12:34 error: array with an 'override' element count can only be used as the store "
@ -458,7 +465,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionVar_Implicit)
// var a = w; // var a = w;
// } // }
Override("size", Expr(10_i)); Override("size", Expr(10_i));
GlobalVar("w", ty.array(ty.f32(), "size"), ast::AddressSpace::kWorkgroup); GlobalVar("w", ty.array(ty.f32(), "size"), type::AddressSpace::kWorkgroup);
Func("f", utils::Empty, ty.void_(), Func("f", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Decl(Var("a", Expr(Source{{12, 34}}, "w"))), Decl(Var("a", Expr(Source{{12, 34}}, "w"))),
@ -476,7 +483,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionLet_Implicit)
// let a = w; // let a = w;
// } // }
Override("size", Expr(10_i)); Override("size", Expr(10_i));
GlobalVar("w", ty.array(ty.f32(), "size"), ast::AddressSpace::kWorkgroup); GlobalVar("w", ty.array(ty.f32(), "size"), type::AddressSpace::kWorkgroup);
Func("f", utils::Empty, ty.void_(), Func("f", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
Decl(Let("a", Expr(Source{{12, 34}}, "w"))), Decl(Let("a", Expr(Source{{12, 34}}, "w"))),
@ -495,8 +502,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnnamedOverride_Equivalence) {
// a = b; // a = b;
// } // }
Override("size", Expr(10_i)); Override("size", Expr(10_i));
GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), ast::AddressSpace::kWorkgroup); GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), type::AddressSpace::kWorkgroup);
GlobalVar("b", ty.array(ty.f32(), Add("size", 1_i)), ast::AddressSpace::kWorkgroup); GlobalVar("b", ty.array(ty.f32(), Add("size", 1_i)), type::AddressSpace::kWorkgroup);
WrapInFunction(Assign(Source{{12, 34}}, "a", "b")); WrapInFunction(Assign(Source{{12, 34}}, "a", "b"));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -530,15 +537,16 @@ TEST_F(ResolverTypeValidationTest, ArraySize_Workgroup_Overridable) {
// var<workgroup> a : array<f32, size>; // var<workgroup> a : array<f32, size>;
Override("size", Expr(10_i)); Override("size", Expr(10_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
ast::AddressSpace::kWorkgroup); type::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) { TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) {
// var<private> size : i32 = 10i; // var<private> size : i32 = 10i;
// var<private> a : array<f32, size>; // var<private> a : array<f32, size>;
GlobalVar("size", ty.i32(), Expr(10_i), ast::AddressSpace::kPrivate); GlobalVar("size", ty.i32(), Expr(10_i), type::AddressSpace::kPrivate);
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
R"(12:34 error: var 'size' cannot be referenced at module-scope R"(12:34 error: var 'size' cannot be referenced at module-scope
@ -698,7 +706,7 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayInStructInArray) {
Structure("Foo", utils::Vector{Member("rt", ty.array<f32>())}); Structure("Foo", utils::Vector{Member("rt", ty.array<f32>())});
GlobalVar("v", ty.array(ty.type_name(Source{{12, 34}}, "Foo"), 4_u), GlobalVar("v", ty.array(ty.type_name(Source{{12, 34}}, "Foo"), 4_u),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()) << r()->error(); EXPECT_FALSE(r()->Resolve()) << r()->error();
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -744,7 +752,7 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayIsNotLast_Fail) {
TEST_F(ResolverTypeValidationTest, RuntimeArrayAsGlobalVariable) { TEST_F(ResolverTypeValidationTest, RuntimeArrayAsGlobalVariable) {
GlobalVar(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32()), GlobalVar(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32()),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());
@ -793,7 +801,7 @@ TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsPointerParameter_Fail) {
// fn func(a : ptr<workgroup, array<u32>>) {} // fn func(a : ptr<workgroup, array<u32>>) {}
auto* param = Param("a", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()), auto* param = Param("a", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()),
ast::AddressSpace::kWorkgroup)); type::AddressSpace::kWorkgroup));
Func("func", utils::Vector{param}, ty.void_(), Func("func", utils::Vector{param}, ty.void_(),
utils::Vector{ utils::Vector{
@ -858,7 +866,7 @@ TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsLast_Pass) {
TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) { TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) {
auto* tex_ty = ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, ty.f32()); auto* tex_ty = ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, ty.f32());
GlobalVar("arr", ty.array(tex_ty, 4_i), ast::AddressSpace::kPrivate); GlobalVar("arr", ty.array(tex_ty, 4_i), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -866,8 +874,8 @@ TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) {
} }
TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) { TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) {
auto* ptr_ty = ty.pointer<u32>(Source{{12, 34}}, ast::AddressSpace::kUniform); auto* ptr_ty = ty.pointer<u32>(Source{{12, 34}}, type::AddressSpace::kUniform);
GlobalVar("arr", ty.array(ptr_ty, 4_i, 16), ast::AddressSpace::kPrivate); GlobalVar("arr", ty.array(ptr_ty, 4_i, 16), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -877,8 +885,8 @@ TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) {
TEST_F(ResolverTypeValidationTest, VariableAsType) { TEST_F(ResolverTypeValidationTest, VariableAsType) {
// var<private> a : i32; // var<private> a : i32;
// var<private> b : a; // var<private> b : a;
GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
GlobalVar("b", ty.type_name("a"), ast::AddressSpace::kPrivate); GlobalVar("b", ty.type_name("a"), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -890,7 +898,7 @@ TEST_F(ResolverTypeValidationTest, FunctionAsType) {
// fn f() {} // fn f() {}
// var<private> v : f; // var<private> v : f;
Func("f", utils::Empty, ty.void_(), {}); Func("f", utils::Empty, ty.void_(), {});
GlobalVar("v", ty.type_name("f"), ast::AddressSpace::kPrivate); GlobalVar("v", ty.type_name("f"), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -900,7 +908,7 @@ note: 'f' declared here)");
TEST_F(ResolverTypeValidationTest, BuiltinAsType) { TEST_F(ResolverTypeValidationTest, BuiltinAsType) {
// var<private> v : max; // var<private> v : max;
GlobalVar("v", ty.type_name("max"), ast::AddressSpace::kPrivate); GlobalVar("v", ty.type_name("max"), type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "error: cannot use builtin 'max' as type"); EXPECT_EQ(r()->error(), "error: cannot use builtin 'max' as type");
@ -1264,7 +1272,7 @@ TEST_P(ValidMatrixTypes, Okay) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("a", ty.mat(params.elem_ty(*this), params.columns, params.rows), GlobalVar("a", ty.mat(params.elem_ty(*this), params.columns, params.rows),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
@ -1303,7 +1311,7 @@ TEST_P(InvalidMatrixElementTypes, InvalidElementType) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("a", ty.mat(Source{{12, 34}}, params.elem_ty(*this), params.columns, params.rows), GlobalVar("a", ty.mat(Source{{12, 34}}, params.elem_ty(*this), params.columns, params.rows),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: matrix element type must be 'f32' or 'f16'"); EXPECT_EQ(r()->error(), "12:34 error: matrix element type must be 'f32' or 'f16'");
} }
@ -1345,7 +1353,7 @@ TEST_P(ValidVectorTypes, Okay) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), ast::AddressSpace::kPrivate); GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), type::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
@ -1380,7 +1388,7 @@ TEST_P(InvalidVectorElementTypes, InvalidElementType) {
Enable(ast::Extension::kF16); Enable(ast::Extension::kF16);
GlobalVar("a", ty.vec(Source{{12, 34}}, params.elem_ty(*this), params.width), GlobalVar("a", ty.vec(Source{{12, 34}}, params.elem_ty(*this), params.width),
ast::AddressSpace::kPrivate); type::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
"12:34 error: vector element type must be 'bool', 'f32', 'f16', 'i32' " "12:34 error: vector element type must be 'bool', 'f32', 'f16', 'i32' "

6
src/tint/resolver/uniformity.cc
View File

@ -1688,11 +1688,11 @@ class UniformityGraph {
auto var_type = [&](const sem::Variable* var) { auto var_type = [&](const sem::Variable* var) {
switch (var->AddressSpace()) { switch (var->AddressSpace()) {
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
return "read_write storage buffer "; return "read_write storage buffer ";
case ast::AddressSpace::kWorkgroup: case type::AddressSpace::kWorkgroup:
return "workgroup storage variable "; return "workgroup storage variable ";
case ast::AddressSpace::kPrivate: case type::AddressSpace::kPrivate:
return "module-scope private variable "; return "module-scope private variable ";
default: default:
return ""; return "";

6
src/tint/resolver/uniformity_test.cc
View File

@ -5305,7 +5305,7 @@ TEST_F(UniformityAnalysisTest, MaximumNumberOfPointerParameters) {
foo_body.Push(b.Decl(b.Let("rhs", rhs_init))); foo_body.Push(b.Decl(b.Let("rhs", rhs_init)));
for (int i = 0; i < 255; i++) { for (int i = 0; i < 255; i++) {
params.Push( params.Push(
b.Param("p" + std::to_string(i), ty.pointer(ty.i32(), ast::AddressSpace::kFunction))); b.Param("p" + std::to_string(i), ty.pointer(ty.i32(), type::AddressSpace::kFunction)));
if (i > 0) { if (i > 0) {
foo_body.Push(b.Assign(b.Deref("p" + std::to_string(i)), "rhs")); foo_body.Push(b.Assign(b.Deref("p" + std::to_string(i)), "rhs"));
} }
@ -5324,7 +5324,7 @@ TEST_F(UniformityAnalysisTest, MaximumNumberOfPointerParameters) {
// workgroupBarrier(); // workgroupBarrier();
// } // }
// } // }
b.GlobalVar("non_uniform_global", ty.i32(), ast::AddressSpace::kPrivate); b.GlobalVar("non_uniform_global", ty.i32(), type::AddressSpace::kPrivate);
utils::Vector<const ast::Statement*, 8> main_body; utils::Vector<const ast::Statement*, 8> main_body;
utils::Vector<const ast::Expression*, 8> args; utils::Vector<const ast::Expression*, 8> args;
for (int i = 0; i < 255; i++) { for (int i = 0; i < 255; i++) {
@ -7850,7 +7850,7 @@ TEST_F(UniformityAnalysisTest, StressGraphTraversalDepth) {
// workgroupBarrier(); // workgroupBarrier();
// } // }
// } // }
b.GlobalVar("v0", ty.i32(), ast::AddressSpace::kPrivate, b.Expr(0_i)); b.GlobalVar("v0", ty.i32(), type::AddressSpace::kPrivate, b.Expr(0_i));
utils::Vector<const ast::Statement*, 8> foo_body; utils::Vector<const ast::Statement*, 8> foo_body;
std::string v_last = "v0"; std::string v_last = "v0";
for (int i = 1; i < 100000; i++) { for (int i = 1; i < 100000; i++) {

40
src/tint/resolver/validation_test.cc
View File

@ -62,8 +62,8 @@ class FakeExpr final : public Castable<FakeExpr, ast::Expression> {
}; };
TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) { TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) {
GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), ast::AddressSpace::kWorkgroup); GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
GlobalVar("dst", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("dst", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg")); auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg"));
Func(Source{{9, 10}}, "f0", utils::Empty, ty.vec4<f32>(), Func(Source{{9, 10}}, "f0", utils::Empty, ty.vec4<f32>(),
@ -94,8 +94,8 @@ TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInFragmentStage) {
// f1(); // f1();
//} //}
GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), ast::AddressSpace::kWorkgroup); GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
GlobalVar("dst", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("dst", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg")); auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg"));
Func(Source{{5, 6}}, "f2", utils::Empty, ty.void_(), utils::Vector{stmt}); Func(Source{{5, 6}}, "f2", utils::Empty, ty.void_(), utils::Vector{stmt});
@ -234,7 +234,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariable_Pass) {
// return; // return;
// } // }
GlobalVar("global_var", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f)); GlobalVar("global_var", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
Func("my_func", utils::Empty, ty.void_(), Func("my_func", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -308,7 +308,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableDifferentScope_Fail) {
} }
TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) { TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) {
auto* var = Var("var", ty.i32(), ast::AddressSpace::kWorkgroup); auto* var = Var("var", ty.i32(), type::AddressSpace::kWorkgroup);
Func("func", utils::Empty, ty.void_(), Func("func", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -322,7 +322,7 @@ TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) {
} }
TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) { TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) {
auto* var = Var("s", ty.i32(), ast::AddressSpace::kPrivate); auto* var = Var("s", ty.i32(), type::AddressSpace::kPrivate);
Func("func", utils::Empty, ty.void_(), Func("func", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -337,7 +337,7 @@ TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) {
TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) { TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) {
auto* t = ty.sampler(ast::SamplerKind::kSampler); auto* t = ty.sampler(ast::SamplerKind::kSampler);
GlobalVar(Source{{12, 34}}, "var", t, ast::AddressSpace::kHandle, Binding(0_a), Group(0_a)); GlobalVar(Source{{12, 34}}, "var", t, type::AddressSpace::kHandle, Binding(0_a), Group(0_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -347,7 +347,7 @@ TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) {
TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) { TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) {
auto* t = ty.sampled_texture(type::TextureDimension::k1d, ty.f32()); auto* t = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
GlobalVar(Source{{12, 34}}, "var", t, ast::AddressSpace::kHandle, Binding(0_a), Group(0_a)); GlobalVar(Source{{12, 34}}, "var", t, type::AddressSpace::kHandle, Binding(0_a), Group(0_a));
EXPECT_FALSE(r()->Resolve()) << r()->error(); EXPECT_FALSE(r()->Resolve()) << r()->error();
@ -356,7 +356,7 @@ TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) {
} }
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) { TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) {
GlobalVar("my_vec", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
auto* ident = Expr(Source{{{3, 3}, {3, 7}}}, "xyqz"); auto* ident = Expr(Source{{{3, 3}, {3, 7}}}, "xyqz");
@ -368,7 +368,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) {
} }
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_MixedChars) { TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_MixedChars) {
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
auto* ident = Expr(Source{{{3, 3}, {3, 7}}}, "rgyw"); auto* ident = Expr(Source{{{3, 3}, {3, 7}}}, "rgyw");
@ -381,7 +381,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_MixedChars) {
} }
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) { TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) {
GlobalVar("my_vec", ty.vec3<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
auto* ident = Expr(Source{{{3, 3}, {3, 8}}}, "zzzzz"); auto* ident = Expr(Source{{{3, 3}, {3, 8}}}, "zzzzz");
auto* mem = MemberAccessor("my_vec", ident); auto* mem = MemberAccessor("my_vec", ident);
@ -392,7 +392,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) {
} }
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadIndex) { TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadIndex) {
GlobalVar("my_vec", ty.vec2<f32>(), ast::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec2<f32>(), type::AddressSpace::kPrivate);
auto* ident = Expr(Source{{3, 3}}, "z"); auto* ident = Expr(Source{{3, 3}}, "z");
auto* mem = MemberAccessor("my_vec", ident); auto* mem = MemberAccessor("my_vec", ident);
@ -425,7 +425,7 @@ TEST_F(ResolverValidationTest, EXpr_MemberAccessor_FuncGoodParent) {
// let x: f32 = (*p).z; // let x: f32 = (*p).z;
// return x; // return x;
// } // }
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)); auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
auto* star_p = Deref(p); auto* star_p = Deref(p);
auto* z = Expr("z"); auto* z = Expr("z");
auto* accessor_expr = MemberAccessor(star_p, z); auto* accessor_expr = MemberAccessor(star_p, z);
@ -443,7 +443,7 @@ TEST_F(ResolverValidationTest, EXpr_MemberAccessor_FuncBadParent) {
// let x: f32 = *p.z; // let x: f32 = *p.z;
// return x; // return x;
// } // }
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)); auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
auto* z = Expr(Source{{12, 34}}, "z"); auto* z = Expr(Source{{12, 34}}, "z");
auto* accessor_expr = MemberAccessor(p, z); auto* accessor_expr = MemberAccessor(p, z);
auto* star_p = Deref(accessor_expr); auto* star_p = Deref(accessor_expr);
@ -1277,8 +1277,8 @@ TEST_F(ResolverValidationTest, OffsetAndAlignAndSizeAttribute) {
TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) { TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) {
auto* vf = Var("vf", ty.f32()); auto* vf = Var("vf", ty.f32());
auto* c = auto* c =
Construct(Source{{12, 34}}, ty.pointer<i32>(ast::AddressSpace::kFunction), ExprList(vf)); Construct(Source{{12, 34}}, ty.pointer<i32>(type::AddressSpace::kFunction), ExprList(vf));
auto* ip = Let("ip", ty.pointer<i32>(ast::AddressSpace::kFunction), c); auto* ip = Let("ip", ty.pointer<i32>(type::AddressSpace::kFunction), c);
WrapInFunction(Decl(vf), Decl(ip)); WrapInFunction(Decl(vf), Decl(ip));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -1286,21 +1286,21 @@ TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) {
} }
TEST_F(ResolverTest, I32_Overflow) { TEST_F(ResolverTest, I32_Overflow) {
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a)); GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:24 error: value 2147483648 cannot be represented as 'i32'"); EXPECT_EQ(r()->error(), "12:24 error: value 2147483648 cannot be represented as 'i32'");
} }
TEST_F(ResolverTest, I32_Underflow) { TEST_F(ResolverTest, I32_Underflow) {
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, -2147483649_a)); GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, -2147483649_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:24 error: value -2147483649 cannot be represented as 'i32'"); EXPECT_EQ(r()->error(), "12:24 error: value -2147483649 cannot be represented as 'i32'");
} }
TEST_F(ResolverTest, U32_Overflow) { TEST_F(ResolverTest, U32_Overflow) {
GlobalVar("v", ty.u32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a)); GlobalVar("v", ty.u32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:24 error: value 4294967296 cannot be represented as 'u32'"); EXPECT_EQ(r()->error(), "12:24 error: value 4294967296 cannot be represented as 'u32'");

72
src/tint/resolver/validator.cc
View File

@ -273,7 +273,7 @@ bool Validator::Atomic(const ast::Atomic* a, const type::Atomic* s) const {
} }
bool Validator::Pointer(const ast::Pointer* a, const type::Pointer* s) const { bool Validator::Pointer(const ast::Pointer* a, const type::Pointer* s) const {
if (s->AddressSpace() == ast::AddressSpace::kUndefined) { if (s->AddressSpace() == type::AddressSpace::kUndefined) {
AddError("ptr missing address space", a->source); AddError("ptr missing address space", a->source);
return false; return false;
} }
@ -283,7 +283,7 @@ bool Validator::Pointer(const ast::Pointer* a, const type::Pointer* s) const {
// When writing a variable declaration or a pointer type in WGSL source: // When writing a variable declaration or a pointer type in WGSL source:
// * For the storage address space, the access mode is optional, and defaults to read. // * For the storage address space, the access mode is optional, and defaults to read.
// * For other address spaces, the access mode must not be written. // * For other address spaces, the access mode must not be written.
if (a->address_space != ast::AddressSpace::kStorage) { if (a->address_space != type::AddressSpace::kStorage) {
AddError("only pointers in <storage> address space may declare an access mode", AddError("only pointers in <storage> address space may declare an access mode",
a->source); a->source);
return false; return false;
@ -358,7 +358,7 @@ bool Validator::Materialize(const type::Type* to,
} }
bool Validator::VariableInitializer(const ast::Variable* v, bool Validator::VariableInitializer(const ast::Variable* v,
ast::AddressSpace address_space, type::AddressSpace address_space,
const type::Type* storage_ty, const type::Type* storage_ty,
const sem::Expression* initializer) const { const sem::Expression* initializer) const {
auto* initializer_ty = initializer->Type(); auto* initializer_ty = initializer->Type();
@ -375,8 +375,8 @@ bool Validator::VariableInitializer(const ast::Variable* v,
if (v->Is<ast::Var>()) { if (v->Is<ast::Var>()) {
switch (address_space) { switch (address_space) {
case ast::AddressSpace::kPrivate: case type::AddressSpace::kPrivate:
case ast::AddressSpace::kFunction: case type::AddressSpace::kFunction:
break; // Allowed an initializer break; // Allowed an initializer
default: default:
// https://gpuweb.github.io/gpuweb/wgsl/#var-and-let // https://gpuweb.github.io/gpuweb/wgsl/#var-and-let
@ -394,17 +394,17 @@ bool Validator::VariableInitializer(const ast::Variable* v,
} }
bool Validator::AddressSpaceLayout(const type::Type* store_ty, bool Validator::AddressSpaceLayout(const type::Type* store_ty,
ast::AddressSpace address_space, type::AddressSpace address_space,
Source source) const { Source source) const {
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class-layout-constraints // https://gpuweb.github.io/gpuweb/wgsl/#storage-class-layout-constraints
auto is_uniform_struct_or_array = [address_space](const type::Type* ty) { auto is_uniform_struct_or_array = [address_space](const type::Type* ty) {
return address_space == ast::AddressSpace::kUniform && return address_space == type::AddressSpace::kUniform &&
ty->IsAnyOf<type::Array, sem::Struct>(); ty->IsAnyOf<type::Array, sem::Struct>();
}; };
auto is_uniform_struct = [address_space](const type::Type* ty) { auto is_uniform_struct = [address_space](const type::Type* ty) {
return address_space == ast::AddressSpace::kUniform && ty->Is<sem::Struct>(); return address_space == type::AddressSpace::kUniform && ty->Is<sem::Struct>();
}; };
auto required_alignment_of = [&](const type::Type* ty) { auto required_alignment_of = [&](const type::Type* ty) {
@ -425,7 +425,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
return true; return true;
} }
if (!ast::IsHostShareable(address_space)) { if (!type::IsHostShareable(address_space)) {
return true; return true;
} }
@ -438,7 +438,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
// Among three host-shareable address spaces, f16 is supported in "uniform" and // Among three host-shareable address spaces, f16 is supported in "uniform" and
// "storage" address space, but not "push_constant" address space yet. // "storage" address space, but not "push_constant" address space yet.
if (Is<type::F16>(type::Type::DeepestElementOf(store_ty)) && if (Is<type::F16>(type::Type::DeepestElementOf(store_ty)) &&
address_space == ast::AddressSpace::kPushConstant) { address_space == type::AddressSpace::kPushConstant) {
AddError("using f16 types in 'push_constant' address space is not implemented yet", source); AddError("using f16 types in 'push_constant' address space is not implemented yet", source);
return false; return false;
} }
@ -515,7 +515,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
return false; return false;
} }
if (address_space == ast::AddressSpace::kUniform) { if (address_space == type::AddressSpace::kUniform) {
// We already validated that this array member is itself aligned to 16 bytes above, so // We already validated that this array member is itself aligned to 16 bytes above, so
// we only need to validate that stride is a multiple of 16 bytes. // we only need to validate that stride is a multiple of 16 bytes.
if (arr->Stride() % 16 != 0) { if (arr->Stride() % 16 != 0) {
@ -581,7 +581,7 @@ bool Validator::GlobalVariable(
const sem::GlobalVariable* global, const sem::GlobalVariable* global,
const utils::Hashmap<OverrideId, const sem::Variable*, 8>& override_ids) const { const utils::Hashmap<OverrideId, const sem::Variable*, 8>& override_ids) const {
auto* decl = global->Declaration(); auto* decl = global->Declaration();
if (global->AddressSpace() != ast::AddressSpace::kWorkgroup && if (global->AddressSpace() != type::AddressSpace::kWorkgroup &&
IsArrayWithOverrideCount(global->Type())) { IsArrayWithOverrideCount(global->Type())) {
RaiseArrayWithOverrideCountError(decl->type ? decl->type->source RaiseArrayWithOverrideCountError(decl->type ? decl->type->source
: decl->initializer->source); : decl->initializer->source);
@ -597,7 +597,7 @@ bool Validator::GlobalVariable(
return false; return false;
} }
if (global->AddressSpace() == ast::AddressSpace::kNone) { if (global->AddressSpace() == type::AddressSpace::kNone) {
AddError("module-scope 'var' declaration must have a address space", decl->source); AddError("module-scope 'var' declaration must have a address space", decl->source);
return false; return false;
} }
@ -606,8 +606,8 @@ bool Validator::GlobalVariable(
bool is_shader_io_attribute = bool is_shader_io_attribute =
attr->IsAnyOf<ast::BuiltinAttribute, ast::InterpolateAttribute, attr->IsAnyOf<ast::BuiltinAttribute, ast::InterpolateAttribute,
ast::InvariantAttribute, ast::LocationAttribute>(); ast::InvariantAttribute, ast::LocationAttribute>();
bool has_io_address_space = global->AddressSpace() == ast::AddressSpace::kIn || bool has_io_address_space = global->AddressSpace() == type::AddressSpace::kIn ||
global->AddressSpace() == ast::AddressSpace::kOut; global->AddressSpace() == type::AddressSpace::kOut;
if (!attr->IsAnyOf<ast::BindingAttribute, ast::GroupAttribute, if (!attr->IsAnyOf<ast::BindingAttribute, ast::GroupAttribute,
ast::InternalAttribute>() && ast::InternalAttribute>() &&
(!is_shader_io_attribute || !has_io_address_space)) { (!is_shader_io_attribute || !has_io_address_space)) {
@ -639,15 +639,15 @@ bool Validator::GlobalVariable(
return false; return false;
} }
if (global->AddressSpace() == ast::AddressSpace::kFunction) { if (global->AddressSpace() == type::AddressSpace::kFunction) {
AddError("module-scope 'var' must not use address space 'function'", decl->source); AddError("module-scope 'var' must not use address space 'function'", decl->source);
return false; return false;
} }
switch (global->AddressSpace()) { switch (global->AddressSpace()) {
case ast::AddressSpace::kUniform: case type::AddressSpace::kUniform:
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
case ast::AddressSpace::kHandle: { case type::AddressSpace::kHandle: {
// https://gpuweb.github.io/gpuweb/wgsl/#resource-interface // https://gpuweb.github.io/gpuweb/wgsl/#resource-interface
// Each resource variable must be declared with both group and binding attributes. // Each resource variable must be declared with both group and binding attributes.
if (!decl->HasBindingPoint()) { if (!decl->HasBindingPoint()) {
@ -682,7 +682,7 @@ bool Validator::Var(const sem::Variable* v) const {
} }
if (store_ty->is_handle()) { if (store_ty->is_handle()) {
if (var->declared_address_space != ast::AddressSpace::kNone) { if (var->declared_address_space != type::AddressSpace::kNone) {
// https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables // https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
// If the store type is a texture type or a sampler type, then the variable declaration // If the store type is a texture type or a sampler type, then the variable declaration
// must not have a address space attribute. The address space will always be handle. // must not have a address space attribute. The address space will always be handle.
@ -698,7 +698,7 @@ bool Validator::Var(const sem::Variable* v) const {
// When writing a variable declaration or a pointer type in WGSL source: // When writing a variable declaration or a pointer type in WGSL source:
// * For the storage address space, the access mode is optional, and defaults to read. // * For the storage address space, the access mode is optional, and defaults to read.
// * For other address spaces, the access mode must not be written. // * For other address spaces, the access mode must not be written.
if (var->declared_address_space != ast::AddressSpace::kStorage) { if (var->declared_address_space != type::AddressSpace::kStorage) {
AddError("only variables in <storage> address space may declare an access mode", AddError("only variables in <storage> address space may declare an access mode",
var->source); var->source);
return false; return false;
@ -711,8 +711,8 @@ bool Validator::Var(const sem::Variable* v) const {
} }
if (IsValidationEnabled(var->attributes, ast::DisabledValidation::kIgnoreAddressSpace) && if (IsValidationEnabled(var->attributes, ast::DisabledValidation::kIgnoreAddressSpace) &&
(var->declared_address_space == ast::AddressSpace::kIn || (var->declared_address_space == type::AddressSpace::kIn ||
var->declared_address_space == ast::AddressSpace::kOut)) { var->declared_address_space == type::AddressSpace::kOut)) {
AddError("invalid use of input/output address space", var->source); AddError("invalid use of input/output address space", var->source);
return false; return false;
} }
@ -806,13 +806,13 @@ bool Validator::Parameter(const ast::Function* func, const sem::Variable* var) c
auto sc = ref->AddressSpace(); auto sc = ref->AddressSpace();
switch (sc) { switch (sc) {
case ast::AddressSpace::kFunction: case type::AddressSpace::kFunction:
case ast::AddressSpace::kPrivate: case type::AddressSpace::kPrivate:
ok = true; ok = true;
break; break;
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
case ast::AddressSpace::kUniform: case type::AddressSpace::kUniform:
case ast::AddressSpace::kWorkgroup: case type::AddressSpace::kWorkgroup:
ok = enabled_extensions_.Contains( ok = enabled_extensions_.Contains(
ast::Extension::kChromiumExperimentalFullPtrParameters); ast::Extension::kChromiumExperimentalFullPtrParameters);
break; break;
@ -1863,7 +1863,7 @@ bool Validator::PipelineStages(utils::VectorRef<sem::Function*> entry_points) co
auto stage = entry_point->Declaration()->PipelineStage(); auto stage = entry_point->Declaration()->PipelineStage();
if (stage != ast::PipelineStage::kCompute) { if (stage != ast::PipelineStage::kCompute) {
for (auto* var : func->DirectlyReferencedGlobals()) { for (auto* var : func->DirectlyReferencedGlobals()) {
if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) { if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
std::stringstream stage_name; std::stringstream stage_name;
stage_name << stage; stage_name << stage;
for (auto* user : var->Users()) { for (auto* user : var->Users()) {
@ -1949,7 +1949,7 @@ bool Validator::PushConstants(utils::VectorRef<sem::Function*> entry_points) con
auto check_push_constant = [&](const sem::Function* func, const sem::Function* ep) { auto check_push_constant = [&](const sem::Function* func, const sem::Function* ep) {
for (auto* var : func->DirectlyReferencedGlobals()) { for (auto* var : func->DirectlyReferencedGlobals()) {
if (var->AddressSpace() != ast::AddressSpace::kPushConstant || if (var->AddressSpace() != type::AddressSpace::kPushConstant ||
var == push_constant_var) { var == push_constant_var) {
continue; continue;
} }
@ -2455,14 +2455,14 @@ std::string Validator::VectorPretty(uint32_t size, const type::Type* element_typ
bool Validator::CheckTypeAccessAddressSpace( bool Validator::CheckTypeAccessAddressSpace(
const type::Type* store_ty, const type::Type* store_ty,
ast::Access access, ast::Access access,
ast::AddressSpace address_space, type::AddressSpace address_space,
utils::VectorRef<const tint::ast::Attribute*> attributes, utils::VectorRef<const tint::ast::Attribute*> attributes,
const Source& source) const { const Source& source) const {
if (!AddressSpaceLayout(store_ty, address_space, source)) { if (!AddressSpaceLayout(store_ty, address_space, source)) {
return false; return false;
} }
if (address_space == ast::AddressSpace::kPushConstant && if (address_space == type::AddressSpace::kPushConstant &&
!enabled_extensions_.Contains(ast::Extension::kChromiumExperimentalPushConstant) && !enabled_extensions_.Contains(ast::Extension::kChromiumExperimentalPushConstant) &&
IsValidationEnabled(attributes, ast::DisabledValidation::kIgnoreAddressSpace)) { IsValidationEnabled(attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
AddError( AddError(
@ -2472,7 +2472,7 @@ bool Validator::CheckTypeAccessAddressSpace(
return false; return false;
} }
if (address_space == ast::AddressSpace::kStorage && access == ast::Access::kWrite) { if (address_space == type::AddressSpace::kStorage && access == ast::Access::kWrite) {
// The access mode for the storage address space can only be 'read' or // The access mode for the storage address space can only be 'read' or
// 'read_write'. // 'read_write'.
AddError("access mode 'write' is not valid for the 'storage' address space", source); AddError("access mode 'write' is not valid for the 'storage' address space", source);
@ -2480,11 +2480,11 @@ bool Validator::CheckTypeAccessAddressSpace(
} }
auto atomic_error = [&]() -> const char* { auto atomic_error = [&]() -> const char* {
if (address_space != ast::AddressSpace::kStorage && if (address_space != type::AddressSpace::kStorage &&
address_space != ast::AddressSpace::kWorkgroup) { address_space != type::AddressSpace::kWorkgroup) {
return "atomic variables must have <storage> or <workgroup> address space"; return "atomic variables must have <storage> or <workgroup> address space";
} }
if (address_space == ast::AddressSpace::kStorage && access != ast::Access::kReadWrite) { if (address_space == type::AddressSpace::kStorage && access != ast::Access::kReadWrite) {
return "atomic variables in <storage> address space must have read_write access " return "atomic variables in <storage> address space must have read_write access "
"mode"; "mode";
} }

8
src/tint/resolver/validator.h
View File

@ -74,7 +74,7 @@ struct TypeAndAddressSpace {
/// The type /// The type
const type::Type* type; const type::Type* type;
/// The address space /// The address space
ast::AddressSpace address_space; type::AddressSpace address_space;
/// Equality operator /// Equality operator
/// @param other the other TypeAndAddressSpace to compare this TypeAndAddressSpace to /// @param other the other TypeAndAddressSpace to compare this TypeAndAddressSpace to
@ -418,7 +418,7 @@ class Validator {
/// @param initializer the RHS initializer expression /// @param initializer the RHS initializer expression
/// @returns true on succes, false otherwise /// @returns true on succes, false otherwise
bool VariableInitializer(const ast::Variable* v, bool VariableInitializer(const ast::Variable* v,
ast::AddressSpace address_space, type::AddressSpace address_space,
const type::Type* storage_type, const type::Type* storage_type,
const sem::Expression* initializer) const; const sem::Expression* initializer) const;
@ -464,7 +464,7 @@ class Validator {
/// @param sc the address space /// @param sc the address space
/// @param source the source of the type /// @param source the source of the type
/// @returns true on success, false otherwise /// @returns true on success, false otherwise
bool AddressSpaceLayout(const type::Type* type, ast::AddressSpace sc, Source source) const; bool AddressSpaceLayout(const type::Type* type, type::AddressSpace sc, Source source) const;
/// @returns true if the attribute list contains a /// @returns true if the attribute list contains a
/// ast::DisableValidationAttribute with the validation mode equal to /// ast::DisableValidationAttribute with the validation mode equal to
@ -519,7 +519,7 @@ class Validator {
/// @returns true on success, false if an error was raised. /// @returns true on success, false if an error was raised.
bool CheckTypeAccessAddressSpace(const type::Type* store_ty, bool CheckTypeAccessAddressSpace(const type::Type* store_ty,
ast::Access access, ast::Access access,
ast::AddressSpace address_space, type::AddressSpace address_space,
utils::VectorRef<const tint::ast::Attribute*> attributes, utils::VectorRef<const tint::ast::Attribute*> attributes,
const Source& source) const; const Source& source) const;
SymbolTable& symbols_; SymbolTable& symbols_;

2
src/tint/resolver/validator_is_storeable_test.cc
View File

@ -78,7 +78,7 @@ TEST_F(ValidatorIsStorableTest, Matrix) {
} }
TEST_F(ValidatorIsStorableTest, Pointer) { TEST_F(ValidatorIsStorableTest, Pointer) {
auto* ptr = create<type::Pointer>(create<type::I32>(), ast::AddressSpace::kPrivate, auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
ast::Access::kReadWrite); ast::Access::kReadWrite);
EXPECT_FALSE(v()->IsStorable(ptr)); EXPECT_FALSE(v()->IsStorable(ptr));
} }

24
src/tint/resolver/variable_test.cc
View File

@ -238,7 +238,7 @@ TEST_F(ResolverVariableTest, LocalVar_ShadowsGlobalVar) {
// var a = a; // var a = a;
// } // }
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
auto* v = Var("a", Expr("a")); auto* v = Var("a", Expr("a"));
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(v)}); Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(v)});
@ -421,7 +421,7 @@ TEST_F(ResolverVariableTest, LocalLet) {
auto* b = Let("b", ty.bool_(), b_c); auto* b = Let("b", ty.bool_(), b_c);
auto* s = Let("s", ty.Of(S), s_c); auto* s = Let("s", ty.Of(S), s_c);
auto* a = Let("a", ty.Of(A), a_c); auto* a = Let("a", ty.Of(A), a_c);
auto* p = Let("p", ty.pointer<i32>(ast::AddressSpace::kFunction), p_c); auto* p = Let("p", ty.pointer<i32>(type::AddressSpace::kFunction), p_c);
Func("F", utils::Empty, ty.void_(), Func("F", utils::Empty, ty.void_(),
utils::Vector{ utils::Vector{
@ -472,8 +472,8 @@ TEST_F(ResolverVariableTest, LocalLet_InheritsAccessFromOriginatingVariable) {
// } // }
auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())}); auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))}); auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))});
auto* storage = GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, ast::Access::kReadWrite, auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage,
Binding(0_a), Group(0_a)); ast::Access::kReadWrite, Binding(0_a), Group(0_a));
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 3_i); auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 3_i);
auto* ptr = Let("p", AddressOf(expr)); auto* ptr = Let("p", AddressOf(expr));
@ -554,7 +554,7 @@ TEST_F(ResolverVariableTest, LocalLet_ShadowsGlobalVar) {
// let a = a; // let a = a;
// } // }
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
auto* l = Let("a", Expr("a")); auto* l = Let("a", Expr("a"));
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(l)}); Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(l)});
@ -766,7 +766,7 @@ TEST_F(ResolverVariableTest, LocalConst_ShadowsGlobalVar) {
// const a = 1i; // const a = 1i;
// } // }
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
auto* c = Const("a", Expr(1_i)); auto* c = Const("a", Expr(1_i));
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(c)}); Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(c)});
@ -1037,12 +1037,12 @@ TEST_F(ResolverVariableTest, GlobalVar_AddressSpace) {
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class // https://gpuweb.github.io/gpuweb/wgsl/#storage-class
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())}); auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
auto* private_ = GlobalVar("p", ty.i32(), ast::AddressSpace::kPrivate); auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate);
auto* workgroup = GlobalVar("w", ty.i32(), ast::AddressSpace::kWorkgroup); auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup);
auto* uniform = auto* uniform =
GlobalVar("ub", ty.Of(buf), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); GlobalVar("ub", ty.Of(buf), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
auto* storage = auto* storage =
GlobalVar("sb", ty.Of(buf), ast::AddressSpace::kStorage, Binding(1_a), Group(0_a)); GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage, Binding(1_a), Group(0_a));
auto* handle = auto* handle =
GlobalVar("h", ty.depth_texture(type::TextureDimension::k2d), Binding(2_a), Group(0_a)); GlobalVar("h", ty.depth_texture(type::TextureDimension::k2d), Binding(2_a), Group(0_a));
@ -1065,7 +1065,7 @@ TEST_F(ResolverVariableTest, GlobalVar_ExplicitAddressSpace) {
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class // https://gpuweb.github.io/gpuweb/wgsl/#storage-class
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())}); auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
auto* storage = GlobalVar("sb", ty.Of(buf), ast::AddressSpace::kStorage, auto* storage = GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage,
ast::Access::kReadWrite, Binding(1_a), Group(0_a)); ast::Access::kReadWrite, Binding(1_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -1222,7 +1222,7 @@ TEST_F(ResolverVariableTest, Param_ShadowsGlobalVar) {
// fn F(a : bool) { // fn F(a : bool) {
// } // }
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
auto* p = Param("a", ty.bool_()); auto* p = Param("a", ty.bool_());
Func("F", utils::Vector{p}, ty.void_(), utils::Empty); Func("F", utils::Vector{p}, ty.void_(), utils::Empty);

24
src/tint/resolver/variable_validation_test.cc
View File

@ -61,8 +61,8 @@ TEST_F(ResolverVariableValidationTest, GlobalVarInitializerNoReturnValueBuiltin)
TEST_F(ResolverVariableValidationTest, GlobalVarUsedAtModuleScope) { TEST_F(ResolverVariableValidationTest, GlobalVarUsedAtModuleScope) {
// var<private> a : i32; // var<private> a : i32;
// var<private> b : i32 = a; // var<private> b : i32 = a;
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kPrivate); GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kPrivate);
GlobalVar("b", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a")); GlobalVar("b", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a"));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(56:78 error: var 'a' cannot be referenced at module-scope EXPECT_EQ(r()->error(), R"(56:78 error: var 'a' cannot be referenced at module-scope
@ -112,8 +112,8 @@ TEST_F(ResolverVariableValidationTest, VarTypeNotConstructible) {
// var i : i32; // var i : i32;
// var p : pointer<function, i32> = &v; // var p : pointer<function, i32> = &v;
auto* i = Var("i", ty.i32()); auto* i = Var("i", ty.i32());
auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, ast::AddressSpace::kFunction), auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, type::AddressSpace::kFunction),
ast::AddressSpace::kNone, AddressOf(Source{{12, 34}}, "i")); type::AddressSpace::kNone, AddressOf(Source{{12, 34}}, "i"));
WrapInFunction(i, p); WrapInFunction(i, p);
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -205,7 +205,7 @@ TEST_F(ResolverVariableValidationTest, VarInitializerWrongTypeViaAlias) {
TEST_F(ResolverVariableValidationTest, LetOfPtrConstructedWithRef) { TEST_F(ResolverVariableValidationTest, LetOfPtrConstructedWithRef) {
// var a : f32; // var a : f32;
// let b : ptr<function,f32> = a; // let b : ptr<function,f32> = a;
const auto priv = ast::AddressSpace::kFunction; const auto priv = type::AddressSpace::kFunction;
auto* var_a = Var("a", ty.f32(), priv); auto* var_a = Var("a", ty.f32(), priv);
auto* var_b = Let(Source{{12, 34}}, "b", ty.pointer<f32>(priv), Expr("a")); auto* var_b = Let(Source{{12, 34}}, "b", ty.pointer<f32>(priv), Expr("a"));
WrapInFunction(var_a, var_b); WrapInFunction(var_a, var_b);
@ -236,7 +236,7 @@ TEST_F(ResolverVariableValidationTest, GlobalVarRedeclaredAsLocal) {
// return 0; // return 0;
// } // }
GlobalVar("v", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f)); GlobalVar("v", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
WrapInFunction(Var(Source{{12, 34}}, "v", ty.f32(), Expr(2_f))); WrapInFunction(Var(Source{{12, 34}}, "v", ty.f32(), Expr(2_f)));
@ -295,12 +295,12 @@ TEST_F(ResolverVariableValidationTest, InferredPtrStorageAccessMismatch) {
Member("inner", ty.Of(inner)), Member("inner", ty.Of(inner)),
}); });
auto* storage = auto* storage =
GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i); auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i);
auto* ptr = auto* ptr = Let(Source{{12, 34}}, "p",
Let(Source{{12, 34}}, "p", ty.pointer<i32>(type::AddressSpace::kStorage, ast::Access::kReadWrite),
ty.pointer<i32>(ast::AddressSpace::kStorage, ast::Access::kReadWrite), AddressOf(expr)); AddressOf(expr));
WrapInFunction(ptr); WrapInFunction(ptr);
@ -359,7 +359,7 @@ TEST_F(ResolverVariableValidationTest, NonConstructibleType_InferredType) {
TEST_F(ResolverVariableValidationTest, InvalidAddressSpaceForInitializer) { TEST_F(ResolverVariableValidationTest, InvalidAddressSpaceForInitializer) {
// var<workgroup> v : f32 = 1.23; // var<workgroup> v : f32 = 1.23;
GlobalVar(Source{{12, 34}}, "v", ty.f32(), ast::AddressSpace::kWorkgroup, Expr(1.23_f)); GlobalVar(Source{{12, 34}}, "v", ty.f32(), type::AddressSpace::kWorkgroup, Expr(1.23_f));
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),
@ -490,7 +490,7 @@ TEST_F(ResolverVariableValidationTest, GlobalVariable_PushConstantWithInitialize
// enable chromium_experimental_push_constant; // enable chromium_experimental_push_constant;
// var<push_constant> a : u32 = 0u; // var<push_constant> a : u32 = 0u;
Enable(ast::Extension::kChromiumExperimentalPushConstant); Enable(ast::Extension::kChromiumExperimentalPushConstant);
GlobalVar(Source{{1u, 2u}}, "a", ty.u32(), ast::AddressSpace::kPushConstant, GlobalVar(Source{{1u, 2u}}, "a", ty.u32(), type::AddressSpace::kPushConstant,
Expr(Source{{3u, 4u}}, u32(0))); Expr(Source{{3u, 4u}}, u32(0)));
ASSERT_FALSE(r()->Resolve()); ASSERT_FALSE(r()->Resolve());

4
src/tint/sem/function.cc
View File

@ -68,7 +68,7 @@ Function::VariableBindings Function::TransitivelyReferencedUniformVariables() co
VariableBindings ret; VariableBindings ret;
for (auto* global : TransitivelyReferencedGlobals()) { for (auto* global : TransitivelyReferencedGlobals()) {
if (global->AddressSpace() != ast::AddressSpace::kUniform) { if (global->AddressSpace() != type::AddressSpace::kUniform) {
continue; continue;
} }
@ -83,7 +83,7 @@ Function::VariableBindings Function::TransitivelyReferencedStorageBufferVariable
VariableBindings ret; VariableBindings ret;
for (auto* global : TransitivelyReferencedGlobals()) { for (auto* global : TransitivelyReferencedGlobals()) {
if (global->AddressSpace() != ast::AddressSpace::kStorage) { if (global->AddressSpace() != type::AddressSpace::kStorage) {
continue; continue;
} }

2
src/tint/sem/struct.h
View File

@ -17,9 +17,9 @@
#include <optional> #include <optional>
#include "src/tint/ast/address_space.h"
#include "src/tint/ast/struct.h" #include "src/tint/ast/struct.h"
#include "src/tint/symbol.h" #include "src/tint/symbol.h"
#include "src/tint/type/address_space.h"
#include "src/tint/type/struct.h" #include "src/tint/type/struct.h"
#include "src/tint/type/type.h" #include "src/tint/type/type.h"
#include "src/tint/utils/vector.h" #include "src/tint/utils/vector.h"

8
src/tint/sem/variable.cc
View File

@ -31,7 +31,7 @@ namespace tint::sem {
Variable::Variable(const ast::Variable* declaration, Variable::Variable(const ast::Variable* declaration,
const type::Type* type, const type::Type* type,
EvaluationStage stage, EvaluationStage stage,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const constant::Value* constant_value) const constant::Value* constant_value)
: declaration_(declaration), : declaration_(declaration),
@ -46,7 +46,7 @@ Variable::~Variable() = default;
LocalVariable::LocalVariable(const ast::Variable* declaration, LocalVariable::LocalVariable(const ast::Variable* declaration,
const type::Type* type, const type::Type* type,
EvaluationStage stage, EvaluationStage stage,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const sem::Statement* statement, const sem::Statement* statement,
const constant::Value* constant_value) const constant::Value* constant_value)
@ -58,7 +58,7 @@ LocalVariable::~LocalVariable() = default;
GlobalVariable::GlobalVariable(const ast::Variable* declaration, GlobalVariable::GlobalVariable(const ast::Variable* declaration,
const type::Type* type, const type::Type* type,
EvaluationStage stage, EvaluationStage stage,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const constant::Value* constant_value, const constant::Value* constant_value,
sem::BindingPoint binding_point, sem::BindingPoint binding_point,
@ -72,7 +72,7 @@ GlobalVariable::~GlobalVariable() = default;
Parameter::Parameter(const ast::Parameter* declaration, Parameter::Parameter(const ast::Parameter* declaration,
uint32_t index, uint32_t index,
const type::Type* type, const type::Type* type,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const ParameterUsage usage /* = ParameterUsage::kNone */, const ParameterUsage usage /* = ParameterUsage::kNone */,
sem::BindingPoint binding_point /* = {} */, sem::BindingPoint binding_point /* = {} */,

14
src/tint/sem/variable.h
View File

@ -22,11 +22,11 @@
#include "tint/override_id.h" #include "tint/override_id.h"
#include "src/tint/ast/access.h" #include "src/tint/ast/access.h"
#include "src/tint/ast/address_space.h"
#include "src/tint/ast/parameter.h" #include "src/tint/ast/parameter.h"
#include "src/tint/sem/binding_point.h" #include "src/tint/sem/binding_point.h"
#include "src/tint/sem/expression.h" #include "src/tint/sem/expression.h"
#include "src/tint/sem/parameter_usage.h" #include "src/tint/sem/parameter_usage.h"
#include "src/tint/type/address_space.h"
#include "src/tint/type/type.h" #include "src/tint/type/type.h"
#include "src/tint/utils/unique_vector.h" #include "src/tint/utils/unique_vector.h"
@ -57,7 +57,7 @@ class Variable : public Castable<Variable, Node> {
Variable(const ast::Variable* declaration, Variable(const ast::Variable* declaration,
const type::Type* type, const type::Type* type,
EvaluationStage stage, EvaluationStage stage,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const constant::Value* constant_value); const constant::Value* constant_value);
@ -74,7 +74,7 @@ class Variable : public Castable<Variable, Node> {
EvaluationStage Stage() const { return stage_; } EvaluationStage Stage() const { return stage_; }
/// @returns the address space for the variable /// @returns the address space for the variable
ast::AddressSpace AddressSpace() const { return address_space_; } type::AddressSpace AddressSpace() const { return address_space_; }
/// @returns the access control for the variable /// @returns the access control for the variable
ast::Access Access() const { return access_; } ast::Access Access() const { return access_; }
@ -100,7 +100,7 @@ class Variable : public Castable<Variable, Node> {
const ast::Variable* const declaration_; const ast::Variable* const declaration_;
const type::Type* const type_; const type::Type* const type_;
const EvaluationStage stage_; const EvaluationStage stage_;
const ast::AddressSpace address_space_; const type::AddressSpace address_space_;
const ast::Access access_; const ast::Access access_;
const constant::Value* constant_value_; const constant::Value* constant_value_;
const Expression* initializer_ = nullptr; const Expression* initializer_ = nullptr;
@ -121,7 +121,7 @@ class LocalVariable final : public Castable<LocalVariable, Variable> {
LocalVariable(const ast::Variable* declaration, LocalVariable(const ast::Variable* declaration,
const type::Type* type, const type::Type* type,
EvaluationStage stage, EvaluationStage stage,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const sem::Statement* statement, const sem::Statement* statement,
const constant::Value* constant_value); const constant::Value* constant_value);
@ -162,7 +162,7 @@ class GlobalVariable final : public Castable<GlobalVariable, Variable> {
GlobalVariable(const ast::Variable* declaration, GlobalVariable(const ast::Variable* declaration,
const type::Type* type, const type::Type* type,
EvaluationStage stage, EvaluationStage stage,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const constant::Value* constant_value, const constant::Value* constant_value,
sem::BindingPoint binding_point = {}, sem::BindingPoint binding_point = {},
@ -205,7 +205,7 @@ class Parameter final : public Castable<Parameter, Variable> {
Parameter(const ast::Parameter* declaration, Parameter(const ast::Parameter* declaration,
uint32_t index, uint32_t index,
const type::Type* type, const type::Type* type,
ast::AddressSpace address_space, type::AddressSpace address_space,
ast::Access access, ast::Access access,
const ParameterUsage usage = ParameterUsage::kNone, const ParameterUsage usage = ParameterUsage::kNone,
sem::BindingPoint binding_point = {}, sem::BindingPoint binding_point = {},

2
src/tint/transform/add_block_attribute.cc
View File

@ -47,7 +47,7 @@ Transform::ApplyResult AddBlockAttribute::Apply(const Program* src,
bool made_changes = false; bool made_changes = false;
for (auto* global : src->AST().GlobalVariables()) { for (auto* global : src->AST().GlobalVariables()) {
auto* var = sem.Get(global); auto* var = sem.Get(global);
if (!ast::IsHostShareable(var->AddressSpace())) { if (!type::IsHostShareable(var->AddressSpace())) {
// Not declared in a host-sharable address space // Not declared in a host-sharable address space
continue; continue;
} }

2
src/tint/transform/array_length_from_uniform.cc
View File

@ -107,7 +107,7 @@ struct ArrayLengthFromUniform::State {
u32((max_buffer_size_index / 4) + 1))), u32((max_buffer_size_index / 4) + 1))),
}); });
buffer_size_ubo = buffer_size_ubo =
b.GlobalVar(b.Sym(), b.ty.Of(buffer_size_struct), ast::AddressSpace::kUniform, b.GlobalVar(b.Sym(), b.ty.Of(buffer_size_struct), type::AddressSpace::kUniform,
b.Group(AInt(cfg->ubo_binding.group)), b.Group(AInt(cfg->ubo_binding.group)),
b.Binding(AInt(cfg->ubo_binding.binding))); b.Binding(AInt(cfg->ubo_binding.binding)));
} }

2
src/tint/transform/binding_remapper.cc
View File

@ -130,7 +130,7 @@ Transform::ApplyResult BindingRemapper::Apply(const Program* src,
return Program(std::move(b)); return Program(std::move(b));
} }
auto* sem = src->Sem().Get(var); auto* sem = src->Sem().Get(var);
if (sem->AddressSpace() != ast::AddressSpace::kStorage) { if (sem->AddressSpace() != type::AddressSpace::kStorage) {
b.Diagnostics().add_error( b.Diagnostics().add_error(
diag::System::Transform, diag::System::Transform,
"cannot apply access control to variable with address space " + "cannot apply access control to variable with address space " +

2
src/tint/transform/builtin_polyfill.cc
View File

@ -679,7 +679,7 @@ struct BuiltinPolyfill::State {
auto name = b.Symbols().New("tint_workgroupUniformLoad"); auto name = b.Symbols().New("tint_workgroupUniformLoad");
b.Func(name, b.Func(name,
utils::Vector{ utils::Vector{
b.Param("p", b.ty.pointer(T(type), ast::AddressSpace::kWorkgroup)), b.Param("p", b.ty.pointer(T(type), type::AddressSpace::kWorkgroup)),
}, },
T(type), T(type),
utils::Vector{ utils::Vector{

2
src/tint/transform/calculate_array_length.cc
View File

@ -112,7 +112,7 @@ Transform::ApplyResult CalculateArrayLength::Apply(const Program* src,
b.Param("buffer", b.Param("buffer",
b.ty.pointer(type, buffer_type->AddressSpace(), buffer_type->Access()), b.ty.pointer(type, buffer_type->AddressSpace(), buffer_type->Access()),
utils::Vector{disable_validation}), utils::Vector{disable_validation}),
b.Param("result", b.ty.pointer(b.ty.u32(), ast::AddressSpace::kFunction)), b.Param("result", b.ty.pointer(b.ty.u32(), type::AddressSpace::kFunction)),
}, },
b.ty.void_(), nullptr, b.ty.void_(), nullptr,
utils::Vector{ utils::Vector{

12
src/tint/transform/canonicalize_entry_point_io.cc
View File

@ -234,7 +234,7 @@ struct CanonicalizeEntryPointIO::State {
auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attributes); auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attributes);
if (cfg.shader_style == ShaderStyle::kGlsl && builtin) { if (cfg.shader_style == ShaderStyle::kGlsl && builtin) {
name = GLSLBuiltinToString(builtin->builtin, func_ast->PipelineStage(), name = GLSLBuiltinToString(builtin->builtin, func_ast->PipelineStage(),
ast::AddressSpace::kIn); type::AddressSpace::kIn);
} }
auto symbol = ctx.dst->Symbols().New(name); auto symbol = ctx.dst->Symbols().New(name);
@ -251,7 +251,7 @@ struct CanonicalizeEntryPointIO::State {
value = ctx.dst->IndexAccessor(value, 0_i); value = ctx.dst->IndexAccessor(value, 0_i);
} }
} }
ctx.dst->GlobalVar(symbol, ast_type, ast::AddressSpace::kIn, std::move(attributes)); ctx.dst->GlobalVar(symbol, ast_type, type::AddressSpace::kIn, std::move(attributes));
return value; return value;
} else if (cfg.shader_style == ShaderStyle::kMsl && } else if (cfg.shader_style == ShaderStyle::kMsl &&
ast::HasAttribute<ast::BuiltinAttribute>(attributes)) { ast::HasAttribute<ast::BuiltinAttribute>(attributes)) {
@ -300,7 +300,7 @@ struct CanonicalizeEntryPointIO::State {
if (cfg.shader_style == ShaderStyle::kGlsl) { if (cfg.shader_style == ShaderStyle::kGlsl) {
if (auto* b = ast::GetAttribute<ast::BuiltinAttribute>(attributes)) { if (auto* b = ast::GetAttribute<ast::BuiltinAttribute>(attributes)) {
name = GLSLBuiltinToString(b->builtin, func_ast->PipelineStage(), name = GLSLBuiltinToString(b->builtin, func_ast->PipelineStage(),
ast::AddressSpace::kOut); type::AddressSpace::kOut);
value = ToGLSLBuiltin(b->builtin, value, type); value = ToGLSLBuiltin(b->builtin, value, type);
} }
} }
@ -530,7 +530,7 @@ struct CanonicalizeEntryPointIO::State {
type = ctx.dst->ty.array(type, 1_u); type = ctx.dst->ty.array(type, 1_u);
lhs = ctx.dst->IndexAccessor(lhs, 0_i); lhs = ctx.dst->IndexAccessor(lhs, 0_i);
} }
ctx.dst->GlobalVar(name, type, ast::AddressSpace::kOut, std::move(attributes)); ctx.dst->GlobalVar(name, type, type::AddressSpace::kOut, std::move(attributes));
wrapper_body.Push(ctx.dst->Assign(lhs, outval.value)); wrapper_body.Push(ctx.dst->Assign(lhs, outval.value));
} }
} }
@ -674,7 +674,7 @@ struct CanonicalizeEntryPointIO::State {
/// @returns the gl_ string corresponding to that builtin /// @returns the gl_ string corresponding to that builtin
const char* GLSLBuiltinToString(ast::BuiltinValue builtin, const char* GLSLBuiltinToString(ast::BuiltinValue builtin,
ast::PipelineStage stage, ast::PipelineStage stage,
ast::AddressSpace address_space) { type::AddressSpace address_space) {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kPosition: case ast::BuiltinValue::kPosition:
switch (stage) { switch (stage) {
@ -706,7 +706,7 @@ struct CanonicalizeEntryPointIO::State {
case ast::BuiltinValue::kSampleIndex: case ast::BuiltinValue::kSampleIndex:
return "gl_SampleID"; return "gl_SampleID";
case ast::BuiltinValue::kSampleMask: case ast::BuiltinValue::kSampleMask:
if (address_space == ast::AddressSpace::kIn) { if (address_space == type::AddressSpace::kIn) {
return "gl_SampleMaskIn"; return "gl_SampleMaskIn";
} else { } else {
return "gl_SampleMask"; return "gl_SampleMask";

4
src/tint/transform/clamp_frag_depth.cc
View File

@ -89,7 +89,7 @@ Transform::ApplyResult ClampFragDepth::Apply(const Program* src, const DataMap&,
// Abort on any use of push constants in the module. // Abort on any use of push constants in the module.
for (auto* global : src->AST().GlobalVariables()) { for (auto* global : src->AST().GlobalVariables()) {
if (auto* var = global->As<ast::Var>()) { if (auto* var = global->As<ast::Var>()) {
if (TINT_UNLIKELY(var->declared_address_space == ast::AddressSpace::kPushConstant)) { if (TINT_UNLIKELY(var->declared_address_space == type::AddressSpace::kPushConstant)) {
TINT_ICE(Transform, b.Diagnostics()) TINT_ICE(Transform, b.Diagnostics())
<< "ClampFragDepth doesn't know how to handle module that already use push " << "ClampFragDepth doesn't know how to handle module that already use push "
"constants."; "constants.";
@ -124,7 +124,7 @@ Transform::ApplyResult ClampFragDepth::Apply(const Program* src, const DataMap&,
utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())}); utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())});
auto args_sym = b.Symbols().New("frag_depth_clamp_args"); auto args_sym = b.Symbols().New("frag_depth_clamp_args");
b.GlobalVar(args_sym, b.ty.type_name("FragDepthClampArgs"), ast::AddressSpace::kPushConstant); b.GlobalVar(args_sym, b.ty.type_name("FragDepthClampArgs"), type::AddressSpace::kPushConstant);
auto base_fn_sym = b.Symbols().New("clamp_frag_depth"); auto base_fn_sym = b.Symbols().New("clamp_frag_depth");
b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(), b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(),

26
src/tint/transform/decompose_memory_access.cc
View File

@ -50,8 +50,8 @@ namespace {
bool ShouldRun(const Program* program) { bool ShouldRun(const Program* program) {
for (auto* decl : program->AST().GlobalDeclarations()) { for (auto* decl : program->AST().GlobalDeclarations()) {
if (auto* var = program->Sem().Get<sem::Variable>(decl)) { if (auto* var = program->Sem().Get<sem::Variable>(decl)) {
if (var->AddressSpace() == ast::AddressSpace::kStorage || if (var->AddressSpace() == type::AddressSpace::kStorage ||
var->AddressSpace() == ast::AddressSpace::kUniform) { var->AddressSpace() == type::AddressSpace::kUniform) {
return true; return true;
} }
} }
@ -109,7 +109,7 @@ struct OffsetBinOp : Offset {
/// LoadStoreKey is the unordered map key to a load or store intrinsic. /// LoadStoreKey is the unordered map key to a load or store intrinsic.
struct LoadStoreKey { struct LoadStoreKey {
ast::AddressSpace const address_space; // buffer address space type::AddressSpace const address_space; // buffer address space
ast::Access const access; // buffer access ast::Access const access; // buffer access
type::Type const* buf_ty = nullptr; // buffer type type::Type const* buf_ty = nullptr; // buffer type
type::Type const* el_ty = nullptr; // element type type::Type const* el_ty = nullptr; // element type
@ -223,7 +223,7 @@ bool IntrinsicDataTypeFor(const type::Type* ty, DecomposeMemoryAccess::Intrinsic
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied
/// to a stub function to load the type `ty`. /// to a stub function to load the type `ty`.
DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder, DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder,
ast::AddressSpace address_space, type::AddressSpace address_space,
const type::Type* ty) { const type::Type* ty) {
DecomposeMemoryAccess::Intrinsic::DataType type; DecomposeMemoryAccess::Intrinsic::DataType type;
if (!IntrinsicDataTypeFor(ty, type)) { if (!IntrinsicDataTypeFor(ty, type)) {
@ -237,7 +237,7 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder,
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied
/// to a stub function to store the type `ty`. /// to a stub function to store the type `ty`.
DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder, DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder,
ast::AddressSpace address_space, type::AddressSpace address_space,
const type::Type* ty) { const type::Type* ty) {
DecomposeMemoryAccess::Intrinsic::DataType type; DecomposeMemoryAccess::Intrinsic::DataType type;
if (!IntrinsicDataTypeFor(ty, type)) { if (!IntrinsicDataTypeFor(ty, type)) {
@ -300,7 +300,7 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder,
return nullptr; return nullptr;
} }
return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>( return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
builder->ID(), builder->AllocateNodeID(), op, ast::AddressSpace::kStorage, type); builder->ID(), builder->AllocateNodeID(), op, type::AddressSpace::kStorage, type);
} }
/// BufferAccess describes a single storage or uniform buffer access /// BufferAccess describes a single storage or uniform buffer access
@ -466,7 +466,7 @@ struct DecomposeMemoryAccess::State {
const sem::VariableUser* var_user) { const sem::VariableUser* var_user) {
auto address_space = var_user->Variable()->AddressSpace(); auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access(); auto access = var_user->Variable()->Access();
if (address_space != ast::AddressSpace::kStorage) { if (address_space != type::AddressSpace::kStorage) {
access = ast::Access::kUndefined; access = ast::Access::kUndefined;
} }
return utils::GetOrCreate( return utils::GetOrCreate(
@ -565,7 +565,7 @@ struct DecomposeMemoryAccess::State {
const sem::VariableUser* var_user) { const sem::VariableUser* var_user) {
auto address_space = var_user->Variable()->AddressSpace(); auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access(); auto access = var_user->Variable()->Access();
if (address_space != ast::AddressSpace::kStorage) { if (address_space != type::AddressSpace::kStorage) {
access = ast::Access::kUndefined; access = ast::Access::kUndefined;
} }
return utils::GetOrCreate( return utils::GetOrCreate(
@ -678,7 +678,7 @@ struct DecomposeMemoryAccess::State {
auto op = intrinsic->Type(); auto op = intrinsic->Type();
auto address_space = var_user->Variable()->AddressSpace(); auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access(); auto access = var_user->Variable()->Access();
if (address_space != ast::AddressSpace::kStorage) { if (address_space != type::AddressSpace::kStorage) {
access = ast::Access::kUndefined; access = ast::Access::kUndefined;
} }
return utils::GetOrCreate(atomic_funcs, AtomicKey{access, buf_ty, el_ty, op}, [&] { return utils::GetOrCreate(atomic_funcs, AtomicKey{access, buf_ty, el_ty, op}, [&] {
@ -686,7 +686,7 @@ struct DecomposeMemoryAccess::State {
// atomic. This is replaced with two parameters: the buffer and offset. // atomic. This is replaced with two parameters: the buffer and offset.
utils::Vector params{ utils::Vector params{
b.Param("buffer", b.Param("buffer",
b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), ast::AddressSpace::kStorage, b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), type::AddressSpace::kStorage,
access), access),
utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}), utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}),
b.Param("offset", b.ty.u32()), b.Param("offset", b.ty.u32()),
@ -744,7 +744,7 @@ struct DecomposeMemoryAccess::State {
DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid, DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid,
ast::NodeID nid, ast::NodeID nid,
Op o, Op o,
ast::AddressSpace sc, type::AddressSpace sc,
DataType ty) DataType ty)
: Base(pid, nid), op(o), address_space(sc), type(ty) {} : Base(pid, nid), op(o), address_space(sc), type(ty) {}
DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default; DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default;
@ -883,8 +883,8 @@ Transform::ApplyResult DecomposeMemoryAccess::Apply(const Program* src,
// X // X
if (auto* sem_ident = sem.Get(ident)) { if (auto* sem_ident = sem.Get(ident)) {
if (auto* var = sem_ident->UnwrapLoad()->As<sem::VariableUser>()) { if (auto* var = sem_ident->UnwrapLoad()->As<sem::VariableUser>()) {
if (var->Variable()->AddressSpace() == ast::AddressSpace::kStorage || if (var->Variable()->AddressSpace() == type::AddressSpace::kStorage ||
var->Variable()->AddressSpace() == ast::AddressSpace::kUniform) { var->Variable()->AddressSpace() == type::AddressSpace::kUniform) {
// Variable to a storage or uniform buffer // Variable to a storage or uniform buffer
state.AddAccess(ident, { state.AddAccess(ident, {
var, var,

4
src/tint/transform/decompose_memory_access.h
View File

@ -81,7 +81,7 @@ class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Trans
/// @param o the op of the intrinsic /// @param o the op of the intrinsic
/// @param sc the address space of the buffer /// @param sc the address space of the buffer
/// @param ty the data type of the intrinsic /// @param ty the data type of the intrinsic
Intrinsic(ProgramID pid, ast::NodeID nid, Op o, ast::AddressSpace sc, DataType ty); Intrinsic(ProgramID pid, ast::NodeID nid, Op o, type::AddressSpace sc, DataType ty);
/// Destructor /// Destructor
~Intrinsic() override; ~Intrinsic() override;
@ -101,7 +101,7 @@ class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Trans
const Op op; const Op op;
/// The address space of the buffer this intrinsic operates on /// The address space of the buffer this intrinsic operates on
ast::AddressSpace const address_space; type::AddressSpace const address_space;
/// The type of the intrinsic /// The type of the intrinsic
const DataType type; const DataType type;

38
src/tint/transform/decompose_strided_array_test.cc
View File

@ -39,7 +39,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunNonStridedArray) {
// var<private> arr : array<f32, 4u> // var<private> arr : array<f32, 4u>
ProgramBuilder b; ProgramBuilder b;
b.GlobalVar("arr", b.ty.array<f32, 4u>(), ast::AddressSpace::kPrivate); b.GlobalVar("arr", b.ty.array<f32, 4u>(), type::AddressSpace::kPrivate);
EXPECT_FALSE(ShouldRun<DecomposeStridedArray>(Program(std::move(b)))); EXPECT_FALSE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
} }
@ -47,7 +47,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunDefaultStridedArray) {
// var<private> arr : @stride(4) array<f32, 4u> // var<private> arr : @stride(4) array<f32, 4u>
ProgramBuilder b; ProgramBuilder b;
b.GlobalVar("arr", b.ty.array<f32, 4u>(4), ast::AddressSpace::kPrivate); b.GlobalVar("arr", b.ty.array<f32, 4u>(4), type::AddressSpace::kPrivate);
EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b)))); EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
} }
@ -55,7 +55,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunExplicitStridedArray) {
// var<private> arr : @stride(16) array<f32, 4u> // var<private> arr : @stride(16) array<f32, 4u>
ProgramBuilder b; ProgramBuilder b;
b.GlobalVar("arr", b.ty.array<f32, 4u>(16), ast::AddressSpace::kPrivate); b.GlobalVar("arr", b.ty.array<f32, 4u>(16), type::AddressSpace::kPrivate);
EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b)))); EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
} }
@ -78,7 +78,7 @@ TEST_F(DecomposeStridedArrayTest, PrivateDefaultStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
b.GlobalVar("arr", b.ty.array<f32, 4u>(4), ast::AddressSpace::kPrivate); b.GlobalVar("arr", b.ty.array<f32, 4u>(4), type::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.array<f32, 4u>(4), b.Expr("arr"))), b.Decl(b.Let("a", b.ty.array<f32, 4u>(4), b.Expr("arr"))),
@ -114,7 +114,7 @@ TEST_F(DecomposeStridedArrayTest, PrivateStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
b.GlobalVar("arr", b.ty.array<f32, 4u>(32), ast::AddressSpace::kPrivate); b.GlobalVar("arr", b.ty.array<f32, 4u>(32), type::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.Expr("arr"))), b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.Expr("arr"))),
@ -158,7 +158,7 @@ TEST_F(DecomposeStridedArrayTest, ReadUniformStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.MemberAccessor("s", "a"))), b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.MemberAccessor("s", "a"))),
@ -206,7 +206,7 @@ TEST_F(DecomposeStridedArrayTest, ReadUniformDefaultStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(b.ty.vec4<f32>(), 4_u, 16))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(b.ty.vec4<f32>(), 4_u, 16))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func( b.Func(
"f", utils::Empty, b.ty.void_(), "f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
@ -252,7 +252,7 @@ TEST_F(DecomposeStridedArrayTest, ReadStorageStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.MemberAccessor("s", "a"))), b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.MemberAccessor("s", "a"))),
@ -300,7 +300,7 @@ TEST_F(DecomposeStridedArrayTest, ReadStorageDefaultStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(4))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(4))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.array<f32, 4u>(4), b.MemberAccessor("s", "a"))), b.Decl(b.Let("a", b.ty.array<f32, 4u>(4), b.MemberAccessor("s", "a"))),
@ -344,8 +344,8 @@ TEST_F(DecomposeStridedArrayTest, WriteStorageStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array<f32, 4u>(32))), b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array<f32, 4u>(32))),
@ -398,8 +398,8 @@ TEST_F(DecomposeStridedArrayTest, WriteStorageDefaultStridedArray) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(4))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(4))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array<f32, 4u>(4))), b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array<f32, 4u>(4))),
@ -450,8 +450,8 @@ TEST_F(DecomposeStridedArrayTest, ReadWriteViaPointerLets) {
// } // }
ProgramBuilder b; ProgramBuilder b;
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "a")))), b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "a")))),
@ -511,8 +511,8 @@ TEST_F(DecomposeStridedArrayTest, PrivateAliasedStridedArray) {
ProgramBuilder b; ProgramBuilder b;
b.Alias("ARR", b.ty.array<f32, 4u>(32)); b.Alias("ARR", b.ty.array<f32, 4u>(32));
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.type_name("ARR"))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.type_name("ARR"))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.type_name("ARR"), b.MemberAccessor("s", "a"))), b.Decl(b.Let("a", b.ty.type_name("ARR"), b.MemberAccessor("s", "a"))),
@ -581,8 +581,8 @@ TEST_F(DecomposeStridedArrayTest, PrivateNestedStridedArray) {
b.ty.array(b.ty.type_name("ARR_A"), 3_u, 16), // b.ty.array(b.ty.type_name("ARR_A"), 3_u, 16), //
4_u, 128)); 4_u, 128));
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.type_name("ARR_B"))}); auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.type_name("ARR_B"))});
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.ty.type_name("ARR_B"), b.MemberAccessor("s", "a"))), b.Decl(b.Let("a", b.ty.type_name("ARR_B"), b.MemberAccessor("s", "a"))),

4
src/tint/transform/decompose_strided_matrix.cc
View File

@ -72,8 +72,8 @@ Transform::ApplyResult DecomposeStridedMatrix::Apply(const Program* src,
for (auto* node : src->ASTNodes().Objects()) { for (auto* node : src->ASTNodes().Objects()) {
if (auto* str = node->As<ast::Struct>()) { if (auto* str = node->As<ast::Struct>()) {
auto* str_ty = src->Sem().Get(str); auto* str_ty = src->Sem().Get(str);
if (!str_ty->UsedAs(ast::AddressSpace::kUniform) && if (!str_ty->UsedAs(type::AddressSpace::kUniform) &&
!str_ty->UsedAs(ast::AddressSpace::kStorage)) { !str_ty->UsedAs(type::AddressSpace::kStorage)) {
continue; continue;
} }
for (auto* member : str_ty->Members()) { for (auto* member : str_ty->Members()) {

30
src/tint/transform/decompose_strided_matrix_test.cc
View File

@ -76,7 +76,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformMatrix) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))), b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
@ -133,7 +133,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformColumn) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func( b.Func(
"f", utils::Empty, b.ty.void_(), "f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
@ -187,7 +187,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformMatrix_DefaultStride) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))), b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
@ -241,8 +241,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadStorageMatrix) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))), b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
@ -299,8 +299,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadStorageColumn) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func( b.Func(
"f", utils::Empty, b.ty.void_(), "f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
@ -354,8 +354,8 @@ TEST_F(DecomposeStridedMatrixTest, WriteStorageMatrix) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Assign(b.MemberAccessor("s", "m"), b.Assign(b.MemberAccessor("s", "m"),
@ -413,8 +413,8 @@ TEST_F(DecomposeStridedMatrixTest, WriteStorageColumn) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Assign(b.IndexAccessor(b.MemberAccessor("s", "m"), 1_i), b.vec2<f32>(1_f, 2_f)), b.Assign(b.IndexAccessor(b.MemberAccessor("s", "m"), 1_i), b.vec2<f32>(1_f, 2_f)),
@ -473,8 +473,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadWriteViaPointerLets) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
b.Binding(0_a)); b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "m")))), b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "m")))),
@ -545,7 +545,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadPrivateMatrix) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kPrivate); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))), b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
@ -599,7 +599,7 @@ TEST_F(DecomposeStridedMatrixTest, WritePrivateMatrix) {
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}), }),
}); });
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kPrivate); b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(), b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{ utils::Vector{
b.Assign(b.MemberAccessor("s", "m"), b.Assign(b.MemberAccessor("s", "m"),

10
src/tint/transform/demote_to_helper.cc
View File

@ -81,7 +81,7 @@ Transform::ApplyResult DemoteToHelper::Apply(const Program* src, const DataMap&,
// Create a module-scope flag that indicates whether the current invocation has been discarded. // Create a module-scope flag that indicates whether the current invocation has been discarded.
auto flag = b.Symbols().New("tint_discarded"); auto flag = b.Symbols().New("tint_discarded");
b.GlobalVar(flag, ast::AddressSpace::kPrivate, b.Expr(false)); b.GlobalVar(flag, type::AddressSpace::kPrivate, b.Expr(false));
// Replace all discard statements with a statement that marks the invocation as discarded. // Replace all discard statements with a statement that marks the invocation as discarded.
ctx.ReplaceAll([&](const ast::DiscardStatement*) -> const ast::Statement* { ctx.ReplaceAll([&](const ast::DiscardStatement*) -> const ast::Statement* {
@ -125,12 +125,12 @@ Transform::ApplyResult DemoteToHelper::Apply(const Program* src, const DataMap&,
// Skip writes to invocation-private address spaces. // Skip writes to invocation-private address spaces.
auto* ref = sem.Get(assign->lhs)->Type()->As<type::Reference>(); auto* ref = sem.Get(assign->lhs)->Type()->As<type::Reference>();
switch (ref->AddressSpace()) { switch (ref->AddressSpace()) {
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
// Need to mask these. // Need to mask these.
break; break;
case ast::AddressSpace::kFunction: case type::AddressSpace::kFunction:
case ast::AddressSpace::kPrivate: case type::AddressSpace::kPrivate:
case ast::AddressSpace::kOut: case type::AddressSpace::kOut:
// Skip these. // Skip these.
return; return;
default: default:

26
src/tint/transform/direct_variable_access.cc
View File

@ -50,7 +50,7 @@ struct AccessRoot {
/// function-scope variable ('function'), or pointer parameter in the source program. /// function-scope variable ('function'), or pointer parameter in the source program.
tint::sem::Variable const* variable = nullptr; tint::sem::Variable const* variable = nullptr;
/// The address space of the variable or pointer type. /// The address space of the variable or pointer type.
tint::ast::AddressSpace address_space = tint::ast::AddressSpace::kUndefined; tint::type::AddressSpace address_space = tint::type::AddressSpace::kUndefined;
}; };
/// Inequality operator for AccessRoot /// Inequality operator for AccessRoot
@ -450,7 +450,7 @@ struct DirectVariableAccess::State {
Switch( Switch(
variable->Declaration(), variable->Declaration(),
[&](const ast::Var*) { [&](const ast::Var*) {
if (variable->AddressSpace() != ast::AddressSpace::kHandle) { if (variable->AddressSpace() != type::AddressSpace::kHandle) {
// Start a new access chain for the non-handle 'var' access // Start a new access chain for the non-handle 'var' access
create_new_chain(); create_new_chain();
} }
@ -749,15 +749,15 @@ struct DirectVariableAccess::State {
/// @returns true if the address space @p address_space requires transforming given the /// @returns true if the address space @p address_space requires transforming given the
/// transform's options. /// transform's options.
bool AddressSpaceRequiresTransform(ast::AddressSpace address_space) const { bool AddressSpaceRequiresTransform(type::AddressSpace address_space) const {
switch (address_space) { switch (address_space) {
case ast::AddressSpace::kUniform: case type::AddressSpace::kUniform:
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
case ast::AddressSpace::kWorkgroup: case type::AddressSpace::kWorkgroup:
return true; return true;
case ast::AddressSpace::kPrivate: case type::AddressSpace::kPrivate:
return opts.transform_private; return opts.transform_private;
case ast::AddressSpace::kFunction: case type::AddressSpace::kFunction:
return opts.transform_function; return opts.transform_function;
default: default:
return false; return false;
@ -1180,9 +1180,9 @@ struct DirectVariableAccess::State {
for (auto* param : fn->Parameters()) { for (auto* param : fn->Parameters()) {
if (auto* ptr = param->Type()->As<type::Pointer>()) { if (auto* ptr = param->Type()->As<type::Pointer>()) {
switch (ptr->AddressSpace()) { switch (ptr->AddressSpace()) {
case ast::AddressSpace::kUniform: case type::AddressSpace::kUniform:
case ast::AddressSpace::kStorage: case type::AddressSpace::kStorage:
case ast::AddressSpace::kWorkgroup: case type::AddressSpace::kWorkgroup:
return true; return true;
default: default:
return false; return false;
@ -1193,8 +1193,8 @@ struct DirectVariableAccess::State {
} }
/// @returns true if the given address space is 'private' or 'function'. /// @returns true if the given address space is 'private' or 'function'.
static bool IsPrivateOrFunction(const ast::AddressSpace sc) { static bool IsPrivateOrFunction(const type::AddressSpace sc) {
return sc == ast::AddressSpace::kPrivate || sc == ast::AddressSpace::kFunction; return sc == type::AddressSpace::kPrivate || sc == type::AddressSpace::kFunction;
} }
}; };

Some files were not shown because too many files have changed in this diff Show More