From 18b2158b4e1431defc212a4b9e16b09ab036523d Mon Sep 17 00:00:00 2001 From: dan sinclair Date: Sat, 21 Jan 2023 19:56:49 +0000 Subject: [PATCH] Move ast/address_space to type/ 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 Reviewed-by: Ben Clayton Commit-Queue: Dan Sinclair --- src/tint/BUILD.gn | 7 +- src/tint/CMakeLists.txt | 2 +- src/tint/ast/module_test.cc | 4 +- src/tint/ast/pointer.cc | 4 +- src/tint/ast/pointer.h | 6 +- src/tint/ast/pointer_test.cc | 8 +- src/tint/ast/var.cc | 2 +- src/tint/ast/var.h | 4 +- src/tint/ast/variable.h | 2 +- src/tint/ast/variable_test.cc | 22 +- src/tint/inspector/inspector.cc | 2 +- src/tint/inspector/inspector_test.cc | 8 +- src/tint/inspector/test_inspector_builder.cc | 8 +- src/tint/ir/builder_impl_test.cc | 12 +- src/tint/program_builder.h | 28 +-- src/tint/program_test.cc | 2 +- src/tint/reader/spirv/enum_converter.cc | 20 +- src/tint/reader/spirv/enum_converter.h | 4 +- src/tint/reader/spirv/enum_converter_test.cc | 20 +- src/tint/reader/spirv/function.cc | 18 +- src/tint/reader/spirv/function.h | 4 +- src/tint/reader/spirv/parser_impl.cc | 40 ++-- src/tint/reader/spirv/parser_impl.h | 4 +- .../spirv/parser_impl_convert_type_test.cc | 20 +- src/tint/reader/spirv/parser_type.cc | 8 +- src/tint/reader/spirv/parser_type.h | 14 +- src/tint/reader/spirv/parser_type_test.cc | 12 +- src/tint/reader/wgsl/parser_impl.cc | 8 +- src/tint/reader/wgsl/parser_impl.h | 10 +- .../wgsl/parser_impl_address_space_test.cc | 12 +- .../parser_impl_global_variable_decl_test.cc | 8 +- .../reader/wgsl/parser_impl_type_decl_test.cc | 6 +- ...arser_impl_type_decl_without_ident_test.cc | 6 +- .../wgsl/parser_impl_variable_decl_test.cc | 4 +- .../parser_impl_variable_qualifier_test.cc | 18 +- .../address_space_layout_validation_test.cc | 62 +++--- .../resolver/address_space_validation_test.cc | 190 +++++++++--------- src/tint/resolver/alias_analysis_test.cc | 78 +++---- src/tint/resolver/array_accessor_test.cc | 28 +-- .../resolver/assignment_validation_test.cc | 24 +-- src/tint/resolver/atomics_test.cc | 6 +- src/tint/resolver/atomics_validation_test.cc | 36 ++-- .../resolver/attribute_validation_test.cc | 20 +- src/tint/resolver/builtin_test.cc | 50 ++--- src/tint/resolver/builtin_validation_test.cc | 16 +- src/tint/resolver/builtins_validation_test.cc | 2 +- src/tint/resolver/call_validation_test.cc | 44 ++-- .../compound_assignment_validation_test.cc | 6 +- src/tint/resolver/const_eval_indexing_test.cc | 2 +- src/tint/resolver/dependency_graph_test.cc | 20 +- .../resolver/entry_point_validation_test.cc | 20 +- src/tint/resolver/f16_extension_test.cc | 24 +-- src/tint/resolver/function_validation_test.cc | 34 ++-- .../host_shareable_validation_test.cc | 10 +- .../increment_decrement_validation_test.cc | 8 +- src/tint/resolver/inferred_type_test.cc | 8 +- src/tint/resolver/intrinsic_table.cc | 10 +- src/tint/resolver/intrinsic_table_test.cc | 8 +- src/tint/resolver/is_host_shareable_test.cc | 2 +- src/tint/resolver/is_storeable_test.cc | 6 +- src/tint/resolver/materialize_test.cc | 2 +- src/tint/resolver/override_test.cc | 10 +- src/tint/resolver/ptr_ref_test.cc | 20 +- src/tint/resolver/ptr_ref_validation_test.cc | 6 +- src/tint/resolver/resolver.cc | 60 +++--- src/tint/resolver/resolver.h | 4 +- src/tint/resolver/resolver_test.cc | 130 ++++++------ src/tint/resolver/resolver_test_helper.h | 6 +- src/tint/resolver/root_identifier_test.cc | 18 +- src/tint/resolver/side_effects_test.cc | 36 ++-- src/tint/resolver/static_assert_test.cc | 2 +- .../resolver/struct_address_space_use_test.cc | 36 ++-- .../type_initializer_validation_test.cc | 24 ++- src/tint/resolver/type_validation_test.cc | 108 +++++----- src/tint/resolver/uniformity.cc | 6 +- src/tint/resolver/uniformity_test.cc | 6 +- src/tint/resolver/validation_test.cc | 40 ++-- src/tint/resolver/validator.cc | 72 +++---- src/tint/resolver/validator.h | 8 +- .../resolver/validator_is_storeable_test.cc | 2 +- src/tint/resolver/variable_test.cc | 24 +-- src/tint/resolver/variable_validation_test.cc | 24 +-- src/tint/sem/function.cc | 4 +- src/tint/sem/struct.h | 2 +- src/tint/sem/variable.cc | 8 +- src/tint/sem/variable.h | 14 +- src/tint/transform/add_block_attribute.cc | 2 +- .../transform/array_length_from_uniform.cc | 2 +- src/tint/transform/binding_remapper.cc | 2 +- src/tint/transform/builtin_polyfill.cc | 2 +- src/tint/transform/calculate_array_length.cc | 2 +- .../transform/canonicalize_entry_point_io.cc | 12 +- src/tint/transform/clamp_frag_depth.cc | 4 +- src/tint/transform/decompose_memory_access.cc | 26 +-- src/tint/transform/decompose_memory_access.h | 4 +- .../transform/decompose_strided_array_test.cc | 38 ++-- .../transform/decompose_strided_matrix.cc | 4 +- .../decompose_strided_matrix_test.cc | 30 +-- src/tint/transform/demote_to_helper.cc | 10 +- src/tint/transform/direct_variable_access.cc | 26 +-- src/tint/transform/first_index_offset.cc | 2 +- .../localize_struct_array_assignment.cc | 8 +- .../module_scope_var_to_entry_point_param.cc | 44 ++-- .../transform/multiplanar_external_texture.cc | 2 +- .../transform/num_workgroups_from_uniform.cc | 2 +- src/tint/transform/pad_structs.cc | 4 +- src/tint/transform/preserve_padding.cc | 4 +- src/tint/transform/robustness.cc | 10 +- src/tint/transform/std140.cc | 8 +- src/tint/transform/vertex_pulling.cc | 2 +- .../transform/zero_init_workgroup_memory.cc | 4 +- src/tint/{ast => type}/address_space.cc | 8 +- src/tint/{ast => type}/address_space.cc.tmpl | 6 +- src/tint/{ast => type}/address_space.h | 17 +- src/tint/{ast => type}/address_space.h.tmpl | 15 +- src/tint/{ast => type}/address_space_bench.cc | 8 +- .../{ast => type}/address_space_bench.cc.tmpl | 6 +- src/tint/{ast => type}/address_space_test.cc | 10 +- .../{ast => type}/address_space_test.cc.tmpl | 8 +- src/tint/type/pointer.cc | 4 +- src/tint/type/pointer.h | 8 +- src/tint/type/pointer_test.cc | 34 ++-- src/tint/type/reference.cc | 4 +- src/tint/type/reference.h | 8 +- src/tint/type/reference_test.cc | 45 ++--- src/tint/type/struct.h | 14 +- src/tint/type/texture.h | 1 - src/tint/type/type_test.cc | 2 +- src/tint/writer/append_vector.cc | 4 +- src/tint/writer/append_vector_test.cc | 16 +- src/tint/writer/flatten_bindings_test.cc | 18 +- ...generate_external_texture_bindings_test.cc | 2 +- src/tint/writer/glsl/generator_impl.cc | 90 ++++----- src/tint/writer/glsl/generator_impl.h | 4 +- .../generator_impl_array_accessor_test.cc | 2 +- .../writer/glsl/generator_impl_assign_test.cc | 4 +- .../writer/glsl/generator_impl_binary_test.cc | 138 ++++++------- .../glsl/generator_impl_builtin_test.cc | 78 +++---- .../writer/glsl/generator_impl_call_test.cc | 8 +- .../glsl/generator_impl_function_test.cc | 28 +-- .../glsl/generator_impl_identifier_test.cc | 2 +- .../writer/glsl/generator_impl_if_test.cc | 12 +- .../writer/glsl/generator_impl_import_test.cc | 2 +- .../writer/glsl/generator_impl_loop_test.cc | 6 +- .../generator_impl_member_accessor_test.cc | 4 +- .../glsl/generator_impl_sanitizer_test.cc | 14 +- .../generator_impl_storage_buffer_test.cc | 2 +- .../writer/glsl/generator_impl_switch_test.cc | 4 +- src/tint/writer/glsl/generator_impl_test.cc | 4 +- .../writer/glsl/generator_impl_type_test.cc | 52 ++--- .../glsl/generator_impl_unary_op_test.cc | 10 +- .../generator_impl_uniform_buffer_test.cc | 4 +- ...rator_impl_variable_decl_statement_test.cc | 2 +- .../glsl/generator_impl_workgroup_var_test.cc | 4 +- src/tint/writer/hlsl/generator_impl.cc | 130 ++++++------ src/tint/writer/hlsl/generator_impl.h | 4 +- .../generator_impl_array_accessor_test.cc | 2 +- .../writer/hlsl/generator_impl_binary_test.cc | 92 ++++----- .../hlsl/generator_impl_builtin_test.cc | 54 ++--- .../writer/hlsl/generator_impl_call_test.cc | 8 +- .../hlsl/generator_impl_function_test.cc | 28 +-- .../hlsl/generator_impl_identifier_test.cc | 2 +- .../writer/hlsl/generator_impl_if_test.cc | 12 +- .../writer/hlsl/generator_impl_import_test.cc | 6 +- .../writer/hlsl/generator_impl_loop_test.cc | 6 +- .../generator_impl_member_accessor_test.cc | 6 +- .../hlsl/generator_impl_sanitizer_test.cc | 18 +- .../writer/hlsl/generator_impl_switch_test.cc | 8 +- .../writer/hlsl/generator_impl_type_test.cc | 52 ++--- .../hlsl/generator_impl_unary_op_test.cc | 10 +- ...rator_impl_variable_decl_statement_test.cc | 2 +- .../hlsl/generator_impl_workgroup_var_test.cc | 4 +- src/tint/writer/msl/generator_impl.cc | 48 ++--- src/tint/writer/msl/generator_impl.h | 4 +- .../msl/generator_impl_array_accessor_test.cc | 2 +- .../writer/msl/generator_impl_builtin_test.cc | 36 ++-- .../writer/msl/generator_impl_call_test.cc | 8 +- .../msl/generator_impl_function_test.cc | 12 +- .../writer/msl/generator_impl_import_test.cc | 6 +- .../writer/msl/generator_impl_loop_test.cc | 12 +- .../generator_impl_member_accessor_test.cc | 6 +- .../msl/generator_impl_sanitizer_test.cc | 14 +- src/tint/writer/msl/generator_impl_test.cc | 24 +-- .../writer/msl/generator_impl_type_test.cc | 24 +-- .../msl/generator_impl_unary_op_test.cc | 10 +- ...rator_impl_variable_decl_statement_test.cc | 4 +- src/tint/writer/spirv/builder.cc | 56 +++--- src/tint/writer/spirv/builder.h | 4 +- src/tint/writer/spirv/builder_assign_test.cc | 16 +- .../spirv/builder_binary_expression_test.cc | 32 +-- src/tint/writer/spirv/builder_builtin_test.cc | 64 +++--- .../writer/spirv/builder_entry_point_test.cc | 2 +- .../writer/spirv/builder_function_test.cc | 4 +- .../spirv/builder_function_variable_test.cc | 4 +- .../spirv/builder_global_variable_test.cc | 66 +++--- .../spirv/builder_ident_expression_test.cc | 6 +- src/tint/writer/spirv/builder_if_test.cc | 10 +- .../builder_initializer_expression_test.cc | 100 ++++----- src/tint/writer/spirv/builder_loop_test.cc | 4 +- src/tint/writer/spirv/builder_switch_test.cc | 24 +-- src/tint/writer/spirv/builder_type_test.cc | 34 ++-- src/tint/writer/wgsl/generator_impl.cc | 2 +- .../generator_impl_array_accessor_test.cc | 4 +- .../writer/wgsl/generator_impl_assign_test.cc | 4 +- .../writer/wgsl/generator_impl_binary_test.cc | 4 +- .../writer/wgsl/generator_impl_call_test.cc | 8 +- .../wgsl/generator_impl_function_test.cc | 2 +- .../wgsl/generator_impl_global_decl_test.cc | 6 +- .../wgsl/generator_impl_identifier_test.cc | 2 +- .../writer/wgsl/generator_impl_if_test.cc | 12 +- .../writer/wgsl/generator_impl_loop_test.cc | 6 +- .../generator_impl_member_accessor_test.cc | 4 +- .../writer/wgsl/generator_impl_switch_test.cc | 4 +- .../writer/wgsl/generator_impl_type_test.cc | 4 +- .../wgsl/generator_impl_unary_op_test.cc | 10 +- .../wgsl/generator_impl_variable_test.cc | 10 +- 216 files changed, 1936 insertions(+), 1935 deletions(-) rename src/tint/{ast => type}/address_space.cc (95%) rename src/tint/{ast => type}/address_space.cc.tmpl (87%) rename src/tint/{ast => type}/address_space.h (84%) rename src/tint/{ast => type}/address_space.h.tmpl (72%) rename src/tint/{ast => type}/address_space_bench.cc (93%) rename src/tint/{ast => type}/address_space_bench.cc.tmpl (88%) rename src/tint/{ast => type}/address_space_test.cc (94%) rename src/tint/{ast => type}/address_space_test.cc.tmpl (83%) diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn index 6e171e61b7..e91f2f497b 100644 --- a/src/tint/BUILD.gn +++ b/src/tint/BUILD.gn @@ -183,8 +183,6 @@ libtint_source_set("libtint_core_all_src") { sources = [ "ast/access.cc", "ast/access.h", - "ast/address_space.cc", - "ast/address_space.h", "ast/alias.cc", "ast/alias.h", "ast/array.cc", @@ -563,6 +561,7 @@ libtint_source_set("libtint_core_all_src") { "type/abstract_float.h", "type/abstract_int.h", "type/abstract_numeric.h", + "type/address_space.h", "type/array.h", "type/array_count.h", "type/atomic.h", @@ -695,6 +694,8 @@ libtint_source_set("libtint_type_src") { "type/abstract_int.h", "type/abstract_numeric.cc", "type/abstract_numeric.h", + "type/address_space.cc", + "type/address_space.h", "type/array.cc", "type/array.h", "type/array_count.cc", @@ -1124,7 +1125,6 @@ if (tint_build_unittests) { tint_unittests_source_set("tint_unittests_ast_src") { sources = [ "ast/access_test.cc", - "ast/address_space_test.cc", "ast/alias_test.cc", "ast/array_test.cc", "ast/assignment_statement_test.cc", @@ -1303,6 +1303,7 @@ if (tint_build_unittests) { tint_unittests_source_set("tint_unittests_type_src") { sources = [ + "type/address_space_test.cc", "type/array_test.cc", "type/atomic_test.cc", "type/bool_test.cc", diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt index 45c45e77d7..7d390abaa4 100644 --- a/src/tint/CMakeLists.txt +++ b/src/tint/CMakeLists.txt @@ -567,7 +567,6 @@ list(APPEND TINT_LIB_SRCS ) tint_generated(ast/access BENCH TEST) -tint_generated(ast/address_space BENCH TEST) tint_generated(ast/builtin_value BENCH TEST) tint_generated(ast/extension 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(sem/builtin_type) tint_generated(sem/parameter_usage) +tint_generated(type/address_space BENCH TEST) tint_generated(type/short_name BENCH TEST) if(UNIX) diff --git a/src/tint/ast/module_test.cc b/src/tint/ast/module_test.cc index c34805ec62..c7b77c9faa 100644 --- a/src/tint/ast/module_test.cc +++ b/src/tint/ast/module_test.cc @@ -72,7 +72,7 @@ TEST_F(ModuleTest, Assert_DifferentProgramID_GlobalVariable) { { ProgramBuilder b1; 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"); } @@ -92,7 +92,7 @@ TEST_F(ModuleTest, CloneOrder) { ProgramBuilder b; b.Func("F", {}, b.ty.void_(), {}); 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)); }(); diff --git a/src/tint/ast/pointer.cc b/src/tint/ast/pointer.cc index 71b7004554..503f92fb4e 100644 --- a/src/tint/ast/pointer.cc +++ b/src/tint/ast/pointer.cc @@ -24,14 +24,14 @@ Pointer::Pointer(ProgramID pid, NodeID nid, const Source& src, const Type* const subtype, - ast::AddressSpace addr_space, + type::AddressSpace addr_space, ast::Access ac) : Base(pid, nid, src), type(subtype), address_space(addr_space), access(ac) {} std::string Pointer::FriendlyName(const SymbolTable& symbols) const { std::ostringstream out; out << "ptr<"; - if (address_space != ast::AddressSpace::kNone) { + if (address_space != type::AddressSpace::kNone) { out << address_space << ", "; } out << type->FriendlyName(symbols); diff --git a/src/tint/ast/pointer.h b/src/tint/ast/pointer.h index 0e1e09014c..ca724fa463 100644 --- a/src/tint/ast/pointer.h +++ b/src/tint/ast/pointer.h @@ -18,8 +18,8 @@ #include #include "src/tint/ast/access.h" -#include "src/tint/ast/address_space.h" #include "src/tint/ast/type.h" +#include "src/tint/type/address_space.h" namespace tint::ast { @@ -37,7 +37,7 @@ class Pointer final : public Castable { NodeID nid, const Source& src, const Type* const subtype, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access); /// Move constructor Pointer(Pointer&&); @@ -57,7 +57,7 @@ class Pointer final : public Castable { const Type* const type; /// The address space of the pointer - ast::AddressSpace const address_space; + type::AddressSpace const address_space; /// The access control of the pointer ast::Access const access; diff --git a/src/tint/ast/pointer_test.cc b/src/tint/ast/pointer_test.cc index aea260ae81..6513e16eaa 100644 --- a/src/tint/ast/pointer_test.cc +++ b/src/tint/ast/pointer_test.cc @@ -24,21 +24,21 @@ using AstPointerTest = TestHelper; TEST_F(AstPointerTest, Creation) { auto* i32 = create(); - auto* p = create(i32, ast::AddressSpace::kStorage, Access::kRead); + auto* p = create(i32, type::AddressSpace::kStorage, Access::kRead); 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); } TEST_F(AstPointerTest, FriendlyName) { auto* i32 = create(); - auto* p = create(i32, ast::AddressSpace::kWorkgroup, Access::kUndefined); + auto* p = create(i32, type::AddressSpace::kWorkgroup, Access::kUndefined); EXPECT_EQ(p->FriendlyName(Symbols()), "ptr"); } TEST_F(AstPointerTest, FriendlyNameWithAccess) { auto* i32 = create(); - auto* p = create(i32, ast::AddressSpace::kStorage, Access::kReadWrite); + auto* p = create(i32, type::AddressSpace::kStorage, Access::kReadWrite); EXPECT_EQ(p->FriendlyName(Symbols()), "ptr"); } diff --git a/src/tint/ast/var.cc b/src/tint/ast/var.cc index 12f3f31e39..bac2ae2c85 100644 --- a/src/tint/ast/var.cc +++ b/src/tint/ast/var.cc @@ -25,7 +25,7 @@ Var::Var(ProgramID pid, const Source& src, const Symbol& sym, const ast::Type* ty, - AddressSpace address_space, + type::AddressSpace address_space, Access access, const Expression* init, utils::VectorRef attrs) diff --git a/src/tint/ast/var.h b/src/tint/ast/var.h index 0141d9ce17..36c4b51c6b 100644 --- a/src/tint/ast/var.h +++ b/src/tint/ast/var.h @@ -56,7 +56,7 @@ class Var final : public Castable { const Source& source, const Symbol& sym, const ast::Type* type, - AddressSpace declared_address_space, + type::AddressSpace declared_address_space, Access declared_access, const Expression* initializer, utils::VectorRef attributes); @@ -77,7 +77,7 @@ class Var final : public Castable { const Var* Clone(CloneContext* ctx) const override; /// The declared address space - const AddressSpace declared_address_space; + const type::AddressSpace declared_address_space; /// The declared access control const Access declared_access; diff --git a/src/tint/ast/variable.h b/src/tint/ast/variable.h index 81096e9365..cca137c04b 100644 --- a/src/tint/ast/variable.h +++ b/src/tint/ast/variable.h @@ -19,11 +19,11 @@ #include #include "src/tint/ast/access.h" -#include "src/tint/ast/address_space.h" #include "src/tint/ast/attribute.h" #include "src/tint/ast/binding_attribute.h" #include "src/tint/ast/expression.h" #include "src/tint/ast/group_attribute.h" +#include "src/tint/type/address_space.h" // Forward declarations namespace tint::ast { diff --git a/src/tint/ast/variable_test.cc b/src/tint/ast/variable_test.cc index a0ee93de7a..e797b0d964 100644 --- a/src/tint/ast/variable_test.cc +++ b/src/tint/ast/variable_test.cc @@ -25,10 +25,10 @@ namespace { using VariableTest = TestHelper; 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->declared_address_space, AddressSpace::kFunction); + EXPECT_EQ(v->declared_address_space, type::AddressSpace::kFunction); EXPECT_TRUE(v->type->Is()); EXPECT_EQ(v->source.range.begin.line, 0u); EXPECT_EQ(v->source.range.begin.column, 0u); @@ -38,10 +38,10 @@ TEST_F(VariableTest, Creation) { TEST_F(VariableTest, CreationWithSource) { 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->declared_address_space, AddressSpace::kPrivate); + EXPECT_EQ(v->declared_address_space, type::AddressSpace::kPrivate); EXPECT_TRUE(v->type->Is()); EXPECT_EQ(v->source.range.begin.line, 27u); EXPECT_EQ(v->source.range.begin.column, 4u); @@ -51,10 +51,10 @@ TEST_F(VariableTest, CreationWithSource) { TEST_F(VariableTest, CreationEmpty) { 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->declared_address_space, AddressSpace::kWorkgroup); + EXPECT_EQ(v->declared_address_space, type::AddressSpace::kWorkgroup); EXPECT_TRUE(v->type->Is()); EXPECT_EQ(v->source.range.begin.line, 27u); EXPECT_EQ(v->source.range.begin.column, 4u); @@ -92,7 +92,7 @@ TEST_F(VariableTest, Assert_DifferentProgramID_Initializer) { } 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)); auto& attributes = var->attributes; @@ -107,22 +107,22 @@ TEST_F(VariableTest, WithAttributes) { } 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()); } 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()); } 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()); } 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()); } diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc index e69c3b5bde..8762b25a8e 100644 --- a/src/tint/inspector/inspector.cc +++ b/src/tint/inspector/inspector.cc @@ -586,7 +586,7 @@ uint32_t Inspector::GetWorkgroupStorageSize(const std::string& entry_point) { uint32_t total_size = 0; auto* func_sem = program_->Sem().Get(func); 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(); uint32_t align = ty->Align(); uint32_t size = ty->Size(); diff --git a/src/tint/inspector/inspector_test.cc b/src/tint/inspector/inspector_test.cc index 98f75b61e3..233ca3a235 100644 --- a/src/tint/inspector/inspector_test.cc +++ b/src/tint/inspector/inspector_test.cc @@ -743,7 +743,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly) { TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly_ViaPrivateInitializer) { 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(), utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -834,7 +834,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByAttributeIndirectly) { TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) { 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_(), utils::Vector{ Assign(Phony(), IndexAccessor("v", 0_a)), @@ -857,7 +857,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) { TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySizeIndirectly) { Override("foo", ty.u32()); 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_(), utils::Vector{ 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")))); Override("zoo", ty.u32()); 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_(), utils::Vector{ Assign(Phony(), IndexAccessor("v", 0_a)), diff --git a/src/tint/inspector/test_inspector_builder.cc b/src/tint/inspector/test_inspector_builder.cc index 81d8f39923..e801fcb606 100644 --- a/src/tint/inspector/test_inspector_builder.cc +++ b/src/tint/inspector/test_inspector_builder.cc @@ -126,11 +126,11 @@ void InspectorBuilder::AddUniformBuffer(const std::string& name, const ast::Type* type, uint32_t group, 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) { - GlobalVar(name, type, ast::AddressSpace::kWorkgroup); + GlobalVar(name, type, type::AddressSpace::kWorkgroup); } void InspectorBuilder::AddStorageBuffer(const std::string& name, @@ -138,7 +138,7 @@ void InspectorBuilder::AddStorageBuffer(const std::string& name, ast::Access access, uint32_t group, 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))); } @@ -188,7 +188,7 @@ void InspectorBuilder::AddResource(const std::string& name, } 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( diff --git a/src/tint/ir/builder_impl_test.cc b/src/tint/ir/builder_impl_test.cc index 9dc908d9e0..6424631934 100644 --- a/src/tint/ir/builder_impl_test.cc +++ b/src/tint/ir/builder_impl_test.cc @@ -1468,7 +1468,7 @@ FunctionEnd TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_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 r = b.EmitLiteral(expr); @@ -1482,7 +1482,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) { TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_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 r = b.EmitLiteral(expr); @@ -1496,7 +1496,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) { TEST_F(IR_BuilderImplTest, EmitLiteral_F32) { 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 r = b.EmitLiteral(expr); @@ -1511,7 +1511,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_F32) { TEST_F(IR_BuilderImplTest, EmitLiteral_F16) { Enable(ast::Extension::kF16); 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 r = b.EmitLiteral(expr); @@ -1525,7 +1525,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_F16) { TEST_F(IR_BuilderImplTest, EmitLiteral_I32) { 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 r = b.EmitLiteral(expr); @@ -1539,7 +1539,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_I32) { TEST_F(IR_BuilderImplTest, EmitLiteral_U32) { 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 r = b.EmitLiteral(expr); diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h index e59318160e..676617f3d7 100644 --- a/src/tint/program_builder.h +++ b/src/tint/program_builder.h @@ -181,14 +181,14 @@ class ProgramBuilder { ~VarOptions(); 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; const ast::Expression* initializer = nullptr; utils::Vector attributes; private: 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(const ast::Expression* c) { initializer = c; } void Set(utils::VectorRef l) { attributes = std::move(l); } @@ -940,9 +940,9 @@ class ProgramBuilder { /// @param type the type of the pointer /// @param address_space the address space 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, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access = ast::Access::kUndefined) const { return builder->create(type, address_space, access); } @@ -951,19 +951,19 @@ class ProgramBuilder { /// @param type the type of the pointer /// @param address_space the address space 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::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access = ast::Access::kUndefined) const { return builder->create(source, type, address_space, access); } /// @param address_space the address space 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 - const ast::Pointer* pointer(ast::AddressSpace address_space, + const ast::Pointer* pointer(type::AddressSpace address_space, ast::Access access = ast::Access::kUndefined) const { return pointer(Of(), address_space, access); } @@ -971,10 +971,10 @@ class ProgramBuilder { /// @param source the Source of the node /// @param address_space the address space 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 const ast::Pointer* pointer(const Source& source, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access = ast::Access::kUndefined) const { return pointer(source, Of(), address_space, access); } @@ -1697,7 +1697,7 @@ class ProgramBuilder { /// @param options the extra options passed to the ast::Var initializer /// Can be any of the following, in any order: /// * 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::Expression* - specifies the variable's initializer expression /// * 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 /// Can be any of the following, in any order: /// * 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::Expression* - specifies the variable's initializer expression /// * 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 /// Can be any of the following, in any order: /// * 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::Expression* - specifies the variable's initializer expression /// * 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 /// Can be any of the following, in any order: /// * 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::Expression* - specifies the variable's initializer expression /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) diff --git a/src/tint/program_test.cc b/src/tint/program_test.cc index d2f167358e..f856504786 100644 --- a/src/tint/program_test.cc +++ b/src/tint/program_test.cc @@ -46,7 +46,7 @@ TEST_F(ProgramTest, IDsAreUnique) { } TEST_F(ProgramTest, Assert_GlobalVariable) { - GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate); Program program(std::move(*this)); EXPECT_TRUE(program.IsValid()); diff --git a/src/tint/reader/spirv/enum_converter.cc b/src/tint/reader/spirv/enum_converter.cc index 2ac571d2ec..45c7e5c6c8 100644 --- a/src/tint/reader/spirv/enum_converter.cc +++ b/src/tint/reader/spirv/enum_converter.cc @@ -38,30 +38,30 @@ ast::PipelineStage EnumConverter::ToPipelineStage(spv::ExecutionModel model) { return ast::PipelineStage::kNone; } -ast::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) { +type::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) { switch (sc) { case spv::StorageClass::Input: - return ast::AddressSpace::kIn; + return type::AddressSpace::kIn; case spv::StorageClass::Output: - return ast::AddressSpace::kOut; + return type::AddressSpace::kOut; case spv::StorageClass::Uniform: - return ast::AddressSpace::kUniform; + return type::AddressSpace::kUniform; case spv::StorageClass::Workgroup: - return ast::AddressSpace::kWorkgroup; + return type::AddressSpace::kWorkgroup; case spv::StorageClass::UniformConstant: - return ast::AddressSpace::kNone; + return type::AddressSpace::kNone; case spv::StorageClass::StorageBuffer: - return ast::AddressSpace::kStorage; + return type::AddressSpace::kStorage; case spv::StorageClass::Private: - return ast::AddressSpace::kPrivate; + return type::AddressSpace::kPrivate; case spv::StorageClass::Function: - return ast::AddressSpace::kFunction; + return type::AddressSpace::kFunction; default: break; } Fail() << "unknown SPIR-V storage class: " << uint32_t(sc); - return ast::AddressSpace::kUndefined; + return type::AddressSpace::kUndefined; } ast::BuiltinValue EnumConverter::ToBuiltin(spv::BuiltIn b) { diff --git a/src/tint/reader/spirv/enum_converter.h b/src/tint/reader/spirv/enum_converter.h index 507fd77538..c4e6aeac04 100644 --- a/src/tint/reader/spirv/enum_converter.h +++ b/src/tint/reader/spirv/enum_converter.h @@ -17,10 +17,10 @@ #include "spirv/unified1/spirv.h" #include "spirv/unified1/spirv.hpp11" -#include "src/tint/ast/address_space.h" #include "src/tint/ast/builtin_value.h" #include "src/tint/ast/pipeline_stage.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/texture_dimension.h" @@ -45,7 +45,7 @@ class EnumConverter { /// On failure, logs an error and returns kNone /// @param sc the SPIR-V storage class /// @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. /// On failure, logs an error and returns kNone diff --git a/src/tint/reader/spirv/enum_converter_test.cc b/src/tint/reader/spirv/enum_converter_test.cc index f49abca25b..3b08c89c78 100644 --- a/src/tint/reader/spirv/enum_converter_test.cc +++ b/src/tint/reader/spirv/enum_converter_test.cc @@ -85,7 +85,7 @@ INSTANTIATE_TEST_SUITE_P(EnumConverterBad, struct StorageClassCase { spv::StorageClass sc; bool expect_success; - ast::AddressSpace expected; + type::AddressSpace expected; }; inline std::ostream& operator<<(std::ostream& out, StorageClassCase scc) { out << "StorageClassCase{ spv::StorageClass:::" << int(scc.sc) @@ -126,19 +126,19 @@ INSTANTIATE_TEST_SUITE_P( EnumConverterGood, SpvStorageClassTest, testing::Values( - StorageClassCase{spv::StorageClass::Input, true, ast::AddressSpace::kIn}, - StorageClassCase{spv::StorageClass::Output, true, ast::AddressSpace::kOut}, - StorageClassCase{spv::StorageClass::Uniform, true, ast::AddressSpace::kUniform}, - StorageClassCase{spv::StorageClass::Workgroup, true, ast::AddressSpace::kWorkgroup}, - StorageClassCase{spv::StorageClass::UniformConstant, true, ast::AddressSpace::kNone}, - StorageClassCase{spv::StorageClass::StorageBuffer, true, ast::AddressSpace::kStorage}, - StorageClassCase{spv::StorageClass::Private, true, ast::AddressSpace::kPrivate}, - StorageClassCase{spv::StorageClass::Function, true, ast::AddressSpace::kFunction})); + StorageClassCase{spv::StorageClass::Input, true, type::AddressSpace::kIn}, + StorageClassCase{spv::StorageClass::Output, true, type::AddressSpace::kOut}, + StorageClassCase{spv::StorageClass::Uniform, true, type::AddressSpace::kUniform}, + StorageClassCase{spv::StorageClass::Workgroup, true, type::AddressSpace::kWorkgroup}, + StorageClassCase{spv::StorageClass::UniformConstant, true, type::AddressSpace::kNone}, + StorageClassCase{spv::StorageClass::StorageBuffer, true, type::AddressSpace::kStorage}, + StorageClassCase{spv::StorageClass::Private, true, type::AddressSpace::kPrivate}, + StorageClassCase{spv::StorageClass::Function, true, type::AddressSpace::kFunction})); INSTANTIATE_TEST_SUITE_P(EnumConverterBad, SpvStorageClassTest, testing::Values(StorageClassCase{static_cast(9999), - false, ast::AddressSpace::kUndefined})); + false, type::AddressSpace::kUndefined})); // Builtin diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc index 0bae341edf..2e87551212 100644 --- a/src/tint/reader/spirv/function.cc +++ b/src/tint/reader/spirv/function.cc @@ -2536,11 +2536,11 @@ bool FunctionEmitter::EmitFunctionVariables() { return false; } } - auto* var = parser_impl_.MakeVar(inst.result_id(), ast::AddressSpace::kNone, var_store_type, - initializer, AttributeList{}); + auto* var = parser_impl_.MakeVar(inst.result_id(), type::AddressSpace::kNone, + var_store_type, initializer, AttributeList{}); auto* var_decl_stmt = create(Source{}, var); 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); } return success(); @@ -3390,9 +3390,9 @@ bool FunctionEmitter::EmitStatementsInBasicBlock(const BlockInfo& block_info, // no need to remap pointer properties. auto* store_type = parser_impl_.ConvertType(def_inst->type_id()); AddStatement(create( - Source{}, parser_impl_.MakeVar(id, ast::AddressSpace::kNone, store_type, nullptr, + Source{}, parser_impl_.MakeVar(id, type::AddressSpace::kNone, store_type, nullptr, AttributeList{}))); - auto* type = ty_.Reference(store_type, ast::AddressSpace::kNone); + auto* type = ty_.Reference(store_type, type::AddressSpace::kNone); 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 // access mode. - return DefInfo::Pointer{ast::AddressSpace::kFunction, ast::Access::kUndefined}; + return DefInfo::Pointer{type::AddressSpace::kFunction, ast::Access::kUndefined}; } case spv::Op::OpFunctionParameter: { const auto* type = As(parser_impl_.ConvertType(inst.type_id())); @@ -5117,7 +5117,7 @@ void FunctionEmitter::FindValuesNeedingNamedOrHoistedDefinition() { // Avoid moving combinatorial values across constructs. This is a // simple heuristic to avoid changing the cost of an operation // 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) { should_hoist_to_let = true; } @@ -6254,7 +6254,7 @@ bool FunctionEmitter::MakeVectorInsertDynamic(const spvtools::opt::Instruction& // API in parser_impl_. 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); 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 // API in parser_impl_. 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); AddStatement(builder_.Decl({}, temp_var)); } diff --git a/src/tint/reader/spirv/function.h b/src/tint/reader/spirv/function.h index 65a1e3b316..3be0a005f0 100644 --- a/src/tint/reader/spirv/function.h +++ b/src/tint/reader/spirv/function.h @@ -331,7 +331,7 @@ struct DefInfo { /// buffer expressed in the old style (with Uniform address space) /// that needs to be remapped to StorageBuffer address space. /// This is kInvalid for non-pointers. - ast::AddressSpace address_space = ast::AddressSpace::kUndefined; + type::AddressSpace address_space = type::AddressSpace::kUndefined; /// The declared access mode. 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") << " 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); } switch (di.skip) { diff --git a/src/tint/reader/spirv/parser_impl.cc b/src/tint/reader/spirv/parser_impl.cc index 84e07ed007..50e290b81c 100644 --- a/src/tint/reader/spirv/parser_impl.cc +++ b/src/tint/reader/spirv/parser_impl.cc @@ -1222,21 +1222,21 @@ const Type* ParserImpl::ConvertType(uint32_t type_id, } 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 " << static_cast(storage_class); return nullptr; } - if (ast_address_space == ast::AddressSpace::kUniform && + if (ast_address_space == type::AddressSpace::kUniform && 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); } // Pipeline input and output variables map to private variables. - if (ast_address_space == ast::AddressSpace::kIn || - ast_address_space == ast::AddressSpace::kOut) { - ast_address_space = ast::AddressSpace::kPrivate; + if (ast_address_space == type::AddressSpace::kIn || + ast_address_space == type::AddressSpace::kOut) { + ast_address_space = type::AddressSpace::kPrivate; } switch (ptr_as) { case PtrAs::Ref: @@ -1460,14 +1460,14 @@ bool ParserImpl::EmitModuleScopeVariables() { continue; } switch (enum_converter_.ToAddressSpace(spirv_storage_class)) { - case ast::AddressSpace::kNone: - case ast::AddressSpace::kIn: - case ast::AddressSpace::kOut: - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kHandle: - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kWorkgroup: - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kNone: + case type::AddressSpace::kIn: + case type::AddressSpace::kOut: + case type::AddressSpace::kUniform: + case type::AddressSpace::kHandle: + case type::AddressSpace::kStorage: + case type::AddressSpace::kWorkgroup: + case type::AddressSpace::kPrivate: break; default: return Fail() << "invalid SPIR-V storage class " << int(spirv_storage_class) @@ -1477,7 +1477,7 @@ bool ParserImpl::EmitModuleScopeVariables() { return false; } 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) { // These are opaque handles: samplers or textures 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::AddressSpace address_space, + type::AddressSpace address_space, const Type* storage_type, const ast::Expression* initializer, AttributeList decorations) { @@ -1588,7 +1588,7 @@ ast::Var* ParserImpl::MakeVar(uint32_t id, } ast::Access access = ast::Access::kUndefined; - if (address_space == ast::AddressSpace::kStorage) { + if (address_space == type::AddressSpace::kStorage) { bool read_only = false; if (auto* tn = storage_type->As()) { 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 // address space, so we don't mention the address space. - if (address_space == ast::AddressSpace::kHandle) { - address_space = ast::AddressSpace::kNone; + if (address_space == type::AddressSpace::kHandle) { + address_space = type::AddressSpace::kNone; } if (!ConvertDecorationsForVariable(id, &storage_type, &decorations, - address_space != ast::AddressSpace::kPrivate)) { + address_space != type::AddressSpace::kPrivate)) { return nullptr; } diff --git a/src/tint/reader/spirv/parser_impl.h b/src/tint/reader/spirv/parser_impl.h index 7713734faf..bdac876be1 100644 --- a/src/tint/reader/spirv/parser_impl.h +++ b/src/tint/reader/spirv/parser_impl.h @@ -423,14 +423,14 @@ class ParserImpl : Reader { /// Creates an AST 'var' node for a SPIR-V ID, including any attached decorations, unless it's /// an ignorable builtin variable. /// @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 initializer the variable initializer /// @param decorations the variable decorations /// @returns a new Variable node, or null in the ignorable variable case and /// in the error case ast::Var* MakeVar(uint32_t id, - ast::AddressSpace address_space, + type::AddressSpace address_space, const Type* storage_type, const ast::Expression* initializer, AttributeList decorations); diff --git a/src/tint/reader/spirv/parser_impl_convert_type_test.cc b/src/tint/reader/spirv/parser_impl_convert_type_test.cc index 3b8fa625c5..a4716320a5 100644 --- a/src/tint/reader/spirv/parser_impl_convert_type_test.cc +++ b/src/tint/reader/spirv/parser_impl_convert_type_test.cc @@ -731,7 +731,7 @@ TEST_F(SpvParserTest, ConvertType_PointerInput) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate); EXPECT_TRUE(p->error().empty()); } @@ -747,7 +747,7 @@ TEST_F(SpvParserTest, ConvertType_PointerOutput) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate); EXPECT_TRUE(p->error().empty()); } @@ -763,7 +763,7 @@ TEST_F(SpvParserTest, ConvertType_PointerUniform) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kUniform); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kUniform); EXPECT_TRUE(p->error().empty()); } @@ -779,7 +779,7 @@ TEST_F(SpvParserTest, ConvertType_PointerWorkgroup) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kWorkgroup); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kWorkgroup); EXPECT_TRUE(p->error().empty()); } @@ -795,7 +795,7 @@ TEST_F(SpvParserTest, ConvertType_PointerUniformConstant) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kNone); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kNone); EXPECT_TRUE(p->error().empty()); } @@ -811,7 +811,7 @@ TEST_F(SpvParserTest, ConvertType_PointerStorageBuffer) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kStorage); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kStorage); EXPECT_TRUE(p->error().empty()); } @@ -827,7 +827,7 @@ TEST_F(SpvParserTest, ConvertType_PointerPrivate) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate); EXPECT_TRUE(p->error().empty()); } @@ -843,7 +843,7 @@ TEST_F(SpvParserTest, ConvertType_PointerFunction) { auto* ptr_ty = type->As(); EXPECT_NE(ptr_ty, nullptr); EXPECT_TRUE(ptr_ty->type->Is()); - EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kFunction); + EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kFunction); EXPECT_TRUE(p->error().empty()); } @@ -862,12 +862,12 @@ TEST_F(SpvParserTest, ConvertType_PointerToPointer) { auto* ptr_ty = type->As(); 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()); auto* ptr_ptr_ty = ptr_ty->type->As(); 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()); EXPECT_TRUE(p->error().empty()); diff --git a/src/tint/reader/spirv/parser_type.cc b/src/tint/reader/spirv/parser_type.cc index ef46c1822d..c66286a7c9 100644 --- a/src/tint/reader/spirv/parser_type.cc +++ b/src/tint/reader/spirv/parser_type.cc @@ -175,7 +175,7 @@ Type::~Type() = 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) {} 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); } -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) {} Reference::Reference(const Reference&) = default; @@ -460,13 +460,13 @@ const Type* TypeManager::AsUnsigned(const Type* ty) { } const spirv::Pointer* TypeManager::Pointer(const Type* el, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access) { return state->pointers_.Get(el, address_space, access); } const spirv::Reference* TypeManager::Reference(const Type* el, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access) { return state->references_.Get(el, address_space, access); } diff --git a/src/tint/reader/spirv/parser_type.h b/src/tint/reader/spirv/parser_type.h index 4d42292c69..fc949d6f37 100644 --- a/src/tint/reader/spirv/parser_type.h +++ b/src/tint/reader/spirv/parser_type.h @@ -20,10 +20,10 @@ #include #include "src/tint/ast/access.h" -#include "src/tint/ast/address_space.h" #include "src/tint/ast/sampler.h" #include "src/tint/ast/storage_texture.h" #include "src/tint/castable.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/texture_dimension.h" #include "src/tint/utils/block_allocator.h" @@ -163,7 +163,7 @@ struct Pointer final : public Castable { /// @param ty the store type /// @param sc the pointer address space /// @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 /// @param other the other type to copy @@ -181,7 +181,7 @@ struct Pointer final : public Castable { /// the store type Type const* const type; /// the pointer address space - ast::AddressSpace const address_space; + type::AddressSpace const address_space; /// the pointer declared access mode ast::Access const access; }; @@ -194,7 +194,7 @@ struct Reference final : public Castable { /// @param ty the referenced type /// @param sc the reference address space /// @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 /// @param other the other type to copy @@ -212,7 +212,7 @@ struct Reference final : public Castable { /// the store type Type const* const type; /// the pointer address space - ast::AddressSpace const address_space; + type::AddressSpace const address_space; /// the pointer declared access mode ast::Access const access; }; @@ -550,7 +550,7 @@ class TypeManager { /// @return a Pointer type. Repeated calls with the same arguments will return /// the same pointer. const spirv::Pointer* Pointer(const Type* ty, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access = ast::Access::kUndefined); /// @param ty the referenced type /// @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 the same pointer. const spirv::Reference* Reference(const Type* ty, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access = ast::Access::kUndefined); /// @param ty the element type /// @param sz the number of elements in the vector diff --git a/src/tint/reader/spirv/parser_type_test.cc b/src/tint/reader/spirv/parser_type_test.cc index 392b637f90..1934fd8adb 100644 --- a/src/tint/reader/spirv/parser_type_test.cc +++ b/src/tint/reader/spirv/parser_type_test.cc @@ -29,8 +29,8 @@ TEST(SpvParserTypeTest, SameArgumentsGivesSamePointer) { EXPECT_EQ(ty.U32(), ty.U32()); EXPECT_EQ(ty.F32(), ty.F32()); EXPECT_EQ(ty.I32(), ty.I32()); - EXPECT_EQ(ty.Pointer(ty.I32(), ast::AddressSpace::kNone), - ty.Pointer(ty.I32(), ast::AddressSpace::kNone)); + EXPECT_EQ(ty.Pointer(ty.I32(), type::AddressSpace::kNone), + ty.Pointer(ty.I32(), type::AddressSpace::kNone)); 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.Array(ty.I32(), 3, 2), ty.Array(ty.I32(), 3, 2)); @@ -54,10 +54,10 @@ TEST(SpvParserTypeTest, DifferentArgumentsGivesDifferentPointer) { Symbol sym_b(Symbol(2, {})); TypeManager ty; - EXPECT_NE(ty.Pointer(ty.I32(), ast::AddressSpace::kNone), - ty.Pointer(ty.U32(), ast::AddressSpace::kNone)); - EXPECT_NE(ty.Pointer(ty.I32(), ast::AddressSpace::kNone), - ty.Pointer(ty.I32(), ast::AddressSpace::kIn)); + EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kNone), + ty.Pointer(ty.U32(), type::AddressSpace::kNone)); + EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kNone), + 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.I32(), 2)); EXPECT_NE(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.U32(), 3, 2)); diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc index 132e29488b..9e9930ebbe 100644 --- a/src/tint/reader/wgsl/parser_impl.cc +++ b/src/tint/reader/wgsl/parser_impl.cc @@ -213,7 +213,7 @@ ParserImpl::VarDeclInfo::VarDeclInfo(const VarDeclInfo&) = default; ParserImpl::VarDeclInfo::VarDeclInfo(Source source_in, std::string name_in, - ast::AddressSpace address_space_in, + type::AddressSpace address_space_in, ast::Access access_in, const ast::Type* type_in) : source(std::move(source_in)), @@ -1251,7 +1251,7 @@ Expect ParserImpl::expect_type(std::string_view use) { Expect ParserImpl::expect_type_specifier_pointer(const Source& s) { const char* use = "ptr declaration"; - auto address_space = ast::AddressSpace::kNone; + auto address_space = type::AddressSpace::kNone; auto access = ast::Access::kUndefined; auto subtype = expect_lt_gt_block(use, [&]() -> Expect { @@ -1372,8 +1372,8 @@ Expect ParserImpl::expect_type_specifier_matrix(const Source& // | 'storage' // // Note, we also parse `push_constant` from the experimental extension -Expect ParserImpl::expect_address_space(std::string_view use) { - return expect_enum("address space", ast::ParseAddressSpace, ast::kAddressSpaceStrings, use); +Expect ParserImpl::expect_address_space(std::string_view use) { + return expect_enum("address space", type::ParseAddressSpace, type::kAddressSpaceStrings, use); } // struct_decl diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h index 23e74bfc77..a60cfef858 100644 --- a/src/tint/reader/wgsl/parser_impl.h +++ b/src/tint/reader/wgsl/parser_impl.h @@ -284,7 +284,7 @@ class ParserImpl { /// @param type_in variable type VarDeclInfo(Source source_in, std::string name_in, - ast::AddressSpace address_space_in, + type::AddressSpace address_space_in, ast::Access access_in, const ast::Type* type_in); /// Destructor @@ -295,7 +295,7 @@ class ParserImpl { /// Variable name std::string name; /// Variable address space - ast::AddressSpace address_space = ast::AddressSpace::kNone; + type::AddressSpace address_space = type::AddressSpace::kNone; /// Variable access control ast::Access access = ast::Access::kUndefined; /// Variable type @@ -305,7 +305,7 @@ class ParserImpl { /// VariableQualifier contains the parsed information for a variable qualifier struct VariableQualifier { /// The variable's address space - ast::AddressSpace address_space = ast::AddressSpace::kNone; + type::AddressSpace address_space = type::AddressSpace::kNone; /// The variable's access control ast::Access access = ast::Access::kUndefined; }; @@ -461,8 +461,8 @@ class ParserImpl { Maybe type_specifier(); /// Parses an `address_space` grammar element, erroring on parse failure. /// @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 - Expect expect_address_space(std::string_view use); + /// @returns the address space or type::AddressSpace::kNone if none matched + Expect expect_address_space(std::string_view use); /// Parses a `struct_decl` grammar element. /// @returns the struct type or nullptr on error Maybe struct_decl(); diff --git a/src/tint/reader/wgsl/parser_impl_address_space_test.cc b/src/tint/reader/wgsl/parser_impl_address_space_test.cc index 251c1d0ec0..32c3c47c69 100644 --- a/src/tint/reader/wgsl/parser_impl_address_space_test.cc +++ b/src/tint/reader/wgsl/parser_impl_address_space_test.cc @@ -19,7 +19,7 @@ namespace { struct AddressSpaceData { const char* input; - ast::AddressSpace result; + type::AddressSpace result; }; inline std::ostream& operator<<(std::ostream& out, AddressSpaceData data) { out << std::string(data.input); @@ -43,11 +43,11 @@ TEST_P(ParserAddressSpaceTest, Parses) { INSTANTIATE_TEST_SUITE_P( ParserImplTest, ParserAddressSpaceTest, - testing::Values(AddressSpaceData{"uniform", ast::AddressSpace::kUniform}, - AddressSpaceData{"workgroup", ast::AddressSpace::kWorkgroup}, - AddressSpaceData{"storage", ast::AddressSpace::kStorage}, - AddressSpaceData{"private", ast::AddressSpace::kPrivate}, - AddressSpaceData{"function", ast::AddressSpace::kFunction})); + testing::Values(AddressSpaceData{"uniform", type::AddressSpace::kUniform}, + AddressSpaceData{"workgroup", type::AddressSpace::kWorkgroup}, + AddressSpaceData{"storage", type::AddressSpace::kStorage}, + AddressSpaceData{"private", type::AddressSpace::kPrivate}, + AddressSpaceData{"function", type::AddressSpace::kFunction})); TEST_F(ParserImplTest, AddressSpace_NoMatch) { auto p = parser("not-a-address-space"); diff --git a/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc b/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc index 695fc867da..0dcde16cfd 100644 --- a/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc +++ b/src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc @@ -31,7 +31,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithoutInitializer) { EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); EXPECT_TRUE(var->type->Is()); - 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.column, 14u); @@ -55,7 +55,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithInitializer) { EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); EXPECT_TRUE(var->type->Is()); - 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.column, 14u); @@ -81,7 +81,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithAttribute) { EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); ASSERT_NE(var->type, nullptr); EXPECT_TRUE(var->type->Is()); - 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.column, 36u); @@ -112,7 +112,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithAttribute_MulitpleGroups) { EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a")); ASSERT_NE(var->type, nullptr); EXPECT_TRUE(var->type->Is()); - 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.column, 36u); diff --git a/src/tint/reader/wgsl/parser_impl_type_decl_test.cc b/src/tint/reader/wgsl/parser_impl_type_decl_test.cc index c40c2981a4..972d49bccc 100644 --- a/src/tint/reader/wgsl/parser_impl_type_decl_test.cc +++ b/src/tint/reader/wgsl/parser_impl_type_decl_test.cc @@ -176,7 +176,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr) { auto* ptr = t.value->As(); ASSERT_TRUE(ptr->type->Is()); - 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}})); } @@ -191,7 +191,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_WithAccess) { auto* ptr = t.value->As(); ASSERT_TRUE(ptr->type->Is()); - ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); + ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction); ASSERT_EQ(ptr->access, ast::Access::kRead); 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(); ASSERT_TRUE(ptr->type->Is()); - ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); + ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction); auto* vec = ptr->type->As(); ASSERT_EQ(vec->width, 2u); diff --git a/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc b/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc index bd96659a6a..503c88d6d4 100644 --- a/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc +++ b/src/tint/reader/wgsl/parser_impl_type_decl_without_ident_test.cc @@ -167,7 +167,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr) { auto* ptr = t.value->As(); ASSERT_TRUE(ptr->type->Is()); - 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}})); } @@ -182,7 +182,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_WithAccess) { auto* ptr = t.value->As(); ASSERT_TRUE(ptr->type->Is()); - ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); + ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction); ASSERT_EQ(ptr->access, ast::Access::kRead); 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(); ASSERT_TRUE(ptr->type->Is()); - ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction); + ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction); auto* vec = ptr->type->As(); ASSERT_EQ(vec->width, 2u); diff --git a/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc b/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc index 5cf038bcd2..ba4a8727ca 100644 --- a/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc +++ b/src/tint/reader/wgsl/parser_impl_variable_decl_test.cc @@ -80,7 +80,7 @@ TEST_F(ParserImplTest, VariableDecl_WithAddressSpace) { EXPECT_FALSE(p->has_error()); EXPECT_EQ(v->name, "my_var"); EXPECT_TRUE(v->type->Is()); - 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.column, 14u); @@ -96,7 +96,7 @@ TEST_F(ParserImplTest, VariableDecl_WithPushConstant) { EXPECT_FALSE(p->has_error()); EXPECT_EQ(v->name, "my_var"); EXPECT_TRUE(v->type->Is()); - EXPECT_EQ(v->address_space, ast::AddressSpace::kPushConstant); + EXPECT_EQ(v->address_space, type::AddressSpace::kPushConstant); } TEST_F(ParserImplTest, VariableDecl_InvalidAddressSpace) { diff --git a/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc b/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc index 5c0cd5ef32..a9373ae187 100644 --- a/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc +++ b/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc @@ -19,7 +19,7 @@ namespace { struct VariableStorageData { const char* input; - ast::AddressSpace address_space; + type::AddressSpace address_space; ast::Access access; }; inline std::ostream& operator<<(std::ostream& out, VariableStorageData data) { @@ -47,14 +47,14 @@ INSTANTIATE_TEST_SUITE_P( ParserImplTest, VariableQualifierTest, testing::Values( - VariableStorageData{"uniform", ast::AddressSpace::kUniform, ast::Access::kUndefined}, - VariableStorageData{"workgroup", ast::AddressSpace::kWorkgroup, ast::Access::kUndefined}, - VariableStorageData{"storage", ast::AddressSpace::kStorage, ast::Access::kUndefined}, - VariableStorageData{"private", ast::AddressSpace::kPrivate, ast::Access::kUndefined}, - VariableStorageData{"function", ast::AddressSpace::kFunction, ast::Access::kUndefined}, - VariableStorageData{"storage, read", ast::AddressSpace::kStorage, ast::Access::kRead}, - VariableStorageData{"storage, write", ast::AddressSpace::kStorage, ast::Access::kWrite}, - VariableStorageData{"storage, read_write", ast::AddressSpace::kStorage, + VariableStorageData{"uniform", type::AddressSpace::kUniform, ast::Access::kUndefined}, + VariableStorageData{"workgroup", type::AddressSpace::kWorkgroup, ast::Access::kUndefined}, + VariableStorageData{"storage", type::AddressSpace::kStorage, ast::Access::kUndefined}, + VariableStorageData{"private", type::AddressSpace::kPrivate, ast::Access::kUndefined}, + VariableStorageData{"function", type::AddressSpace::kFunction, ast::Access::kUndefined}, + VariableStorageData{"storage, read", type::AddressSpace::kStorage, ast::Access::kRead}, + VariableStorageData{"storage, write", type::AddressSpace::kStorage, ast::Access::kWrite}, + VariableStorageData{"storage, read_write", type::AddressSpace::kStorage, ast::Access::kReadWrite})); TEST_F(ParserImplTest, VariableQualifier_NoMatch) { diff --git a/src/tint/resolver/address_space_layout_validation_test.cc b/src/tint/resolver/address_space_layout_validation_test.cc index 638df2130f..40558429e6 100644 --- a/src/tint/resolver/address_space_layout_validation_test.cc +++ b/src/tint/resolver/address_space_layout_validation_test.cc @@ -39,7 +39,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, StorageBuffer_UnalignedMember) 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)); 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)}), }); - 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)); 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")), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -145,8 +145,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, utils::Vector{MemberAlign(16_i)}), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); 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")), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -204,8 +204,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_A utils::Vector{MemberAlign(16_i)}), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -236,8 +236,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_MembersOffsetNotM Member(Source{{78, 90}}, "scalar", ty.i32()), }); - GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -288,8 +288,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, Member(Source{{78, 90}}, "scalar", ty.i32()), }); - GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -336,8 +336,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, 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), - Binding(0_a)); + GlobalVar(Source{{22, 34}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -358,7 +358,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_Vec3MemberOffset_ }); 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(); } @@ -381,7 +381,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_Vec3F16MemberOffs }); 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(); } @@ -406,8 +406,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid Member("scalar", ty.i32()), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -440,8 +440,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid Member("scalar", ty.i32()), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -483,8 +483,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid Member("scalar", ty.i32()), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -502,7 +502,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid // @group(0) @binding(0) // var a : array; 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()); 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)), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -556,8 +556,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid Member("scalar", ty.i32()), }); - GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a), - Binding(0_a)); + GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform, + Group(0_a), Binding(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -575,7 +575,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, PushConstant_UnalignedMember) { Source{{12, 34}}, "S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}), 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()); EXPECT_EQ( @@ -600,7 +600,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, PushConstant_Aligned) { Enable(ast::Extension::kChromiumExperimentalPushConstant); Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}), 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(); } diff --git a/src/tint/resolver/address_space_validation_test.cc b/src/tint/resolver/address_space_validation_test.cc index bc6c4a4937..d9513fe15a 100644 --- a/src/tint/resolver/address_space_validation_test.cc +++ b/src/tint/resolver/address_space_validation_test.cc @@ -38,7 +38,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NoAddressSpace_Fail) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NoAddressSpace_Fail) { // type g = ptr; - 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_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) { // var 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_EQ(r()->error(), @@ -56,7 +56,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_F TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray) { // var v : array; GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), @@ -67,7 +67,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray) TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArray) { // type t : ptr>; 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_EQ(r()->error(), @@ -79,7 +79,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArrayIn // struct S { m : array }; // var v : S; 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_EQ(r()->error(), @@ -92,7 +92,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArrayInSt // struct S { m : array }; // type t = ptr; 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_EQ(r()->error(), @@ -104,7 +104,7 @@ note: while instantiating ptr)"); TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray) { // var v : array; GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()), - ast::AddressSpace::kWorkgroup); + type::AddressSpace::kWorkgroup); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), @@ -114,7 +114,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArray) { // type t = ptr>; - 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_EQ(r()->error(), @@ -126,7 +126,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray // struct S { m : array }; // var v : S; 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_EQ(r()->error(), @@ -139,7 +139,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArrayIn // struct S { m : array }; // type t = ptr; 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_EQ(r()->error(), @@ -150,7 +150,7 @@ note: while instantiating ptr)"); TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) { // var 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)); ASSERT_FALSE(r()->Resolve()); @@ -164,7 +164,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Bool) { // type t = ptr; 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()); @@ -179,7 +179,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_BoolAlias) { // @binding(0) @group(0) var g : a; Alias("a", ty.bool_()); 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()); @@ -194,7 +194,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_BoolAlias) { // type t = ptr; Alias("a", ty.bool_()); 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()); @@ -207,8 +207,8 @@ note: while instantiating ptr)"); TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) { // var g : ptr; GlobalVar(Source{{56, 78}}, "g", - ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), - ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); + ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate), + type::AddressSpace::kStorage, Binding(0_a), Group(0_a)); ASSERT_FALSE(r()->Resolve()); @@ -221,8 +221,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) { // type t = ptr>; Alias("t", ty.pointer(Source{{56, 78}}, - ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), - ast::AddressSpace::kStorage)); + ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate), + type::AddressSpace::kStorage)); ASSERT_FALSE(r()->Resolve()); @@ -234,14 +234,14 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_IntScalar) { // var 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(); } TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_IntScalar) { // type t = ptrResolve()) << r()->error(); } @@ -251,7 +251,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_F16) { // var g : f16; 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(); } @@ -261,7 +261,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_F16) { // type t = ptr; 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(); } @@ -273,7 +273,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_F16Alias) { Enable(ast::Extension::kF16); 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(); } @@ -285,21 +285,21 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_F16Alias) { Enable(ast::Extension::kF16); 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(); } TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF32) { // var g : vec4; - GlobalVar("g", ty.vec4(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a)); + GlobalVar("g", ty.vec4(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) { // type t = ptr>; - Alias("t", ty.pointer(ty.vec4(), ast::AddressSpace::kStorage)); + Alias("t", ty.pointer(ty.vec4(), type::AddressSpace::kStorage)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -307,7 +307,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) { // var g : vec4; 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(); } @@ -315,7 +315,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF16) { // type t = ptr>; 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(); } @@ -324,7 +324,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ArrayF32) { // struct S{ a : f32 }; // var g : array; 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -334,7 +334,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ArrayF32) { // struct S{ a : f32 }; // type t = ptr>; 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(); } @@ -346,7 +346,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ArrayF16) { Enable(ast::Extension::kF16); 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -359,7 +359,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ArrayF16) { Enable(ast::Extension::kF16); 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -369,8 +369,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructI32) { // struct S { x : i32 }; // var g : S; Structure("S", utils::Vector{Member("x", ty.i32())}); - GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), - Group(0_a)); + GlobalVar("g", ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead, + Binding(0_a), Group(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -379,7 +379,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructI32) { // struct S { x : i32 }; // type t = ptr; 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(); } @@ -391,7 +391,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructI32Alias Structure("S", utils::Vector{Member("x", ty.i32())}); Alias("a1", ty.type_name("S")); 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -404,7 +404,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructI32Aliases Structure("S", utils::Vector{Member("x", ty.i32())}); Alias("a1", ty.type_name("S")); 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(); } @@ -415,8 +415,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructF16) { Enable(ast::Extension::kF16); Structure("S", utils::Vector{Member("x", ty.f16())}); - GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), - Group(0_a)); + GlobalVar("g", ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead, + Binding(0_a), Group(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -427,7 +427,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructF16) { Enable(ast::Extension::kF16); 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(); } @@ -441,7 +441,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructF16Alias Structure("S", utils::Vector{Member("x", ty.f16())}); Alias("a1", ty.type_name("S")); 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -456,14 +456,14 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructF16Aliases Structure("S", utils::Vector{Member("x", ty.f16())}); Alias("a1", ty.type_name("S")); 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(); } TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode) { // var 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()); @@ -475,7 +475,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode) TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) { // type t = ptr; 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()); @@ -486,7 +486,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode) { // @group(0) @binding(0) var 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -494,14 +494,14 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadAccessMode) { // type t = ptr; - 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(); } TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAccessMode) { // @group(0) @binding(0) var 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -509,14 +509,14 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAcces TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadWriteAccessMode) { // type t = ptr; - 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(); } TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMode) { // @group(0) @binding(0) var 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)); ASSERT_FALSE(r()->Resolve()); @@ -527,8 +527,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMod TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_WriteAccessMode) { // type t = ptr; - Alias("t", - ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kStorage, ast::Access::kWrite)); + Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kStorage, + ast::Access::kWrite)); ASSERT_FALSE(r()->Resolve()); @@ -543,7 +543,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBuffer_Struct_R Structure("S", 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)); ASSERT_FALSE(r()->Resolve()); @@ -560,7 +560,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBuffer_Struct_Run Structure("S", 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()); EXPECT_EQ( @@ -575,7 +575,7 @@ note: see layout of struct: TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) { // var 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)); ASSERT_FALSE(r()->Resolve()); @@ -589,7 +589,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBool) { // type t = ptr; 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()); @@ -604,7 +604,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBoolAlias // var g : a; Alias("a", ty.bool_()); 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()); @@ -619,7 +619,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBoolAlias) // type t = ptr; Alias("a", ty.bool_()); Alias("t", ty.pointer(Source{{56, 78}}, ty.type_name(Source{{12, 34}}, "a"), - ast::AddressSpace::kUniform)); + type::AddressSpace::kUniform)); ASSERT_FALSE(r()->Resolve()); @@ -632,8 +632,8 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBoolAlias) TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) { // var g : ptr; GlobalVar(Source{{56, 78}}, "g", - ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), - ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); + ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate), + type::AddressSpace::kUniform, Binding(0_a), Group(0_a)); ASSERT_FALSE(r()->Resolve()); @@ -646,8 +646,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) { TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) { // type t = ptr>; Alias("t", ty.pointer(Source{{56, 78}}, - ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), - ast::AddressSpace::kUniform)); + ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate), + type::AddressSpace::kUniform)); ASSERT_FALSE(r()->Resolve()); @@ -659,7 +659,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) { TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar) { // var 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -667,7 +667,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferIntScalar) { // type t = ptr; - Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kUniform)); + Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kUniform)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -677,7 +677,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferF16) { // var g : f16; 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(); } @@ -687,21 +687,21 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferF16) { // type t = ptr; 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(); } TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF32) { // var g : vec4; - GlobalVar("g", ty.vec4(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); + GlobalVar("g", ty.vec4(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF32) { // type t = ptr>; - Alias("t", ty.pointer(ty.vec4(), ast::AddressSpace::kUniform)); + Alias("t", ty.pointer(ty.vec4(), type::AddressSpace::kUniform)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -711,7 +711,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF16 // var g : vec4; Enable(ast::Extension::kF16); - GlobalVar("g", ty.vec4(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a)); + GlobalVar("g", ty.vec4(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -721,7 +721,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF16) // type t = ptr>; Enable(ast::Extension::kF16); - Alias("t", ty.pointer(ty.vec4(), ast::AddressSpace::kUniform)); + Alias("t", ty.pointer(ty.vec4(), type::AddressSpace::kUniform)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -732,7 +732,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferArrayF32) // } // var g : array; 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -744,7 +744,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferArrayF32) { // } // type t = ptr>; 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(); } @@ -758,7 +758,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferArrayF16) Enable(ast::Extension::kF16); 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -773,7 +773,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferArrayF16) { Enable(ast::Extension::kF16); 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(); } @@ -782,7 +782,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructI32 // struct S { x : i32 }; // var g : S; 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(); } @@ -791,7 +791,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructI32) // struct S { x : i32 }; // type t = ptr; 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(); } @@ -802,7 +802,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructI32 // var g : a1; Structure("S", utils::Vector{Member("x", ty.i32())}); 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(); } @@ -813,7 +813,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructI32Al // type t = ptr; Structure("S", utils::Vector{Member("x", ty.i32())}); 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(); } @@ -825,7 +825,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructF16 Enable(ast::Extension::kF16); 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(); } @@ -837,7 +837,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructF16) Enable(ast::Extension::kF16); 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(); } @@ -851,7 +851,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructF16 Structure("S", utils::Vector{Member("x", ty.f16())}); 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(); } @@ -865,7 +865,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructF16Al Structure("S", utils::Vector{Member("x", ty.f16())}); 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(); } @@ -874,7 +874,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantBool) { // enable chromium_experimental_push_constant; // var g : bool; 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()); EXPECT_EQ( @@ -888,7 +888,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantBool) { // type t = ptr; Enable(ast::Extension::kChromiumExperimentalPushConstant); 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()); EXPECT_EQ( @@ -903,7 +903,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantF16) { // var g : f16; Enable(ast::Extension::kF16); 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()); EXPECT_EQ(r()->error(), @@ -916,7 +916,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantF16) { // type t = ptr; Enable(ast::Extension::kF16); 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()); EXPECT_EQ(r()->error(), @@ -928,8 +928,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantPointer) { // var g : ptr; Enable(ast::Extension::kChromiumExperimentalPushConstant); GlobalVar(Source{{56, 78}}, "g", - ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), - ast::AddressSpace::kPushConstant); + ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate), + type::AddressSpace::kPushConstant); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -943,8 +943,8 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantPointer) { // type t = ptr>; Enable(ast::Extension::kChromiumExperimentalPushConstant); Alias(Source{{56, 78}}, "t", - ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate), - ast::AddressSpace::kPushConstant)); + ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate), + type::AddressSpace::kPushConstant)); ASSERT_FALSE(r()->Resolve()); EXPECT_EQ( @@ -957,7 +957,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantIntScalar) // enable chromium_experimental_push_constant; // var g : i32; Enable(ast::Extension::kChromiumExperimentalPushConstant); - GlobalVar("g", ty.i32(), ast::AddressSpace::kPushConstant); + GlobalVar("g", ty.i32(), type::AddressSpace::kPushConstant); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -966,7 +966,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantIntScalar) { // enable chromium_experimental_push_constant; // type t = ptr; 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(); } @@ -975,7 +975,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantVectorF32) // enable chromium_experimental_push_constant; // var g : vec4; Enable(ast::Extension::kChromiumExperimentalPushConstant); - GlobalVar("g", ty.vec4(), ast::AddressSpace::kPushConstant); + GlobalVar("g", ty.vec4(), type::AddressSpace::kPushConstant); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -984,7 +984,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantVectorF32) { // enable chromium_experimental_push_constant; // var g : vec4; Enable(ast::Extension::kChromiumExperimentalPushConstant); - Alias("t", ty.pointer(ty.vec4(), ast::AddressSpace::kPushConstant)); + Alias("t", ty.pointer(ty.vec4(), type::AddressSpace::kPushConstant)); ASSERT_TRUE(r()->Resolve()) << r()->error(); } @@ -995,7 +995,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantArrayF32) // var g : array; Enable(ast::Extension::kChromiumExperimentalPushConstant); 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(); } @@ -1006,7 +1006,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantArrayF32) { // type t = ptr>; Enable(ast::Extension::kChromiumExperimentalPushConstant); 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(); } diff --git a/src/tint/resolver/alias_analysis_test.cc b/src/tint/resolver/alias_analysis_test.cc index 490f54cac0..db78d64b83 100644 --- a/src/tint/resolver/alias_analysis_test.cc +++ b/src/tint/resolver/alias_analysis_test.cc @@ -35,19 +35,19 @@ struct ResolverAliasAnalysisTest : public resolver::TestHelper, public testing:: // target(&v1, aliased ? &v1 : &v2); // } 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. }; class TwoPointers : public ResolverTestWithParam { protected: void SetUp() override { utils::Vector 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("v2", ty.i32()))); } else { - GlobalVar("v1", ast::AddressSpace::kPrivate, ty.i32()); - GlobalVar("v2", ast::AddressSpace::kPrivate, ty.i32()); + GlobalVar("v1", type::AddressSpace::kPrivate, ty.i32()); + GlobalVar("v2", type::AddressSpace::kPrivate, ty.i32()); } body.Push(CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"), AddressOf(Source{{56, 78}}, GetParam().aliased ? "v1" : "v2")))); @@ -190,10 +190,10 @@ TEST_P(TwoPointers, ReadWriteAcrossDifferentFunctions) { INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, TwoPointers, - ::testing::Values(TwoPointerConfig{ast::AddressSpace::kFunction, false}, - TwoPointerConfig{ast::AddressSpace::kFunction, true}, - TwoPointerConfig{ast::AddressSpace::kPrivate, false}, - TwoPointerConfig{ast::AddressSpace::kPrivate, true}), + ::testing::Values(TwoPointerConfig{type::AddressSpace::kFunction, false}, + TwoPointerConfig{type::AddressSpace::kFunction, true}, + TwoPointerConfig{type::AddressSpace::kPrivate, false}, + TwoPointerConfig{type::AddressSpace::kPrivate, true}), [](const ::testing::TestParamInfo& p) { std::stringstream ss; ss << (p.param.aliased ? "Aliased" : "Unaliased") << "_" @@ -214,8 +214,8 @@ INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, class OnePointerOneModuleScope : public ResolverTestWithParam { protected: void SetUp() override { - GlobalVar("global_1", ast::AddressSpace::kPrivate, ty.i32()); - GlobalVar("global_2", ast::AddressSpace::kPrivate, ty.i32()); + GlobalVar("global_1", type::AddressSpace::kPrivate, ty.i32()); + GlobalVar("global_2", type::AddressSpace::kPrivate, ty.i32()); Func("caller", utils::Empty, ty.void_(), utils::Vector{ CallStmt(Call("target", @@ -226,7 +226,7 @@ class OnePointerOneModuleScope : public ResolverTestWithParam { void Run(utils::Vector&& body, const char* err = nullptr) { Func("target", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), std::move(body)); if (GetParam() && err) { @@ -295,7 +295,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) { // f1(p1); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -303,7 +303,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) { }); Func("f1", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -330,7 +330,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) { // f1(p1); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -339,7 +339,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) { }); Func("f1", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -365,7 +365,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) { // f1(p1); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -373,7 +373,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) { }); Func("f1", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -400,7 +400,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) { // f1(p1); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -409,7 +409,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) { }); Func("f1", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -435,7 +435,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteAcrossDifferentFunctions) { // f2(); Func("f1", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p1", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Vector{ @@ -487,8 +487,8 @@ class Use : public ResolverTestWithParam { void Run(const ast::Statement* stmt, const char* err = nullptr) { Func("target", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kFunction)), - Param("p2", ty.pointer(ast::AddressSpace::kFunction)), + Param("p1", ty.pointer(type::AddressSpace::kFunction)), + Param("p2", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -531,7 +531,7 @@ TEST_P(Use, Write_CompoundAssignment_LHS) { TEST_P(Use, Read_CompoundAssignment_RHS) { // var global : i32; // global += *p2; - GlobalVar("global", ast::AddressSpace::kPrivate, ty.i32()); + GlobalVar("global", type::AddressSpace::kPrivate, ty.i32()); Run(CompoundAssign("global", Deref("p2"), ast::BinaryOp::kAdd), R"(56:78 warning: invalid aliased pointer argument 12:34 note: aliases with another argument passed here)"); @@ -578,7 +578,7 @@ TEST_P(Use, Read_Convert) { TEST_P(Use, Read_IndexAccessor) { // var data : array; // _ = data[*p2]; - GlobalVar("data", ast::AddressSpace::kPrivate, ty.array()); + GlobalVar("data", type::AddressSpace::kPrivate, ty.array()); Run(Assign(Phony(), IndexAccessor("data", Deref("p2"))), R"(56:78 warning: invalid aliased pointer argument 12:34 note: aliases with another argument passed here)"); @@ -592,7 +592,7 @@ TEST_P(Use, Read_LetInitializer) { TEST_P(Use, Read_VarInitializer) { // 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 12:34 note: aliases with another argument passed here)"); } @@ -602,7 +602,7 @@ TEST_P(Use, Read_ReturnValue) { // foo(p2); Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.i32(), utils::Vector{ @@ -659,8 +659,8 @@ class UseBool : public ResolverTestWithParam { void Run(const ast::Statement* stmt, const char* err = nullptr) { Func("target", utils::Vector{ - Param("p1", ty.pointer(ast::AddressSpace::kFunction)), - Param("p2", ty.pointer(ast::AddressSpace::kFunction)), + Param("p1", ty.pointer(type::AddressSpace::kFunction)), + Param("p2", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -724,8 +724,8 @@ TEST_F(ResolverAliasAnalysisTest, NoAccess_MemberAccessor) { Structure("S", utils::Vector{Member("a", ty.i32())}); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), - Param("p2", 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"), type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -753,8 +753,8 @@ TEST_F(ResolverAliasAnalysisTest, Read_MemberAccessor) { Structure("S", utils::Vector{Member("a", ty.i32())}); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), - Param("p2", 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"), type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -785,8 +785,8 @@ TEST_F(ResolverAliasAnalysisTest, Write_MemberAccessor) { Structure("S", utils::Vector{Member("a", ty.i32())}); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)), - Param("p2", 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"), type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -816,8 +816,8 @@ TEST_F(ResolverAliasAnalysisTest, Read_MultiComponentSwizzle) { Structure("S", utils::Vector{Member("a", ty.i32())}); Func("f2", utils::Vector{ - Param("p1", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction)), - Param("p2", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction)), + Param("p1", ty.pointer(ty.vec4(), type::AddressSpace::kFunction)), + Param("p2", ty.pointer(ty.vec4(), type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -848,7 +848,7 @@ TEST_F(ResolverAliasAnalysisTest, SinglePointerReadWrite) { // } Func("f1", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -901,7 +901,7 @@ TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) { // } Func("f2", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -909,7 +909,7 @@ TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) { }); Func("f3", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ diff --git a/src/tint/resolver/array_accessor_test.cc b/src/tint/resolver/array_accessor_test.cc index 65fbb8313c..255d109588 100644 --- a/src/tint/resolver/array_accessor_test.cc +++ b/src/tint/resolver/array_accessor_test.cc @@ -27,7 +27,7 @@ namespace { using ResolverIndexAccessorTest = ResolverTest; TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) { - GlobalVar("my_var", ty.mat2x3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1_f)); WrapInFunction(acc); @@ -36,7 +36,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) { } TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) { - GlobalVar("my_var", ty.mat2x3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* idx = Var("idx", ty.i32(), Construct(ty.i32())); auto* acc = IndexAccessor("my_var", idx); WrapInFunction(Decl(idx), acc); @@ -50,7 +50,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) { } TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) { - GlobalVar("my_var", ty.mat4x4(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.mat4x4(), type::AddressSpace::kPrivate); auto* idx = Var("idx", ty.u32(), Expr(3_u)); auto* idy = Var("idy", ty.u32(), Expr(2_u)); auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy); @@ -100,7 +100,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_BothDimension_Dynamic) { } TEST_F(ResolverIndexAccessorTest, Matrix) { - GlobalVar("my_var", ty.mat2x3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", 1_i); WrapInFunction(acc); @@ -118,7 +118,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix) { } TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) { - GlobalVar("my_var", ty.mat2x3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor(IndexAccessor("my_var", 0_i), 1_i); WrapInFunction(acc); @@ -135,7 +135,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) { } TEST_F(ResolverIndexAccessorTest, Vector_F32) { - GlobalVar("my_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec3(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2_f)); WrapInFunction(acc); @@ -144,7 +144,7 @@ TEST_F(ResolverIndexAccessorTest, Vector_F32) { } TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) { - GlobalVar("my_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec3(), type::AddressSpace::kPrivate); auto* idx = Var("idx", ty.i32(), Expr(2_i)); auto* acc = IndexAccessor("my_var", idx); WrapInFunction(Decl(idx), acc); @@ -167,7 +167,7 @@ TEST_F(ResolverIndexAccessorTest, Vector_Dynamic) { } TEST_F(ResolverIndexAccessorTest, Vector) { - GlobalVar("my_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec3(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", 2_i); WrapInFunction(acc); @@ -184,7 +184,7 @@ TEST_F(ResolverIndexAccessorTest, Vector) { } TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) { - GlobalVar("my_var", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.array(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", 2_i); WrapInFunction(acc); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -197,7 +197,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) { } TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) { - GlobalVar("my_var", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.array(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", 2_u); WrapInFunction(acc); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -210,7 +210,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) { } TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) { - GlobalVar("my_var", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.array(), type::AddressSpace::kPrivate); auto* acc = IndexAccessor("my_var", 2_a); WrapInFunction(acc); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -225,7 +225,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) { TEST_F(ResolverIndexAccessorTest, Alias_Array) { auto* aary = Alias("myarrty", ty.array()); - 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); WrapInFunction(acc); @@ -316,7 +316,7 @@ TEST_F(ResolverIndexAccessorTest, Expr_Deref_FuncGoodParent) { // let x: f32 = (*p)[idx]; // return x; // } - auto* p = Param("p", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction)); + auto* p = Param("p", ty.pointer(ty.vec4(), type::AddressSpace::kFunction)); auto* idx = Let("idx", ty.u32(), Construct(ty.u32())); auto* star_p = Deref(p); auto* acc = IndexAccessor(Source{{12, 34}}, star_p, idx); @@ -337,7 +337,7 @@ TEST_F(ResolverIndexAccessorTest, Expr_Deref_FuncBadParent) { // let x: f32 = *p[idx]; // return x; // } - auto* p = Param("p", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction)); + auto* p = Param("p", ty.pointer(ty.vec4(), type::AddressSpace::kFunction)); auto* idx = Let("idx", ty.u32(), Construct(ty.u32())); auto* accessor_expr = IndexAccessor(Source{{12, 34}}, p, idx); auto* star_p = Deref(accessor_expr); diff --git a/src/tint/resolver/assignment_validation_test.cc b/src/tint/resolver/assignment_validation_test.cc index d7ad48894f..ca94780f7a 100644 --- a/src/tint/resolver/assignment_validation_test.cc +++ b/src/tint/resolver/assignment_validation_test.cc @@ -33,7 +33,7 @@ TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) { auto* s = Structure("S", utils::Vector{ 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)); WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i)); @@ -193,7 +193,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) { // var a : i32; // let b : ptr = &a; // *b = 2i; - const auto func = ast::AddressSpace::kFunction; + const auto func = type::AddressSpace::kFunction; WrapInFunction(Var("a", ty.i32(), func, Expr(2_i)), // Let("b", ty.pointer(func), AddressOf(Expr("a"))), // Assign(Deref("b"), 2_i)); @@ -205,7 +205,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignMaterializedThroughPointer_Pass) // var a : i32; // let b : ptr = &a; // *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_b = Let("b", ty.pointer(func), AddressOf(Expr("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{ Member("a", ty.atomic(ty.i32())), }); - GlobalVar(Source{{12, 34}}, "v", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, - Binding(0_a), Group(0_a)); + GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage, + ast::Access::kReadWrite, Binding(0_a), Group(0_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{ Member("a", ty.array(ty.f32())), }); - GlobalVar(Source{{12, 34}}, "v", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, - Binding(0_a), Group(0_a)); + GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage, + ast::Access::kReadWrite, Binding(0_a), Group(0_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{ Member("arr", ty.array()), }); - 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"))); @@ -311,7 +311,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) { auto* s = Structure("S", utils::Vector{ Member("arr", ty.array()), }); - 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"))); @@ -364,9 +364,9 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) { GlobalVar("tex", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a), Binding(0_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("s", ty.Of(S), ast::AddressSpace::kStorage, Group(0_a), Binding(3_a)); - GlobalVar("wg", ty.array(), ast::AddressSpace::kWorkgroup); + GlobalVar("u", ty.Of(U), type::AddressSpace::kUniform, Group(0_a), Binding(2_a)); + GlobalVar("s", ty.Of(S), type::AddressSpace::kStorage, Group(0_a), Binding(3_a)); + GlobalVar("wg", ty.array(), type::AddressSpace::kWorkgroup); WrapInFunction(Assign(Phony(), 1_i), // Assign(Phony(), 2_u), // diff --git a/src/tint/resolver/atomics_test.cc b/src/tint/resolver/atomics_test.cc index a7d4f073ad..a35dcc6538 100644 --- a/src/tint/resolver/atomics_test.cc +++ b/src/tint/resolver/atomics_test.cc @@ -27,7 +27,7 @@ using namespace tint::number_suffixes; // NOLINT struct ResolverAtomicTest : public resolver::TestHelper, public testing::Test {}; 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(); ASSERT_TRUE(TypeOf(g)->Is()); @@ -37,7 +37,7 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) { } 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(); ASSERT_TRUE(TypeOf(g)->Is()); @@ -48,7 +48,7 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) { TEST_F(ResolverAtomicTest, GlobalStorageStruct) { 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)); EXPECT_TRUE(r()->Resolve()) << r()->error(); diff --git a/src/tint/resolver/atomics_validation_test.cc b/src/tint/resolver/atomics_validation_test.cc index 13509350eb..e8de3cb37e 100644 --- a/src/tint/resolver/atomics_validation_test.cc +++ b/src/tint/resolver/atomics_validation_test.cc @@ -27,13 +27,13 @@ namespace { struct ResolverAtomicValidationTest : public resolver::TestHelper, public testing::Test {}; 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()); } 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)); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -41,21 +41,21 @@ TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) { TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage_Struct) { 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)); EXPECT_TRUE(r()->Resolve()) << r()->error(); } 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_EQ(r()->error(), "12:34 error: atomic only supports i32 or u32 types"); } 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_EQ(r()->error(), @@ -63,7 +63,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Simple) { } 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_EQ(r()->error(), @@ -72,7 +72,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) { TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Struct) { 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_EQ(r()->error(), @@ -88,7 +88,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_StructOfStruct) { auto* Inner = Structure("Inner", utils::Vector{Member("m", ty.atomic(Source{{12, 34}}, ty.i32()))}); 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_EQ(r()->error(), @@ -104,7 +104,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_StructOfStructOfArray) auto* Inner = Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))}); 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_EQ(r()->error(), @@ -118,7 +118,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfArray) { auto* atomic_array = 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_EQ(r()->error(), @@ -132,7 +132,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfStruct) { // var v: array; auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic())}); - 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_EQ(r()->error(), @@ -149,7 +149,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfStructOfArray) { auto* atomic_array = Alias("AtomicArray", ty.atomic(ty.i32())); 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_EQ(r()->error(), @@ -188,7 +188,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Complex) { auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))}); auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))}); 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_EQ(r()->error(), @@ -198,7 +198,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Complex) { TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) { 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)); EXPECT_FALSE(r()->Resolve()); @@ -210,7 +210,7 @@ TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) { TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Struct) { 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)); EXPECT_FALSE(r()->Resolve()); @@ -228,7 +228,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStruct) { auto* Inner = Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))}); 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)); EXPECT_FALSE(r()->Resolve()); @@ -246,7 +246,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStructOfArray) { auto* Inner = Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))}); 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)); 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* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))}); 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)); EXPECT_FALSE(r()->Resolve()); diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc index 3c01f8672b..31a5e9ea05 100644 --- a/src/tint/resolver/attribute_validation_test.cc +++ b/src/tint/resolver/attribute_validation_test.cc @@ -722,8 +722,8 @@ TEST_F(StructMemberAttributeTest, Align_Attribute_ConstAFloat) { } TEST_F(StructMemberAttributeTest, Align_Attribute_Var) { - GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined, - Expr(1.23_f)); + GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate, + ast::Access::kUndefined, Expr(1.23_f)); Structure(Source{{6, 4}}, "mystruct", 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) { - GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined, - Expr(1.23_f)); + GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate, + ast::Access::kUndefined, Expr(1.23_f)); Structure(Source{{6, 4}}, "mystruct", utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(), @@ -875,7 +875,7 @@ TEST_P(VariableAttributeTest, IsValid) { if (IsBindingAttribute(params.kind)) { GlobalVar("a", ty.sampler(ast::SamplerKind::kSampler), attrs); } else { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, attrs); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, attrs); } if (params.should_pass) { @@ -1046,7 +1046,7 @@ TEST_P(ArrayStrideTest, All) { create(Source{{12, 34}}, params.stride), }); - GlobalVar("myarray", arr, ast::AddressSpace::kPrivate); + GlobalVar("myarray", arr, type::AddressSpace::kPrivate); if (params.should_pass) { EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -1129,7 +1129,7 @@ TEST_F(ArrayStrideTest, DuplicateAttribute) { create(Source{{56, 78}}, 4u), }); - GlobalVar("myarray", arr, ast::AddressSpace::kPrivate); + GlobalVar("myarray", arr, type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), @@ -1148,7 +1148,7 @@ TEST_F(ResourceAttributeTest, UniformBufferMissingBinding) { auto* s = Structure("S", utils::Vector{ 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_EQ(r()->error(), @@ -1159,7 +1159,7 @@ TEST_F(ResourceAttributeTest, StorageBufferMissingBinding) { auto* s = Structure("S", utils::Vector{ 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_EQ(r()->error(), @@ -1245,7 +1245,7 @@ TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByDifferentEntryPoints) { } 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)); EXPECT_FALSE(r()->Resolve()); diff --git a/src/tint/resolver/builtin_test.cc b/src/tint/resolver/builtin_test.cc index b2b1e3091d..2a689c5f8b 100644 --- a/src/tint/resolver/builtin_test.cc +++ b/src/tint/resolver/builtin_test.cc @@ -80,7 +80,7 @@ using ResolverBuiltinTest_BoolMethod = ResolverTestWithParam; TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) { 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"); WrapInFunction(expr); @@ -93,7 +93,7 @@ TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) { TEST_P(ResolverBuiltinTest_BoolMethod, Vector) { auto name = GetParam(); - GlobalVar("my_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call(name, "my_var"); WrapInFunction(expr); @@ -108,9 +108,9 @@ INSTANTIATE_TEST_SUITE_P(ResolverTest, testing::Values("any", "all")); TEST_F(ResolverBuiltinTest, Select) { - GlobalVar("my_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec3(), type::AddressSpace::kPrivate); - GlobalVar("bool_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("bool_var", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("select", "my_var", "my_var", "bool_var"); WrapInFunction(expr); @@ -214,7 +214,7 @@ using ResolverBuiltinArrayTest = ResolverTest; TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) { auto* ary = ty.array(); 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)); auto* call = Call("arrayLength", AddressOf(MemberAccessor("a", "x"))); @@ -227,7 +227,7 @@ TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) { } TEST_F(ResolverBuiltinArrayTest, ArrayLength_Error_ArraySized) { - GlobalVar("arr", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("arr", ty.array(), type::AddressSpace::kPrivate); auto* call = Call("arrayLength", AddressOf("arr")); WrapInFunction(call); @@ -1070,7 +1070,7 @@ TEST_F(ResolverBuiltinFloatTest, FrexpVector_sig) { } 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")); WrapInFunction(call); @@ -1319,7 +1319,7 @@ TEST_F(ResolverBuiltinFloatTest, ModfVector_f16) { } 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")); WrapInFunction(call); @@ -1335,7 +1335,7 @@ TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) { } 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")); WrapInFunction(call); @@ -1365,7 +1365,7 @@ TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamNotAPointer) { } TEST_F(ResolverBuiltinFloatTest, Modf_Error_VectorSizesDontMatch) { - GlobalVar("whole", ty.vec4(), ast::AddressSpace::kWorkgroup); + GlobalVar("whole", ty.vec4(), type::AddressSpace::kWorkgroup); auto* call = Call("modf", vec2(1_f, 2_f), AddressOf("whole")); WrapInFunction(call); @@ -1845,7 +1845,7 @@ INSTANTIATE_TEST_SUITE_P( namespace matrix_builtin_tests { TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) { - GlobalVar("var", ty.mat2x2(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat2x2(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1859,7 +1859,7 @@ TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) { TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) { Enable(ast::Extension::kF16); - GlobalVar("var", ty.mat2x2(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat2x2(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1871,7 +1871,7 @@ TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) { } TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) { - GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1885,7 +1885,7 @@ TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) { TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) { Enable(ast::Extension::kF16); - GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1897,7 +1897,7 @@ TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) { } TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) { - GlobalVar("var", ty.mat4x4(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat4x4(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1911,7 +1911,7 @@ TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) { TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) { Enable(ast::Extension::kF16); - GlobalVar("var", ty.mat4x4(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat4x4(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1923,7 +1923,7 @@ TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) { } TEST_F(ResolverBuiltinTest, Determinant_NotSquare) { - GlobalVar("var", ty.mat2x3(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1938,7 +1938,7 @@ TEST_F(ResolverBuiltinTest, Determinant_NotSquare) { } TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) { - GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("determinant", "var"); WrapInFunction(call); @@ -1958,7 +1958,7 @@ TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) { namespace vector_builtin_tests { TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) { - GlobalVar("my_var", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec2(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "my_var", "my_var"); WrapInFunction(expr); @@ -1972,7 +1972,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) { TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) { Enable(ast::Extension::kF16); - GlobalVar("my_var", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec2(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "my_var", "my_var"); WrapInFunction(expr); @@ -1984,7 +1984,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) { } TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) { - GlobalVar("my_var", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "my_var", "my_var"); WrapInFunction(expr); @@ -1996,7 +1996,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) { } TEST_F(ResolverBuiltinTest, Dot_Vec4_u32) { - GlobalVar("my_var", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_var", ty.vec4(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "my_var", "my_var"); WrapInFunction(expr); @@ -2031,7 +2031,7 @@ using ResolverBuiltinDerivativeTest = ResolverTestWithParam; TEST_P(ResolverBuiltinDerivativeTest, Scalar) { auto name = GetParam(); - GlobalVar("ident", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.f32(), type::AddressSpace::kPrivate); auto* expr = Call(name, "ident"); Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)}, @@ -2045,7 +2045,7 @@ TEST_P(ResolverBuiltinDerivativeTest, Scalar) { TEST_P(ResolverBuiltinDerivativeTest, Vector) { auto name = GetParam(); - GlobalVar("ident", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.vec4(), type::AddressSpace::kPrivate); auto* expr = Call(name, "ident"); Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)}, @@ -2141,7 +2141,7 @@ class ResolverBuiltinTest_TextureOperation : public ResolverTestWithParamPush(Expr(name)); diff --git a/src/tint/resolver/builtin_validation_test.cc b/src/tint/resolver/builtin_validation_test.cc index 2b45386504..1b785ebe51 100644 --- a/src/tint/resolver/builtin_validation_test.cc +++ b/src/tint/resolver/builtin_validation_test.cc @@ -166,7 +166,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalConstUsedAsType) } 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)); EXPECT_FALSE(r()->Resolve()); @@ -176,7 +176,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsFunction TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable) { 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"); WrapInFunction(Decl(Var("v", use))); @@ -187,7 +187,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable } 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"))); EXPECT_FALSE(r()->Resolve()); @@ -481,7 +481,7 @@ TEST_P(BuiltinTextureConstExprArgValidationTest, GlobalVar) { overload.BuildSamplerVariable(this); // 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*& arg_to_replace = (param.position == Position::kFirst) ? args.Front() : args.Back(); @@ -652,7 +652,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_WrongAddressSpace) { // fn foo() { // 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)}); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v")))); @@ -670,7 +670,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_Atomic) { // fn foo() { // workgroupUniformLoad(&v); // } - GlobalVar("v", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("v", ty.atomic(), type::AddressSpace::kWorkgroup); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v")))); EXPECT_FALSE(r()->Resolve()); @@ -684,7 +684,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_AtomicInArray) { // fn foo() { // workgroupUniformLoad(&v); // } - GlobalVar("v", ty.array(ty.atomic(), 4_a), ast::AddressSpace::kWorkgroup); + GlobalVar("v", ty.array(ty.atomic(), 4_a), type::AddressSpace::kWorkgroup); WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v")))); EXPECT_FALSE(r()->Resolve()); @@ -703,7 +703,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_AtomicInStruct) { Structure("Inner", utils::Vector{Member("a", ty.array(ty.atomic(), 4_a))}); Structure("S", utils::Vector{Member("i", ty.type_name("Inner"))}); 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")))); EXPECT_FALSE(r()->Resolve()); diff --git a/src/tint/resolver/builtins_validation_test.cc b/src/tint/resolver/builtins_validation_test.cc index b6fdddb8a1..efee2c913e 100644 --- a/src/tint/resolver/builtins_validation_test.cc +++ b/src/tint/resolver/builtins_validation_test.cc @@ -100,7 +100,7 @@ using ResolverBuiltinsStageTest = ResolverTestWithParam; TEST_P(ResolverBuiltinsStageTest, All_input) { const Params& params = GetParam(); - auto* p = GlobalVar("p", ty.vec4(), ast::AddressSpace::kPrivate); + auto* p = GlobalVar("p", ty.vec4(), type::AddressSpace::kPrivate); auto* input = Param("input", params.type(*this), utils::Vector{Builtin(Source{{12, 34}}, params.builtin)}); switch (params.stage) { diff --git a/src/tint/resolver/call_validation_test.cc b/src/tint/resolver/call_validation_test.cc index e94e7b86a9..9e90cf8d9e 100644 --- a/src/tint/resolver/call_validation_test.cc +++ b/src/tint/resolver/call_validation_test.cc @@ -103,7 +103,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_VariableIdentExpr) { // var z: i32 = 1i; // foo(&z); // } - auto* param = Param("p", ty.pointer(ast::AddressSpace::kFunction)); + auto* param = Param("p", ty.pointer(type::AddressSpace::kFunction)); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ @@ -120,7 +120,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_LetIdentExpr) { // let z: i32 = 1i; // foo(&z); // } - auto* param = Param("p", ty.pointer(ast::AddressSpace::kFunction)); + auto* param = Param("p", ty.pointer(type::AddressSpace::kFunction)); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ @@ -142,7 +142,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfFunctionMember) { auto* S = Structure("S", utils::Vector{ Member("m", ty.i32()), }); - auto* param = Param("p", ty.pointer(ast::AddressSpace::kFunction)); + auto* param = Param("p", ty.pointer(type::AddressSpace::kFunction)); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ @@ -169,7 +169,7 @@ TEST_F(ResolverCallValidationTest, auto* S = Structure("S", utils::Vector{ Member("m", ty.i32()), }); - auto* param = Param("p", ty.pointer(ast::AddressSpace::kFunction)); + auto* param = Param("p", ty.pointer(type::AddressSpace::kFunction)); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ @@ -189,7 +189,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfLetMember) { auto* S = Structure("S", utils::Vector{ Member("m", ty.i32()), }); - auto* param = Param("p", ty.pointer(ast::AddressSpace::kFunction)); + auto* param = Param("p", ty.pointer(type::AddressSpace::kFunction)); Func("foo", utils::Vector{param}, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ @@ -208,12 +208,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParam) { // } Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("bar", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -235,12 +235,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParamWithMain) { // } Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("bar", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Vector{ @@ -268,13 +268,13 @@ TEST_F(ResolverCallValidationTest, LetPointer) { // } Func("x", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ 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")), }, utils::Vector{ @@ -293,13 +293,13 @@ TEST_F(ResolverCallValidationTest, LetPointerPrivate) { // } Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kPrivate)), + Param("p", ty.pointer(type::AddressSpace::kPrivate)), }, ty.void_(), utils::Empty); - GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); Func("main", utils::Empty, ty.void_(), 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"))), }, utils::Vector{ @@ -318,13 +318,13 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar) { // } Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ Decl(Var("v", ty.array())), - 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)))), CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))), }, @@ -349,13 +349,13 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar_WithFullPtrParametersE Enable(ast::Extension::kChromiumExperimentalFullPtrParameters); Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), utils::Vector{ Decl(Var("v", ty.array())), - 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)))), CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))), }, @@ -377,7 +377,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain) { // } Func("foo", utils::Vector{ - Param("p", ty.pointer(ty.array(), ast::AddressSpace::kFunction)), + Param("p", ty.pointer(ty.array(), type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), @@ -406,7 +406,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar) { // } Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), @@ -440,7 +440,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar_WithFullPtrPa Enable(ast::Extension::kChromiumExperimentalFullPtrParameters); Func("foo", utils::Vector{ - Param("p", ty.pointer(ast::AddressSpace::kFunction)), + Param("p", ty.pointer(type::AddressSpace::kFunction)), }, ty.void_(), utils::Empty); Func("main", utils::Empty, ty.void_(), @@ -462,7 +462,7 @@ TEST_F(ResolverCallValidationTest, CallVariable) { // fn f() { // v(); // } - GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); Func("f", utils::Empty, ty.void_(), utils::Vector{ CallStmt(Call(Source{{12, 34}}, "v")), diff --git a/src/tint/resolver/compound_assignment_validation_test.cc b/src/tint/resolver/compound_assignment_validation_test.cc index 941fce22cb..f8f2ee6607 100644 --- a/src/tint/resolver/compound_assignment_validation_test.cc +++ b/src/tint/resolver/compound_assignment_validation_test.cc @@ -51,7 +51,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, CompatibleTypesAssignThroughPoi // var a : i32; // let b : ptr = &a; // *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_b = Let("b", ty.pointer(func), AddressOf(Expr("a"))); WrapInFunction(var_a, var_b, @@ -233,7 +233,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, ReadOnlyBuffer) { // { // 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)); WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1_i, ast::BinaryOp::kAdd)); @@ -264,7 +264,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, LhsLiteral) { TEST_F(ResolverCompoundAssignmentValidationTest, LhsAtomic) { // var a : atomic; // 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)); EXPECT_FALSE(r()->Resolve()); diff --git a/src/tint/resolver/const_eval_indexing_test.cc b/src/tint/resolver/const_eval_indexing_test.cc index 9229f983e7..e7c96887d4 100644 --- a/src/tint/resolver/const_eval_indexing_test.cc +++ b/src/tint/resolver/const_eval_indexing_test.cc @@ -279,7 +279,7 @@ TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index_OOB_Low) { TEST_F(ResolverConstEvalTest, RuntimeArray_vec3_f32_Index_OOB_Low) { auto* sb = GlobalVar("sb", ty.array(ty.vec3()), Group(0_a), Binding(0_a), - ast::AddressSpace::kStorage); + type::AddressSpace::kStorage); auto* expr = IndexAccessor(sb, Expr(Source{{12, 34}}, -2_i)); WrapInFunction(expr); diff --git a/src/tint/resolver/dependency_graph_test.cc b/src/tint/resolver/dependency_graph_test.cc index b73033c26d..756cb3f8a0 100644 --- a/src/tint/resolver/dependency_graph_test.cc +++ b/src/tint/resolver/dependency_graph_test.cc @@ -426,7 +426,7 @@ const ast::Node* SymbolTestHelper::Add(SymbolDeclKind kind, Symbol symbol, Sourc auto& b = *builder; switch (kind) { 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: return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1_i)); case SymbolDeclKind::Alias: @@ -469,27 +469,27 @@ const ast::Node* SymbolTestHelper::Add(SymbolUseKind kind, Symbol symbol, Source switch (kind) { case SymbolUseKind::GlobalVarType: { 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; } case SymbolUseKind::GlobalVarArrayElemType: { 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; } case SymbolUseKind::GlobalVarArraySizeValue: { 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; } case SymbolUseKind::GlobalVarVectorElemType: { 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; } case SymbolUseKind::GlobalVarMatrixElemType: { 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; } case SymbolUseKind::GlobalVarSampledTexElemType: { @@ -504,7 +504,7 @@ const ast::Node* SymbolTestHelper::Add(SymbolUseKind kind, Symbol symbol, Source } case SymbolUseKind::GlobalVarValue: { 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; } case SymbolUseKind::GlobalConstType: { @@ -725,7 +725,7 @@ TEST_F(ResolverDependencyGraphUsedBeforeDeclTest, VarUsed) { 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(); } @@ -1212,7 +1212,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) { const auto type_sym = Sym("TYPE"); 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* 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.vec3(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.depth_texture(type::TextureDimension::k2d)); GlobalVar(Sym(), ty.depth_multisampled_texture(type::TextureDimension::k2d)); diff --git a/src/tint/resolver/entry_point_validation_test.cc b/src/tint/resolver/entry_point_validation_test.cc index cd49dedf71..9a026c7e6a 100644 --- a/src/tint/resolver/entry_point_validation_test.cc +++ b/src/tint/resolver/entry_point_validation_test.cc @@ -453,14 +453,14 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithEnable) { // enable chromium_experimental_push_constant; // var a : u32; Enable(ast::Extension::kChromiumExperimentalPushConstant); - GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant); + GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant); EXPECT_TRUE(r()->Resolve()); } TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) { // var 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_EQ(r()->error(), @@ -470,7 +470,7 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) { TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithIgnoreAddressSpaceAttribute) { // var 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)}); EXPECT_TRUE(r()->Resolve()); @@ -483,7 +483,7 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantOneVariableUsedInEntryPoint // _ = a; // } 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")}, utils::Vector{Stage(ast::PipelineStage::kCompute), @@ -501,8 +501,8 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantTwoVariablesUsedInEntryPoin // _ = b; // } Enable(ast::Extension::kChromiumExperimentalPushConstant); - GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant); - GlobalVar(Source{{3, 4}}, "b", ty.u32(), ast::AddressSpace::kPushConstant); + GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant); + GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant); Func(Source{{5, 6}}, "main", {}, ty.void_(), utils::Vector{Assign(Phony(), "a"), Assign(Phony(), "b")}, @@ -532,8 +532,8 @@ TEST_F(ResolverEntryPointValidationTest, // uses_b(); // } Enable(ast::Extension::kChromiumExperimentalPushConstant); - GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant); - GlobalVar(Source{{3, 4}}, "b", ty.u32(), ast::AddressSpace::kPushConstant); + GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::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{{7, 8}}, "uses_b", {}, ty.void_(), utils::Vector{Assign(Phony(), "b")}); @@ -565,8 +565,8 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantTwoVariablesUsedInDifferent // _ = a; // } Enable(ast::Extension::kChromiumExperimentalPushConstant); - GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant); - GlobalVar("b", ty.u32(), ast::AddressSpace::kPushConstant); + GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant); + GlobalVar("b", ty.u32(), type::AddressSpace::kPushConstant); Func("uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")}, utils::Vector{Stage(ast::PipelineStage::kCompute), diff --git a/src/tint/resolver/f16_extension_test.cc b/src/tint/resolver/f16_extension_test.cc index 4bcf6cceb3..8e5271e597 100644 --- a/src/tint/resolver/f16_extension_test.cc +++ b/src/tint/resolver/f16_extension_test.cc @@ -29,14 +29,14 @@ TEST_F(ResolverF16ExtensionTest, TypeUsedWithExtension) { // var v : f16; Enable(ast::Extension::kF16); - GlobalVar("v", ty.f16(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.f16(), type::AddressSpace::kPrivate); EXPECT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverF16ExtensionTest, TypeUsedWithoutExtension) { // var 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_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); @@ -47,14 +47,14 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithExtension) { // var v : vec2; Enable(ast::Extension::kF16); - GlobalVar("v", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.vec2(), type::AddressSpace::kPrivate); EXPECT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithoutExtension) { // var v : vec2; - 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_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); @@ -65,14 +65,14 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithExtension) { // var v = vec2(); Enable(ast::Extension::kF16); - GlobalVar("v", Construct(ty.vec2()), ast::AddressSpace::kPrivate); + GlobalVar("v", Construct(ty.vec2()), type::AddressSpace::kPrivate); EXPECT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithoutExtension) { // var v = vec2(); - 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_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); GlobalVar("v", Construct(ty.vec2(), Construct(ty.vec2())), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_TRUE(r()->Resolve()) << r()->error(); } @@ -92,7 +92,7 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithExtension) { TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithoutExtension) { // var v = vec2(vec2()); GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}})), Construct(ty.vec2())), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); @@ -103,14 +103,14 @@ TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithExtension) { // var v = 16h; 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(); } TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithoutExtension) { // var 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_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); @@ -123,14 +123,14 @@ TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithExtension) { // var v : vec2h; 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(); } TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithoutExtension) { // var 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_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled"); diff --git a/src/tint/resolver/function_validation_test.cc b/src/tint/resolver/function_validation_test.cc index ef40bffcc2..0c075d71e1 100644 --- a/src/tint/resolver/function_validation_test.cc +++ b/src/tint/resolver/function_validation_test.cc @@ -39,7 +39,7 @@ TEST_F(ResolverFunctionValidationTest, DuplicateParameterName) { TEST_F(ResolverFunctionValidationTest, ParameterMayShadowGlobal) { // var 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); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -420,7 +420,7 @@ TEST_F(ResolverFunctionValidationTest, CannotCallFunctionAtModuleScope) { utils::Vector{ 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_EQ(r()->error(), R"(12:34 error: functions cannot be called at module-scope)"); @@ -874,7 +874,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) { // var x = 64i; // @compute @workgroup_size(x) // 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, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -890,7 +890,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) { TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) { // @compute @workgroup_size(1 << 2 + 4) // 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, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -906,7 +906,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) { TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) { // @compute @workgroup_size(1, 1 << 2 + 4) // 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, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -922,7 +922,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) { TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) { // @compute @workgroup_size(1, 1, 1 << 2 + 4) // 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, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -936,7 +936,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) { } 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); EXPECT_FALSE(r()->Resolve()); @@ -1050,7 +1050,7 @@ enum class Expectation { kAlwaysFail, }; struct TestParams { - ast::AddressSpace address_space; + type::AddressSpace address_space; Expectation expectation; }; @@ -1094,15 +1094,15 @@ INSTANTIATE_TEST_SUITE_P( ResolverTest, ResolverFunctionParameterValidationTest, testing::Values( - TestParams{ast::AddressSpace::kNone, Expectation::kAlwaysFail}, - TestParams{ast::AddressSpace::kIn, Expectation::kAlwaysFail}, - TestParams{ast::AddressSpace::kOut, Expectation::kAlwaysFail}, - TestParams{ast::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension}, - TestParams{ast::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension}, - TestParams{ast::AddressSpace::kHandle, Expectation::kAlwaysFail}, - TestParams{ast::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension}, - TestParams{ast::AddressSpace::kPrivate, Expectation::kAlwaysPass}, - TestParams{ast::AddressSpace::kFunction, Expectation::kAlwaysPass})); + TestParams{type::AddressSpace::kNone, Expectation::kAlwaysFail}, + TestParams{type::AddressSpace::kIn, Expectation::kAlwaysFail}, + TestParams{type::AddressSpace::kOut, Expectation::kAlwaysFail}, + TestParams{type::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension}, + TestParams{type::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension}, + TestParams{type::AddressSpace::kHandle, Expectation::kAlwaysFail}, + TestParams{type::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension}, + TestParams{type::AddressSpace::kPrivate, Expectation::kAlwaysPass}, + TestParams{type::AddressSpace::kFunction, Expectation::kAlwaysPass})); } // namespace } // namespace tint::resolver diff --git a/src/tint/resolver/host_shareable_validation_test.cc b/src/tint/resolver/host_shareable_validation_test.cc index 325595ccbe..12560e3851 100644 --- a/src/tint/resolver/host_shareable_validation_test.cc +++ b/src/tint/resolver/host_shareable_validation_test.cc @@ -29,7 +29,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolMember) { auto* s = 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)); ASSERT_FALSE(r()->Resolve()); @@ -45,7 +45,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolVectorMember) { auto* s = Structure( "S", utils::Vector{Member(Source{{56, 78}}, "x", ty.vec3(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)); ASSERT_FALSE(r()->Resolve()); @@ -62,7 +62,7 @@ TEST_F(ResolverHostShareableValidationTest, Aliases) { auto* s = Structure( "S", utils::Vector{Member(Source{{56, 78}}, "x", ty.type_name(Source{{12, 34}}, "a1"))}); 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)); 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))}); - 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)); 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))}); - 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); diff --git a/src/tint/resolver/increment_decrement_validation_test.cc b/src/tint/resolver/increment_decrement_validation_test.cc index e822de3d4b..d03e6f3608 100644 --- a/src/tint/resolver/increment_decrement_validation_test.cc +++ b/src/tint/resolver/increment_decrement_validation_test.cc @@ -64,8 +64,8 @@ TEST_F(ResolverIncrementDecrementValidationTest, ThroughPointer) { // var a : i32; // let b : ptr = &a; // *b++; - auto* var_a = Var("a", ty.i32(), ast::AddressSpace::kFunction); - auto* var_b = Let("b", ty.pointer(ast::AddressSpace::kFunction), AddressOf(Expr("a"))); + auto* var_a = Var("a", ty.i32(), type::AddressSpace::kFunction); + auto* var_b = Let("b", ty.pointer(type::AddressSpace::kFunction), AddressOf(Expr("a"))); WrapInFunction(var_a, var_b, Increment(Source{{12, 34}}, Deref("b"))); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -127,7 +127,7 @@ TEST_F(ResolverIncrementDecrementValidationTest, Vector) { TEST_F(ResolverIncrementDecrementValidationTest, Atomic) { // var a : atomic; // 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"))); EXPECT_FALSE(r()->Resolve()); @@ -193,7 +193,7 @@ TEST_F(ResolverIncrementDecrementValidationTest, ReadOnlyBuffer) { // { // 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)); WrapInFunction(Increment(Source{{56, 78}}, "a")); diff --git a/src/tint/resolver/inferred_type_test.cc b/src/tint/resolver/inferred_type_test.cc index 6406bea414..0835275456 100644 --- a/src/tint/resolver/inferred_type_test.cc +++ b/src/tint/resolver/inferred_type_test.cc @@ -97,7 +97,7 @@ TEST_P(ResolverInferredTypeParamTest, GlobalVar_Pass) { // var a = ; 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_EQ(TypeOf(var)->UnwrapRef(), expected_type); @@ -124,7 +124,7 @@ TEST_P(ResolverInferredTypeParamTest, LocalVar_Pass) { // var a = ; 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); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -139,7 +139,7 @@ TEST_F(ResolverInferredTypeTest, InferArray_Pass) { create(), create(10u), 4u, 4u * 10u, 4u, 4u); 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); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -158,7 +158,7 @@ TEST_F(ResolverInferredTypeTest, InferStruct_Pass) { 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); EXPECT_TRUE(r()->Resolve()) << r()->error(); diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc index 129fcc3171..234eb49a2f 100644 --- a/src/tint/resolver/intrinsic_table.cc +++ b/src/tint/resolver/intrinsic_table.cc @@ -330,7 +330,7 @@ class TemplateNumberMatcher : public NumberMatcher { //////////////////////////////////////////////////////////////////////////////// using TexelFormat = ast::TexelFormat; using Access = ast::Access; -using AddressSpace = ast::AddressSpace; +using AddressSpace = type::AddressSpace; using ParameterUsage = sem::ParameterUsage; 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) { - return state.builder.create(T, static_cast(S.Value()), + return state.builder.create(T, static_cast(S.Value()), static_cast(A.Value())); } @@ -1275,7 +1275,7 @@ Impl::Builtin Impl::Lookup(sem::BuiltinType builtin_type, params.Reserve(match.parameters.Length()); for (auto& p : match.parameters) { params.Push(builder.create( - nullptr, static_cast(params.Length()), p.type, ast::AddressSpace::kNone, + nullptr, static_cast(params.Length()), p.type, type::AddressSpace::kNone, ast::Access::kUndefined, p.usage)); } sem::PipelineStageSet supported_stages; @@ -1476,7 +1476,7 @@ IntrinsicTable::InitOrConv Impl::Lookup(InitConvIntrinsic type, params.Reserve(match.parameters.Length()); for (auto& p : match.parameters) { params.Push(builder.create( - nullptr, static_cast(params.Length()), p.type, ast::AddressSpace::kNone, + nullptr, static_cast(params.Length()), p.type, type::AddressSpace::kNone, ast::Access::kUndefined, p.usage)); } auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant @@ -1491,7 +1491,7 @@ IntrinsicTable::InitOrConv Impl::Lookup(InitConvIntrinsic type, // Conversion. auto* target = converters.GetOrCreate(match, [&]() { auto param = builder.create( - 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); auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant : sem::EvaluationStage::kRuntime; diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc index fbd00afc65..114862acc6 100644 --- a/src/tint/resolver/intrinsic_table_test.cc +++ b/src/tint/resolver/intrinsic_table_test.cc @@ -232,7 +232,7 @@ TEST_F(IntrinsicTableTest, MatchPointer) { auto* i32 = create(); auto* atomicI32 = create(i32); auto* ptr = - create(atomicI32, ast::AddressSpace::kWorkgroup, ast::Access::kReadWrite); + create(atomicI32, type::AddressSpace::kWorkgroup, ast::Access::kReadWrite); auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr}, sem::EvaluationStage::kConstant, Source{}); ASSERT_NE(result.sem, nullptr) << Diagnostics().str(); @@ -256,7 +256,7 @@ TEST_F(IntrinsicTableTest, MatchArray) { auto* arr = create(create(), create(), 4u, 4u, 4u, 4u); auto* arr_ptr = - create(arr, ast::AddressSpace::kStorage, ast::Access::kReadWrite); + create(arr, type::AddressSpace::kStorage, ast::Access::kReadWrite); auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{arr_ptr}, sem::EvaluationStage::kConstant, Source{}); ASSERT_NE(result.sem, nullptr) << Diagnostics().str(); @@ -448,7 +448,7 @@ TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) { auto result = table->Lookup( BuiltinType::kCos, utils::Vector{ - create(f32, ast::AddressSpace::kFunction, ast::Access::kReadWrite), + create(f32, type::AddressSpace::kFunction, ast::Access::kReadWrite), }, sem::EvaluationStage::kConstant, Source{}); ASSERT_NE(result.sem, nullptr) << Diagnostics().str(); @@ -548,7 +548,7 @@ TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) { TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_RuntimeEval) { auto* af = create(); - auto* bool_ref = create(create(), ast::AddressSpace::kFunction, + auto* bool_ref = create(create(), type::AddressSpace::kFunction, ast::Access::kReadWrite); auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_ref}, sem::EvaluationStage::kRuntime, Source{}); diff --git a/src/tint/resolver/is_host_shareable_test.cc b/src/tint/resolver/is_host_shareable_test.cc index 1bc38b4167..1e03b652a7 100644 --- a/src/tint/resolver/is_host_shareable_test.cc +++ b/src/tint/resolver/is_host_shareable_test.cc @@ -95,7 +95,7 @@ TEST_F(ResolverIsHostShareable, Matrix) { } TEST_F(ResolverIsHostShareable, Pointer) { - auto* ptr = create(create(), ast::AddressSpace::kPrivate, + auto* ptr = create(create(), type::AddressSpace::kPrivate, ast::Access::kReadWrite); EXPECT_FALSE(r()->IsHostShareable(ptr)); } diff --git a/src/tint/resolver/is_storeable_test.cc b/src/tint/resolver/is_storeable_test.cc index 58c0871911..d7896f2811 100644 --- a/src/tint/resolver/is_storeable_test.cc +++ b/src/tint/resolver/is_storeable_test.cc @@ -78,7 +78,7 @@ TEST_F(ResolverIsStorableTest, Matrix) { } TEST_F(ResolverIsStorableTest, Pointer) { - auto* ptr = create(create(), ast::AddressSpace::kPrivate, + auto* ptr = create(create(), type::AddressSpace::kPrivate, ast::Access::kReadWrite); EXPECT_FALSE(r()->IsStorable(ptr)); } @@ -112,7 +112,7 @@ TEST_F(ResolverIsStorableTest, Struct_AllMembersStorable) { TEST_F(ResolverIsStorableTest, Struct_SomeMembersNonStorable) { Structure("S", utils::Vector{ Member("a", ty.i32()), - Member("b", ty.pointer(ast::AddressSpace::kPrivate)), + Member("b", ty.pointer(type::AddressSpace::kPrivate)), }); EXPECT_FALSE(r()->Resolve()); @@ -138,7 +138,7 @@ TEST_F(ResolverIsStorableTest, Struct_NestedNonStorable) { auto* non_storable = Structure("nonstorable", utils::Vector{ Member("a", ty.i32()), - Member("b", ty.pointer(ast::AddressSpace::kPrivate)), + Member("b", ty.pointer(type::AddressSpace::kPrivate)), }); Structure("S", utils::Vector{ Member("a", ty.i32()), diff --git a/src/tint/resolver/materialize_test.cc b/src/tint/resolver/materialize_test.cc index 49da49457d..3f7740f149 100644 --- a/src/tint/resolver/materialize_test.cc +++ b/src/tint/resolver/materialize_test.cc @@ -929,7 +929,7 @@ TEST_P(MaterializeAbstractNumericToDefaultType, Test) { break; } case Method::kIndex: { - GlobalVar("arr", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("arr", ty.array(), type::AddressSpace::kPrivate); WrapInFunction(IndexAccessor("arr", abstract_expr())); break; } diff --git a/src/tint/resolver/override_test.cc b/src/tint/resolver/override_test.cc index 8d6b8e77c3..69102c7094 100644 --- a/src/tint/resolver/override_test.cc +++ b/src/tint/resolver/override_test.cc @@ -159,7 +159,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaOverrideInit) { TEST_F(ResolverOverrideTest, TransitiveReferences_ViaPrivateInit) { 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)); auto* func = Func("foo", utils::Empty, ty.void_(), utils::Vector{ @@ -209,7 +209,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize) { auto* a = Override("a", ty.i32()); auto* b = Override("b", ty.i32(), Mul(2_a, "a")); 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)); auto* func = Func("foo", utils::Empty, ty.void_(), utils::Vector{ @@ -249,7 +249,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize_Alias) { auto* a = Override("a", ty.i32()); 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 = 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)); auto* func = Func("foo", utils::Empty, ty.void_(), utils::Vector{ @@ -294,8 +294,8 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_MultipleEntryPoints) { auto* d = Override("d", ty.i32()); Alias("arr_ty1", ty.array(ty.i32(), Mul("b1", "c1"))); Alias("arr_ty2", ty.array(ty.i32(), Mul("b2", "c2"))); - auto* arr1 = GlobalVar("arr1", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty1")); - auto* arr2 = GlobalVar("arr2", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty2")); + auto* arr1 = GlobalVar("arr1", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty1")); + auto* arr2 = GlobalVar("arr2", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty2")); Override("unused", ty.i32(), Expr(1_a)); auto* func1 = Func("foo1", utils::Empty, ty.void_(), utils::Vector{ diff --git a/src/tint/resolver/ptr_ref_test.cc b/src/tint/resolver/ptr_ref_test.cc index 417642369b..5e41ace703 100644 --- a/src/tint/resolver/ptr_ref_test.cc +++ b/src/tint/resolver/ptr_ref_test.cc @@ -39,7 +39,7 @@ TEST_F(ResolverPtrRefTest, AddressOf) { ASSERT_TRUE(TypeOf(expr)->Is()); EXPECT_TRUE(TypeOf(expr)->As()->StoreType()->Is()); - EXPECT_EQ(TypeOf(expr)->As()->AddressSpace(), ast::AddressSpace::kFunction); + EXPECT_EQ(TypeOf(expr)->As()->AddressSpace(), type::AddressSpace::kFunction); } TEST_F(ResolverPtrRefTest, AddressOfThenDeref) { @@ -68,23 +68,23 @@ TEST_F(ResolverPtrRefTest, DefaultPtrAddressSpace) { auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())}); auto* function = Var("f", ty.i32()); - auto* private_ = GlobalVar("p", ty.i32(), ast::AddressSpace::kPrivate); - auto* workgroup = GlobalVar("w", ty.i32(), ast::AddressSpace::kWorkgroup); + auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate); + auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup); 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 = - 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 = - 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 = - 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 = - 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 = - 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 = - 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); diff --git a/src/tint/resolver/ptr_ref_validation_test.cc b/src/tint/resolver/ptr_ref_validation_test.cc index a79a546349..2302689644 100644 --- a/src/tint/resolver/ptr_ref_validation_test.cc +++ b/src/tint/resolver/ptr_ref_validation_test.cc @@ -143,12 +143,12 @@ TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) { // } auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array())}); auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))}); - auto* storage = GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, ast::Access::kReadWrite, - Binding(0_a), Group(0_a)); + auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage, + ast::Access::kReadWrite, Binding(0_a), Group(0_a)); auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i); auto* ptr = - Let(Source{{12, 34}}, "p", ty.pointer(ast::AddressSpace::kStorage), AddressOf(expr)); + Let(Source{{12, 34}}, "p", ty.pointer(type::AddressSpace::kStorage), AddressOf(expr)); WrapInFunction(ptr); diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc index 48c310f5df..032234127b 100644 --- a/src/tint/resolver/resolver.cc +++ b/src/tint/resolver/resolver.cc @@ -391,11 +391,11 @@ sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) { 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; } - if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast(ty), + if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast(ty), v->source)) { AddNote("while instantiating 'let' " + builder_->Symbols().NameFor(v->symbol), v->source); return nullptr; @@ -404,12 +404,12 @@ sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) { sem::Variable* sem = nullptr; if (is_global) { sem = builder_->create( - v, ty, sem::EvaluationStage::kRuntime, ast::AddressSpace::kNone, + v, ty, sem::EvaluationStage::kRuntime, type::AddressSpace::kNone, ast::Access::kUndefined, /* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt); } else { sem = builder_->create(v, ty, sem::EvaluationStage::kRuntime, - ast::AddressSpace::kNone, + type::AddressSpace::kNone, ast::Access::kUndefined, current_statement_, /* constant_value */ nullptr); } @@ -453,11 +453,11 @@ sem::Variable* Resolver::Override(const ast::Override* v) { return nullptr; } - if (rhs && !validator_.VariableInitializer(v, ast::AddressSpace::kNone, ty, rhs)) { + if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kNone, ty, rhs)) { return nullptr; } - if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast(ty), + if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast(ty), v->source)) { AddNote("while instantiating 'override' " + builder_->Symbols().NameFor(v->symbol), v->source); @@ -465,7 +465,7 @@ sem::Variable* Resolver::Override(const ast::Override* v) { } auto* sem = builder_->create( - 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); sem->SetInitializer(rhs); @@ -546,11 +546,11 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) { ty = rhs->Type(); } - if (!validator_.VariableInitializer(c, ast::AddressSpace::kNone, ty, rhs)) { + if (!validator_.VariableInitializer(c, type::AddressSpace::kNone, ty, rhs)) { return nullptr; } - if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast(ty), + if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast(ty), c->source)) { AddNote("while instantiating 'const' " + builder_->Symbols().NameFor(c->symbol), c->source); return nullptr; @@ -558,10 +558,10 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) { const auto value = rhs->ConstantValue(); auto* sem = is_global ? static_cast(builder_->create( - c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone, + c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kNone, ast::Access::kUndefined, value, sem::BindingPoint{}, std::nullopt)) : static_cast(builder_->create( - c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone, + c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kNone, ast::Access::kUndefined, current_statement_, value)); 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; - if (address_space == ast::AddressSpace::kNone) { + if (address_space == type::AddressSpace::kNone) { // No declared address space. Infer from usage / type. if (!is_global) { - address_space = ast::AddressSpace::kFunction; + address_space = type::AddressSpace::kFunction; } else if (storage_ty->UnwrapRef()->is_handle()) { // 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 must not have a address space attribute. The // 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, ast::DisabledValidation::kIgnoreAddressSpace)) { 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; } - if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, ty, param->type->source)) { + if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, ty, param->type->source)) { add_note(); return nullptr; } @@ -791,7 +791,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, uint32_t index) } auto* sem = builder_->create( - param, index, ty, ast::AddressSpace::kNone, ast::Access::kUndefined, + param, index, ty, type::AddressSpace::kNone, ast::Access::kUndefined, sem::ParameterUsage::kNone, binding_point, location); builder_->Sem().Add(param, sem); return sem; @@ -821,12 +821,12 @@ utils::Result Resolver::LocationAttribute(const ast::LocationAttribute return static_cast(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 switch (address_space) { - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kHandle: + case type::AddressSpace::kStorage: + case type::AddressSpace::kUniform: + case type::AddressSpace::kHandle: return ast::Access::kRead; default: break; @@ -1036,7 +1036,7 @@ sem::Function* Resolver::Function(const ast::Function* decl) { } if (auto* str = return_type->As()) { - if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, str, decl->source)) { + if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, str, decl->source)) { AddNote( "while instantiating return type for " + builder_->Symbols().NameFor(decl->symbol), decl->source); @@ -2099,10 +2099,10 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { [&]() -> sem::TypeInitializer* { auto params = utils::Transform(args, [&](auto, size_t i) { return builder_->create( - nullptr, // declaration - static_cast(i), // index - arr->ElemType(), // type - ast::AddressSpace::kNone, // address_space + nullptr, // declaration + static_cast(i), // index + arr->ElemType(), // type + type::AddressSpace::kNone, // address_space ast::Access::kUndefined); }); return builder_->create(arr, std::move(params), @@ -2131,7 +2131,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { nullptr, // declaration static_cast(i), // index str->Members()[i]->Type(), // type - ast::AddressSpace::kNone, // address_space + type::AddressSpace::kNone, // address_space ast::Access::kUndefined); // access } return builder_->create(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, const Source& usage) { ty = const_cast(ty->UnwrapRef()); @@ -3787,7 +3787,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space, } if (auto* arr = ty->As()) { - if (address_space != ast::AddressSpace::kStorage) { + if (address_space != type::AddressSpace::kStorage) { if (arr->Count()->Is()) { AddError("runtime-sized arrays can only be used in the address space", usage); @@ -3806,7 +3806,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space, usage); } - if (ast::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) { + if (type::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) { std::stringstream err; err << "Type '" << sem_.TypeNameOf(ty) << "' cannot be used in address space '" << address_space << "' as it is non-host-shareable"; diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h index 1a29a75452..e1006a40ee 100644 --- a/src/tint/resolver/resolver.h +++ b/src/tint/resolver/resolver.h @@ -378,11 +378,11 @@ class Resolver { /// given type and address space. Used for generating sensible error /// messages. /// @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 /// @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. /// @returns true on success, false on error diff --git a/src/tint/resolver/resolver_test.cc b/src/tint/resolver/resolver_test.cc index a5a914852c..c4fa05fb2a 100644 --- a/src/tint/resolver/resolver_test.cc +++ b/src/tint/resolver/resolver_test.cc @@ -325,7 +325,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_Alias) { TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) { 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(); @@ -405,7 +405,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) { Func("func_i32", utils::Empty, ty.void_(), utils::Vector{fn_i32_decl}); // 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; AST().AddGlobalVariable(mod_f32); @@ -433,7 +433,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) { TEST_F(ResolverTest, ArraySize_UnsignedLiteral) { // var a : array; - 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(); @@ -446,7 +446,7 @@ TEST_F(ResolverTest, ArraySize_UnsignedLiteral) { TEST_F(ResolverTest, ArraySize_SignedLiteral) { // var a : array; - 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(); @@ -461,7 +461,7 @@ TEST_F(ResolverTest, ArraySize_UnsignedConst) { // const size = 10u; // var a : array; 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(); @@ -476,7 +476,7 @@ TEST_F(ResolverTest, ArraySize_SignedConst) { // const size = 0; // var a : array; 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(); @@ -491,7 +491,7 @@ TEST_F(ResolverTest, ArraySize_NamedOverride) { // override size = 10i; // var a : array; 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(); @@ -509,8 +509,8 @@ TEST_F(ResolverTest, ArraySize_NamedOverride_Equivalence) { // var a : array; // var b : array; auto* override = Override("size", Expr(10_i)); - auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kWorkgroup); - auto* b = GlobalVar("b", 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")), type::AddressSpace::kWorkgroup); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -536,7 +536,7 @@ TEST_F(ResolverTest, ArraySize_UnnamedOverride) { // var a : array; auto* override = Override("size", Expr(10_i)); 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(); @@ -556,8 +556,8 @@ TEST_F(ResolverTest, ArraySize_UnamedOverride_Equivalence) { auto* override = Override("size", Expr(10_i)); auto* a_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* b = GlobalVar("b", ty.array(ty.f32(), b_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), type::AddressSpace::kWorkgroup); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -579,7 +579,7 @@ TEST_F(ResolverTest, ArraySize_UnamedOverride_Equivalence) { } TEST_F(ResolverTest, Expr_Bitcast) { - GlobalVar("name", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate); auto* bitcast = create(ty.f32(), Expr("name")); WrapInFunction(bitcast); @@ -642,7 +642,7 @@ TEST_F(ResolverTest, Expr_Call_Builtin) { } 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"); WrapInFunction(cast); @@ -700,7 +700,7 @@ TEST_F(ResolverTest, Expr_Initializer_Type_Vec4) { } 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"); WrapInFunction(ident); @@ -801,7 +801,7 @@ TEST_F(ResolverTest, Expr_Identifier_Function_Ptr) { auto* v = Expr("v"); auto* p = Expr("p"); auto* v_decl = Decl(Var("v", ty.f32())); - auto* p_decl = Decl(Let("p", ty.pointer(ast::AddressSpace::kFunction), AddressOf(v))); + auto* p_decl = Decl(Let("p", ty.pointer(type::AddressSpace::kFunction), AddressOf(v))); auto* assign = Assign(Deref(p), 1.23_f); Func("my_func", utils::Empty, ty.void_(), 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_c = Param("c", ty.u32(), utils::Vector{Location(1_a)}); - GlobalVar("my_vec", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec4(), type::AddressSpace::kPrivate); auto* func = Func("my_func", utils::Vector{ param_a, @@ -906,7 +906,7 @@ TEST_F(ResolverTest, Function_Parameters_Locations) { TEST_F(ResolverTest, Function_GlobalVariable_Location) { auto* var = GlobalVar( - "my_vec", ty.vec4(), ast::AddressSpace::kIn, + "my_vec", ty.vec4(), type::AddressSpace::kIn, utils::Vector{Location(3_a), Disable(ast::DisabledValidation::kIgnoreAddressSpace)}); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -919,10 +919,10 @@ TEST_F(ResolverTest, Function_GlobalVariable_Location) { TEST_F(ResolverTest, Function_RegisterInputOutputVariables) { 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)); - auto* wg_var = GlobalVar("wg_var", ty.f32(), ast::AddressSpace::kWorkgroup); - auto* priv_var = GlobalVar("priv_var", ty.f32(), ast::AddressSpace::kPrivate); + auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup); + auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate); auto* func = Func("my_func", utils::Empty, ty.void_(), utils::Vector{ @@ -965,7 +965,7 @@ TEST_F(ResolverTest, Function_ReturnType_Location) { } TEST_F(ResolverTest, Function_ReturnType_NoLocation) { - GlobalVar("my_vec", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec4(), type::AddressSpace::kPrivate); auto* func = Func("my_func", utils::Empty, ty.vec4(), utils::Vector{ Return("my_vec"), @@ -987,10 +987,10 @@ TEST_F(ResolverTest, Function_ReturnType_NoLocation) { TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) { 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)); - auto* wg_var = GlobalVar("wg_var", ty.f32(), ast::AddressSpace::kWorkgroup); - auto* priv_var = GlobalVar("priv_var", ty.f32(), ast::AddressSpace::kPrivate); + auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup); + auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate); Func("my_func", utils::Empty, ty.f32(), 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) { auto* st = Structure( "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"); WrapInFunction(mem); @@ -1262,7 +1262,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) { auto* st = Structure( "S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())}); 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"); WrapInFunction(mem); @@ -1279,7 +1279,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) { } TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) { - GlobalVar("my_vec", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec4(), type::AddressSpace::kPrivate); auto* mem = MemberAccessor("my_vec", "xzyw"); WrapInFunction(mem); @@ -1297,7 +1297,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) { } TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle_SingleElement) { - GlobalVar("my_vec", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec3(), type::AddressSpace::kPrivate); auto* mem = MemberAccessor("my_vec", "b"); WrapInFunction(mem); @@ -1330,7 +1330,7 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) { auto* stB = Structure("B", utils::Vector{Member("foo", ty.vec4())}); 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 = 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) { auto* st = Structure( "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"), 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); SCOPED_TRACE(ss.str()); - GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); - GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); + GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate); + GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate); auto* expr = create(params.op, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -1686,8 +1686,8 @@ TEST_P(Expr_Binary_Test_WithAlias_Valid, All) { << FriendlyName(rhs_type); SCOPED_TRACE(ss.str()); - GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); - GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); + GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate); + GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate); auto* expr = create(params.op, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -1732,8 +1732,8 @@ TEST_P(Expr_Binary_Test_Invalid, All) { ss << FriendlyName(lhs_type) << " " << op << " " << FriendlyName(rhs_type); SCOPED_TRACE(ss.str()); - GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); - GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); + GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate); + GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate); auto* expr = create(Source{{12, 34}}, op, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -1772,8 +1772,8 @@ TEST_P(Expr_Binary_Test_Invalid_VectorMatrixMultiply, All) { is_valid_expr = vec_size == mat_cols; } - GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); - GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); + GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate); + GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate); auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -1809,8 +1809,8 @@ TEST_P(Expr_Binary_Test_Invalid_MatrixMatrixMultiply, All) { auto* col = create(f32, lhs_mat_rows); auto* result_type = create(col, rhs_mat_cols); - GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate); - GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate); + GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate); + GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate); auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -1838,11 +1838,11 @@ TEST_P(UnaryOpExpressionTest, Expr_UnaryOp) { auto op = GetParam(); if (op == ast::UnaryOp::kNot) { - GlobalVar("ident", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.vec4(), type::AddressSpace::kPrivate); } else if (op == ast::UnaryOp::kNegation || op == ast::UnaryOp::kComplement) { - GlobalVar("ident", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.vec4(), type::AddressSpace::kPrivate); } else { - GlobalVar("ident", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.vec4(), type::AddressSpace::kPrivate); } auto* der = create(op, Expr("ident")); WrapInFunction(der); @@ -1874,7 +1874,7 @@ TEST_F(ResolverTest, AddressSpace_SetsIfMissing) { 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) { @@ -1883,7 +1883,7 @@ TEST_F(ResolverTest, AddressSpace_SetForSampler) { 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) { @@ -1892,7 +1892,7 @@ TEST_F(ResolverTest, AddressSpace_SetForTexture) { 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) { @@ -1902,14 +1902,14 @@ TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) { 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) { // struct S { x : i32 }; // var g : S; 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)); EXPECT_TRUE(r()->Resolve()) << r()->error(); @@ -1942,11 +1942,11 @@ TEST_F(ResolverTest, Function_EntryPoints_StageAttribute) { // ep_1 -> {} // ep_2 -> {} - GlobalVar("first", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("second", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("call_a", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("call_b", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("call_c", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("first", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("second", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("call_a", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("call_b", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("call_c", ty.f32(), type::AddressSpace::kPrivate); auto* func_b = Func("b", utils::Empty, ty.f32(), utils::Vector{ @@ -2086,8 +2086,8 @@ TEST_F(ResolverTest, ASTNodeReachedTwice) { { ProgramBuilder b; auto* expr = b.Expr(1_i); - b.GlobalVar("a", b.ty.i32(), ast::AddressSpace::kPrivate, expr); - b.GlobalVar("b", b.ty.i32(), ast::AddressSpace::kPrivate, expr); + b.GlobalVar("a", b.ty.i32(), type::AddressSpace::kPrivate, expr); + b.GlobalVar("b", b.ty.i32(), type::AddressSpace::kPrivate, expr); Resolver(&b).Resolve(); }, "internal compiler error: AST node 'tint::ast::IntLiteralExpression' was encountered twice " @@ -2095,7 +2095,7 @@ TEST_F(ResolverTest, ASTNodeReachedTwice) { } TEST_F(ResolverTest, UnaryOp_Not) { - GlobalVar("ident", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.vec4(), type::AddressSpace::kPrivate); auto* der = create(ast::UnaryOp::kNot, Expr(Source{{12, 34}}, "ident")); WrapInFunction(der); @@ -2104,7 +2104,7 @@ TEST_F(ResolverTest, UnaryOp_Not) { } TEST_F(ResolverTest, UnaryOp_Complement) { - GlobalVar("ident", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.vec4(), type::AddressSpace::kPrivate); auto* der = create(ast::UnaryOp::kComplement, Expr(Source{{12, 34}}, "ident")); WrapInFunction(der); @@ -2114,7 +2114,7 @@ TEST_F(ResolverTest, UnaryOp_Complement) { } TEST_F(ResolverTest, UnaryOp_Negation) { - GlobalVar("ident", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("ident", ty.u32(), type::AddressSpace::kPrivate); auto* der = create(ast::UnaryOp::kNegation, Expr(Source{{12, 34}}, "ident")); 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("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a), Binding(1_a)); - GlobalVar("c", ty.vec2(), ast::AddressSpace::kUniform, Group(0_a), Binding(2_a)); + GlobalVar("c", ty.vec2(), type::AddressSpace::kUniform, Group(0_a), Binding(2_a)); Func("main", utils::Empty, ty.vec4(), utils::Vector{ @@ -2289,9 +2289,9 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715 Func("helper", utils::Vector{ 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()), - ast::AddressSpace::kFunction)), + type::AddressSpace::kFunction)), }, ty.vec4(), utils::Vector{ @@ -2304,15 +2304,15 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715 TEST_F(ResolverTest, ModuleDependencyOrderedDeclarations) { 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* s0 = Structure("s0", utils::Vector{Member("m", ty.i32())}); 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* s1 = Structure("s1", utils::Vector{Member("m", ty.i32())}); 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* s2 = Structure("s2", utils::Vector{Member("m", ty.i32())}); diff --git a/src/tint/resolver/resolver_test_helper.h b/src/tint/resolver/resolver_test_helper.h index 53c187f985..449944a650 100644 --- a/src/tint/resolver/resolver_test_helper.h +++ b/src/tint/resolver/resolver_test_helper.h @@ -616,13 +616,13 @@ struct DataType> { /// @param b the ProgramBuilder /// @return a new AST alias type static inline const ast::Type* AST(ProgramBuilder& b) { - return b.create(DataType::AST(b), ast::AddressSpace::kPrivate, + return b.create(DataType::AST(b), type::AddressSpace::kPrivate, ast::Access::kUndefined); } /// @param b the ProgramBuilder /// @return the semantic aliased type static inline const type::Type* Sem(ProgramBuilder& b) { - return b.create(DataType::Sem(b), ast::AddressSpace::kPrivate, + return b.create(DataType::Sem(b), type::AddressSpace::kPrivate, ast::Access::kReadWrite); } @@ -631,7 +631,7 @@ struct DataType> { static inline const ast::Expression* Expr(ProgramBuilder& b, utils::VectorRef /*unused*/) { auto sym = b.Symbols().New("global_for_ptr"); - b.GlobalVar(sym, DataType::AST(b), ast::AddressSpace::kPrivate); + b.GlobalVar(sym, DataType::AST(b), type::AddressSpace::kPrivate); return b.AddressOf(sym); } diff --git a/src/tint/resolver/root_identifier_test.cc b/src/tint/resolver/root_identifier_test.cc index adf92395fb..95806951a9 100644 --- a/src/tint/resolver/root_identifier_test.cc +++ b/src/tint/resolver/root_identifier_test.cc @@ -27,7 +27,7 @@ namespace { class ResolverRootIdentifierTest : public ResolverTest {}; 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); WrapInFunction(expr); @@ -38,7 +38,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) { } 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); WrapInFunction(expr); @@ -49,7 +49,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) { } 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); WrapInFunction(expr); @@ -60,7 +60,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) { } 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); WrapInFunction(expr); @@ -72,7 +72,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) { TEST_F(ResolverRootIdentifierTest, GlobalTextureVar) { 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); WrapInFunction(Call("textureDimensions", expr)); @@ -142,7 +142,7 @@ TEST_F(ResolverRootIdentifierTest, PointerParameter) { // { // 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* let = Let("b", expr_param); auto* expr_let = Expr("b"); @@ -199,7 +199,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughIndexAccessor) { // { // 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); WrapInFunction(expr); @@ -216,7 +216,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughMemberAccessor) { // a.f // } 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"); WrapInFunction(expr); @@ -232,7 +232,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughPointers) { // let a_ptr1 = &*&a; // 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* deref_1 = Deref(address_of_1); auto* address_of_2 = AddressOf(deref_1); diff --git a/src/tint/resolver/side_effects_test.cc b/src/tint/resolver/side_effects_test.cc index e3677149e9..ba3950d5e1 100644 --- a/src/tint/resolver/side_effects_test.cc +++ b/src/tint/resolver/side_effects_test.cc @@ -31,7 +31,7 @@ struct SideEffectsTest : ResolverTest { template void MakeSideEffectFunc(const char* name) { auto global = Sym(); - GlobalVar(global, ty.Of(), ast::AddressSpace::kPrivate); + GlobalVar(global, ty.Of(), type::AddressSpace::kPrivate); auto local = Sym(); Func(name, utils::Empty, ty.Of(), utils::Vector{ @@ -44,7 +44,7 @@ struct SideEffectsTest : ResolverTest { template void MakeSideEffectFunc(const char* name, MAKE_TYPE_FUNC make_type) { auto global = Sym(); - GlobalVar(global, make_type(), ast::AddressSpace::kPrivate); + GlobalVar(global, make_type(), type::AddressSpace::kPrivate); auto local = Sym(); Func(name, utils::Empty, make_type(), utils::Vector{ @@ -89,7 +89,7 @@ TEST_F(SideEffectsTest, VariableUser) { } 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"); Func("f", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)}, utils::Vector{create(ast::PipelineStage::kFragment)}); @@ -115,7 +115,7 @@ TEST_F(SideEffectsTest, Call_Builtin_NoSE_WithSEArg) { } 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); WrapInFunction(expr); @@ -164,21 +164,21 @@ TEST_P(SideEffectsBuiltinTest, Test) { auto& c = GetParam(); uint32_t next_binding = 0; - GlobalVar("f", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("i", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("u", ty.u32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("vf", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("vf2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("vi2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("vf4", ty.vec4(), ast::AddressSpace::kPrivate); - GlobalVar("vb", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("m", ty.mat3x3(), ast::AddressSpace::kPrivate); - GlobalVar("arr", ty.array(), ast::AddressSpace::kPrivate); - GlobalVar("storage_arr", ty.array(), ast::AddressSpace::kStorage, Group(0_a), + GlobalVar("f", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("i", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("u", ty.u32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("vf", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("vf2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("vi2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("vf4", ty.vec4(), type::AddressSpace::kPrivate); + GlobalVar("vb", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("m", ty.mat3x3(), type::AddressSpace::kPrivate); + GlobalVar("arr", ty.array(), type::AddressSpace::kPrivate); + GlobalVar("storage_arr", ty.array(), type::AddressSpace::kStorage, Group(0_a), Binding(AInt(next_binding++))); - GlobalVar("workgroup_arr", ty.array(), ast::AddressSpace::kWorkgroup); - GlobalVar("a", ty.atomic(ty.i32()), ast::AddressSpace::kStorage, ast::Access::kReadWrite, + GlobalVar("workgroup_arr", ty.array(), type::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), Binding(AInt(next_binding++))); if (c.pipeline_stage != ast::PipelineStage::kCompute) { GlobalVar("t2d", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a), diff --git a/src/tint/resolver/static_assert_test.cc b/src/tint/resolver/static_assert_test.cc index 6e8ecb7be6..3915dcd4fa 100644 --- a/src/tint/resolver/static_assert_test.cc +++ b/src/tint/resolver/static_assert_test.cc @@ -84,7 +84,7 @@ TEST_F(ResolverStaticAssertTest, Local_Const_Fail) { } 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"))); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), diff --git a/src/tint/resolver/struct_address_space_use_test.cc b/src/tint/resolver/struct_address_space_use_test.cc index ff85ce4f27..fe7b5cc236 100644 --- a/src/tint/resolver/struct_address_space_use_test.cc +++ b/src/tint/resolver/struct_address_space_use_test.cc @@ -46,7 +46,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromParameter) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kNone)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kNone)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) { @@ -58,55 +58,55 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kNone)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kNone)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableFromGlobal) { 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(); auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalAlias) { auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); 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(); auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalStruct) { auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); 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(); auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalArray) { auto* s = Structure("S", utils::Vector{Member("a", ty.f32())}); 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(); auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) { @@ -118,7 +118,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) { @@ -130,7 +130,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) { @@ -142,7 +142,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction)); } TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) { @@ -154,13 +154,13 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); - EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction)); + EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction)); } TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) { 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("y", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("x", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(0_a)); + GlobalVar("y", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(0_a)); WrapInFunction(Var("g", ty.Of(s))); @@ -169,8 +169,8 @@ TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) { auto* sem = TypeOf(s)->As(); ASSERT_NE(sem, nullptr); EXPECT_THAT(sem->AddressSpaceUsage(), - UnorderedElementsAre(ast::AddressSpace::kUniform, ast::AddressSpace::kStorage, - ast::AddressSpace::kFunction)); + UnorderedElementsAre(type::AddressSpace::kUniform, type::AddressSpace::kStorage, + type::AddressSpace::kFunction)); } } // namespace diff --git a/src/tint/resolver/type_initializer_validation_test.cc b/src/tint/resolver/type_initializer_validation_test.cc index 6f7d78b90f..9220fd46eb 100644 --- a/src/tint/resolver/type_initializer_validation_test.cc +++ b/src/tint/resolver/type_initializer_validation_test.cc @@ -69,10 +69,12 @@ TEST_F(ResolverTypeInitializerValidationTest, InferTypeTest_Simple) { ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(TypeOf(a_ident)->Is()); EXPECT_TRUE(TypeOf(a_ident)->As()->StoreType()->Is()); - EXPECT_EQ(TypeOf(a_ident)->As()->AddressSpace(), ast::AddressSpace::kFunction); + EXPECT_EQ(TypeOf(a_ident)->As()->AddressSpace(), + type::AddressSpace::kFunction); ASSERT_TRUE(TypeOf(b_ident)->Is()); EXPECT_TRUE(TypeOf(b_ident)->As()->StoreType()->Is()); - EXPECT_EQ(TypeOf(b_ident)->As()->AddressSpace(), ast::AddressSpace::kFunction); + EXPECT_EQ(TypeOf(b_ident)->As()->AddressSpace(), + type::AddressSpace::kFunction); } using InferTypeTest_FromInitializerExpression = ResolverTestWithParam; @@ -95,8 +97,8 @@ TEST_P(InferTypeTest_FromInitializerExpression, All) { ASSERT_TRUE(r()->Resolve()) << r()->error(); auto* got = TypeOf(a_ident); - auto* expected = create(params.create_rhs_sem_type(*this), - ast::AddressSpace::kFunction, ast::Access::kReadWrite); + auto* expected = create( + params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite); ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" << "expected: " << FriendlyName(expected) << "\n"; } @@ -149,8 +151,8 @@ TEST_P(InferTypeTest_FromArithmeticExpression, All) { ASSERT_TRUE(r()->Resolve()) << r()->error(); auto* got = TypeOf(a_ident); - auto* expected = create(params.create_rhs_sem_type(*this), - ast::AddressSpace::kFunction, ast::Access::kReadWrite); + auto* expected = create( + params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite); ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" << "expected: " << FriendlyName(expected) << "\n"; } @@ -197,8 +199,8 @@ TEST_P(InferTypeTest_FromCallExpression, All) { ASSERT_TRUE(r()->Resolve()) << r()->error(); auto* got = TypeOf(a_ident); - auto* expected = create(params.create_rhs_sem_type(*this), - ast::AddressSpace::kFunction, ast::Access::kReadWrite); + auto* expected = create( + params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite); ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" << "expected: " << FriendlyName(expected) << "\n"; } @@ -1968,7 +1970,7 @@ TEST_F(ResolverTypeInitializerValidationTest, NestedVectorInitializers_Success) TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) { 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(Source{{12, 34}}, "uint_var"); WrapInFunction(tc); @@ -1980,8 +1982,8 @@ TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) { TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Success) { auto* f32_alias = Alias("Float32", ty.f32()); auto* vec2_alias = Alias("VectorFloat2", ty.vec2()); - GlobalVar("my_f32", ty.Of(f32_alias), ast::AddressSpace::kPrivate); - GlobalVar("my_vec2", ty.Of(vec2_alias), ast::AddressSpace::kPrivate); + GlobalVar("my_f32", ty.Of(f32_alias), type::AddressSpace::kPrivate); + GlobalVar("my_vec2", ty.Of(vec2_alias), type::AddressSpace::kPrivate); auto* tc = vec3("my_vec2", "my_f32"); WrapInFunction(tc); diff --git a/src/tint/resolver/type_validation_test.cc b/src/tint/resolver/type_validation_test.cc index bfc9d23a38..88254a8cb9 100644 --- a/src/tint/resolver/type_validation_test.cc +++ b/src/tint/resolver/type_validation_test.cc @@ -95,7 +95,7 @@ TEST_F(ResolverTypeValidationTest, GlobalOverrideNoInitializer_Pass) { TEST_F(ResolverTypeValidationTest, GlobalVariableWithAddressSpace_Pass) { // var 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(); } @@ -111,9 +111,9 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableUnique_Pass) { // var global_var0 : f32 = 0.1; // 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(); } @@ -129,7 +129,7 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Pass) 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(); } @@ -193,19 +193,19 @@ TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierDifferentFunctions_Pass) TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Pass) { // var a : array; - 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(); } TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) { // var a : array; - 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(); } TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) { // var a : array; - 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(); } @@ -213,7 +213,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Pass) { // const size = 4u; // var a : array; 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(); } @@ -221,34 +222,35 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Pass) { // const size = 4i; // var a : array; 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(); } TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Zero) { // var a : array; - 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_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); } TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Zero) { // var a : array; - 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_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); } TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Zero) { // var a : array; - 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_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); } TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Negative) { // var a : array; - 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_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; // var a : array; 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_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; // var a : array; 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_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; // var a : array; 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_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0"); } TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) { // var a : array; - 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_EQ( r()->error(), @@ -293,7 +298,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) { TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) { // var a : array(10, 10)>; GlobalVar("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.vec2(), 10_i, 10_i)), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ( r()->error(), @@ -305,7 +310,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_FloatConst) { // const size = 10.0; // var a : array; 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_EQ( r()->error(), @@ -317,7 +323,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) { // const size = vec2(100, 100); // var a : array; GlobalConst("size", Construct(ty.vec2(), 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_EQ( r()->error(), @@ -328,14 +335,14 @@ TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) { TEST_F(ResolverTypeValidationTest, ArraySize_UnderElementCountLimit) { // var a : array; GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a)), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) { // var a : array; 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_EQ(r()->error(), R"(12:34 error: array count (65536) must be less than 65536 56:78 note: while instantiating 'var' a)"); @@ -343,8 +350,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) { TEST_F(ResolverTypeValidationTest, ArraySize_StorageBufferLargeArray) { // var a : array; - GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)), ast::AddressSpace::kStorage, - utils::Vector{Binding(0_u), Group(0_u)}); + GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)), + type::AddressSpace::kStorage, utils::Vector{Binding(0_u), Group(0_u)}); EXPECT_TRUE(r()->Resolve()) << r()->error(); } @@ -355,7 +362,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NestedStorageBufferLargeArray) { // var a : S; Structure("S", utils::Vector{Member(Source{{12, 34}}, "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)}); 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(), utils::Vector{MemberOffset(800000_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_EQ(r()->error(), "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) { // var a : @stride(8000000) array; GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a), 8000000), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), "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; // var a : array; 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_EQ(r()->error(), "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 a : array, 4>; Override("size", Expr(10_i)); 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_EQ(r()->error(), "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; // } 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_(), utils::Vector{ Decl(Var("a", Expr(Source{{12, 34}}, "w"))), @@ -476,7 +483,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionLet_Implicit) // let a = w; // } 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_(), utils::Vector{ Decl(Let("a", Expr(Source{{12, 34}}, "w"))), @@ -495,8 +502,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnnamedOverride_Equivalence) { // a = b; // } Override("size", Expr(10_i)); - GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), ast::AddressSpace::kWorkgroup); - GlobalVar("b", 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)), type::AddressSpace::kWorkgroup); WrapInFunction(Assign(Source{{12, 34}}, "a", "b")); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), @@ -530,15 +537,16 @@ TEST_F(ResolverTypeValidationTest, ArraySize_Workgroup_Overridable) { // var a : array; Override("size", Expr(10_i)); GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), - ast::AddressSpace::kWorkgroup); + type::AddressSpace::kWorkgroup); EXPECT_TRUE(r()->Resolve()) << r()->error(); } TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) { // var size : i32 = 10i; // var a : array; - GlobalVar("size", ty.i32(), Expr(10_i), ast::AddressSpace::kPrivate); - GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate); + GlobalVar("size", ty.i32(), Expr(10_i), type::AddressSpace::kPrivate); + GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), + type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), 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())}); 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_EQ(r()->error(), @@ -744,7 +752,7 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayIsNotLast_Fail) { TEST_F(ResolverTypeValidationTest, RuntimeArrayAsGlobalVariable) { GlobalVar(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32()), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); ASSERT_FALSE(r()->Resolve()); @@ -793,7 +801,7 @@ TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsPointerParameter_Fail) { // fn func(a : ptr>) {} 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_(), utils::Vector{ @@ -858,7 +866,7 @@ TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsLast_Pass) { TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) { 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_EQ(r()->error(), @@ -866,8 +874,8 @@ TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) { } TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) { - auto* ptr_ty = ty.pointer(Source{{12, 34}}, ast::AddressSpace::kUniform); - GlobalVar("arr", ty.array(ptr_ty, 4_i, 16), ast::AddressSpace::kPrivate); + auto* ptr_ty = ty.pointer(Source{{12, 34}}, type::AddressSpace::kUniform); + GlobalVar("arr", ty.array(ptr_ty, 4_i, 16), type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), @@ -877,8 +885,8 @@ TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) { TEST_F(ResolverTypeValidationTest, VariableAsType) { // var a : i32; // var b : a; - GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.type_name("a"), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.type_name("a"), type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), @@ -890,7 +898,7 @@ TEST_F(ResolverTypeValidationTest, FunctionAsType) { // fn f() {} // var v : f; 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_EQ(r()->error(), @@ -900,7 +908,7 @@ note: 'f' declared here)"); TEST_F(ResolverTypeValidationTest, BuiltinAsType) { // var 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_EQ(r()->error(), "error: cannot use builtin 'max' as type"); @@ -1264,7 +1272,7 @@ TEST_P(ValidMatrixTypes, Okay) { Enable(ast::Extension::kF16); GlobalVar("a", ty.mat(params.elem_ty(*this), params.columns, params.rows), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_TRUE(r()->Resolve()) << r()->error(); } INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, @@ -1303,7 +1311,7 @@ TEST_P(InvalidMatrixElementTypes, InvalidElementType) { Enable(ast::Extension::kF16); 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_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); - 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(); } INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, @@ -1380,7 +1388,7 @@ TEST_P(InvalidVectorElementTypes, InvalidElementType) { Enable(ast::Extension::kF16); GlobalVar("a", ty.vec(Source{{12, 34}}, params.elem_ty(*this), params.width), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); EXPECT_FALSE(r()->Resolve()); EXPECT_EQ(r()->error(), "12:34 error: vector element type must be 'bool', 'f32', 'f16', 'i32' " diff --git a/src/tint/resolver/uniformity.cc b/src/tint/resolver/uniformity.cc index 5fed4716d4..d75b7796d6 100644 --- a/src/tint/resolver/uniformity.cc +++ b/src/tint/resolver/uniformity.cc @@ -1688,11 +1688,11 @@ class UniformityGraph { auto var_type = [&](const sem::Variable* var) { switch (var->AddressSpace()) { - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: return "read_write storage buffer "; - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: return "workgroup storage variable "; - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: return "module-scope private variable "; default: return ""; diff --git a/src/tint/resolver/uniformity_test.cc b/src/tint/resolver/uniformity_test.cc index 5052a1f3db..26319762bf 100644 --- a/src/tint/resolver/uniformity_test.cc +++ b/src/tint/resolver/uniformity_test.cc @@ -5305,7 +5305,7 @@ TEST_F(UniformityAnalysisTest, MaximumNumberOfPointerParameters) { foo_body.Push(b.Decl(b.Let("rhs", rhs_init))); for (int i = 0; i < 255; i++) { 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) { foo_body.Push(b.Assign(b.Deref("p" + std::to_string(i)), "rhs")); } @@ -5324,7 +5324,7 @@ TEST_F(UniformityAnalysisTest, MaximumNumberOfPointerParameters) { // workgroupBarrier(); // } // } - b.GlobalVar("non_uniform_global", ty.i32(), ast::AddressSpace::kPrivate); + b.GlobalVar("non_uniform_global", ty.i32(), type::AddressSpace::kPrivate); utils::Vector main_body; utils::Vector args; for (int i = 0; i < 255; i++) { @@ -7850,7 +7850,7 @@ TEST_F(UniformityAnalysisTest, StressGraphTraversalDepth) { // 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 foo_body; std::string v_last = "v0"; for (int i = 1; i < 100000; i++) { diff --git a/src/tint/resolver/validation_test.cc b/src/tint/resolver/validation_test.cc index 7f41be6a31..67a26c7669 100644 --- a/src/tint/resolver/validation_test.cc +++ b/src/tint/resolver/validation_test.cc @@ -62,8 +62,8 @@ class FakeExpr final : public Castable { }; TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) { - GlobalVar(Source{{1, 2}}, "wg", ty.vec4(), ast::AddressSpace::kWorkgroup); - GlobalVar("dst", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar(Source{{1, 2}}, "wg", ty.vec4(), type::AddressSpace::kWorkgroup); + GlobalVar("dst", ty.vec4(), type::AddressSpace::kPrivate); auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg")); Func(Source{{9, 10}}, "f0", utils::Empty, ty.vec4(), @@ -94,8 +94,8 @@ TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInFragmentStage) { // f1(); //} - GlobalVar(Source{{1, 2}}, "wg", ty.vec4(), ast::AddressSpace::kWorkgroup); - GlobalVar("dst", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar(Source{{1, 2}}, "wg", ty.vec4(), type::AddressSpace::kWorkgroup); + GlobalVar("dst", ty.vec4(), type::AddressSpace::kPrivate); auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg")); Func(Source{{5, 6}}, "f2", utils::Empty, ty.void_(), utils::Vector{stmt}); @@ -234,7 +234,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariable_Pass) { // 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_(), utils::Vector{ @@ -308,7 +308,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableDifferentScope_Fail) { } 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_(), utils::Vector{ @@ -322,7 +322,7 @@ TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) { } 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_(), utils::Vector{ @@ -337,7 +337,7 @@ TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) { TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) { 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()); @@ -347,7 +347,7 @@ TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) { TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) { 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(); @@ -356,7 +356,7 @@ TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) { } TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) { - GlobalVar("my_vec", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec3(), type::AddressSpace::kPrivate); 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) { - GlobalVar("my_vec", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec4(), type::AddressSpace::kPrivate); 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) { - GlobalVar("my_vec", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec3(), type::AddressSpace::kPrivate); auto* ident = Expr(Source{{{3, 3}, {3, 8}}}, "zzzzz"); auto* mem = MemberAccessor("my_vec", ident); @@ -392,7 +392,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) { } TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadIndex) { - GlobalVar("my_vec", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec2(), type::AddressSpace::kPrivate); auto* ident = Expr(Source{{3, 3}}, "z"); auto* mem = MemberAccessor("my_vec", ident); @@ -425,7 +425,7 @@ TEST_F(ResolverValidationTest, EXpr_MemberAccessor_FuncGoodParent) { // let x: f32 = (*p).z; // return x; // } - auto* p = Param("p", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction)); + auto* p = Param("p", ty.pointer(ty.vec4(), type::AddressSpace::kFunction)); auto* star_p = Deref(p); auto* z = Expr("z"); auto* accessor_expr = MemberAccessor(star_p, z); @@ -443,7 +443,7 @@ TEST_F(ResolverValidationTest, EXpr_MemberAccessor_FuncBadParent) { // let x: f32 = *p.z; // return x; // } - auto* p = Param("p", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction)); + auto* p = Param("p", ty.pointer(ty.vec4(), type::AddressSpace::kFunction)); auto* z = Expr(Source{{12, 34}}, "z"); auto* accessor_expr = MemberAccessor(p, z); auto* star_p = Deref(accessor_expr); @@ -1277,8 +1277,8 @@ TEST_F(ResolverValidationTest, OffsetAndAlignAndSizeAttribute) { TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) { auto* vf = Var("vf", ty.f32()); auto* c = - Construct(Source{{12, 34}}, ty.pointer(ast::AddressSpace::kFunction), ExprList(vf)); - auto* ip = Let("ip", ty.pointer(ast::AddressSpace::kFunction), c); + Construct(Source{{12, 34}}, ty.pointer(type::AddressSpace::kFunction), ExprList(vf)); + auto* ip = Let("ip", ty.pointer(type::AddressSpace::kFunction), c); WrapInFunction(Decl(vf), Decl(ip)); EXPECT_FALSE(r()->Resolve()); @@ -1286,21 +1286,21 @@ TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) { } 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_EQ(r()->error(), "12:24 error: value 2147483648 cannot be represented as 'i32'"); } 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_EQ(r()->error(), "12:24 error: value -2147483649 cannot be represented as 'i32'"); } 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_EQ(r()->error(), "12:24 error: value 4294967296 cannot be represented as 'u32'"); diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc index 556350e825..1f357d33ad 100644 --- a/src/tint/resolver/validator.cc +++ b/src/tint/resolver/validator.cc @@ -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 { - if (s->AddressSpace() == ast::AddressSpace::kUndefined) { + if (s->AddressSpace() == type::AddressSpace::kUndefined) { AddError("ptr missing address space", a->source); 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: // * 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. - if (a->address_space != ast::AddressSpace::kStorage) { + if (a->address_space != type::AddressSpace::kStorage) { AddError("only pointers in address space may declare an access mode", a->source); return false; @@ -358,7 +358,7 @@ bool Validator::Materialize(const type::Type* to, } bool Validator::VariableInitializer(const ast::Variable* v, - ast::AddressSpace address_space, + type::AddressSpace address_space, const type::Type* storage_ty, const sem::Expression* initializer) const { auto* initializer_ty = initializer->Type(); @@ -375,8 +375,8 @@ bool Validator::VariableInitializer(const ast::Variable* v, if (v->Is()) { switch (address_space) { - case ast::AddressSpace::kPrivate: - case ast::AddressSpace::kFunction: + case type::AddressSpace::kPrivate: + case type::AddressSpace::kFunction: break; // Allowed an initializer default: // 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, - ast::AddressSpace address_space, + type::AddressSpace address_space, Source source) const { // https://gpuweb.github.io/gpuweb/wgsl/#storage-class-layout-constraints 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(); }; auto is_uniform_struct = [address_space](const type::Type* ty) { - return address_space == ast::AddressSpace::kUniform && ty->Is(); + return address_space == type::AddressSpace::kUniform && ty->Is(); }; auto required_alignment_of = [&](const type::Type* ty) { @@ -425,7 +425,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty, return true; } - if (!ast::IsHostShareable(address_space)) { + if (!type::IsHostShareable(address_space)) { 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 // "storage" address space, but not "push_constant" address space yet. if (Is(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); return false; } @@ -515,7 +515,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty, 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 only need to validate that stride is a multiple of 16 bytes. if (arr->Stride() % 16 != 0) { @@ -581,7 +581,7 @@ bool Validator::GlobalVariable( const sem::GlobalVariable* global, const utils::Hashmap& override_ids) const { auto* decl = global->Declaration(); - if (global->AddressSpace() != ast::AddressSpace::kWorkgroup && + if (global->AddressSpace() != type::AddressSpace::kWorkgroup && IsArrayWithOverrideCount(global->Type())) { RaiseArrayWithOverrideCountError(decl->type ? decl->type->source : decl->initializer->source); @@ -597,7 +597,7 @@ bool Validator::GlobalVariable( 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); return false; } @@ -606,8 +606,8 @@ bool Validator::GlobalVariable( bool is_shader_io_attribute = attr->IsAnyOf(); - bool has_io_address_space = global->AddressSpace() == ast::AddressSpace::kIn || - global->AddressSpace() == ast::AddressSpace::kOut; + bool has_io_address_space = global->AddressSpace() == type::AddressSpace::kIn || + global->AddressSpace() == type::AddressSpace::kOut; if (!attr->IsAnyOf() && (!is_shader_io_attribute || !has_io_address_space)) { @@ -639,15 +639,15 @@ bool Validator::GlobalVariable( 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); return false; } switch (global->AddressSpace()) { - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kHandle: { + case type::AddressSpace::kUniform: + case type::AddressSpace::kStorage: + case type::AddressSpace::kHandle: { // https://gpuweb.github.io/gpuweb/wgsl/#resource-interface // Each resource variable must be declared with both group and binding attributes. if (!decl->HasBindingPoint()) { @@ -682,7 +682,7 @@ bool Validator::Var(const sem::Variable* v) const { } 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 // 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. @@ -698,7 +698,7 @@ bool Validator::Var(const sem::Variable* v) const { // 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 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 address space may declare an access mode", var->source); return false; @@ -711,8 +711,8 @@ bool Validator::Var(const sem::Variable* v) const { } if (IsValidationEnabled(var->attributes, ast::DisabledValidation::kIgnoreAddressSpace) && - (var->declared_address_space == ast::AddressSpace::kIn || - var->declared_address_space == ast::AddressSpace::kOut)) { + (var->declared_address_space == type::AddressSpace::kIn || + var->declared_address_space == type::AddressSpace::kOut)) { AddError("invalid use of input/output address space", var->source); return false; } @@ -806,13 +806,13 @@ bool Validator::Parameter(const ast::Function* func, const sem::Variable* var) c auto sc = ref->AddressSpace(); switch (sc) { - case ast::AddressSpace::kFunction: - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kFunction: + case type::AddressSpace::kPrivate: ok = true; break; - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kStorage: + case type::AddressSpace::kUniform: + case type::AddressSpace::kWorkgroup: ok = enabled_extensions_.Contains( ast::Extension::kChromiumExperimentalFullPtrParameters); break; @@ -1863,7 +1863,7 @@ bool Validator::PipelineStages(utils::VectorRef entry_points) co auto stage = entry_point->Declaration()->PipelineStage(); if (stage != ast::PipelineStage::kCompute) { for (auto* var : func->DirectlyReferencedGlobals()) { - if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) { + if (var->AddressSpace() == type::AddressSpace::kWorkgroup) { std::stringstream stage_name; stage_name << stage; for (auto* user : var->Users()) { @@ -1949,7 +1949,7 @@ bool Validator::PushConstants(utils::VectorRef entry_points) con auto check_push_constant = [&](const sem::Function* func, const sem::Function* ep) { for (auto* var : func->DirectlyReferencedGlobals()) { - if (var->AddressSpace() != ast::AddressSpace::kPushConstant || + if (var->AddressSpace() != type::AddressSpace::kPushConstant || var == push_constant_var) { continue; } @@ -2455,14 +2455,14 @@ std::string Validator::VectorPretty(uint32_t size, const type::Type* element_typ bool Validator::CheckTypeAccessAddressSpace( const type::Type* store_ty, ast::Access access, - ast::AddressSpace address_space, + type::AddressSpace address_space, utils::VectorRef attributes, const Source& source) const { if (!AddressSpaceLayout(store_ty, address_space, source)) { return false; } - if (address_space == ast::AddressSpace::kPushConstant && + if (address_space == type::AddressSpace::kPushConstant && !enabled_extensions_.Contains(ast::Extension::kChromiumExperimentalPushConstant) && IsValidationEnabled(attributes, ast::DisabledValidation::kIgnoreAddressSpace)) { AddError( @@ -2472,7 +2472,7 @@ bool Validator::CheckTypeAccessAddressSpace( 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 // 'read_write'. 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* { - if (address_space != ast::AddressSpace::kStorage && - address_space != ast::AddressSpace::kWorkgroup) { + if (address_space != type::AddressSpace::kStorage && + address_space != type::AddressSpace::kWorkgroup) { return "atomic variables must have or 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 address space must have read_write access " "mode"; } diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h index aa6d9b3760..72d9d20fdc 100644 --- a/src/tint/resolver/validator.h +++ b/src/tint/resolver/validator.h @@ -74,7 +74,7 @@ struct TypeAndAddressSpace { /// The type const type::Type* type; /// The address space - ast::AddressSpace address_space; + type::AddressSpace address_space; /// Equality operator /// @param other the other TypeAndAddressSpace to compare this TypeAndAddressSpace to @@ -418,7 +418,7 @@ class Validator { /// @param initializer the RHS initializer expression /// @returns true on succes, false otherwise bool VariableInitializer(const ast::Variable* v, - ast::AddressSpace address_space, + type::AddressSpace address_space, const type::Type* storage_type, const sem::Expression* initializer) const; @@ -464,7 +464,7 @@ class Validator { /// @param sc the address space /// @param source the source of the type /// @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 /// ast::DisableValidationAttribute with the validation mode equal to @@ -519,7 +519,7 @@ class Validator { /// @returns true on success, false if an error was raised. bool CheckTypeAccessAddressSpace(const type::Type* store_ty, ast::Access access, - ast::AddressSpace address_space, + type::AddressSpace address_space, utils::VectorRef attributes, const Source& source) const; SymbolTable& symbols_; diff --git a/src/tint/resolver/validator_is_storeable_test.cc b/src/tint/resolver/validator_is_storeable_test.cc index 5bca58e144..e8a1fdff84 100644 --- a/src/tint/resolver/validator_is_storeable_test.cc +++ b/src/tint/resolver/validator_is_storeable_test.cc @@ -78,7 +78,7 @@ TEST_F(ValidatorIsStorableTest, Matrix) { } TEST_F(ValidatorIsStorableTest, Pointer) { - auto* ptr = create(create(), ast::AddressSpace::kPrivate, + auto* ptr = create(create(), type::AddressSpace::kPrivate, ast::Access::kReadWrite); EXPECT_FALSE(v()->IsStorable(ptr)); } diff --git a/src/tint/resolver/variable_test.cc b/src/tint/resolver/variable_test.cc index 744fb998bf..2ca1719ef3 100644 --- a/src/tint/resolver/variable_test.cc +++ b/src/tint/resolver/variable_test.cc @@ -238,7 +238,7 @@ TEST_F(ResolverVariableTest, LocalVar_ShadowsGlobalVar) { // 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")); 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* s = Let("s", ty.Of(S), s_c); auto* a = Let("a", ty.Of(A), a_c); - auto* p = Let("p", ty.pointer(ast::AddressSpace::kFunction), p_c); + auto* p = Let("p", ty.pointer(type::AddressSpace::kFunction), p_c); Func("F", utils::Empty, ty.void_(), utils::Vector{ @@ -472,8 +472,8 @@ TEST_F(ResolverVariableTest, LocalLet_InheritsAccessFromOriginatingVariable) { // } auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array())}); auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))}); - auto* storage = GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, ast::Access::kReadWrite, - Binding(0_a), Group(0_a)); + auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage, + ast::Access::kReadWrite, Binding(0_a), Group(0_a)); auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 3_i); auto* ptr = Let("p", AddressOf(expr)); @@ -554,7 +554,7 @@ TEST_F(ResolverVariableTest, LocalLet_ShadowsGlobalVar) { // 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")); Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(l)}); @@ -766,7 +766,7 @@ TEST_F(ResolverVariableTest, LocalConst_ShadowsGlobalVar) { // 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)); 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 auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())}); - auto* private_ = GlobalVar("p", ty.i32(), ast::AddressSpace::kPrivate); - auto* workgroup = GlobalVar("w", ty.i32(), ast::AddressSpace::kWorkgroup); + auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate); + auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup); 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 = - 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 = 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 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)); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -1222,7 +1222,7 @@ TEST_F(ResolverVariableTest, Param_ShadowsGlobalVar) { // 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_()); Func("F", utils::Vector{p}, ty.void_(), utils::Empty); diff --git a/src/tint/resolver/variable_validation_test.cc b/src/tint/resolver/variable_validation_test.cc index c4232e25f2..529a11945f 100644 --- a/src/tint/resolver/variable_validation_test.cc +++ b/src/tint/resolver/variable_validation_test.cc @@ -61,8 +61,8 @@ TEST_F(ResolverVariableValidationTest, GlobalVarInitializerNoReturnValueBuiltin) TEST_F(ResolverVariableValidationTest, GlobalVarUsedAtModuleScope) { // var a : i32; // var b : i32 = a; - GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a")); + GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a")); EXPECT_FALSE(r()->Resolve()); 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 p : pointer = &v; auto* i = Var("i", ty.i32()); - auto* p = Var("a", ty.pointer(Source{{56, 78}}, ast::AddressSpace::kFunction), - ast::AddressSpace::kNone, AddressOf(Source{{12, 34}}, "i")); + auto* p = Var("a", ty.pointer(Source{{56, 78}}, type::AddressSpace::kFunction), + type::AddressSpace::kNone, AddressOf(Source{{12, 34}}, "i")); WrapInFunction(i, p); EXPECT_FALSE(r()->Resolve()); @@ -205,7 +205,7 @@ TEST_F(ResolverVariableValidationTest, VarInitializerWrongTypeViaAlias) { TEST_F(ResolverVariableValidationTest, LetOfPtrConstructedWithRef) { // var a : f32; // let b : ptr = a; - const auto priv = ast::AddressSpace::kFunction; + const auto priv = type::AddressSpace::kFunction; auto* var_a = Var("a", ty.f32(), priv); auto* var_b = Let(Source{{12, 34}}, "b", ty.pointer(priv), Expr("a")); WrapInFunction(var_a, var_b); @@ -236,7 +236,7 @@ TEST_F(ResolverVariableValidationTest, GlobalVarRedeclaredAsLocal) { // 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))); @@ -295,12 +295,12 @@ TEST_F(ResolverVariableValidationTest, InferredPtrStorageAccessMismatch) { Member("inner", ty.Of(inner)), }); 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* ptr = - Let(Source{{12, 34}}, "p", - ty.pointer(ast::AddressSpace::kStorage, ast::Access::kReadWrite), AddressOf(expr)); + auto* ptr = Let(Source{{12, 34}}, "p", + ty.pointer(type::AddressSpace::kStorage, ast::Access::kReadWrite), + AddressOf(expr)); WrapInFunction(ptr); @@ -359,7 +359,7 @@ TEST_F(ResolverVariableValidationTest, NonConstructibleType_InferredType) { TEST_F(ResolverVariableValidationTest, InvalidAddressSpaceForInitializer) { // var 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_EQ(r()->error(), @@ -490,7 +490,7 @@ TEST_F(ResolverVariableValidationTest, GlobalVariable_PushConstantWithInitialize // enable chromium_experimental_push_constant; // var a : u32 = 0u; 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))); ASSERT_FALSE(r()->Resolve()); diff --git a/src/tint/sem/function.cc b/src/tint/sem/function.cc index 6f074a4c3e..dabf1ae796 100644 --- a/src/tint/sem/function.cc +++ b/src/tint/sem/function.cc @@ -68,7 +68,7 @@ Function::VariableBindings Function::TransitivelyReferencedUniformVariables() co VariableBindings ret; for (auto* global : TransitivelyReferencedGlobals()) { - if (global->AddressSpace() != ast::AddressSpace::kUniform) { + if (global->AddressSpace() != type::AddressSpace::kUniform) { continue; } @@ -83,7 +83,7 @@ Function::VariableBindings Function::TransitivelyReferencedStorageBufferVariable VariableBindings ret; for (auto* global : TransitivelyReferencedGlobals()) { - if (global->AddressSpace() != ast::AddressSpace::kStorage) { + if (global->AddressSpace() != type::AddressSpace::kStorage) { continue; } diff --git a/src/tint/sem/struct.h b/src/tint/sem/struct.h index a05a96afd5..42a111713c 100644 --- a/src/tint/sem/struct.h +++ b/src/tint/sem/struct.h @@ -17,9 +17,9 @@ #include -#include "src/tint/ast/address_space.h" #include "src/tint/ast/struct.h" #include "src/tint/symbol.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/struct.h" #include "src/tint/type/type.h" #include "src/tint/utils/vector.h" diff --git a/src/tint/sem/variable.cc b/src/tint/sem/variable.cc index db5edfe52e..a772ff56e4 100644 --- a/src/tint/sem/variable.cc +++ b/src/tint/sem/variable.cc @@ -31,7 +31,7 @@ namespace tint::sem { Variable::Variable(const ast::Variable* declaration, const type::Type* type, EvaluationStage stage, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const constant::Value* constant_value) : declaration_(declaration), @@ -46,7 +46,7 @@ Variable::~Variable() = default; LocalVariable::LocalVariable(const ast::Variable* declaration, const type::Type* type, EvaluationStage stage, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const sem::Statement* statement, const constant::Value* constant_value) @@ -58,7 +58,7 @@ LocalVariable::~LocalVariable() = default; GlobalVariable::GlobalVariable(const ast::Variable* declaration, const type::Type* type, EvaluationStage stage, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const constant::Value* constant_value, sem::BindingPoint binding_point, @@ -72,7 +72,7 @@ GlobalVariable::~GlobalVariable() = default; Parameter::Parameter(const ast::Parameter* declaration, uint32_t index, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const ParameterUsage usage /* = ParameterUsage::kNone */, sem::BindingPoint binding_point /* = {} */, diff --git a/src/tint/sem/variable.h b/src/tint/sem/variable.h index bf2a2d5acc..efee4f98a0 100644 --- a/src/tint/sem/variable.h +++ b/src/tint/sem/variable.h @@ -22,11 +22,11 @@ #include "tint/override_id.h" #include "src/tint/ast/access.h" -#include "src/tint/ast/address_space.h" #include "src/tint/ast/parameter.h" #include "src/tint/sem/binding_point.h" #include "src/tint/sem/expression.h" #include "src/tint/sem/parameter_usage.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/type.h" #include "src/tint/utils/unique_vector.h" @@ -57,7 +57,7 @@ class Variable : public Castable { Variable(const ast::Variable* declaration, const type::Type* type, EvaluationStage stage, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const constant::Value* constant_value); @@ -74,7 +74,7 @@ class Variable : public Castable { EvaluationStage Stage() const { return stage_; } /// @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 ast::Access Access() const { return access_; } @@ -100,7 +100,7 @@ class Variable : public Castable { const ast::Variable* const declaration_; const type::Type* const type_; const EvaluationStage stage_; - const ast::AddressSpace address_space_; + const type::AddressSpace address_space_; const ast::Access access_; const constant::Value* constant_value_; const Expression* initializer_ = nullptr; @@ -121,7 +121,7 @@ class LocalVariable final : public Castable { LocalVariable(const ast::Variable* declaration, const type::Type* type, EvaluationStage stage, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const sem::Statement* statement, const constant::Value* constant_value); @@ -162,7 +162,7 @@ class GlobalVariable final : public Castable { GlobalVariable(const ast::Variable* declaration, const type::Type* type, EvaluationStage stage, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const constant::Value* constant_value, sem::BindingPoint binding_point = {}, @@ -205,7 +205,7 @@ class Parameter final : public Castable { Parameter(const ast::Parameter* declaration, uint32_t index, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const ParameterUsage usage = ParameterUsage::kNone, sem::BindingPoint binding_point = {}, diff --git a/src/tint/transform/add_block_attribute.cc b/src/tint/transform/add_block_attribute.cc index c50c2d5a74..c2d674b9af 100644 --- a/src/tint/transform/add_block_attribute.cc +++ b/src/tint/transform/add_block_attribute.cc @@ -47,7 +47,7 @@ Transform::ApplyResult AddBlockAttribute::Apply(const Program* src, bool made_changes = false; for (auto* global : src->AST().GlobalVariables()) { auto* var = sem.Get(global); - if (!ast::IsHostShareable(var->AddressSpace())) { + if (!type::IsHostShareable(var->AddressSpace())) { // Not declared in a host-sharable address space continue; } diff --git a/src/tint/transform/array_length_from_uniform.cc b/src/tint/transform/array_length_from_uniform.cc index 3f470fa6bb..9cbf5f92ac 100644 --- a/src/tint/transform/array_length_from_uniform.cc +++ b/src/tint/transform/array_length_from_uniform.cc @@ -107,7 +107,7 @@ struct ArrayLengthFromUniform::State { u32((max_buffer_size_index / 4) + 1))), }); 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.Binding(AInt(cfg->ubo_binding.binding))); } diff --git a/src/tint/transform/binding_remapper.cc b/src/tint/transform/binding_remapper.cc index 0781355f1e..7b22535e25 100644 --- a/src/tint/transform/binding_remapper.cc +++ b/src/tint/transform/binding_remapper.cc @@ -130,7 +130,7 @@ Transform::ApplyResult BindingRemapper::Apply(const Program* src, return Program(std::move(b)); } auto* sem = src->Sem().Get(var); - if (sem->AddressSpace() != ast::AddressSpace::kStorage) { + if (sem->AddressSpace() != type::AddressSpace::kStorage) { b.Diagnostics().add_error( diag::System::Transform, "cannot apply access control to variable with address space " + diff --git a/src/tint/transform/builtin_polyfill.cc b/src/tint/transform/builtin_polyfill.cc index 2c0f2a9515..7aba0423f2 100644 --- a/src/tint/transform/builtin_polyfill.cc +++ b/src/tint/transform/builtin_polyfill.cc @@ -679,7 +679,7 @@ struct BuiltinPolyfill::State { auto name = b.Symbols().New("tint_workgroupUniformLoad"); b.Func(name, 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), utils::Vector{ diff --git a/src/tint/transform/calculate_array_length.cc b/src/tint/transform/calculate_array_length.cc index 0469dc93c4..886f839c5a 100644 --- a/src/tint/transform/calculate_array_length.cc +++ b/src/tint/transform/calculate_array_length.cc @@ -112,7 +112,7 @@ Transform::ApplyResult CalculateArrayLength::Apply(const Program* src, b.Param("buffer", b.ty.pointer(type, buffer_type->AddressSpace(), buffer_type->Access()), 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, utils::Vector{ diff --git a/src/tint/transform/canonicalize_entry_point_io.cc b/src/tint/transform/canonicalize_entry_point_io.cc index 1afad12a86..a662053911 100644 --- a/src/tint/transform/canonicalize_entry_point_io.cc +++ b/src/tint/transform/canonicalize_entry_point_io.cc @@ -234,7 +234,7 @@ struct CanonicalizeEntryPointIO::State { auto* builtin = ast::GetAttribute(attributes); if (cfg.shader_style == ShaderStyle::kGlsl && builtin) { name = GLSLBuiltinToString(builtin->builtin, func_ast->PipelineStage(), - ast::AddressSpace::kIn); + type::AddressSpace::kIn); } auto symbol = ctx.dst->Symbols().New(name); @@ -251,7 +251,7 @@ struct CanonicalizeEntryPointIO::State { 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; } else if (cfg.shader_style == ShaderStyle::kMsl && ast::HasAttribute(attributes)) { @@ -300,7 +300,7 @@ struct CanonicalizeEntryPointIO::State { if (cfg.shader_style == ShaderStyle::kGlsl) { if (auto* b = ast::GetAttribute(attributes)) { name = GLSLBuiltinToString(b->builtin, func_ast->PipelineStage(), - ast::AddressSpace::kOut); + type::AddressSpace::kOut); value = ToGLSLBuiltin(b->builtin, value, type); } } @@ -530,7 +530,7 @@ struct CanonicalizeEntryPointIO::State { type = ctx.dst->ty.array(type, 1_u); 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)); } } @@ -674,7 +674,7 @@ struct CanonicalizeEntryPointIO::State { /// @returns the gl_ string corresponding to that builtin const char* GLSLBuiltinToString(ast::BuiltinValue builtin, ast::PipelineStage stage, - ast::AddressSpace address_space) { + type::AddressSpace address_space) { switch (builtin) { case ast::BuiltinValue::kPosition: switch (stage) { @@ -706,7 +706,7 @@ struct CanonicalizeEntryPointIO::State { case ast::BuiltinValue::kSampleIndex: return "gl_SampleID"; case ast::BuiltinValue::kSampleMask: - if (address_space == ast::AddressSpace::kIn) { + if (address_space == type::AddressSpace::kIn) { return "gl_SampleMaskIn"; } else { return "gl_SampleMask"; diff --git a/src/tint/transform/clamp_frag_depth.cc b/src/tint/transform/clamp_frag_depth.cc index 94deee544f..34a4624648 100644 --- a/src/tint/transform/clamp_frag_depth.cc +++ b/src/tint/transform/clamp_frag_depth.cc @@ -89,7 +89,7 @@ Transform::ApplyResult ClampFragDepth::Apply(const Program* src, const DataMap&, // Abort on any use of push constants in the module. for (auto* global : src->AST().GlobalVariables()) { if (auto* var = global->As()) { - 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()) << "ClampFragDepth doesn't know how to handle module that already use push " "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())}); 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"); b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(), diff --git a/src/tint/transform/decompose_memory_access.cc b/src/tint/transform/decompose_memory_access.cc index e760bd29eb..d6f98d5bbb 100644 --- a/src/tint/transform/decompose_memory_access.cc +++ b/src/tint/transform/decompose_memory_access.cc @@ -50,8 +50,8 @@ namespace { bool ShouldRun(const Program* program) { for (auto* decl : program->AST().GlobalDeclarations()) { if (auto* var = program->Sem().Get(decl)) { - if (var->AddressSpace() == ast::AddressSpace::kStorage || - var->AddressSpace() == ast::AddressSpace::kUniform) { + if (var->AddressSpace() == type::AddressSpace::kStorage || + var->AddressSpace() == type::AddressSpace::kUniform) { return true; } } @@ -109,7 +109,7 @@ struct OffsetBinOp : Offset { /// LoadStoreKey is the unordered map key to a load or store intrinsic. struct LoadStoreKey { - ast::AddressSpace const address_space; // buffer address space + type::AddressSpace const address_space; // buffer address space ast::Access const access; // buffer access type::Type const* buf_ty = nullptr; // buffer 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 /// to a stub function to load the type `ty`. DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder, - ast::AddressSpace address_space, + type::AddressSpace address_space, const type::Type* ty) { DecomposeMemoryAccess::Intrinsic::DataType type; if (!IntrinsicDataTypeFor(ty, type)) { @@ -237,7 +237,7 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder, /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied /// to a stub function to store the type `ty`. DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder, - ast::AddressSpace address_space, + type::AddressSpace address_space, const type::Type* ty) { DecomposeMemoryAccess::Intrinsic::DataType type; if (!IntrinsicDataTypeFor(ty, type)) { @@ -300,7 +300,7 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder, return nullptr; } return builder->ASTNodes().Create( - 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 @@ -466,7 +466,7 @@ struct DecomposeMemoryAccess::State { const sem::VariableUser* var_user) { auto address_space = var_user->Variable()->AddressSpace(); auto access = var_user->Variable()->Access(); - if (address_space != ast::AddressSpace::kStorage) { + if (address_space != type::AddressSpace::kStorage) { access = ast::Access::kUndefined; } return utils::GetOrCreate( @@ -565,7 +565,7 @@ struct DecomposeMemoryAccess::State { const sem::VariableUser* var_user) { auto address_space = var_user->Variable()->AddressSpace(); auto access = var_user->Variable()->Access(); - if (address_space != ast::AddressSpace::kStorage) { + if (address_space != type::AddressSpace::kStorage) { access = ast::Access::kUndefined; } return utils::GetOrCreate( @@ -678,7 +678,7 @@ struct DecomposeMemoryAccess::State { auto op = intrinsic->Type(); auto address_space = var_user->Variable()->AddressSpace(); auto access = var_user->Variable()->Access(); - if (address_space != ast::AddressSpace::kStorage) { + if (address_space != type::AddressSpace::kStorage) { access = ast::Access::kUndefined; } 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. utils::Vector params{ b.Param("buffer", - b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), ast::AddressSpace::kStorage, + b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), type::AddressSpace::kStorage, access), utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}), b.Param("offset", b.ty.u32()), @@ -744,7 +744,7 @@ struct DecomposeMemoryAccess::State { DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid, ast::NodeID nid, Op o, - ast::AddressSpace sc, + type::AddressSpace sc, DataType ty) : Base(pid, nid), op(o), address_space(sc), type(ty) {} DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default; @@ -883,8 +883,8 @@ Transform::ApplyResult DecomposeMemoryAccess::Apply(const Program* src, // X if (auto* sem_ident = sem.Get(ident)) { if (auto* var = sem_ident->UnwrapLoad()->As()) { - if (var->Variable()->AddressSpace() == ast::AddressSpace::kStorage || - var->Variable()->AddressSpace() == ast::AddressSpace::kUniform) { + if (var->Variable()->AddressSpace() == type::AddressSpace::kStorage || + var->Variable()->AddressSpace() == type::AddressSpace::kUniform) { // Variable to a storage or uniform buffer state.AddAccess(ident, { var, diff --git a/src/tint/transform/decompose_memory_access.h b/src/tint/transform/decompose_memory_access.h index 3c620e07a4..3a51035d09 100644 --- a/src/tint/transform/decompose_memory_access.h +++ b/src/tint/transform/decompose_memory_access.h @@ -81,7 +81,7 @@ class DecomposeMemoryAccess final : public Castable arr : array ProgramBuilder b; - b.GlobalVar("arr", b.ty.array(), ast::AddressSpace::kPrivate); + b.GlobalVar("arr", b.ty.array(), type::AddressSpace::kPrivate); EXPECT_FALSE(ShouldRun(Program(std::move(b)))); } @@ -47,7 +47,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunDefaultStridedArray) { // var arr : @stride(4) array ProgramBuilder b; - b.GlobalVar("arr", b.ty.array(4), ast::AddressSpace::kPrivate); + b.GlobalVar("arr", b.ty.array(4), type::AddressSpace::kPrivate); EXPECT_TRUE(ShouldRun(Program(std::move(b)))); } @@ -55,7 +55,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunExplicitStridedArray) { // var arr : @stride(16) array ProgramBuilder b; - b.GlobalVar("arr", b.ty.array(16), ast::AddressSpace::kPrivate); + b.GlobalVar("arr", b.ty.array(16), type::AddressSpace::kPrivate); EXPECT_TRUE(ShouldRun(Program(std::move(b)))); } @@ -78,7 +78,7 @@ TEST_F(DecomposeStridedArrayTest, PrivateDefaultStridedArray) { // } ProgramBuilder b; - b.GlobalVar("arr", b.ty.array(4), ast::AddressSpace::kPrivate); + b.GlobalVar("arr", b.ty.array(4), type::AddressSpace::kPrivate); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Decl(b.Let("a", b.ty.array(4), b.Expr("arr"))), @@ -114,7 +114,7 @@ TEST_F(DecomposeStridedArrayTest, PrivateStridedArray) { // } ProgramBuilder b; - b.GlobalVar("arr", b.ty.array(32), ast::AddressSpace::kPrivate); + b.GlobalVar("arr", b.ty.array(32), type::AddressSpace::kPrivate); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Decl(b.Let("a", b.ty.array(32), b.Expr("arr"))), @@ -158,7 +158,7 @@ TEST_F(DecomposeStridedArrayTest, ReadUniformStridedArray) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(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_(), utils::Vector{ b.Decl(b.Let("a", b.ty.array(32), b.MemberAccessor("s", "a"))), @@ -206,7 +206,7 @@ TEST_F(DecomposeStridedArrayTest, ReadUniformDefaultStridedArray) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(b.ty.vec4(), 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( "f", utils::Empty, b.ty.void_(), utils::Vector{ @@ -252,7 +252,7 @@ TEST_F(DecomposeStridedArrayTest, ReadStorageStridedArray) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(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_(), utils::Vector{ b.Decl(b.Let("a", b.ty.array(32), b.MemberAccessor("s", "a"))), @@ -300,7 +300,7 @@ TEST_F(DecomposeStridedArrayTest, ReadStorageDefaultStridedArray) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(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_(), utils::Vector{ b.Decl(b.Let("a", b.ty.array(4), b.MemberAccessor("s", "a"))), @@ -344,8 +344,8 @@ TEST_F(DecomposeStridedArrayTest, WriteStorageStridedArray) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(32))}); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array(32))), @@ -398,8 +398,8 @@ TEST_F(DecomposeStridedArrayTest, WriteStorageDefaultStridedArray) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(4))}); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array(4))), @@ -450,8 +450,8 @@ TEST_F(DecomposeStridedArrayTest, ReadWriteViaPointerLets) { // } ProgramBuilder b; auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(32))}); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "a")))), @@ -511,8 +511,8 @@ TEST_F(DecomposeStridedArrayTest, PrivateAliasedStridedArray) { ProgramBuilder b; b.Alias("ARR", b.ty.array(32)); 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.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ 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), // 4_u, 128)); 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.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Decl(b.Let("a", b.ty.type_name("ARR_B"), b.MemberAccessor("s", "a"))), diff --git a/src/tint/transform/decompose_strided_matrix.cc b/src/tint/transform/decompose_strided_matrix.cc index 4f2042a8b8..15cdf62fd2 100644 --- a/src/tint/transform/decompose_strided_matrix.cc +++ b/src/tint/transform/decompose_strided_matrix.cc @@ -72,8 +72,8 @@ Transform::ApplyResult DecomposeStridedMatrix::Apply(const Program* src, for (auto* node : src->ASTNodes().Objects()) { if (auto* str = node->As()) { auto* str_ty = src->Sem().Get(str); - if (!str_ty->UsedAs(ast::AddressSpace::kUniform) && - !str_ty->UsedAs(ast::AddressSpace::kStorage)) { + if (!str_ty->UsedAs(type::AddressSpace::kUniform) && + !str_ty->UsedAs(type::AddressSpace::kStorage)) { continue; } for (auto* member : str_ty->Members()) { diff --git a/src/tint/transform/decompose_strided_matrix_test.cc b/src/tint/transform/decompose_strided_matrix_test.cc index e3ba4bb13a..8b36f6101a 100644 --- a/src/tint/transform/decompose_strided_matrix_test.cc +++ b/src/tint/transform/decompose_strided_matrix_test.cc @@ -76,7 +76,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformMatrix) { 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_(), utils::Vector{ b.Decl(b.Let("x", b.ty.mat2x2(), b.MemberAccessor("s", "m"))), @@ -133,7 +133,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformColumn) { 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_(), utils::Vector{ @@ -187,7 +187,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformMatrix_DefaultStride) { 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_(), utils::Vector{ b.Decl(b.Let("x", b.ty.mat2x2(), b.MemberAccessor("s", "m"))), @@ -241,8 +241,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadStorageMatrix) { b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), }), }); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Decl(b.Let("x", b.ty.mat2x2(), b.MemberAccessor("s", "m"))), @@ -299,8 +299,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadStorageColumn) { b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), }), }); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func( "f", utils::Empty, b.ty.void_(), utils::Vector{ @@ -354,8 +354,8 @@ TEST_F(DecomposeStridedMatrixTest, WriteStorageMatrix) { b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), }), }); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Assign(b.MemberAccessor("s", "m"), @@ -413,8 +413,8 @@ TEST_F(DecomposeStridedMatrixTest, WriteStorageColumn) { b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), }), }); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ b.Assign(b.IndexAccessor(b.MemberAccessor("s", "m"), 1_i), b.vec2(1_f, 2_f)), @@ -473,8 +473,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadWriteViaPointerLets) { b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute), }), }); - b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a), - b.Binding(0_a)); + b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite, + b.Group(0_a), b.Binding(0_a)); b.Func("f", utils::Empty, b.ty.void_(), utils::Vector{ 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.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_(), utils::Vector{ b.Decl(b.Let("x", b.ty.mat2x2(), b.MemberAccessor("s", "m"))), @@ -599,7 +599,7 @@ TEST_F(DecomposeStridedMatrixTest, WritePrivateMatrix) { 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_(), utils::Vector{ b.Assign(b.MemberAccessor("s", "m"), diff --git a/src/tint/transform/demote_to_helper.cc b/src/tint/transform/demote_to_helper.cc index ab86fd9ec3..48a76b7cba 100644 --- a/src/tint/transform/demote_to_helper.cc +++ b/src/tint/transform/demote_to_helper.cc @@ -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. 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. 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. auto* ref = sem.Get(assign->lhs)->Type()->As(); switch (ref->AddressSpace()) { - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: // Need to mask these. break; - case ast::AddressSpace::kFunction: - case ast::AddressSpace::kPrivate: - case ast::AddressSpace::kOut: + case type::AddressSpace::kFunction: + case type::AddressSpace::kPrivate: + case type::AddressSpace::kOut: // Skip these. return; default: diff --git a/src/tint/transform/direct_variable_access.cc b/src/tint/transform/direct_variable_access.cc index 70479be745..a46b384e4c 100644 --- a/src/tint/transform/direct_variable_access.cc +++ b/src/tint/transform/direct_variable_access.cc @@ -50,7 +50,7 @@ struct AccessRoot { /// function-scope variable ('function'), or pointer parameter in the source program. tint::sem::Variable const* variable = nullptr; /// 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 @@ -450,7 +450,7 @@ struct DirectVariableAccess::State { Switch( variable->Declaration(), [&](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 create_new_chain(); } @@ -749,15 +749,15 @@ struct DirectVariableAccess::State { /// @returns true if the address space @p address_space requires transforming given the /// transform's options. - bool AddressSpaceRequiresTransform(ast::AddressSpace address_space) const { + bool AddressSpaceRequiresTransform(type::AddressSpace address_space) const { switch (address_space) { - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kUniform: + case type::AddressSpace::kStorage: + case type::AddressSpace::kWorkgroup: return true; - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: return opts.transform_private; - case ast::AddressSpace::kFunction: + case type::AddressSpace::kFunction: return opts.transform_function; default: return false; @@ -1180,9 +1180,9 @@ struct DirectVariableAccess::State { for (auto* param : fn->Parameters()) { if (auto* ptr = param->Type()->As()) { switch (ptr->AddressSpace()) { - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kUniform: + case type::AddressSpace::kStorage: + case type::AddressSpace::kWorkgroup: return true; default: return false; @@ -1193,8 +1193,8 @@ struct DirectVariableAccess::State { } /// @returns true if the given address space is 'private' or 'function'. - static bool IsPrivateOrFunction(const ast::AddressSpace sc) { - return sc == ast::AddressSpace::kPrivate || sc == ast::AddressSpace::kFunction; + static bool IsPrivateOrFunction(const type::AddressSpace sc) { + return sc == type::AddressSpace::kPrivate || sc == type::AddressSpace::kFunction; } }; diff --git a/src/tint/transform/first_index_offset.cc b/src/tint/transform/first_index_offset.cc index da1587de40..2359ae9c09 100644 --- a/src/tint/transform/first_index_offset.cc +++ b/src/tint/transform/first_index_offset.cc @@ -130,7 +130,7 @@ Transform::ApplyResult FirstIndexOffset::Apply(const Program* src, // Create a global to hold the uniform buffer Symbol buffer_name = b.Sym(); - b.GlobalVar(buffer_name, b.ty.Of(struct_), ast::AddressSpace::kUniform, + b.GlobalVar(buffer_name, b.ty.Of(struct_), type::AddressSpace::kUniform, utils::Vector{ b.Binding(AInt(ub_binding)), b.Group(AInt(ub_group)), diff --git a/src/tint/transform/localize_struct_array_assignment.cc b/src/tint/transform/localize_struct_array_assignment.cc index b389b61212..6ed16b32c9 100644 --- a/src/tint/transform/localize_struct_array_assignment.cc +++ b/src/tint/transform/localize_struct_array_assignment.cc @@ -60,8 +60,8 @@ struct LocalizeStructArrayAssignment::State { continue; } auto og = GetOriginatingTypeAndAddressSpace(assign_stmt); - if (!(og.first->Is() && (og.second == ast::AddressSpace::kFunction || - og.second == ast::AddressSpace::kPrivate))) { + if (!(og.first->Is() && (og.second == type::AddressSpace::kFunction || + og.second == type::AddressSpace::kPrivate))) { continue; } @@ -184,7 +184,7 @@ struct LocalizeStructArrayAssignment::State { // Returns the type and address space of the originating variable of the lhs // of the assignment statement. // See https://www.w3.org/TR/WGSL/#originating-variable-section - std::pair GetOriginatingTypeAndAddressSpace( + std::pair GetOriginatingTypeAndAddressSpace( const ast::AssignmentStatement* assign_stmt) { auto* root_ident = src->Sem().Get(assign_stmt->lhs)->RootIdentifier(); if (TINT_UNLIKELY(!root_ident)) { @@ -206,7 +206,7 @@ struct LocalizeStructArrayAssignment::State { TINT_ICE(Transform, b.Diagnostics()) << "Expecting to find variable of type pointer or reference on lhs " "of assignment statement"; - return std::pair{}; + return std::pair{}; }); } }; diff --git a/src/tint/transform/module_scope_var_to_entry_point_param.cc b/src/tint/transform/module_scope_var_to_entry_point_param.cc index c54d586edd..71d9561999 100644 --- a/src/tint/transform/module_scope_var_to_entry_point_param.cc +++ b/src/tint/transform/module_scope_var_to_entry_point_param.cc @@ -123,9 +123,9 @@ struct ModuleScopeVarToEntryPointParam::State { // Helper to create an AST node for the store type of the variable. auto store_type = [&]() { return CreateASTTypeFor(ctx, ty); }; - ast::AddressSpace sc = var->AddressSpace(); + type::AddressSpace sc = var->AddressSpace(); switch (sc) { - case ast::AddressSpace::kHandle: { + case type::AddressSpace::kHandle: { // For a texture or sampler variable, redeclare it as an entry point parameter. // Disable entry point parameter validation. auto* disable_validation = @@ -137,8 +137,8 @@ struct ModuleScopeVarToEntryPointParam::State { break; } - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kUniform: { + case type::AddressSpace::kStorage: + case type::AddressSpace::kUniform: { // Variables into the Storage and Uniform address spaces are redeclared as entry // point parameters with a pointer type. auto attributes = ctx.Clone(var->Declaration()->attributes); @@ -167,7 +167,7 @@ struct ModuleScopeVarToEntryPointParam::State { break; } - case ast::AddressSpace::kWorkgroup: { + case type::AddressSpace::kWorkgroup: { if (ContainsMatrix(var->Type())) { // Due to a bug in the MSL compiler, we use a threadgroup memory argument for // any workgroup allocation that contains a matrix. See crbug.com/tint/938. @@ -183,7 +183,7 @@ struct ModuleScopeVarToEntryPointParam::State { ctx.dst->MemberAccessor(ctx.dst->Deref(workgroup_param()), member)); auto* local_var = ctx.dst->Let( new_var_symbol, - ctx.dst->ty.pointer(store_type(), ast::AddressSpace::kWorkgroup), + ctx.dst->ty.pointer(store_type(), type::AddressSpace::kWorkgroup), member_ptr); ctx.InsertFront(func->body->statements, ctx.dst->Decl(local_var)); is_pointer = true; @@ -192,7 +192,7 @@ struct ModuleScopeVarToEntryPointParam::State { } [[fallthrough]]; } - case ast::AddressSpace::kPrivate: { + case type::AddressSpace::kPrivate: { // Variables in the Private and Workgroup address spaces are redeclared at function // scope. Disable address space validation on this variable. auto* disable_validation = @@ -204,7 +204,7 @@ struct ModuleScopeVarToEntryPointParam::State { break; } - case ast::AddressSpace::kPushConstant: { + case type::AddressSpace::kPushConstant: { ctx.dst->Diagnostics().add_error( diag::System::Transform, "unhandled module-scope address space (" + utils::ToString(sc) + ")"); @@ -233,13 +233,13 @@ struct ModuleScopeVarToEntryPointParam::State { auto* param_type = CreateASTTypeFor(ctx, ty); auto sc = var->AddressSpace(); switch (sc) { - case ast::AddressSpace::kPrivate: - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kHandle: - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kPrivate: + case type::AddressSpace::kStorage: + case type::AddressSpace::kUniform: + case type::AddressSpace::kHandle: + case type::AddressSpace::kWorkgroup: break; - case ast::AddressSpace::kPushConstant: { + case type::AddressSpace::kPushConstant: { ctx.dst->Diagnostics().add_error( diag::System::Transform, "unhandled module-scope address space (" + utils::ToString(sc) + ")"); @@ -321,7 +321,7 @@ struct ModuleScopeVarToEntryPointParam::State { bool needs_processing = false; for (auto* var : func_sem->TransitivelyReferencedGlobals()) { - if (var->AddressSpace() != ast::AddressSpace::kNone) { + if (var->AddressSpace() != type::AddressSpace::kNone) { needs_processing = true; break; } @@ -378,7 +378,7 @@ struct ModuleScopeVarToEntryPointParam::State { // Process and redeclare all variables referenced by the function. for (auto* var : func_sem->TransitivelyReferencedGlobals()) { - if (var->AddressSpace() == ast::AddressSpace::kNone) { + if (var->AddressSpace() == type::AddressSpace::kNone) { continue; } if (local_private_vars_.count(var)) { @@ -396,7 +396,7 @@ struct ModuleScopeVarToEntryPointParam::State { // Check if this is a private variable that is only referenced by this function. bool local_private = false; - if (var->AddressSpace() == ast::AddressSpace::kPrivate) { + if (var->AddressSpace() == type::AddressSpace::kPrivate) { local_private = true; for (auto* user : var->Users()) { auto* stmt = user->Stmt(); @@ -414,7 +414,7 @@ struct ModuleScopeVarToEntryPointParam::State { auto* initializer = ctx.Clone(var->Declaration()->initializer); auto* local_var = ctx.dst->Var(new_var_symbol, CreateASTTypeFor(ctx, var->Type()->UnwrapRef()), - ast::AddressSpace::kPrivate, initializer, + type::AddressSpace::kPrivate, initializer, utils::Vector{disable_validation}); ctx.InsertFront(func_ast->body->statements, ctx.dst->Decl(local_var)); local_private_vars_.insert(var); @@ -426,7 +426,7 @@ struct ModuleScopeVarToEntryPointParam::State { is_wrapped); } else { ProcessVariableInUserFunction(func_ast, var, new_var_symbol, is_pointer); - if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) { + if (var->AddressSpace() == type::AddressSpace::kWorkgroup) { needs_pointer_aliasing = true; } } @@ -451,7 +451,7 @@ struct ModuleScopeVarToEntryPointParam::State { auto* str = ctx.dst->Structure(ctx.dst->Sym(), std::move(workgroup_parameter_members)); auto* param_type = - ctx.dst->ty.pointer(ctx.dst->ty.Of(str), ast::AddressSpace::kWorkgroup); + ctx.dst->ty.pointer(ctx.dst->ty.Of(str), type::AddressSpace::kWorkgroup); auto* param = ctx.dst->Param( workgroup_param(), param_type, utils::Vector{ @@ -470,7 +470,7 @@ struct ModuleScopeVarToEntryPointParam::State { // For entry points, pass non-handle types as pointers. for (auto* target_var : target_sem->TransitivelyReferencedGlobals()) { auto sc = target_var->AddressSpace(); - if (sc == ast::AddressSpace::kNone) { + if (sc == type::AddressSpace::kNone) { continue; } @@ -501,7 +501,7 @@ struct ModuleScopeVarToEntryPointParam::State { // Now remove all module-scope variables with these address spaces. for (auto* var_ast : ctx.src->AST().GlobalVariables()) { auto* var_sem = ctx.src->Sem().Get(var_ast); - if (var_sem->AddressSpace() != ast::AddressSpace::kNone) { + if (var_sem->AddressSpace() != type::AddressSpace::kNone) { ctx.Remove(ctx.src->AST().GlobalDeclarations(), var_ast); } } diff --git a/src/tint/transform/multiplanar_external_texture.cc b/src/tint/transform/multiplanar_external_texture.cc index 7a2200e4a9..28fe27b0b0 100644 --- a/src/tint/transform/multiplanar_external_texture.cc +++ b/src/tint/transform/multiplanar_external_texture.cc @@ -145,7 +145,7 @@ struct MultiplanarExternalTexture::State { b.Group(AInt(bps.plane_1.group)), b.Binding(AInt(bps.plane_1.binding))); syms.params = b.Symbols().New("ext_tex_params"); b.GlobalVar(syms.params, b.ty.type_name("ExternalTextureParams"), - ast::AddressSpace::kUniform, b.Group(AInt(bps.params.group)), + type::AddressSpace::kUniform, b.Group(AInt(bps.params.group)), b.Binding(AInt(bps.params.binding))); // Replace the original texture_external binding with a texture_2d binding. diff --git a/src/tint/transform/num_workgroups_from_uniform.cc b/src/tint/transform/num_workgroups_from_uniform.cc index c8f8322f9f..47f4ad107f 100644 --- a/src/tint/transform/num_workgroups_from_uniform.cc +++ b/src/tint/transform/num_workgroups_from_uniform.cc @@ -159,7 +159,7 @@ Transform::ApplyResult NumWorkgroupsFromUniform::Apply(const Program* src, } num_workgroups_ubo = - b.GlobalVar(b.Sym(), b.ty.Of(num_workgroups_struct), ast::AddressSpace::kUniform, + b.GlobalVar(b.Sym(), b.ty.Of(num_workgroups_struct), type::AddressSpace::kUniform, b.Group(AInt(group)), b.Binding(AInt(binding))); } return num_workgroups_ubo; diff --git a/src/tint/transform/pad_structs.cc b/src/tint/transform/pad_structs.cc index f34c796ca7..9607851d81 100644 --- a/src/tint/transform/pad_structs.cc +++ b/src/tint/transform/pad_structs.cc @@ -80,7 +80,7 @@ Transform::ApplyResult PadStructs::Apply(const Program* src, const DataMap&, Dat new_members.Push(b.Member(name, type)); uint32_t size = ty->Size(); - if (ty->Is() && str->UsedAs(ast::AddressSpace::kUniform)) { + if (ty->Is() && str->UsedAs(type::AddressSpace::kUniform)) { // std140 structs should be padded out to 16 bytes. size = utils::RoundUp(16u, size); } else if (auto* array_ty = ty->As()) { @@ -93,7 +93,7 @@ Transform::ApplyResult PadStructs::Apply(const Program* src, const DataMap&, Dat // Add any required padding after the last member, if it's not a runtime-sized array. uint32_t struct_size = str->Size(); - if (str->UsedAs(ast::AddressSpace::kUniform)) { + if (str->UsedAs(type::AddressSpace::kUniform)) { struct_size = utils::RoundUp(16u, struct_size); } if (offset < struct_size && !has_runtime_sized_array) { diff --git a/src/tint/transform/preserve_padding.cc b/src/tint/transform/preserve_padding.cc index e2f7e009ce..296e055562 100644 --- a/src/tint/transform/preserve_padding.cc +++ b/src/tint/transform/preserve_padding.cc @@ -53,7 +53,7 @@ struct PreservePadding::State { // Ignore phony assignment. return; } - if (ty->As()->AddressSpace() != ast::AddressSpace::kStorage) { + if (ty->As()->AddressSpace() != type::AddressSpace::kStorage) { // We only care about assignments that write to variables in the storage // address space, as nothing else is host-visible. return; @@ -120,7 +120,7 @@ struct PreservePadding::State { auto helper_name = b.Symbols().New("assign_and_preserve_padding"); utils::Vector params = { b.Param(kDestParamName, - b.ty.pointer(CreateASTTypeFor(ctx, ty), ast::AddressSpace::kStorage, + b.ty.pointer(CreateASTTypeFor(ctx, ty), type::AddressSpace::kStorage, ast::Access::kReadWrite)), b.Param(kValueParamName, CreateASTTypeFor(ctx, ty)), }; diff --git a/src/tint/transform/robustness.cc b/src/tint/transform/robustness.cc index 1ef19c96f2..1d624dfadd 100644 --- a/src/tint/transform/robustness.cc +++ b/src/tint/transform/robustness.cc @@ -38,7 +38,7 @@ struct Robustness::State { /// Constructor /// @param program the source program /// @param omitted the omitted address spaces - State(const Program* program, std::unordered_set&& omitted) + State(const Program* program, std::unordered_set&& omitted) : src(program), omitted_address_spaces(std::move(omitted)) {} /// Runs the transform @@ -60,7 +60,7 @@ struct Robustness::State { CloneContext ctx = {&b, src, /* auto_clone_symbols */ true}; /// Set of address spaces to not apply the transform to - std::unordered_set omitted_address_spaces; + std::unordered_set omitted_address_spaces; /// Apply bounds clamping to array, vector and matrix indexing /// @param expr the array, vector or matrix index expression @@ -294,14 +294,14 @@ Transform::ApplyResult Robustness::Apply(const Program* src, cfg = *cfg_data; } - std::unordered_set omitted_address_spaces; + std::unordered_set omitted_address_spaces; for (auto sc : cfg.omitted_address_spaces) { switch (sc) { case AddressSpace::kUniform: - omitted_address_spaces.insert(ast::AddressSpace::kUniform); + omitted_address_spaces.insert(type::AddressSpace::kUniform); break; case AddressSpace::kStorage: - omitted_address_spaces.insert(ast::AddressSpace::kStorage); + omitted_address_spaces.insert(type::AddressSpace::kStorage); break; } } diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc index d8f1610c45..b1be6032c9 100644 --- a/src/tint/transform/std140.cc +++ b/src/tint/transform/std140.cc @@ -144,7 +144,7 @@ struct Std140::State { // Scan structures for members that need forking for (auto* ty : src->Types()) { if (auto* str = ty->As()) { - if (str->UsedAs(ast::AddressSpace::kUniform)) { + if (str->UsedAs(type::AddressSpace::kUniform)) { for (auto* member : str->Members()) { if (needs_fork(member->Type())) { return true; @@ -157,7 +157,7 @@ struct Std140::State { // Scan uniform variables that have types that need forking for (auto* decl : src->AST().GlobalVariables()) { auto* global = src->Sem().Get(decl); - if (global->AddressSpace() == ast::AddressSpace::kUniform) { + if (global->AddressSpace() == type::AddressSpace::kUniform) { if (needs_fork(global->Type()->UnwrapRef())) { return true; } @@ -280,7 +280,7 @@ struct Std140::State { for (auto* global : src->Sem().Module()->DependencyOrderedDeclarations()) { // Check to see if this is a structure used by a uniform buffer... auto* str = sem.Get(global); - if (str && str->UsedAs(ast::AddressSpace::kUniform)) { + if (str && str->UsedAs(type::AddressSpace::kUniform)) { // Should this uniform buffer be forked for std140 usage? bool fork_std140 = false; utils::Vector members; @@ -350,7 +350,7 @@ struct Std140::State { void ReplaceUniformVarTypes() { for (auto* global : src->AST().GlobalVariables()) { if (auto* var = global->As()) { - if (var->declared_address_space == ast::AddressSpace::kUniform) { + if (var->declared_address_space == type::AddressSpace::kUniform) { auto* v = sem.Get(var); if (auto* std140_ty = Std140Type(v->Type()->UnwrapRef())) { ctx.Replace(global->type, std140_ty); diff --git a/src/tint/transform/vertex_pulling.cc b/src/tint/transform/vertex_pulling.cc index 42dbbe376a..e4cc9ce0ac 100644 --- a/src/tint/transform/vertex_pulling.cc +++ b/src/tint/transform/vertex_pulling.cc @@ -321,7 +321,7 @@ struct VertexPulling::State { }); for (uint32_t i = 0; i < cfg.vertex_state.size(); ++i) { // The decorated variable with struct type - b.GlobalVar(GetVertexBufferName(i), b.ty.Of(struct_type), ast::AddressSpace::kStorage, + b.GlobalVar(GetVertexBufferName(i), b.ty.Of(struct_type), type::AddressSpace::kStorage, ast::Access::kRead, b.Binding(AInt(i)), b.Group(AInt(cfg.pulling_group))); } } diff --git a/src/tint/transform/zero_init_workgroup_memory.cc b/src/tint/transform/zero_init_workgroup_memory.cc index c33834a411..61d7a4bab6 100644 --- a/src/tint/transform/zero_init_workgroup_memory.cc +++ b/src/tint/transform/zero_init_workgroup_memory.cc @@ -36,7 +36,7 @@ namespace { bool ShouldRun(const Program* program) { for (auto* global : program->AST().GlobalVariables()) { if (auto* var = global->As()) { - if (var->declared_address_space == ast::AddressSpace::kWorkgroup) { + if (var->declared_address_space == type::AddressSpace::kWorkgroup) { return true; } } @@ -139,7 +139,7 @@ struct ZeroInitWorkgroupMemory::State { // workgroup storage variables used by `fn`. This will populate #statements. auto* func = sem.Get(fn); for (auto* var : func->TransitivelyReferencedGlobals()) { - if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) { + if (var->AddressSpace() == type::AddressSpace::kWorkgroup) { auto get_expr = [&](uint32_t num_values) { auto var_name = ctx.Clone(var->Declaration()->symbol); return Expression{b.Expr(var_name), num_values, ArrayIndices{}}; diff --git a/src/tint/ast/address_space.cc b/src/tint/type/address_space.cc similarity index 95% rename from src/tint/ast/address_space.cc rename to src/tint/type/address_space.cc index 260f86bacd..c8d9e821be 100644 --- a/src/tint/ast/address_space.cc +++ b/src/tint/type/address_space.cc @@ -15,14 +15,14 @@ //////////////////////////////////////////////////////////////////////////////// // File generated by tools/src/cmd/gen // using the template: -// src/tint/ast/address_space.cc.tmpl +// src/tint/type/address_space.cc.tmpl // // Do not modify this file directly //////////////////////////////////////////////////////////////////////////////// -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" -namespace tint::ast { +namespace tint::type { /// ParseAddressSpace parses a AddressSpace from a string. /// @param str the string to parse @@ -77,4 +77,4 @@ std::ostream& operator<<(std::ostream& out, AddressSpace value) { return out << ""; } -} // namespace tint::ast +} // namespace tint::type diff --git a/src/tint/ast/address_space.cc.tmpl b/src/tint/type/address_space.cc.tmpl similarity index 87% rename from src/tint/ast/address_space.cc.tmpl rename to src/tint/type/address_space.cc.tmpl index 7295f14189..f9036b7df7 100644 --- a/src/tint/ast/address_space.cc.tmpl +++ b/src/tint/type/address_space.cc.tmpl @@ -14,12 +14,12 @@ See: {{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- $enum := (Sem.Enum "address_space") -}} -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" -namespace tint::ast { +namespace tint::type { {{ Eval "ParseEnum" $enum}} {{ Eval "EnumOStream" $enum}} -} // namespace tint::ast +} // namespace tint::type diff --git a/src/tint/ast/address_space.h b/src/tint/type/address_space.h similarity index 84% rename from src/tint/ast/address_space.h rename to src/tint/type/address_space.h index d59997580e..9b70ea5e63 100644 --- a/src/tint/ast/address_space.h +++ b/src/tint/type/address_space.h @@ -15,17 +15,17 @@ //////////////////////////////////////////////////////////////////////////////// // File generated by tools/src/cmd/gen // using the template: -// src/tint/ast/address_space.h.tmpl +// src/tint/type/address_space.h.tmpl // // Do not modify this file directly //////////////////////////////////////////////////////////////////////////////// -#ifndef SRC_TINT_AST_ADDRESS_SPACE_H_ -#define SRC_TINT_AST_ADDRESS_SPACE_H_ +#ifndef SRC_TINT_TYPE_ADDRESS_SPACE_H_ +#define SRC_TINT_TYPE_ADDRESS_SPACE_H_ #include -namespace tint::ast { +namespace tint::type { /// Address space of a given pointer. enum class AddressSpace { @@ -60,11 +60,10 @@ constexpr const char* kAddressSpaceStrings[] = { /// @param address_space the AddressSpace /// @see https://gpuweb.github.io/gpuweb/wgsl.html#host-shareable inline bool IsHostShareable(AddressSpace address_space) { - return address_space == ast::AddressSpace::kUniform || - address_space == ast::AddressSpace::kStorage || - address_space == ast::AddressSpace::kPushConstant; + return address_space == AddressSpace::kUniform || address_space == AddressSpace::kStorage || + address_space == AddressSpace::kPushConstant; } -} // namespace tint::ast +} // namespace tint::type -#endif // SRC_TINT_AST_ADDRESS_SPACE_H_ +#endif // SRC_TINT_TYPE_ADDRESS_SPACE_H_ diff --git a/src/tint/ast/address_space.h.tmpl b/src/tint/type/address_space.h.tmpl similarity index 72% rename from src/tint/ast/address_space.h.tmpl rename to src/tint/type/address_space.h.tmpl index 0726ef3b52..70e308af13 100644 --- a/src/tint/ast/address_space.h.tmpl +++ b/src/tint/type/address_space.h.tmpl @@ -14,12 +14,12 @@ See: {{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- $enum := (Sem.Enum "address_space") -}} -#ifndef SRC_TINT_AST_ADDRESS_SPACE_H_ -#define SRC_TINT_AST_ADDRESS_SPACE_H_ +#ifndef SRC_TINT_TYPE_ADDRESS_SPACE_H_ +#define SRC_TINT_TYPE_ADDRESS_SPACE_H_ #include -namespace tint::ast { +namespace tint::type { /// Address space of a given pointer. {{ Eval "DeclareEnum" $enum}} @@ -28,10 +28,11 @@ namespace tint::ast { /// @param address_space the AddressSpace /// @see https://gpuweb.github.io/gpuweb/wgsl.html#host-shareable inline bool IsHostShareable(AddressSpace address_space) { - return address_space == ast::AddressSpace::kUniform || address_space == ast::AddressSpace::kStorage || - address_space == ast::AddressSpace::kPushConstant; + return address_space == AddressSpace::kUniform || + address_space == AddressSpace::kStorage || + address_space == AddressSpace::kPushConstant; } -} // namespace tint::ast +} // namespace tint::type -#endif // SRC_TINT_AST_ADDRESS_SPACE_H_ +#endif // SRC_TINT_TYPE_ADDRESS_SPACE_H_ diff --git a/src/tint/ast/address_space_bench.cc b/src/tint/type/address_space_bench.cc similarity index 93% rename from src/tint/ast/address_space_bench.cc rename to src/tint/type/address_space_bench.cc index fb3b0a5aac..6a6e4c8dc5 100644 --- a/src/tint/ast/address_space_bench.cc +++ b/src/tint/type/address_space_bench.cc @@ -15,18 +15,18 @@ //////////////////////////////////////////////////////////////////////////////// // File generated by tools/src/cmd/gen // using the template: -// src/tint/ast/address_space_bench.cc.tmpl +// src/tint/type/address_space_bench.cc.tmpl // // Do not modify this file directly //////////////////////////////////////////////////////////////////////////////// -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" #include #include "benchmark/benchmark.h" -namespace tint::ast { +namespace tint::type { namespace { void AddressSpaceParser(::benchmark::State& state) { @@ -52,4 +52,4 @@ void AddressSpaceParser(::benchmark::State& state) { BENCHMARK(AddressSpaceParser); } // namespace -} // namespace tint::ast +} // namespace tint::type diff --git a/src/tint/ast/address_space_bench.cc.tmpl b/src/tint/type/address_space_bench.cc.tmpl similarity index 88% rename from src/tint/ast/address_space_bench.cc.tmpl rename to src/tint/type/address_space_bench.cc.tmpl index 4644944f44..554b2b2da1 100644 --- a/src/tint/ast/address_space_bench.cc.tmpl +++ b/src/tint/type/address_space_bench.cc.tmpl @@ -14,16 +14,16 @@ See: {{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- $enum := (Sem.Enum "address_space") -}} -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" #include #include "benchmark/benchmark.h" -namespace tint::ast { +namespace tint::type { namespace { {{ Eval "BenchmarkParseEnum" $enum }} } // namespace -} // namespace tint::ast +} // namespace tint::type diff --git a/src/tint/ast/address_space_test.cc b/src/tint/type/address_space_test.cc similarity index 94% rename from src/tint/ast/address_space_test.cc rename to src/tint/type/address_space_test.cc index 83646be6ee..8b2af5c661 100644 --- a/src/tint/ast/address_space_test.cc +++ b/src/tint/type/address_space_test.cc @@ -15,19 +15,19 @@ //////////////////////////////////////////////////////////////////////////////// // File generated by tools/src/cmd/gen // using the template: -// src/tint/ast/address_space_test.cc.tmpl +// src/tint/type/address_space_test.cc.tmpl // // Do not modify this file directly //////////////////////////////////////////////////////////////////////////////// -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" #include -#include "src/tint/ast/test_helper.h" +#include "src/tint/type/test_helper.h" #include "src/tint/utils/string.h" -namespace tint::ast { +namespace tint::type { namespace { namespace parse_print_tests { @@ -86,4 +86,4 @@ INSTANTIATE_TEST_SUITE_P(ValidCases, AddressSpacePrintTest, testing::ValuesIn(kV } // namespace parse_print_tests } // namespace -} // namespace tint::ast +} // namespace tint::type diff --git a/src/tint/ast/address_space_test.cc.tmpl b/src/tint/type/address_space_test.cc.tmpl similarity index 83% rename from src/tint/ast/address_space_test.cc.tmpl rename to src/tint/type/address_space_test.cc.tmpl index 2967f7382e..75f16f2b4d 100644 --- a/src/tint/ast/address_space_test.cc.tmpl +++ b/src/tint/type/address_space_test.cc.tmpl @@ -14,17 +14,17 @@ See: {{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- $enum := (Sem.Enum "address_space") -}} -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" #include -#include "src/tint/ast/test_helper.h" +#include "src/tint/type/test_helper.h" #include "src/tint/utils/string.h" -namespace tint::ast { +namespace tint::type { namespace { {{ Eval "TestParsePrintEnum" $enum}} } // namespace -} // namespace tint::ast +} // namespace tint::type diff --git a/src/tint/type/pointer.cc b/src/tint/type/pointer.cc index 8716b92a57..5c9b5c6ec3 100644 --- a/src/tint/type/pointer.cc +++ b/src/tint/type/pointer.cc @@ -22,7 +22,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::type::Pointer); namespace tint::type { -Pointer::Pointer(const Type* subtype, ast::AddressSpace address_space, ast::Access access) +Pointer::Pointer(const Type* subtype, type::AddressSpace address_space, ast::Access access) : Base(utils::Hash(TypeInfo::Of().full_hashcode, address_space, subtype, access), type::Flags{}), subtype_(subtype), @@ -43,7 +43,7 @@ bool Pointer::Equals(const UniqueNode& other) const { std::string Pointer::FriendlyName(const SymbolTable& symbols) const { std::ostringstream out; out << "ptr<"; - if (address_space_ != ast::AddressSpace::kNone) { + if (address_space_ != AddressSpace::kNone) { out << address_space_ << ", "; } out << subtype_->FriendlyName(symbols) << ", " << access_; diff --git a/src/tint/type/pointer.h b/src/tint/type/pointer.h index 083647ecef..cca919d538 100644 --- a/src/tint/type/pointer.h +++ b/src/tint/type/pointer.h @@ -18,7 +18,7 @@ #include #include "src/tint/ast/access.h" -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/type.h" namespace tint::type { @@ -30,7 +30,7 @@ class Pointer final : public Castable { /// @param subtype the pointee type /// @param address_space the address space of the pointer /// @param access the resolved access control of the reference - Pointer(const Type* subtype, ast::AddressSpace address_space, ast::Access access); + Pointer(const Type* subtype, type::AddressSpace address_space, ast::Access access); /// Destructor ~Pointer() override; @@ -43,7 +43,7 @@ class Pointer final : public Castable { const Type* StoreType() const { return subtype_; } /// @returns the address space of the pointer - ast::AddressSpace AddressSpace() const { return address_space_; } + type::AddressSpace AddressSpace() const { return address_space_; } /// @returns the access control of the reference ast::Access Access() const { return access_; } @@ -59,7 +59,7 @@ class Pointer final : public Castable { private: Type const* const subtype_; - ast::AddressSpace const address_space_; + type::AddressSpace const address_space_; ast::Access const access_; }; diff --git a/src/tint/type/pointer_test.cc b/src/tint/type/pointer_test.cc index 85fcab72fb..ddbbbe7d23 100644 --- a/src/tint/type/pointer_test.cc +++ b/src/tint/type/pointer_test.cc @@ -21,14 +21,14 @@ namespace { using PointerTest = TestHelper; TEST_F(PointerTest, Creation) { - auto* a = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* b = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* c = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* d = create(create(), ast::AddressSpace::kPrivate, ast::Access::kReadWrite); - auto* e = create(create(), ast::AddressSpace::kStorage, ast::Access::kRead); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* b = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* c = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* d = create(create(), AddressSpace::kPrivate, ast::Access::kReadWrite); + auto* e = create(create(), AddressSpace::kStorage, ast::Access::kRead); EXPECT_TRUE(a->StoreType()->Is()); - EXPECT_EQ(a->AddressSpace(), ast::AddressSpace::kStorage); + EXPECT_EQ(a->AddressSpace(), AddressSpace::kStorage); EXPECT_EQ(a->Access(), ast::Access::kReadWrite); EXPECT_EQ(a, b); @@ -38,18 +38,18 @@ TEST_F(PointerTest, Creation) { } TEST_F(PointerTest, Hash) { - auto* a = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* b = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* b = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); EXPECT_EQ(a->unique_hash, b->unique_hash); } TEST_F(PointerTest, Equals) { - auto* a = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* b = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* c = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* d = create(create(), ast::AddressSpace::kPrivate, ast::Access::kReadWrite); - auto* e = create(create(), ast::AddressSpace::kStorage, ast::Access::kRead); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* b = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* c = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* d = create(create(), AddressSpace::kPrivate, ast::Access::kReadWrite); + auto* e = create(create(), AddressSpace::kStorage, ast::Access::kRead); EXPECT_TRUE(a->Equals(*b)); EXPECT_FALSE(a->Equals(*c)); @@ -59,24 +59,24 @@ TEST_F(PointerTest, Equals) { } TEST_F(PointerTest, FriendlyName) { - auto* r = create(create(), ast::AddressSpace::kNone, ast::Access::kRead); + auto* r = create(create(), AddressSpace::kNone, ast::Access::kRead); EXPECT_EQ(r->FriendlyName(Symbols()), "ptr"); } TEST_F(PointerTest, FriendlyNameWithAddressSpace) { - auto* r = create(create(), ast::AddressSpace::kWorkgroup, ast::Access::kRead); + auto* r = create(create(), AddressSpace::kWorkgroup, ast::Access::kRead); EXPECT_EQ(r->FriendlyName(Symbols()), "ptr"); } TEST_F(PointerTest, Clone) { - auto* a = create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); type::Manager mgr; type::CloneContext ctx{{nullptr}, {nullptr, &mgr}}; auto* ptr = a->Clone(ctx); EXPECT_TRUE(ptr->StoreType()->Is()); - EXPECT_EQ(ptr->AddressSpace(), ast::AddressSpace::kStorage); + EXPECT_EQ(ptr->AddressSpace(), AddressSpace::kStorage); EXPECT_EQ(ptr->Access(), ast::Access::kReadWrite); } diff --git a/src/tint/type/reference.cc b/src/tint/type/reference.cc index 36915fccfe..8735303739 100644 --- a/src/tint/type/reference.cc +++ b/src/tint/type/reference.cc @@ -21,7 +21,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::type::Reference); namespace tint::type { -Reference::Reference(const Type* subtype, ast::AddressSpace address_space, ast::Access access) +Reference::Reference(const Type* subtype, type::AddressSpace address_space, ast::Access access) : Base(utils::Hash(TypeInfo::Of().full_hashcode, address_space, subtype, access), type::Flags{}), subtype_(subtype), @@ -42,7 +42,7 @@ bool Reference::Equals(const UniqueNode& other) const { std::string Reference::FriendlyName(const SymbolTable& symbols) const { std::ostringstream out; out << "ref<"; - if (address_space_ != ast::AddressSpace::kNone) { + if (address_space_ != AddressSpace::kNone) { out << address_space_ << ", "; } out << subtype_->FriendlyName(symbols) << ", " << access_; diff --git a/src/tint/type/reference.h b/src/tint/type/reference.h index d4235c18b9..1bb1b86943 100644 --- a/src/tint/type/reference.h +++ b/src/tint/type/reference.h @@ -18,7 +18,7 @@ #include #include "src/tint/ast/access.h" -#include "src/tint/ast/address_space.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/type.h" namespace tint::type { @@ -30,7 +30,7 @@ class Reference final : public Castable { /// @param subtype the pointee type /// @param address_space the address space of the reference /// @param access the resolved access control of the reference - Reference(const Type* subtype, ast::AddressSpace address_space, ast::Access access); + Reference(const Type* subtype, type::AddressSpace address_space, ast::Access access); /// Destructor ~Reference() override; @@ -43,7 +43,7 @@ class Reference final : public Castable { const Type* StoreType() const { return subtype_; } /// @returns the address space of the reference - ast::AddressSpace AddressSpace() const { return address_space_; } + type::AddressSpace AddressSpace() const { return address_space_; } /// @returns the resolved access control of the reference. ast::Access Access() const { return access_; } @@ -59,7 +59,7 @@ class Reference final : public Castable { private: Type const* const subtype_; - ast::AddressSpace const address_space_; + type::AddressSpace const address_space_; ast::Access const access_; }; diff --git a/src/tint/type/reference_test.cc b/src/tint/type/reference_test.cc index 93e42ad217..2a2fab0923 100644 --- a/src/tint/type/reference_test.cc +++ b/src/tint/type/reference_test.cc @@ -21,18 +21,14 @@ namespace { using ReferenceTest = TestHelper; TEST_F(ReferenceTest, Creation) { - auto* a = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* b = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* c = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* d = - create(create(), ast::AddressSpace::kPrivate, ast::Access::kReadWrite); - auto* e = create(create(), ast::AddressSpace::kStorage, ast::Access::kRead); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* b = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* c = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* d = create(create(), AddressSpace::kPrivate, ast::Access::kReadWrite); + auto* e = create(create(), AddressSpace::kStorage, ast::Access::kRead); EXPECT_TRUE(a->StoreType()->Is()); - EXPECT_EQ(a->AddressSpace(), ast::AddressSpace::kStorage); + EXPECT_EQ(a->AddressSpace(), AddressSpace::kStorage); EXPECT_EQ(a->Access(), ast::Access::kReadWrite); EXPECT_EQ(a, b); @@ -42,24 +38,18 @@ TEST_F(ReferenceTest, Creation) { } TEST_F(ReferenceTest, Hash) { - auto* a = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* b = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* b = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); EXPECT_EQ(a->unique_hash, b->unique_hash); } TEST_F(ReferenceTest, Equals) { - auto* a = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* b = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* c = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); - auto* d = - create(create(), ast::AddressSpace::kPrivate, ast::Access::kReadWrite); - auto* e = create(create(), ast::AddressSpace::kStorage, ast::Access::kRead); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* b = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* c = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); + auto* d = create(create(), AddressSpace::kPrivate, ast::Access::kReadWrite); + auto* e = create(create(), AddressSpace::kStorage, ast::Access::kRead); EXPECT_TRUE(a->Equals(*b)); EXPECT_FALSE(a->Equals(*c)); @@ -69,25 +59,24 @@ TEST_F(ReferenceTest, Equals) { } TEST_F(ReferenceTest, FriendlyName) { - auto* r = create(create(), ast::AddressSpace::kNone, ast::Access::kRead); + auto* r = create(create(), AddressSpace::kNone, ast::Access::kRead); EXPECT_EQ(r->FriendlyName(Symbols()), "ref"); } TEST_F(ReferenceTest, FriendlyNameWithAddressSpace) { - auto* r = create(create(), ast::AddressSpace::kWorkgroup, ast::Access::kRead); + auto* r = create(create(), AddressSpace::kWorkgroup, ast::Access::kRead); EXPECT_EQ(r->FriendlyName(Symbols()), "ref"); } TEST_F(ReferenceTest, Clone) { - auto* a = - create(create(), ast::AddressSpace::kStorage, ast::Access::kReadWrite); + auto* a = create(create(), AddressSpace::kStorage, ast::Access::kReadWrite); type::Manager mgr; type::CloneContext ctx{{nullptr}, {nullptr, &mgr}}; auto* ref = a->Clone(ctx); EXPECT_TRUE(ref->StoreType()->Is()); - EXPECT_EQ(ref->AddressSpace(), ast::AddressSpace::kStorage); + EXPECT_EQ(ref->AddressSpace(), AddressSpace::kStorage); EXPECT_EQ(ref->Access(), ast::Access::kReadWrite); } diff --git a/src/tint/type/struct.h b/src/tint/type/struct.h index cd545e5798..e80dcc1ea9 100644 --- a/src/tint/type/struct.h +++ b/src/tint/type/struct.h @@ -21,8 +21,8 @@ #include #include -#include "src/tint/ast/address_space.h" #include "src/tint/symbol.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/node.h" #include "src/tint/type/type.h" #include "src/tint/utils/vector.h" @@ -100,22 +100,22 @@ class Struct : public Castable { /// Adds the AddressSpace usage to the structure. /// @param usage the storage usage - void AddUsage(ast::AddressSpace usage) { address_space_usage_.emplace(usage); } + void AddUsage(AddressSpace usage) { address_space_usage_.emplace(usage); } /// @returns the set of address space uses of this structure - const std::unordered_set& AddressSpaceUsage() const { + const std::unordered_set& AddressSpaceUsage() const { return address_space_usage_; } - /// @param usage the ast::AddressSpace usage type to query + /// @param usage the AddressSpace usage type to query /// @returns true iff this structure has been used as the given address space - bool UsedAs(ast::AddressSpace usage) const { return address_space_usage_.count(usage) > 0; } + bool UsedAs(AddressSpace usage) const { return address_space_usage_.count(usage) > 0; } /// @returns true iff this structure has been used by address space that's /// host-shareable. bool IsHostShareable() const { for (auto sc : address_space_usage_) { - if (ast::IsHostShareable(sc)) { + if (type::IsHostShareable(sc)) { return true; } } @@ -160,7 +160,7 @@ class Struct : public Castable { const uint32_t align_; const uint32_t size_; const uint32_t size_no_padding_; - std::unordered_set address_space_usage_; + std::unordered_set address_space_usage_; std::unordered_set pipeline_stage_uses_; utils::Vector concrete_types_; }; diff --git a/src/tint/type/texture.h b/src/tint/type/texture.h index 3205fd140d..4fab761e9c 100644 --- a/src/tint/type/texture.h +++ b/src/tint/type/texture.h @@ -15,7 +15,6 @@ #ifndef SRC_TINT_TYPE_TEXTURE_H_ #define SRC_TINT_TYPE_TEXTURE_H_ -#include "src/tint/ast/texture.h" #include "src/tint/type/texture_dimension.h" #include "src/tint/type/type.h" diff --git a/src/tint/type/type_test.cc b/src/tint/type/type_test.cc index 48b44dd7c0..8c7e8e052a 100644 --- a/src/tint/type/type_test.cc +++ b/src/tint/type/type_test.cc @@ -44,7 +44,7 @@ struct TypeTest : public TestHelper { const Matrix* mat4x3_f16 = create(vec3_f16, 4u); const Matrix* mat4x3_af = create(vec3_af, 4u); const Reference* ref_u32 = - create(u32, ast::AddressSpace::kPrivate, ast::Access::kReadWrite); + create(u32, AddressSpace::kPrivate, ast::Access::kReadWrite); const Struct* str_f32 = create(Source{}, Sym("str_f32"), utils::Vector{ diff --git a/src/tint/writer/append_vector.cc b/src/tint/writer/append_vector.cc index 45030417f6..658a6d2ebf 100644 --- a/src/tint/writer/append_vector.cc +++ b/src/tint/writer/append_vector.cc @@ -137,7 +137,7 @@ const sem::Call* AppendVector(ProgramBuilder* b, auto* scalar_cast_target = b->create( packed_el_sem_ty, b->create(nullptr, 0u, scalar_sem->Type()->UnwrapRef(), - ast::AddressSpace::kNone, ast::Access::kUndefined), + type::AddressSpace::kNone, ast::Access::kUndefined), sem::EvaluationStage::kRuntime); auto* scalar_cast_sem = b->create( scalar_cast_ast, scalar_cast_target, sem::EvaluationStage::kRuntime, @@ -158,7 +158,7 @@ const sem::Call* AppendVector(ProgramBuilder* b, [&](const tint::sem::Expression* arg, size_t i) -> const sem::Parameter* { return b->create( nullptr, static_cast(i), arg->Type()->UnwrapRef(), - ast::AddressSpace::kNone, ast::Access::kUndefined); + type::AddressSpace::kNone, ast::Access::kUndefined); }), sem::EvaluationStage::kRuntime); auto* initializer_sem = diff --git a/src/tint/writer/append_vector_test.cc b/src/tint/writer/append_vector_test.cc index e13ed3d320..c030db4cb3 100644 --- a/src/tint/writer/append_vector_test.cc +++ b/src/tint/writer/append_vector_test.cc @@ -250,7 +250,7 @@ TEST_F(AppendVectorTest, Vec3i32_i32) { // AppendVector(vec_12, 3) -> vec3(vec_12, 3) TEST_F(AppendVectorTest, Vec2i32Var_i32) { - GlobalVar("vec_12", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("vec_12", ty.vec2(), type::AddressSpace::kPrivate); auto* vec_12 = Expr("vec_12"); auto* scalar_3 = Expr(3_i); WrapInFunction(vec_12, scalar_3); @@ -286,7 +286,7 @@ TEST_F(AppendVectorTest, Vec2i32Var_i32) { // AppendVector(1, 2, scalar_3) -> vec3(1, 2, scalar_3) TEST_F(AppendVectorTest, Vec2i32_i32Var) { - GlobalVar("scalar_3", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("scalar_3", ty.i32(), type::AddressSpace::kPrivate); auto* scalar_1 = Expr(1_i); auto* scalar_2 = Expr(2_i); auto* scalar_3 = Expr("scalar_3"); @@ -327,8 +327,8 @@ TEST_F(AppendVectorTest, Vec2i32_i32Var) { // AppendVector(vec_12, scalar_3) -> vec3(vec_12, scalar_3) TEST_F(AppendVectorTest, Vec2i32Var_i32Var) { - GlobalVar("vec_12", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("scalar_3", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("vec_12", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("scalar_3", ty.i32(), type::AddressSpace::kPrivate); auto* vec_12 = Expr("vec_12"); auto* scalar_3 = Expr("scalar_3"); WrapInFunction(vec_12, scalar_3); @@ -364,8 +364,8 @@ TEST_F(AppendVectorTest, Vec2i32Var_i32Var) { // AppendVector(vec_12, scalar_3) -> vec3(vec_12, i32(scalar_3)) TEST_F(AppendVectorTest, Vec2i32Var_f32Var) { - GlobalVar("vec_12", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("scalar_3", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("vec_12", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("scalar_3", ty.f32(), type::AddressSpace::kPrivate); auto* vec_12 = Expr("vec_12"); auto* scalar_3 = Expr("scalar_3"); WrapInFunction(vec_12, scalar_3); @@ -405,8 +405,8 @@ TEST_F(AppendVectorTest, Vec2i32Var_f32Var) { // AppendVector(vec_12, scalar_3) -> vec3(vec_12, scalar_3) TEST_F(AppendVectorTest, Vec2boolVar_boolVar) { - GlobalVar("vec_12", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("scalar_3", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("vec_12", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("scalar_3", ty.bool_(), type::AddressSpace::kPrivate); auto* vec_12 = Expr("vec_12"); auto* scalar_3 = Expr("scalar_3"); WrapInFunction(vec_12, scalar_3); diff --git a/src/tint/writer/flatten_bindings_test.cc b/src/tint/writer/flatten_bindings_test.cc index ed929c54d5..7c67c47d59 100644 --- a/src/tint/writer/flatten_bindings_test.cc +++ b/src/tint/writer/flatten_bindings_test.cc @@ -39,9 +39,9 @@ TEST_F(FlattenBindingsTest, NoBindings) { TEST_F(FlattenBindingsTest, AlreadyFlat) { ProgramBuilder b; - b.GlobalVar("a", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); - b.GlobalVar("b", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(1_a)); - b.GlobalVar("c", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(2_a)); + b.GlobalVar("a", b.ty.i32(), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); + b.GlobalVar("b", b.ty.i32(), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(1_a)); + b.GlobalVar("c", b.ty.i32(), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(2_a)); Program program(std::move(b)); ASSERT_TRUE(program.IsValid()) << program.Diagnostics().str(); @@ -52,9 +52,9 @@ TEST_F(FlattenBindingsTest, AlreadyFlat) { TEST_F(FlattenBindingsTest, NotFlat_SingleNamespace) { ProgramBuilder b; - b.GlobalVar("a", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); - b.GlobalVar("b", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(1_a), b.Binding(1_a)); - b.GlobalVar("c", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(2_a), b.Binding(2_a)); + b.GlobalVar("a", b.ty.i32(), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); + b.GlobalVar("b", b.ty.i32(), type::AddressSpace::kUniform, b.Group(1_a), b.Binding(1_a)); + b.GlobalVar("c", b.ty.i32(), type::AddressSpace::kUniform, b.Group(2_a), b.Binding(2_a)); b.WrapInFunction(b.Expr("a"), b.Expr("b"), b.Expr("c")); Program program(std::move(b)); @@ -85,9 +85,9 @@ TEST_F(FlattenBindingsTest, NotFlat_MultipleNamespaces) { ProgramBuilder b; const size_t num_buffers = 3; - b.GlobalVar("buffer1", b.ty.i32(), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); - b.GlobalVar("buffer2", b.ty.i32(), ast::AddressSpace::kStorage, b.Group(1_a), b.Binding(1_a)); - b.GlobalVar("buffer3", b.ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead, + b.GlobalVar("buffer1", b.ty.i32(), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a)); + b.GlobalVar("buffer2", b.ty.i32(), type::AddressSpace::kStorage, b.Group(1_a), b.Binding(1_a)); + b.GlobalVar("buffer3", b.ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead, b.Group(2_a), b.Binding(2_a)); const size_t num_samplers = 2; diff --git a/src/tint/writer/generate_external_texture_bindings_test.cc b/src/tint/writer/generate_external_texture_bindings_test.cc index 4fc1934a91..e4415172c6 100644 --- a/src/tint/writer/generate_external_texture_bindings_test.cc +++ b/src/tint/writer/generate_external_texture_bindings_test.cc @@ -23,7 +23,7 @@ namespace { using namespace tint::number_suffixes; // NOLINT -constexpr auto kUniform = ast::AddressSpace::kUniform; +constexpr auto kUniform = type::AddressSpace::kUniform; class GenerateExternalTextureBindingsTest : public ::testing::Test {}; diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc index 2bd041d8f4..c3872f0dab 100644 --- a/src/tint/writer/glsl/generator_impl.cc +++ b/src/tint/writer/glsl/generator_impl.cc @@ -374,7 +374,7 @@ bool GeneratorImpl::EmitBitcast(std::ostream& out, const ast::BitcastExpression* dst_type->is_float_scalar_or_vector()) { out << "uintBitsToFloat"; } else { - if (!EmitType(out, dst_type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, dst_type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } } @@ -437,12 +437,12 @@ bool GeneratorImpl::EmitBitwiseBoolOp(std::ostream& out, const ast::BinaryExpres auto* uint_type = BoolTypeToUint(bool_type); // Cast result to bool scalar or vector type. - if (!EmitType(out, bool_type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, bool_type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen outerCastParen(out); // Cast LHS to uint scalar or vector type. - if (!EmitType(out, uint_type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, uint_type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } { @@ -462,7 +462,7 @@ bool GeneratorImpl::EmitBitwiseBoolOp(std::ostream& out, const ast::BinaryExpres return false; } // Cast RHS to uint scalar or vector type. - if (!EmitType(out, uint_type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, uint_type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } { @@ -489,20 +489,20 @@ bool GeneratorImpl::EmitFloatModulo(std::ostream& out, const ast::BinaryExpressi std::vector parameter_names; { auto decl = line(&b); - if (!EmitTypeAndName(decl, ret_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, ret_ty, type::AddressSpace::kNone, ast::Access::kUndefined, fn_name)) { return ""; } { ScopedParen sp(decl); const auto* ty = TypeOf(expr->lhs)->UnwrapRef(); - if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, ty, type::AddressSpace::kNone, ast::Access::kUndefined, "lhs")) { return ""; } decl << ", "; ty = TypeOf(expr->rhs)->UnwrapRef(); - if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, ty, type::AddressSpace::kNone, ast::Access::kUndefined, "rhs")) { return ""; } @@ -828,7 +828,7 @@ bool GeneratorImpl::EmitBuiltinCall(std::ostream& out, bool GeneratorImpl::EmitTypeConversion(std::ostream& out, const sem::Call* call, const sem::TypeConversion* conv) { - if (!EmitType(out, conv->Target(), ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, conv->Target(), type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen sp(out); @@ -851,7 +851,7 @@ bool GeneratorImpl::EmitTypeInitializer(std::ostream& out, return EmitZeroValue(out, type); } - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen sp(out); @@ -921,7 +921,7 @@ bool GeneratorImpl::EmitWorkgroupAtomicCall(std::ostream& out, { auto pre = line(); - if (!EmitTypeAndName(pre, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitTypeAndName(pre, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, result)) { return false; } @@ -1059,8 +1059,8 @@ bool GeneratorImpl::EmitEmulatedFMA(std::ostream& out, const ast::CallExpression bool GeneratorImpl::EmitCountOneBitsCall(std::ostream& out, const ast::CallExpression* expr) { // GLSL's bitCount returns an integer type, so cast it to the appropriate // unsigned type. - if (!EmitType(out, TypeOf(expr)->UnwrapRef(), ast::AddressSpace::kNone, ast::Access::kReadWrite, - "")) { + if (!EmitType(out, TypeOf(expr)->UnwrapRef(), type::AddressSpace::kNone, + ast::Access::kReadWrite, "")) { return false; } out << "(bitCount("; @@ -1131,7 +1131,7 @@ bool GeneratorImpl::EmitDotCall(std::ostream& out, std::string v; { std::stringstream s; - if (!EmitType(s, vec_ty->type(), ast::AddressSpace::kNone, ast::Access::kRead, + if (!EmitType(s, vec_ty->type(), type::AddressSpace::kNone, ast::Access::kRead, "")) { return ""; } @@ -1139,16 +1139,16 @@ bool GeneratorImpl::EmitDotCall(std::ostream& out, } { // (u)int tint_int_dot([i|u]vecN a, [i|u]vecN b) { auto l = line(&b); - if (!EmitType(l, vec_ty->type(), ast::AddressSpace::kNone, ast::Access::kRead, + if (!EmitType(l, vec_ty->type(), type::AddressSpace::kNone, ast::Access::kRead, "")) { return ""; } l << " " << fn_name << "("; - if (!EmitType(l, vec_ty, ast::AddressSpace::kNone, ast::Access::kRead, "")) { + if (!EmitType(l, vec_ty, type::AddressSpace::kNone, ast::Access::kRead, "")) { return ""; } l << " a, "; - if (!EmitType(l, vec_ty, ast::AddressSpace::kNone, ast::Access::kRead, "")) { + if (!EmitType(l, vec_ty, type::AddressSpace::kNone, ast::Access::kRead, "")) { return ""; } l << " b) {"; @@ -1199,7 +1199,7 @@ bool GeneratorImpl::EmitModfCall(std::ostream& out, { auto l = line(b); - if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -1225,7 +1225,7 @@ bool GeneratorImpl::EmitFrexpCall(std::ostream& out, { auto l = line(b); - if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -1883,7 +1883,7 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) { { auto out = line(); auto name = builder_.Symbols().NameFor(func->symbol); - if (!EmitType(out, sem->ReturnType(), ast::AddressSpace::kNone, ast::Access::kReadWrite, + if (!EmitType(out, sem->ReturnType(), type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } @@ -1939,20 +1939,20 @@ bool GeneratorImpl::EmitGlobalVariable(const ast::Variable* global) { [&](const ast::Var* var) { auto* sem = builder_.Sem().Get(global); switch (sem->AddressSpace()) { - case ast::AddressSpace::kUniform: + case type::AddressSpace::kUniform: return EmitUniformVariable(var, sem); - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: return EmitStorageVariable(var, sem); - case ast::AddressSpace::kHandle: + case type::AddressSpace::kHandle: return EmitHandleVariable(var, sem); - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: return EmitPrivateVariable(sem); - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: return EmitWorkgroupVariable(sem); - case ast::AddressSpace::kIn: - case ast::AddressSpace::kOut: + case type::AddressSpace::kIn: + case type::AddressSpace::kOut: return EmitIOVariable(sem); - case ast::AddressSpace::kPushConstant: + case type::AddressSpace::kPushConstant: diagnostics_.add_error( diag::System::Writer, "unhandled address space " + utils::ToString(sem->AddressSpace())); @@ -2337,7 +2337,7 @@ bool GeneratorImpl::EmitConstant(std::ostream& out, const constant::Value* const return true; }, [&](const type::Vector* v) { - if (!EmitType(out, v, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, v, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -2358,7 +2358,7 @@ bool GeneratorImpl::EmitConstant(std::ostream& out, const constant::Value* const return true; }, [&](const type::Matrix* m) { - if (!EmitType(out, m, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, m, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -2375,7 +2375,7 @@ bool GeneratorImpl::EmitConstant(std::ostream& out, const constant::Value* const return true; }, [&](const type::Array* a) { - if (!EmitType(out, a, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, a, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -2467,7 +2467,7 @@ bool GeneratorImpl::EmitZeroValue(std::ostream& out, const type::Type* type) { } else if (type->Is()) { out << "0u"; } else if (auto* vec = type->As()) { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen sp(out); @@ -2480,7 +2480,7 @@ bool GeneratorImpl::EmitZeroValue(std::ostream& out, const type::Type* type) { } } } else if (auto* mat = type->As()) { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen sp(out); @@ -2493,7 +2493,7 @@ bool GeneratorImpl::EmitZeroValue(std::ostream& out, const type::Type* type) { } } } else if (auto* str = type->As()) { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } bool first = true; @@ -2507,7 +2507,7 @@ bool GeneratorImpl::EmitZeroValue(std::ostream& out, const type::Type* type) { EmitZeroValue(out, member->Type()); } } else if (auto* arr = type->As()) { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } ScopedParen sp(out); @@ -2832,7 +2832,7 @@ bool GeneratorImpl::EmitSwitch(const ast::SwitchStatement* stmt) { bool GeneratorImpl::EmitType(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name, bool* name_printed /* = nullptr */) { @@ -2840,16 +2840,16 @@ bool GeneratorImpl::EmitType(std::ostream& out, *name_printed = false; } switch (address_space) { - case ast::AddressSpace::kIn: { + case type::AddressSpace::kIn: { out << "in "; break; } - case ast::AddressSpace::kOut: { + case type::AddressSpace::kOut: { out << "out "; break; } - case ast::AddressSpace::kUniform: - case ast::AddressSpace::kHandle: { + case type::AddressSpace::kUniform: + case type::AddressSpace::kHandle: { out << "uniform "; break; } @@ -3013,7 +3013,7 @@ bool GeneratorImpl::EmitType(std::ostream& out, bool GeneratorImpl::EmitTypeAndName(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name) { bool printed_name = false; @@ -3050,7 +3050,7 @@ bool GeneratorImpl::EmitStructMembers(TextBuffer* b, const sem::Struct* str) { auto out = line(b); - if (!EmitTypeAndName(out, ty, ast::AddressSpace::kNone, ast::Access::kReadWrite, name)) { + if (!EmitTypeAndName(out, ty, type::AddressSpace::kNone, ast::Access::kReadWrite, name)) { return false; } out << ";"; @@ -3118,7 +3118,7 @@ bool GeneratorImpl::EmitLet(const ast::Let* let) { auto out = line(); // TODO(senorblanco): handle const - if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, + if (!EmitTypeAndName(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, builder_.Symbols().NameFor(let->symbol))) { return false; } @@ -3140,7 +3140,7 @@ bool GeneratorImpl::EmitProgramConstVariable(const ast::Variable* var) { auto out = line(); out << "const "; - if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, + if (!EmitTypeAndName(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, builder_.Symbols().NameFor(var->symbol))) { return false; } @@ -3167,7 +3167,7 @@ bool GeneratorImpl::CallBuiltinHelper(std::ostream& out, std::vector parameter_names; { auto decl = line(&b); - if (!EmitTypeAndName(decl, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, fn_name)) { return ""; } @@ -3183,7 +3183,7 @@ bool GeneratorImpl::CallBuiltinHelper(std::ostream& out, decl << "inout "; ty = ptr->StoreType(); } - if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, ty, type::AddressSpace::kNone, ast::Access::kUndefined, param_name)) { return ""; } diff --git a/src/tint/writer/glsl/generator_impl.h b/src/tint/writer/glsl/generator_impl.h index 35043e9aba..d38f845a37 100644 --- a/src/tint/writer/glsl/generator_impl.h +++ b/src/tint/writer/glsl/generator_impl.h @@ -413,7 +413,7 @@ class GeneratorImpl : public TextGenerator { /// @returns true if the type is emitted bool EmitType(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name, bool* name_printed = nullptr); @@ -426,7 +426,7 @@ class GeneratorImpl : public TextGenerator { /// @returns true if the type is emitted bool EmitTypeAndName(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name); /// Handles generating a structure declaration. If the structure has already been emitted, then diff --git a/src/tint/writer/glsl/generator_impl_array_accessor_test.cc b/src/tint/writer/glsl/generator_impl_array_accessor_test.cc index bed3dcff04..cee4506c32 100644 --- a/src/tint/writer/glsl/generator_impl_array_accessor_test.cc +++ b/src/tint/writer/glsl/generator_impl_array_accessor_test.cc @@ -22,7 +22,7 @@ namespace { using GlslGeneratorImplTest_Expression = TestHelper; TEST_F(GlslGeneratorImplTest_Expression, IndexAccessor) { - GlobalVar("ary", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("ary", ty.array(), type::AddressSpace::kPrivate); auto* expr = IndexAccessor("ary", 5_i); WrapInFunction(expr); diff --git a/src/tint/writer/glsl/generator_impl_assign_test.cc b/src/tint/writer/glsl/generator_impl_assign_test.cc index 98eae33a47..73d950cb62 100644 --- a/src/tint/writer/glsl/generator_impl_assign_test.cc +++ b/src/tint/writer/glsl/generator_impl_assign_test.cc @@ -20,8 +20,8 @@ namespace { using GlslGeneratorImplTest_Assign = TestHelper; TEST_F(GlslGeneratorImplTest_Assign, Emit_Assign) { - GlobalVar("lhs", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.i32(), type::AddressSpace::kPrivate); auto* assign = Assign("lhs", "rhs"); WrapInFunction(assign); diff --git a/src/tint/writer/glsl/generator_impl_binary_test.cc b/src/tint/writer/glsl/generator_impl_binary_test.cc index b5e391cd18..884cba0d63 100644 --- a/src/tint/writer/glsl/generator_impl_binary_test.cc +++ b/src/tint/writer/glsl/generator_impl_binary_test.cc @@ -43,8 +43,8 @@ TEST_P(GlslBinaryTest, Emit_f32) { return; } - GlobalVar("left", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.f32(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -71,8 +71,8 @@ TEST_P(GlslBinaryTest, Emit_f16) { Enable(ast::Extension::kF16); - GlobalVar("left", ty.f16(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.f16(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.f16(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.f16(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -90,8 +90,8 @@ TEST_P(GlslBinaryTest, Emit_f16) { TEST_P(GlslBinaryTest, Emit_u32) { auto params = GetParam(); - GlobalVar("left", ty.u32(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.u32(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.u32(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -114,8 +114,8 @@ TEST_P(GlslBinaryTest, Emit_i32) { return; } - GlobalVar("left", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.i32(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -151,7 +151,7 @@ INSTANTIATE_TEST_SUITE_P( BinaryData{"(left % right)", ast::BinaryOp::kModulo})); TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar_f32) { - GlobalVar("a", vec3(1_f, 1_f, 1_f), ast::AddressSpace::kPrivate); + GlobalVar("a", vec3(1_f, 1_f, 1_f), type::AddressSpace::kPrivate); auto* lhs = Expr("a"); auto* rhs = Expr(1_f); @@ -169,7 +169,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar_f16) { Enable(ast::Extension::kF16); - GlobalVar("a", vec3(1_h, 1_h, 1_h), ast::AddressSpace::kPrivate); + GlobalVar("a", vec3(1_h, 1_h, 1_h), type::AddressSpace::kPrivate); auto* lhs = Expr("a"); auto* rhs = Expr(1_h); @@ -185,7 +185,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar_f16) { } TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector_f32) { - GlobalVar("a", vec3(1_f, 1_f, 1_f), ast::AddressSpace::kPrivate); + GlobalVar("a", vec3(1_f, 1_f, 1_f), type::AddressSpace::kPrivate); auto* lhs = Expr(1_f); auto* rhs = Expr("a"); @@ -203,7 +203,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector_f16) { Enable(ast::Extension::kF16); - GlobalVar("a", vec3(1_h, 1_h, 1_h), ast::AddressSpace::kPrivate); + GlobalVar("a", vec3(1_h, 1_h, 1_h), type::AddressSpace::kPrivate); auto* lhs = Expr(1_h); auto* rhs = Expr("a"); @@ -219,7 +219,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector_f16) { } TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = Expr(1_f); @@ -236,7 +236,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = Expr(1_h); @@ -251,7 +251,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f16) { } TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr(1_f); auto* rhs = Expr("mat"); @@ -268,7 +268,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr(1_h); auto* rhs = Expr("mat"); @@ -283,7 +283,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f16) { } TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = vec3(1_f, 1_f, 1_f); @@ -300,7 +300,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = vec3(1_h, 1_h, 1_h); @@ -315,7 +315,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector_f16) { } TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = vec3(1_f, 1_f, 1_f); auto* rhs = Expr("mat"); @@ -332,7 +332,7 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = vec3(1_h, 1_h, 1_h); auto* rhs = Expr("mat"); @@ -347,8 +347,8 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f16) { } TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f32) { - GlobalVar("lhs", ty.mat3x3(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.mat3x3(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -363,8 +363,8 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f32) { TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f16) { Enable(ast::Extension::kF16); - GlobalVar("lhs", ty.mat3x3(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.mat3x3(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -377,8 +377,8 @@ TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f16) { } TEST_F(GlslGeneratorImplTest_Binary, ModF32) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -393,8 +393,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModF32) { TEST_F(GlslGeneratorImplTest_Binary, ModF16) { Enable(ast::Extension::kF16); - GlobalVar("a", ty.f16(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f16(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f16(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -407,8 +407,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModF16) { } TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32) { - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -423,8 +423,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32) { TEST_F(GlslGeneratorImplTest_Binary, ModVec3F16) { Enable(ast::Extension::kF16); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -437,8 +437,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModVec3F16) { } TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32ScalarF32) { - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -453,8 +453,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32ScalarF32) { TEST_F(GlslGeneratorImplTest_Binary, ModVec3F16ScalarF16) { Enable(ast::Extension::kF16); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f16(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f16(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -467,8 +467,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModVec3F16ScalarF16) { } TEST_F(GlslGeneratorImplTest_Binary, ModScalarF32Vec3F32) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -483,8 +483,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModScalarF32Vec3F32) { TEST_F(GlslGeneratorImplTest_Binary, ModScalarF16Vec3F16) { Enable(ast::Extension::kF16); - GlobalVar("a", ty.f16(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kModulo, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -497,8 +497,8 @@ TEST_F(GlslGeneratorImplTest_Binary, ModScalarF16Vec3F16) { } TEST_F(GlslGeneratorImplTest_Binary, ModMixedVec3ScalarF32) { - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate); auto* expr_vec_mod_vec = create(ast::BinaryOp::kModulo, Expr("a"), Expr("a")); @@ -541,8 +541,8 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Binary, ModMixedVec3ScalarF16) { Enable(ast::Extension::kF16); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f16(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f16(), type::AddressSpace::kPrivate); auto* expr_vec_mod_vec = create(ast::BinaryOp::kModulo, Expr("a"), Expr("a")); @@ -584,8 +584,8 @@ void test_function() { } TEST_F(GlslGeneratorImplTest_Binary, Logical_And) { - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -604,10 +604,10 @@ if (tint_tmp) { TEST_F(GlslGeneratorImplTest_Binary, Logical_Multi) { // (a && b) || (c || d) - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = create( ast::BinaryOp::kLogicalOr, @@ -636,8 +636,8 @@ if (!tint_tmp) { } TEST_F(GlslGeneratorImplTest_Binary, Logical_Or) { - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kLogicalOr, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -663,9 +663,9 @@ TEST_F(GlslGeneratorImplTest_Binary, If_WithLogical) { // return 3i; // } - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = If(create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")), @@ -700,9 +700,9 @@ if ((tint_tmp)) { TEST_F(GlslGeneratorImplTest_Binary, Return_WithLogical) { // return (a && b) || c; - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = Return(create( ast::BinaryOp::kLogicalOr, @@ -728,10 +728,10 @@ return (tint_tmp); TEST_F(GlslGeneratorImplTest_Binary, Assign_WithLogical) { // a = (b || c) && d; - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = Assign(Expr("a"), @@ -759,9 +759,9 @@ a = (tint_tmp); TEST_F(GlslGeneratorImplTest_Binary, Decl_WithLogical) { // var a : bool = (b && c) || d; - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); auto* var = Var("a", ty.bool_(), @@ -798,10 +798,10 @@ TEST_F(GlslGeneratorImplTest_Binary, Call_WithLogical) { Param(Sym(), ty.bool_()), }, ty.void_(), utils::Empty, utils::Empty); - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); utils::Vector params{ create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")), diff --git a/src/tint/writer/glsl/generator_impl_builtin_test.cc b/src/tint/writer/glsl/generator_impl_builtin_test.cc index d4b7053b18..be9788b34b 100644 --- a/src/tint/writer/glsl/generator_impl_builtin_test.cc +++ b/src/tint/writer/glsl/generator_impl_builtin_test.cc @@ -198,19 +198,19 @@ TEST_P(GlslBuiltinTest, Emit) { if (param.type == CallParamType::kF16) { Enable(ast::Extension::kF16); - GlobalVar("h2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("h3", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("hm2x2", ty.mat2x2(), ast::AddressSpace::kPrivate); - GlobalVar("hm3x2", ty.mat3x2(), ast::AddressSpace::kPrivate); + GlobalVar("h2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("h3", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("hm2x2", ty.mat2x2(), type::AddressSpace::kPrivate); + GlobalVar("hm3x2", ty.mat3x2(), type::AddressSpace::kPrivate); } - GlobalVar("f2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("f3", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("u2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("i2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("b2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("m2x2", ty.mat2x2(), ast::AddressSpace::kPrivate); - GlobalVar("m3x2", ty.mat3x2(), ast::AddressSpace::kPrivate); + GlobalVar("f2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("f3", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("u2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("i2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("b2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("m2x2", ty.mat2x2(), type::AddressSpace::kPrivate); + GlobalVar("m3x2", ty.mat3x2(), type::AddressSpace::kPrivate); auto* call = GenerateCall(param.builtin, param.type, this); ASSERT_NE(nullptr, call) << "Unhandled builtin"; @@ -342,8 +342,8 @@ INSTANTIATE_TEST_SUITE_P( TEST_F(GlslGeneratorImplTest_Builtin, Builtin_Call) { auto* call = Call("dot", "param1", "param2"); - GlobalVar("param1", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.vec3(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); @@ -356,8 +356,8 @@ TEST_F(GlslGeneratorImplTest_Builtin, Builtin_Call) { } TEST_F(GlslGeneratorImplTest_Builtin, Select_Scalar) { - GlobalVar("a", Expr(1_f), ast::AddressSpace::kPrivate); - GlobalVar("b", Expr(2_f), ast::AddressSpace::kPrivate); + GlobalVar("a", Expr(1_f), type::AddressSpace::kPrivate); + GlobalVar("b", Expr(2_f), type::AddressSpace::kPrivate); auto* call = Call("select", "a", "b", true); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -369,8 +369,8 @@ TEST_F(GlslGeneratorImplTest_Builtin, Select_Scalar) { } TEST_F(GlslGeneratorImplTest_Builtin, Select_Vector) { - GlobalVar("a", vec2(1_i, 2_i), ast::AddressSpace::kPrivate); - GlobalVar("b", vec2(3_i, 4_i), ast::AddressSpace::kPrivate); + GlobalVar("a", vec2(1_i, 2_i), type::AddressSpace::kPrivate); + GlobalVar("b", vec2(3_i, 4_i), type::AddressSpace::kPrivate); auto* call = Call("select", "a", "b", vec2(true, false)); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -384,9 +384,9 @@ TEST_F(GlslGeneratorImplTest_Builtin, Select_Vector) { TEST_F(GlslGeneratorImplTest_Builtin, FMA_f32) { auto* call = Call("fma", "a", "b", "c"); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.vec3(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); @@ -401,9 +401,9 @@ TEST_F(GlslGeneratorImplTest_Builtin, FMA_f32) { TEST_F(GlslGeneratorImplTest_Builtin, FMA_f16) { Enable(ast::Extension::kF16); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.vec3(), type::AddressSpace::kPrivate); auto* call = Call("fma", "a", "b", "c"); WrapInFunction(CallStmt(call)); @@ -1247,7 +1247,7 @@ void main() { TEST_F(GlslGeneratorImplTest_Builtin, Pack4x8Snorm) { auto* call = Call("pack4x8snorm", "p1"); - GlobalVar("p1", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec4(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1265,7 +1265,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Pack4x8Unorm) { auto* call = Call("pack4x8unorm", "p1"); - GlobalVar("p1", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec4(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1283,7 +1283,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Pack2x16Snorm) { auto* call = Call("pack2x16snorm", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1301,7 +1301,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Pack2x16Unorm) { auto* call = Call("pack2x16unorm", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1319,7 +1319,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Pack2x16Float) { auto* call = Call("pack2x16float", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1337,7 +1337,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Unpack4x8Snorm) { auto* call = Call("unpack4x8snorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1355,7 +1355,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Unpack4x8Unorm) { auto* call = Call("unpack4x8unorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1373,7 +1373,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Unpack2x16Snorm) { auto* call = Call("unpack2x16snorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1391,7 +1391,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Unpack2x16Unorm) { auto* call = Call("unpack2x16unorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1409,7 +1409,7 @@ void test_function() { TEST_F(GlslGeneratorImplTest_Builtin, Unpack2x16Float) { auto* call = Call("unpack2x16float", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1472,7 +1472,7 @@ void main() { } TEST_F(GlslGeneratorImplTest_Builtin, DotI32) { - GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(Call("dot", "v", "v"))); GeneratorImpl& gen = SanitizeAndBuild(); @@ -1498,7 +1498,7 @@ void main() { } TEST_F(GlslGeneratorImplTest_Builtin, DotU32) { - GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(Call("dot", "v", "v"))); GeneratorImpl& gen = SanitizeAndBuild(); @@ -1524,7 +1524,7 @@ void main() { } TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Scalar) { - GlobalVar("v", Expr(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate); WrapInFunction(Call("quantizeToF16", "v")); GeneratorImpl& gen = SanitizeAndBuild(); @@ -1551,7 +1551,7 @@ void main() { } TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Vec2) { - GlobalVar("v", vec2(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", vec2(2_f), type::AddressSpace::kPrivate); WrapInFunction(Call("quantizeToF16", "v")); GeneratorImpl& gen = SanitizeAndBuild(); @@ -1578,7 +1578,7 @@ void main() { } TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Vec3) { - GlobalVar("v", vec3(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", vec3(2_f), type::AddressSpace::kPrivate); WrapInFunction(Call("quantizeToF16", "v")); GeneratorImpl& gen = SanitizeAndBuild(); @@ -1607,7 +1607,7 @@ void main() { } TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Vec4) { - GlobalVar("v", vec4(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", vec4(2_f), type::AddressSpace::kPrivate); WrapInFunction(Call("quantizeToF16", "v")); GeneratorImpl& gen = SanitizeAndBuild(); diff --git a/src/tint/writer/glsl/generator_impl_call_test.cc b/src/tint/writer/glsl/generator_impl_call_test.cc index adf66d3cb7..4ea3790fa4 100644 --- a/src/tint/writer/glsl/generator_impl_call_test.cc +++ b/src/tint/writer/glsl/generator_impl_call_test.cc @@ -42,8 +42,8 @@ TEST_F(GlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) { Param(Sym(), ty.f32()), }, ty.f32(), utils::Vector{Return(1.23_f)}); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("my_func", "param1", "param2"); WrapInFunction(call); @@ -62,8 +62,8 @@ TEST_F(GlslGeneratorImplTest_Call, EmitStatement_Call) { Param(Sym(), ty.f32()), }, ty.void_(), utils::Empty, utils::Empty); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = CallStmt(Call("my_func", "param1", "param2")); WrapInFunction(call); diff --git a/src/tint/writer/glsl/generator_impl_function_test.cc b/src/tint/writer/glsl/generator_impl_function_test.cc index 0cb72ee607..352689bb8d 100644 --- a/src/tint/writer/glsl/generator_impl_function_test.cc +++ b/src/tint/writer/glsl/generator_impl_function_test.cc @@ -110,7 +110,7 @@ TEST_F(GlslGeneratorImplTest_Function, PtrParameter) { // fn f(foo : ptr) -> f32 { // return *foo; // } - Func("f", utils::Vector{Param("foo", ty.pointer(ast::AddressSpace::kFunction))}, ty.f32(), + Func("f", utils::Vector{Param("foo", ty.pointer(type::AddressSpace::kFunction))}, ty.f32(), utils::Vector{Return(Deref("foo"))}); GeneratorImpl& gen = SanitizeAndBuild(); @@ -352,7 +352,7 @@ tint_symbol_2 vert_main2() { TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_Uniform) { auto* ubo_ty = Structure("UBO", utils::Vector{Member("coord", ty.vec4())}); auto* ubo = - GlobalVar("ubo", ty.Of(ubo_ty), ast::AddressSpace::kUniform, Binding(0_a), Group(1_a)); + GlobalVar("ubo", ty.Of(ubo_ty), type::AddressSpace::kUniform, Binding(0_a), Group(1_a)); Func("sub_func", utils::Vector{ @@ -402,7 +402,7 @@ void frag_main() { TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_UniformStruct) { auto* s = Structure("Uniforms", utils::Vector{Member("coord", ty.vec4())}); - GlobalVar("uniforms", ty.Of(s), ast::AddressSpace::kUniform, Binding(0_a), Group(1_a)); + GlobalVar("uniforms", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(1_a)); auto* var = Var("v", ty.f32(), MemberAccessor(MemberAccessor("uniforms", "coord"), "x")); @@ -442,8 +442,8 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RW_Storage Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b")); @@ -489,7 +489,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RO_Storage Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(1_a)); auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b")); @@ -537,8 +537,8 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_WO_Storage Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); Func("frag_main", utils::Empty, ty.void_(), utils::Vector{ @@ -582,8 +582,8 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_StorageBuf Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); Func("frag_main", utils::Empty, ty.void_(), utils::Vector{ @@ -623,7 +623,7 @@ void main() { TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_Uniform) { auto* s = Structure("S", utils::Vector{Member("x", ty.f32())}); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kUniform, Binding(0_a), Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(1_a)); Func("sub_func", utils::Vector{Param("param", ty.f32())}, ty.f32(), utils::Vector{ @@ -668,8 +668,8 @@ void frag_main() { TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_StorageBuffer) { auto* s = Structure("S", utils::Vector{Member("x", ty.f32())}); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); Func("sub_func", utils::Vector{Param("param", ty.f32())}, ty.f32(), utils::Vector{ @@ -879,7 +879,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Multiple_EntryPoint_With_Same_Module auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())}); - GlobalVar("data", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), + GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), Group(0_a)); { diff --git a/src/tint/writer/glsl/generator_impl_identifier_test.cc b/src/tint/writer/glsl/generator_impl_identifier_test.cc index 76835c1153..7e528ace34 100644 --- a/src/tint/writer/glsl/generator_impl_identifier_test.cc +++ b/src/tint/writer/glsl/generator_impl_identifier_test.cc @@ -20,7 +20,7 @@ namespace { using GlslGeneratorImplTest_Identifier = TestHelper; TEST_F(GlslGeneratorImplTest_Identifier, EmitIdentifierExpression) { - GlobalVar("foo", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("foo", ty.i32(), type::AddressSpace::kPrivate); auto* i = Expr("foo"); WrapInFunction(i); diff --git a/src/tint/writer/glsl/generator_impl_if_test.cc b/src/tint/writer/glsl/generator_impl_if_test.cc index d2368aa07d..a0957e15f0 100644 --- a/src/tint/writer/glsl/generator_impl_if_test.cc +++ b/src/tint/writer/glsl/generator_impl_if_test.cc @@ -20,7 +20,7 @@ namespace { using GlslGeneratorImplTest_If = TestHelper; TEST_F(GlslGeneratorImplTest_If, Emit_If) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); auto* cond = Expr("cond"); auto* body = Block(Return()); @@ -38,8 +38,8 @@ TEST_F(GlslGeneratorImplTest_If, Emit_If) { } TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElseIf) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("else_cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_cond = Expr("else_cond"); auto* else_body = Block(Return()); @@ -65,7 +65,7 @@ TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElseIf) { } TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElse) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_body = Block(Return()); @@ -88,8 +88,8 @@ TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElse) { } TEST_F(GlslGeneratorImplTest_If, Emit_IfWithMultiple) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("else_cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_cond = Expr("else_cond"); diff --git a/src/tint/writer/glsl/generator_impl_import_test.cc b/src/tint/writer/glsl/generator_impl_import_test.cc index d21d6db7e9..54c2405833 100644 --- a/src/tint/writer/glsl/generator_impl_import_test.cc +++ b/src/tint/writer/glsl/generator_impl_import_test.cc @@ -253,7 +253,7 @@ INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import, testing::Values(GlslImportData{"clamp", "clamp"})); TEST_F(GlslGeneratorImplTest_Import, GlslImportData_Determinant) { - GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = Call("determinant", "var"); WrapInFunction(expr); diff --git a/src/tint/writer/glsl/generator_impl_loop_test.cc b/src/tint/writer/glsl/generator_impl_loop_test.cc index 53e26f6bee..79374a2aaa 100644 --- a/src/tint/writer/glsl/generator_impl_loop_test.cc +++ b/src/tint/writer/glsl/generator_impl_loop_test.cc @@ -93,8 +93,8 @@ TEST_F(GlslGeneratorImplTest_Loop, Emit_LoopWithContinuing_BreakIf) { TEST_F(GlslGeneratorImplTest_Loop, Emit_LoopNestedWithContinuing) { Func("a_statement", {}, ty.void_(), {}); - GlobalVar("lhs", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate); auto* body = Block(Break()); auto* continuing = Block(CallStmt(Call("a_statement"))); @@ -142,7 +142,7 @@ TEST_F(GlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) { // } // } - GlobalVar("rhs", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate); auto* body = Block(Decl(Var("lhs", ty.f32(), Expr(2.4_f))), // Decl(Var("other", ty.f32())), // diff --git a/src/tint/writer/glsl/generator_impl_member_accessor_test.cc b/src/tint/writer/glsl/generator_impl_member_accessor_test.cc index a90639049e..08f93ccb4e 100644 --- a/src/tint/writer/glsl/generator_impl_member_accessor_test.cc +++ b/src/tint/writer/glsl/generator_impl_member_accessor_test.cc @@ -91,7 +91,7 @@ class GlslGeneratorImplTest_MemberAccessorBase : public BASE { auto* s = b.Structure("Data", members); - b.GlobalVar("data", b.ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, + b.GlobalVar("data", b.ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(1_a), b.Binding(0_a)); } @@ -112,7 +112,7 @@ using GlslGeneratorImplTest_MemberAccessorWithParam = TEST_F(GlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) { auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())}); - GlobalVar("str", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate); auto* expr = MemberAccessor("str", "mem"); WrapInFunction(Var("expr", ty.f32(), expr)); diff --git a/src/tint/writer/glsl/generator_impl_sanitizer_test.cc b/src/tint/writer/glsl/generator_impl_sanitizer_test.cc index 6bcca219de..a6ed6f68a0 100644 --- a/src/tint/writer/glsl/generator_impl_sanitizer_test.cc +++ b/src/tint/writer/glsl/generator_impl_sanitizer_test.cc @@ -26,7 +26,7 @@ using GlslSanitizerTest = TestHelper; TEST_F(GlslSanitizerTest, Call_ArrayLength) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -66,7 +66,7 @@ TEST_F(GlslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) { Member(0, "z", ty.f32()), Member(4, "a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -105,7 +105,7 @@ void main() { TEST_F(GlslSanitizerTest, Call_ArrayLength_ViaLets) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* p = Let("p", AddressOf("b")); @@ -233,7 +233,7 @@ TEST_F(GlslSanitizerTest, InlinePtrLetsBasic) { // let p : ptr = &v; // let x : i32 = *p; auto* v = Var("v", ty.i32()); - auto* p = Let("p", ty.pointer(ast::AddressSpace::kFunction), AddressOf(v)); + auto* p = Let("p", ty.pointer(type::AddressSpace::kFunction), AddressOf(v)); auto* x = Var("x", ty.i32(), Deref(p)); Func("main", utils::Empty, ty.void_(), @@ -274,11 +274,11 @@ TEST_F(GlslSanitizerTest, InlinePtrLetsComplexChain) { // let vp : ptr> = &(*mp)[2i]; // let v : vec4 = *vp; auto* a = Var("a", ty.array(ty.mat4x4(), 4_u)); - auto* ap = Let("ap", ty.pointer(ty.array(ty.mat4x4(), 4_u), ast::AddressSpace::kFunction), + auto* ap = Let("ap", ty.pointer(ty.array(ty.mat4x4(), 4_u), type::AddressSpace::kFunction), AddressOf(a)); - auto* mp = Let("mp", ty.pointer(ty.mat4x4(), ast::AddressSpace::kFunction), + auto* mp = Let("mp", ty.pointer(ty.mat4x4(), type::AddressSpace::kFunction), AddressOf(IndexAccessor(Deref(ap), 3_i))); - auto* vp = Let("vp", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction), + auto* vp = Let("vp", ty.pointer(ty.vec4(), type::AddressSpace::kFunction), AddressOf(IndexAccessor(Deref(mp), 2_i))); auto* v = Var("v", ty.vec4(), Deref(vp)); diff --git a/src/tint/writer/glsl/generator_impl_storage_buffer_test.cc b/src/tint/writer/glsl/generator_impl_storage_buffer_test.cc index 59ae98e748..3572da48c9 100644 --- a/src/tint/writer/glsl/generator_impl_storage_buffer_test.cc +++ b/src/tint/writer/glsl/generator_impl_storage_buffer_test.cc @@ -37,7 +37,7 @@ void TestAlign(ProgramBuilder* ctx) { ctx->Member("dewey", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256_i)}), ctx->Member("louie", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256_i)}), }); - ctx->GlobalVar("nephews", ctx->ty.Of(nephews), ast::AddressSpace::kStorage, ctx->Binding(0_a), + ctx->GlobalVar("nephews", ctx->ty.Of(nephews), type::AddressSpace::kStorage, ctx->Binding(0_a), ctx->Group(0_a)); } diff --git a/src/tint/writer/glsl/generator_impl_switch_test.cc b/src/tint/writer/glsl/generator_impl_switch_test.cc index ada3c0ba55..2f90c8f8c0 100644 --- a/src/tint/writer/glsl/generator_impl_switch_test.cc +++ b/src/tint/writer/glsl/generator_impl_switch_test.cc @@ -22,7 +22,7 @@ namespace { using GlslGeneratorImplTest_Switch = TestHelper; TEST_F(GlslGeneratorImplTest_Switch, Emit_Switch) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); auto* def_body = Block(create()); auto* def = create(utils::Vector{DefaultCaseSelector()}, def_body); @@ -51,7 +51,7 @@ TEST_F(GlslGeneratorImplTest_Switch, Emit_Switch) { } TEST_F(GlslGeneratorImplTest_Switch, Emit_Switch_MixedDefault) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); auto* def_body = Block(create()); auto* def = create(utils::Vector{CaseSelector(5_i), DefaultCaseSelector()}, diff --git a/src/tint/writer/glsl/generator_impl_test.cc b/src/tint/writer/glsl/generator_impl_test.cc index c06b53ecaa..abb391faa3 100644 --- a/src/tint/writer/glsl/generator_impl_test.cc +++ b/src/tint/writer/glsl/generator_impl_test.cc @@ -62,7 +62,7 @@ TEST_F(GlslGeneratorImplTest, GenerateSampleIndexES) { Builtin(ast::BuiltinValue::kSampleIndex), Disable(ast::DisabledValidation::kIgnoreAddressSpace), }, - ast::AddressSpace::kIn); + type::AddressSpace::kIn); Func("my_func", utils::Empty, ty.i32(), utils::Vector{ Return(Expr("gl_SampleID")), @@ -87,7 +87,7 @@ TEST_F(GlslGeneratorImplTest, GenerateSampleIndexDesktop) { Builtin(ast::BuiltinValue::kSampleIndex), Disable(ast::DisabledValidation::kIgnoreAddressSpace), }, - ast::AddressSpace::kIn); + type::AddressSpace::kIn); Func("my_func", utils::Empty, ty.i32(), utils::Vector{ Return(Expr("gl_SampleID")), diff --git a/src/tint/writer/glsl/generator_impl_type_test.cc b/src/tint/writer/glsl/generator_impl_type_test.cc index fc5b0cef57..36eb31b448 100644 --- a/src/tint/writer/glsl/generator_impl_type_test.cc +++ b/src/tint/writer/glsl/generator_impl_type_test.cc @@ -34,12 +34,12 @@ using GlslGeneratorImplTest_Type = TestHelper; TEST_F(GlslGeneratorImplTest_Type, EmitType_Array) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "ary")) << gen.error(); EXPECT_EQ(out.str(), "bool ary[4]"); @@ -47,12 +47,12 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Array) { TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArray) { auto* arr = ty.array(ty.array(), 5_u); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "ary")) << gen.error(); EXPECT_EQ(out.str(), "bool ary[5][4]"); @@ -60,12 +60,12 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArray) { TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) { auto* arr = ty.array(ty.array(ty.array(), 5_u), 6_u); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "ary")) << gen.error(); EXPECT_EQ(out.str(), "bool ary[6][5][4]"); @@ -73,12 +73,12 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) { TEST_F(GlslGeneratorImplTest_Type, EmitType_Array_WithoutName) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "bool[4]"); @@ -90,7 +90,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Bool) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, bool_, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, bool_, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "bool"); } @@ -101,7 +101,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_F32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, f32, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, f32, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "float"); } @@ -114,7 +114,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_F16) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, f16, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, f16, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "float16_t"); } @@ -125,7 +125,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_I32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, i32, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, i32, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "int"); } @@ -138,7 +138,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Matrix_F32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, mat2x3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, mat2x3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "mat2x3"); } @@ -153,7 +153,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Matrix_F16) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, mat2x3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, mat2x3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "f16mat2x3"); } @@ -163,7 +163,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_StructDecl) { Member("a", ty.i32()), Member("b", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -183,13 +183,13 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Struct) { Member("a", ty.i32()), Member("b", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); auto* sem_s = program->TypeOf(s)->As(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, sem_s, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, sem_s, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "S"); } @@ -199,7 +199,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) { Member("double", ty.i32()), Member("float", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = SanitizeAndBuild(); @@ -216,7 +216,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Struct_WithOffsetAttributes) { Member("a", ty.i32(), utils::Vector{MemberOffset(0_a)}), Member("b", ty.f32(), utils::Vector{MemberOffset(8_a)}), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -237,7 +237,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_U32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, u32, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, u32, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "uint"); } @@ -249,7 +249,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Vector_F32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, vec3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, vec3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "vec3"); } @@ -263,7 +263,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Vector_F16) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, vec3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, vec3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "f16vec3"); } @@ -274,7 +274,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitType_Void) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, void_, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, void_, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "void"); } @@ -285,7 +285,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitSampler) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_FALSE(gen.EmitType(out, sampler, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_FALSE(gen.EmitType(out, sampler, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); } @@ -295,7 +295,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitSamplerComparison) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_FALSE(gen.EmitType(out, sampler, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_FALSE(gen.EmitType(out, sampler, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); } @@ -501,7 +501,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitMultisampledTexture) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, s, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, s, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "highp sampler2DMS"); } diff --git a/src/tint/writer/glsl/generator_impl_unary_op_test.cc b/src/tint/writer/glsl/generator_impl_unary_op_test.cc index ac54b4e994..c0eb7b1783 100644 --- a/src/tint/writer/glsl/generator_impl_unary_op_test.cc +++ b/src/tint/writer/glsl/generator_impl_unary_op_test.cc @@ -20,7 +20,7 @@ namespace { using GlslUnaryOpTest = TestHelper; TEST_F(GlslUnaryOpTest, AddressOf) { - GlobalVar("expr", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kAddressOf, Expr("expr")); WrapInFunction(op); @@ -32,7 +32,7 @@ TEST_F(GlslUnaryOpTest, AddressOf) { } TEST_F(GlslUnaryOpTest, Complement) { - GlobalVar("expr", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.u32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kComplement, Expr("expr")); WrapInFunction(op); @@ -44,7 +44,7 @@ TEST_F(GlslUnaryOpTest, Complement) { } TEST_F(GlslUnaryOpTest, Indirection) { - GlobalVar("G", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate); auto* p = Let("expr", create(ast::UnaryOp::kAddressOf, Expr("G"))); auto* op = create(ast::UnaryOp::kIndirection, Expr("expr")); WrapInFunction(p, op); @@ -57,7 +57,7 @@ TEST_F(GlslUnaryOpTest, Indirection) { } TEST_F(GlslUnaryOpTest, Not) { - GlobalVar("expr", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNot, Expr("expr")); WrapInFunction(op); @@ -69,7 +69,7 @@ TEST_F(GlslUnaryOpTest, Not) { } TEST_F(GlslUnaryOpTest, Negation) { - GlobalVar("expr", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNegation, Expr("expr")); WrapInFunction(op); diff --git a/src/tint/writer/glsl/generator_impl_uniform_buffer_test.cc b/src/tint/writer/glsl/generator_impl_uniform_buffer_test.cc index 35b14075c2..48f635a34f 100644 --- a/src/tint/writer/glsl/generator_impl_uniform_buffer_test.cc +++ b/src/tint/writer/glsl/generator_impl_uniform_buffer_test.cc @@ -26,7 +26,7 @@ using GlslGeneratorImplTest_UniformBuffer = TestHelper; TEST_F(GlslGeneratorImplTest_UniformBuffer, Simple) { auto* simple = Structure("Simple", utils::Vector{Member("member", ty.f32())}); - GlobalVar("simple", ty.Of(simple), ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); + GlobalVar("simple", ty.Of(simple), type::AddressSpace::kUniform, Group(0_a), Binding(0_a)); GeneratorImpl& gen = Build(); @@ -46,7 +46,7 @@ layout(binding = 0, std140) uniform Simple_ubo { TEST_F(GlslGeneratorImplTest_UniformBuffer, Simple_Desktop) { auto* simple = Structure("Simple", utils::Vector{Member("member", ty.f32())}); - GlobalVar("simple", ty.Of(simple), ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); + GlobalVar("simple", ty.Of(simple), type::AddressSpace::kUniform, Group(0_a), Binding(0_a)); GeneratorImpl& gen = Build(Version(Version::Standard::kDesktop, 4, 4)); diff --git a/src/tint/writer/glsl/generator_impl_variable_decl_statement_test.cc b/src/tint/writer/glsl/generator_impl_variable_decl_statement_test.cc index 650e2b4a3f..2cbea9540b 100644 --- a/src/tint/writer/glsl/generator_impl_variable_decl_statement_test.cc +++ b/src/tint/writer/glsl/generator_impl_variable_decl_statement_test.cc @@ -475,7 +475,7 @@ TEST_F(GlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) { } TEST_F(GlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); WrapInFunction(Expr("a")); diff --git a/src/tint/writer/glsl/generator_impl_workgroup_var_test.cc b/src/tint/writer/glsl/generator_impl_workgroup_var_test.cc index ef4070870e..97f8cf87d2 100644 --- a/src/tint/writer/glsl/generator_impl_workgroup_var_test.cc +++ b/src/tint/writer/glsl/generator_impl_workgroup_var_test.cc @@ -27,7 +27,7 @@ namespace { using GlslGeneratorImplTest_WorkgroupVar = TestHelper; TEST_F(GlslGeneratorImplTest_WorkgroupVar, Basic) { - GlobalVar("wg", ty.f32(), ast::AddressSpace::kWorkgroup); + GlobalVar("wg", ty.f32(), type::AddressSpace::kWorkgroup); Func("main", utils::Empty, ty.void_(), utils::Vector{Assign("wg", 1.2_f)}, utils::Vector{ @@ -43,7 +43,7 @@ TEST_F(GlslGeneratorImplTest_WorkgroupVar, Basic) { TEST_F(GlslGeneratorImplTest_WorkgroupVar, Aliased) { auto* alias = Alias("F32", ty.f32()); - GlobalVar("wg", ty.Of(alias), ast::AddressSpace::kWorkgroup); + GlobalVar("wg", ty.Of(alias), type::AddressSpace::kWorkgroup); Func("main", utils::Empty, ty.void_(), utils::Vector{Assign("wg", 1.2_f)}, utils::Vector{ diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc index f2b525eb09..a033ff60f9 100644 --- a/src/tint/writer/hlsl/generator_impl.cc +++ b/src/tint/writer/hlsl/generator_impl.cc @@ -334,8 +334,8 @@ bool GeneratorImpl::Generate() { auto* ty = builder_.Sem().Get(str); auto address_space_uses = ty->AddressSpaceUsage(); if (address_space_uses.size() != - (address_space_uses.count(ast::AddressSpace::kStorage) + - address_space_uses.count(ast::AddressSpace::kUniform))) { + (address_space_uses.count(type::AddressSpace::kStorage) + + address_space_uses.count(type::AddressSpace::kUniform))) { // The structure is used as something other than a storage buffer or // uniform buffer, so it needs to be emitted. // Storage buffer are read and written to via a ByteAddressBuffer @@ -376,7 +376,7 @@ bool GeneratorImpl::EmitDynamicVectorAssignment(const ast::AssignmentStatement* std::string fn; { std::ostringstream ss; - if (!EmitType(ss, vec, tint::ast::AddressSpace::kUndefined, ast::Access::kUndefined, + if (!EmitType(ss, vec, tint::type::AddressSpace::kUndefined, ast::Access::kUndefined, "")) { return ""; } @@ -385,12 +385,12 @@ bool GeneratorImpl::EmitDynamicVectorAssignment(const ast::AssignmentStatement* { auto out = line(&helpers_); out << "void " << fn << "(inout "; - if (!EmitTypeAndName(out, vec, ast::AddressSpace::kUndefined, ast::Access::kUndefined, + if (!EmitTypeAndName(out, vec, type::AddressSpace::kUndefined, ast::Access::kUndefined, "vec")) { return ""; } out << ", int idx, "; - if (!EmitTypeAndName(out, vec->type(), ast::AddressSpace::kUndefined, + if (!EmitTypeAndName(out, vec->type(), type::AddressSpace::kUndefined, ast::Access::kUndefined, "val")) { return ""; } @@ -450,7 +450,7 @@ bool GeneratorImpl::EmitDynamicMatrixVectorAssignment(const ast::AssignmentState std::string fn; { std::ostringstream ss; - if (!EmitType(ss, mat, tint::ast::AddressSpace::kUndefined, ast::Access::kUndefined, + if (!EmitType(ss, mat, tint::type::AddressSpace::kUndefined, ast::Access::kUndefined, "")) { return ""; } @@ -459,12 +459,12 @@ bool GeneratorImpl::EmitDynamicMatrixVectorAssignment(const ast::AssignmentState { auto out = line(&helpers_); out << "void " << fn << "(inout "; - if (!EmitTypeAndName(out, mat, ast::AddressSpace::kUndefined, ast::Access::kUndefined, + if (!EmitTypeAndName(out, mat, type::AddressSpace::kUndefined, ast::Access::kUndefined, "mat")) { return ""; } out << ", int col, "; - if (!EmitTypeAndName(out, mat->ColumnType(), ast::AddressSpace::kUndefined, + if (!EmitTypeAndName(out, mat->ColumnType(), type::AddressSpace::kUndefined, ast::Access::kUndefined, "val")) { return ""; } @@ -519,7 +519,7 @@ bool GeneratorImpl::EmitDynamicMatrixScalarAssignment(const ast::AssignmentState std::string fn; { std::ostringstream ss; - if (!EmitType(ss, mat, tint::ast::AddressSpace::kUndefined, ast::Access::kUndefined, + if (!EmitType(ss, mat, tint::type::AddressSpace::kUndefined, ast::Access::kUndefined, "")) { return ""; } @@ -528,12 +528,12 @@ bool GeneratorImpl::EmitDynamicMatrixScalarAssignment(const ast::AssignmentState { auto out = line(&helpers_); out << "void " << fn << "(inout "; - if (!EmitTypeAndName(out, mat, ast::AddressSpace::kUndefined, ast::Access::kUndefined, + if (!EmitTypeAndName(out, mat, type::AddressSpace::kUndefined, ast::Access::kUndefined, "mat")) { return ""; } out << ", int col, int row, "; - if (!EmitTypeAndName(out, mat->type(), ast::AddressSpace::kUndefined, + if (!EmitTypeAndName(out, mat->type(), type::AddressSpace::kUndefined, ast::Access::kUndefined, "val")) { return ""; } @@ -638,7 +638,7 @@ bool GeneratorImpl::EmitBitcast(std::ostream& out, const ast::BitcastExpression* } out << "as"; - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } out << "("; @@ -905,9 +905,9 @@ bool GeneratorImpl::EmitFunctionCall(std::ostream& out, if (auto* intrinsic = ast::GetAttribute( func->Declaration()->attributes)) { switch (intrinsic->address_space) { - case ast::AddressSpace::kUniform: + case type::AddressSpace::kUniform: return EmitUniformBufferAccess(out, expr, intrinsic); - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: if (!intrinsic->IsAtomic()) { return EmitStorageBufferAccess(out, expr, intrinsic); } @@ -1026,7 +1026,7 @@ bool GeneratorImpl::EmitBuiltinCall(std::ostream& out, bool GeneratorImpl::EmitTypeConversion(std::ostream& out, const sem::Call* call, const sem::TypeConversion* conv) { - if (!EmitType(out, conv->Target(), ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, conv->Target(), type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } out << "("; @@ -1071,7 +1071,7 @@ bool GeneratorImpl::EmitTypeInitializer(std::ostream& out, if (brackets) { out << "{"; } else { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } out << "("; @@ -1588,12 +1588,12 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( auto rmw = [&](const char* hlsl) -> bool { { auto fn = line(&buf); - if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kUndefined, + if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, name)) { return false; } fn << "(RWByteAddressBuffer buffer, uint offset, "; - if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, ast::Access::kUndefined, + if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "value")) { return false; } @@ -1609,7 +1609,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( { auto l = line(&buf); - if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, ast::Access::kUndefined, + if (!EmitTypeAndName(l, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "original_value")) { return false; } @@ -1658,7 +1658,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( // InterlockedOr using 0 as the OR value { auto fn = line(&buf); - if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, name)) { return false; } @@ -1674,7 +1674,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( { auto l = line(&buf); - if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(l, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "value")) { return false; } @@ -1692,7 +1692,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( { auto fn = line(&buf); fn << "void " << name << "(RWByteAddressBuffer buffer, uint offset, "; - if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(fn, value_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "value")) { return false; } @@ -1708,8 +1708,8 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( { auto l = line(&buf); - if (!EmitTypeAndName(l, value_ty, ast::AddressSpace::kNone, ast::Access::kUndefined, - "ignored")) { + if (!EmitTypeAndName(l, value_ty, type::AddressSpace::kNone, + ast::Access::kUndefined, "ignored")) { return false; } l << ";"; @@ -1723,17 +1723,17 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( auto* value_ty = params[2]->Type()->UnwrapRef(); { auto fn = line(&buf); - if (!EmitTypeAndName(fn, result_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, name)) { return false; } fn << "(RWByteAddressBuffer buffer, uint offset, "; - if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(fn, value_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "compare")) { return false; } fn << ", "; - if (!EmitTypeAndName(fn, value_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(fn, value_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "value")) { return false; } @@ -1749,7 +1749,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic( { // T result = {0}; auto l = line(&buf); - if (!EmitTypeAndName(l, result_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(l, result_ty, type::AddressSpace::kNone, ast::Access::kUndefined, "result")) { return false; } @@ -1784,7 +1784,7 @@ bool GeneratorImpl::EmitWorkgroupAtomicCall(std::ostream& out, if (!builtin->ReturnType()->Is()) { auto pre = line(); - if (!EmitTypeAndName(pre, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitTypeAndName(pre, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, result)) { return false; } @@ -1848,7 +1848,7 @@ bool GeneratorImpl::EmitWorkgroupAtomicCall(std::ostream& out, { // T result = 0; auto pre = line(); auto* value_ty = builtin->Parameters()[1]->Type()->UnwrapRef(); - if (!EmitTypeAndName(pre, value_ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(pre, value_ty, type::AddressSpace::kNone, ast::Access::kUndefined, result)) { return false; } @@ -1887,7 +1887,7 @@ bool GeneratorImpl::EmitWorkgroupAtomicCall(std::ostream& out, { // T compare_value = ; auto pre = line(); if (!EmitTypeAndName(pre, TypeOf(compare_value)->UnwrapRef(), - ast::AddressSpace::kNone, ast::Access::kUndefined, compare)) { + type::AddressSpace::kNone, ast::Access::kUndefined, compare)) { return false; } pre << " = "; @@ -1996,7 +1996,7 @@ bool GeneratorImpl::EmitModfCall(std::ostream& out, { auto l = line(b); - if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -2038,7 +2038,7 @@ bool GeneratorImpl::EmitFrexpCall(std::ostream& out, line(b) << member_type << " fract = frexp(" << in << ", exp);"; { auto l = line(b); - if (!EmitType(l, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -2076,7 +2076,7 @@ bool GeneratorImpl::EmitRadiansCall(std::ostream& out, // type after the call to `sign`. bool GeneratorImpl::EmitSignCall(std::ostream& out, const sem::Call* call, const sem::Builtin*) { auto* arg = call->Arguments()[0]; - if (!EmitType(out, arg->Type(), ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, arg->Type(), type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } out << "(sign("; @@ -2856,7 +2856,7 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) { // Emit storage atomic helpers if (auto* intrinsic = ast::GetAttribute(func->attributes)) { - if (intrinsic->address_space == ast::AddressSpace::kStorage && intrinsic->IsAtomic()) { + if (intrinsic->address_space == type::AddressSpace::kStorage && intrinsic->IsAtomic()) { if (!EmitStorageAtomicIntrinsic(func, intrinsic)) { return false; } @@ -2878,15 +2878,15 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) { auto typedef_name = UniqueIdentifier(name + "_ret"); auto pre = line(); pre << "typedef "; - if (!EmitTypeAndName(pre, sem->ReturnType(), ast::AddressSpace::kNone, + if (!EmitTypeAndName(pre, sem->ReturnType(), type::AddressSpace::kNone, ast::Access::kReadWrite, typedef_name)) { return false; } pre << ";"; out << typedef_name; } else { - if (!EmitType(out, sem->ReturnType(), ast::AddressSpace::kNone, ast::Access::kReadWrite, - "")) { + if (!EmitType(out, sem->ReturnType(), type::AddressSpace::kNone, + ast::Access::kReadWrite, "")) { return false; } } @@ -2902,14 +2902,14 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) { first = false; auto const* type = v->Type(); - auto address_space = ast::AddressSpace::kNone; + auto address_space = type::AddressSpace::kNone; auto access = ast::Access::kUndefined; if (auto* ptr = type->As()) { type = ptr->StoreType(); switch (ptr->AddressSpace()) { - case ast::AddressSpace::kStorage: - case ast::AddressSpace::kUniform: + case type::AddressSpace::kStorage: + case type::AddressSpace::kUniform: // Not allowed by WGSL, but is used by certain transforms (e.g. DMA) to pass // storage buffers and uniform buffers down into transform-generated // functions. In this situation we want to generate the parameter without an @@ -2976,7 +2976,7 @@ bool GeneratorImpl::EmitFunctionBodyWithDiscard(const ast::Function* func) { auto name = builder_.Symbols().NameFor(builder_.Symbols().New("unused")); { auto out = line(); - if (!EmitTypeAndName(out, sem->ReturnType(), ast::AddressSpace::kNone, + if (!EmitTypeAndName(out, sem->ReturnType(), type::AddressSpace::kNone, ast::Access::kReadWrite, name)) { return false; } @@ -2993,17 +2993,17 @@ bool GeneratorImpl::EmitGlobalVariable(const ast::Variable* global) { [&](const ast::Var* var) { auto* sem = builder_.Sem().Get(global); switch (sem->AddressSpace()) { - case ast::AddressSpace::kUniform: + case type::AddressSpace::kUniform: return EmitUniformVariable(var, sem); - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: return EmitStorageVariable(var, sem); - case ast::AddressSpace::kHandle: + case type::AddressSpace::kHandle: return EmitHandleVariable(var, sem); - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: return EmitPrivateVariable(sem); - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: return EmitWorkgroupVariable(sem); - case ast::AddressSpace::kPushConstant: + case type::AddressSpace::kPushConstant: diagnostics_.add_error( diag::System::Writer, "unhandled address space " + utils::ToString(sem->AddressSpace())); @@ -3042,7 +3042,7 @@ bool GeneratorImpl::EmitUniformVariable(const ast::Var* var, const sem::Variable { ScopedIndent si(this); auto out = line(); - if (!EmitTypeAndName(out, type, ast::AddressSpace::kUniform, sem->Access(), name)) { + if (!EmitTypeAndName(out, type, type::AddressSpace::kUniform, sem->Access(), name)) { return false; } out << ";"; @@ -3056,7 +3056,7 @@ bool GeneratorImpl::EmitUniformVariable(const ast::Var* var, const sem::Variable bool GeneratorImpl::EmitStorageVariable(const ast::Var* var, const sem::Variable* sem) { auto* type = sem->Type()->UnwrapRef(); auto out = line(); - if (!EmitTypeAndName(out, type, ast::AddressSpace::kStorage, sem->Access(), + if (!EmitTypeAndName(out, type, type::AddressSpace::kStorage, sem->Access(), builder_.Symbols().NameFor(var->symbol))) { return false; } @@ -3327,7 +3327,7 @@ bool GeneratorImpl::EmitConstant(std::ostream& out, return true; } - if (!EmitType(out, v, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, v, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -3344,7 +3344,7 @@ bool GeneratorImpl::EmitConstant(std::ostream& out, return true; }, [&](const type::Matrix* m) { - if (!EmitType(out, m, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, m, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } @@ -3363,7 +3363,7 @@ bool GeneratorImpl::EmitConstant(std::ostream& out, [&](const type::Array* a) { if (constant->AllZero()) { out << "("; - if (!EmitType(out, a, ast::AddressSpace::kNone, ast::Access::kUndefined, "")) { + if (!EmitType(out, a, type::AddressSpace::kNone, ast::Access::kUndefined, "")) { return false; } out << ")0"; @@ -3503,7 +3503,7 @@ bool GeneratorImpl::EmitValue(std::ostream& out, const type::Type* type, int val return true; }, [&](const type::Vector* vec) { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen sp(out); @@ -3518,7 +3518,7 @@ bool GeneratorImpl::EmitValue(std::ostream& out, const type::Type* type, int val return true; }, [&](const type::Matrix* mat) { - if (!EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) { + if (!EmitType(out, type, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) { return false; } ScopedParen sp(out); @@ -3535,12 +3535,12 @@ bool GeneratorImpl::EmitValue(std::ostream& out, const type::Type* type, int val [&](const sem::Struct*) { out << "("; TINT_DEFER(out << ")" << value); - return EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, ""); + return EmitType(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, ""); }, [&](const type::Array*) { out << "("; TINT_DEFER(out << ")" << value); - return EmitType(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, ""); + return EmitType(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, ""); }, [&](Default) { diagnostics_.add_error( @@ -3915,7 +3915,7 @@ bool GeneratorImpl::EmitSwitch(const ast::SwitchStatement* stmt) { bool GeneratorImpl::EmitType(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name, bool* name_printed /* = nullptr */) { @@ -3923,13 +3923,13 @@ bool GeneratorImpl::EmitType(std::ostream& out, *name_printed = false; } switch (address_space) { - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: if (access != ast::Access::kRead) { out << "RW"; } out << "ByteAddressBuffer"; return true; - case ast::AddressSpace::kUniform: { + case type::AddressSpace::kUniform: { auto array_length = (type->Size() + 15) / 16; out << "uint4 " << name << "[" << array_length << "]"; if (name_printed) { @@ -4142,7 +4142,7 @@ bool GeneratorImpl::EmitType(std::ostream& out, bool GeneratorImpl::EmitTypeAndName(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name) { bool name_printed = false; @@ -4225,7 +4225,7 @@ bool GeneratorImpl::EmitStructType(TextBuffer* b, const sem::Struct* str) { } out << pre; - if (!EmitTypeAndName(out, ty, ast::AddressSpace::kNone, ast::Access::kReadWrite, + if (!EmitTypeAndName(out, ty, type::AddressSpace::kNone, ast::Access::kReadWrite, mem_name)) { return false; } @@ -4295,7 +4295,7 @@ bool GeneratorImpl::EmitLet(const ast::Let* let) { auto out = line(); out << "const "; - if (!EmitTypeAndName(out, type, ast::AddressSpace::kNone, ast::Access::kUndefined, + if (!EmitTypeAndName(out, type, type::AddressSpace::kNone, ast::Access::kUndefined, builder_.Symbols().NameFor(let->symbol))) { return false; } @@ -4322,7 +4322,7 @@ bool GeneratorImpl::CallBuiltinHelper(std::ostream& out, std::vector parameter_names; { auto decl = line(&b); - if (!EmitTypeAndName(decl, builtin->ReturnType(), ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, builtin->ReturnType(), type::AddressSpace::kNone, ast::Access::kUndefined, fn_name)) { return ""; } @@ -4338,7 +4338,7 @@ bool GeneratorImpl::CallBuiltinHelper(std::ostream& out, decl << "inout "; ty = ptr->StoreType(); } - if (!EmitTypeAndName(decl, ty, ast::AddressSpace::kNone, + if (!EmitTypeAndName(decl, ty, type::AddressSpace::kNone, ast::Access::kUndefined, param_name)) { return ""; } diff --git a/src/tint/writer/hlsl/generator_impl.h b/src/tint/writer/hlsl/generator_impl.h index 76b9042952..04e13a0c69 100644 --- a/src/tint/writer/hlsl/generator_impl.h +++ b/src/tint/writer/hlsl/generator_impl.h @@ -413,7 +413,7 @@ class GeneratorImpl : public TextGenerator { /// @returns true if the type is emitted bool EmitType(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name, bool* name_printed = nullptr); @@ -426,7 +426,7 @@ class GeneratorImpl : public TextGenerator { /// @returns true if the type is emitted bool EmitTypeAndName(std::ostream& out, const type::Type* type, - ast::AddressSpace address_space, + type::AddressSpace address_space, ast::Access access, const std::string& name); /// Handles generating a structure declaration. If the structure has already been emitted, then diff --git a/src/tint/writer/hlsl/generator_impl_array_accessor_test.cc b/src/tint/writer/hlsl/generator_impl_array_accessor_test.cc index 0da678ac7b..71bf057567 100644 --- a/src/tint/writer/hlsl/generator_impl_array_accessor_test.cc +++ b/src/tint/writer/hlsl/generator_impl_array_accessor_test.cc @@ -22,7 +22,7 @@ namespace { using HlslGeneratorImplTest_Expression = TestHelper; TEST_F(HlslGeneratorImplTest_Expression, IndexAccessor) { - GlobalVar("ary", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("ary", ty.array(), type::AddressSpace::kPrivate); auto* expr = IndexAccessor("ary", 5_i); WrapInFunction(expr); diff --git a/src/tint/writer/hlsl/generator_impl_binary_test.cc b/src/tint/writer/hlsl/generator_impl_binary_test.cc index 6e2b3c7aa6..afc6b8fa11 100644 --- a/src/tint/writer/hlsl/generator_impl_binary_test.cc +++ b/src/tint/writer/hlsl/generator_impl_binary_test.cc @@ -50,8 +50,8 @@ TEST_P(HlslBinaryTest, Emit_f32) { return; } - GlobalVar("left", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.f32(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -82,8 +82,8 @@ TEST_P(HlslBinaryTest, Emit_f16) { Enable(ast::Extension::kF16); - GlobalVar("left", ty.f16(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.f16(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.f16(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.f16(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -105,8 +105,8 @@ TEST_P(HlslBinaryTest, Emit_u32) { return; } - GlobalVar("left", ty.u32(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.u32(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.u32(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -133,8 +133,8 @@ TEST_P(HlslBinaryTest, Emit_i32) { return; } - GlobalVar("left", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("right", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("left", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("right", ty.i32(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); @@ -237,7 +237,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarVector_f16) { } TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = Expr(1_f); @@ -254,7 +254,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f32) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = Expr(1_h); @@ -269,7 +269,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f16) { } TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr(1_f); auto* rhs = Expr("mat"); @@ -286,7 +286,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f32) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr(1_h); auto* rhs = Expr("mat"); @@ -301,7 +301,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f16) { } TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = vec3(1_f, 1_f, 1_f); @@ -318,7 +318,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector_f32) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = Expr("mat"); auto* rhs = vec3(1_h, 1_h, 1_h); @@ -333,7 +333,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector_f16) { } TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f32) { - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = vec3(1_f, 1_f, 1_f); auto* rhs = Expr("mat"); @@ -350,7 +350,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f32) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f16) { Enable(ast::Extension::kF16); - GlobalVar("mat", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("mat", ty.mat3x3(), type::AddressSpace::kPrivate); auto* lhs = vec3(1_h, 1_h, 1_h); auto* rhs = Expr("mat"); @@ -365,8 +365,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f16) { } TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f32) { - GlobalVar("lhs", ty.mat3x3(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.mat3x3(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -381,8 +381,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f32) { TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f16) { Enable(ast::Extension::kF16); - GlobalVar("lhs", ty.mat3x3(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.mat3x3(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs")); WrapInFunction(expr); @@ -395,8 +395,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f16) { } TEST_F(HlslGeneratorImplTest_Binary, Logical_And) { - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -415,10 +415,10 @@ if (tint_tmp) { TEST_F(HlslGeneratorImplTest_Binary, Logical_Multi) { // (a && b) || (c || d) - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = create( ast::BinaryOp::kLogicalOr, @@ -447,8 +447,8 @@ if (!tint_tmp) { } TEST_F(HlslGeneratorImplTest_Binary, Logical_Or) { - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = create(ast::BinaryOp::kLogicalOr, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -474,9 +474,9 @@ TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) { // return 3i; // } - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = If(create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")), @@ -511,9 +511,9 @@ if ((tint_tmp)) { TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) { // return (a && b) || c; - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = Return(create( ast::BinaryOp::kLogicalOr, @@ -539,10 +539,10 @@ return (tint_tmp); TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) { // a = (b || c) && d; - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = Assign(Expr("a"), @@ -570,12 +570,12 @@ a = (tint_tmp); TEST_F(HlslGeneratorImplTest_Binary, Decl_WithLogical) { // var a : bool = (b && c) || d; - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); auto* var = - Var("a", ty.bool_(), ast::AddressSpace::kNone, + Var("a", ty.bool_(), type::AddressSpace::kNone, create( ast::BinaryOp::kLogicalOr, create(ast::BinaryOp::kLogicalAnd, Expr("b"), Expr("c")), @@ -609,10 +609,10 @@ TEST_F(HlslGeneratorImplTest_Binary, Call_WithLogical) { Param(Sym(), ty.bool_()), }, ty.void_(), utils::Empty, utils::Empty); - GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("d", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate); utils::Vector params{ create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")), diff --git a/src/tint/writer/hlsl/generator_impl_builtin_test.cc b/src/tint/writer/hlsl/generator_impl_builtin_test.cc index 785e1fd9a9..fadfbd275c 100644 --- a/src/tint/writer/hlsl/generator_impl_builtin_test.cc +++ b/src/tint/writer/hlsl/generator_impl_builtin_test.cc @@ -197,19 +197,19 @@ TEST_P(HlslBuiltinTest, Emit) { if (param.type == CallParamType::kF16) { Enable(ast::Extension::kF16); - GlobalVar("h2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("h3", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("hm2x2", ty.mat2x2(), ast::AddressSpace::kPrivate); - GlobalVar("hm3x2", ty.mat3x2(), ast::AddressSpace::kPrivate); + GlobalVar("h2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("h3", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("hm2x2", ty.mat2x2(), type::AddressSpace::kPrivate); + GlobalVar("hm3x2", ty.mat3x2(), type::AddressSpace::kPrivate); } - GlobalVar("f2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("f3", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("u2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("i2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("b2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("m2x2", ty.mat2x2(), ast::AddressSpace::kPrivate); - GlobalVar("m3x2", ty.mat3x2(), ast::AddressSpace::kPrivate); + GlobalVar("f2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("f3", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("u2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("i2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("b2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("m2x2", ty.mat2x2(), type::AddressSpace::kPrivate); + GlobalVar("m3x2", ty.mat3x2(), type::AddressSpace::kPrivate); auto* call = GenerateCall(param.builtin, param.type, this); ASSERT_NE(nullptr, call) << "Unhandled builtin"; @@ -339,8 +339,8 @@ INSTANTIATE_TEST_SUITE_P( TEST_F(HlslGeneratorImplTest_Builtin, Builtin_Call) { auto* call = Call("dot", "param1", "param2"); - GlobalVar("param1", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.vec3(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); @@ -353,8 +353,8 @@ TEST_F(HlslGeneratorImplTest_Builtin, Builtin_Call) { } TEST_F(HlslGeneratorImplTest_Builtin, Select_Scalar) { - GlobalVar("a", Expr(1_f), ast::AddressSpace::kPrivate); - GlobalVar("b", Expr(2_f), ast::AddressSpace::kPrivate); + GlobalVar("a", Expr(1_f), type::AddressSpace::kPrivate); + GlobalVar("b", Expr(2_f), type::AddressSpace::kPrivate); auto* call = Call("select", "a", "b", true); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -366,8 +366,8 @@ TEST_F(HlslGeneratorImplTest_Builtin, Select_Scalar) { } TEST_F(HlslGeneratorImplTest_Builtin, Select_Vector) { - GlobalVar("a", vec2(1_i, 2_i), ast::AddressSpace::kPrivate); - GlobalVar("b", vec2(3_i, 4_i), ast::AddressSpace::kPrivate); + GlobalVar("a", vec2(1_i, 2_i), type::AddressSpace::kPrivate); + GlobalVar("b", vec2(3_i, 4_i), type::AddressSpace::kPrivate); auto* call = Call("select", "a", "b", vec2(true, false)); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1107,7 +1107,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Pack4x8Snorm) { auto* call = Call("pack4x8snorm", "p1"); - GlobalVar("p1", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec4(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1129,7 +1129,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Pack4x8Unorm) { auto* call = Call("pack4x8unorm", "p1"); - GlobalVar("p1", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec4(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1151,7 +1151,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Pack2x16Snorm) { auto* call = Call("pack2x16snorm", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1173,7 +1173,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Pack2x16Unorm) { auto* call = Call("pack2x16unorm", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1195,7 +1195,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Pack2x16Float) { auto* call = Call("pack2x16float", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1217,7 +1217,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Unpack4x8Snorm) { auto* call = Call("unpack4x8snorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1240,7 +1240,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Unpack4x8Unorm) { auto* call = Call("unpack4x8unorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1263,7 +1263,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Unpack2x16Snorm) { auto* call = Call("unpack2x16snorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1286,7 +1286,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Unpack2x16Unorm) { auto* call = Call("unpack2x16unorm", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1309,7 +1309,7 @@ void test_function() { TEST_F(HlslGeneratorImplTest_Builtin, Unpack2x16Float) { auto* call = Call("unpack2x16float", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); diff --git a/src/tint/writer/hlsl/generator_impl_call_test.cc b/src/tint/writer/hlsl/generator_impl_call_test.cc index 33e0762394..46b14061ed 100644 --- a/src/tint/writer/hlsl/generator_impl_call_test.cc +++ b/src/tint/writer/hlsl/generator_impl_call_test.cc @@ -42,8 +42,8 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) { Param(Sym(), ty.f32()), }, ty.f32(), utils::Vector{Return(1.23_f)}); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("my_func", "param1", "param2"); WrapInFunction(call); @@ -62,8 +62,8 @@ TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) { Param(Sym(), ty.f32()), }, ty.void_(), utils::Empty, utils::Empty); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = CallStmt(Call("my_func", "param1", "param2")); WrapInFunction(call); diff --git a/src/tint/writer/hlsl/generator_impl_function_test.cc b/src/tint/writer/hlsl/generator_impl_function_test.cc index 56465d30a5..36051aee41 100644 --- a/src/tint/writer/hlsl/generator_impl_function_test.cc +++ b/src/tint/writer/hlsl/generator_impl_function_test.cc @@ -101,7 +101,7 @@ TEST_F(HlslGeneratorImplTest_Function, PtrParameter) { // fn f(foo : ptr) -> f32 { // return *foo; // } - Func("f", utils::Vector{Param("foo", ty.pointer(ast::AddressSpace::kFunction))}, ty.f32(), + Func("f", utils::Vector{Param("foo", ty.pointer(type::AddressSpace::kFunction))}, ty.f32(), utils::Vector{Return(Deref("foo"))}); GeneratorImpl& gen = SanitizeAndBuild(); @@ -361,7 +361,7 @@ tint_symbol_1 vert_main2() { TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_Uniform) { auto* ubo_ty = Structure("UBO", utils::Vector{Member("coord", ty.vec4())}); auto* ubo = - GlobalVar("ubo", ty.Of(ubo_ty), ast::AddressSpace::kUniform, Binding(0_a), Group(1_a)); + GlobalVar("ubo", ty.Of(ubo_ty), type::AddressSpace::kUniform, Binding(0_a), Group(1_a)); Func("sub_func", utils::Vector{ @@ -404,7 +404,7 @@ void frag_main() { TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_UniformStruct) { auto* s = Structure("Uniforms", utils::Vector{Member("coord", ty.vec4())}); - GlobalVar("uniforms", ty.Of(s), ast::AddressSpace::kUniform, Binding(0_a), Group(1_a)); + GlobalVar("uniforms", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(1_a)); auto* var = Var("v", ty.f32(), MemberAccessor(MemberAccessor("uniforms", "coord"), "x")); @@ -437,8 +437,8 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RW_Storage Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b")); @@ -470,7 +470,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RO_Storage Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(1_a)); auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b")); @@ -503,8 +503,8 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_WO_Storage Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); Func("frag_main", utils::Empty, ty.void_(), utils::Vector{ @@ -534,8 +534,8 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_StorageBuf Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); Func("frag_main", utils::Empty, ty.void_(), utils::Vector{ @@ -561,7 +561,7 @@ void frag_main() { TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_Uniform) { auto* s = Structure("S", utils::Vector{Member("x", ty.f32())}); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kUniform, Binding(0_a), Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(1_a)); Func("sub_func", utils::Vector{ @@ -603,8 +603,8 @@ void frag_main() { TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_StorageBuffer) { auto* s = Structure("S", utils::Vector{Member("x", ty.f32())}); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), - Group(1_a)); + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, + Binding(0_a), Group(1_a)); Func("sub_func", utils::Vector{ @@ -831,7 +831,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Multiple_EntryPoint_With_Same_Module auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())}); - GlobalVar("data", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), + GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), Group(0_a)); { diff --git a/src/tint/writer/hlsl/generator_impl_identifier_test.cc b/src/tint/writer/hlsl/generator_impl_identifier_test.cc index b6434d8a54..c28e757cc6 100644 --- a/src/tint/writer/hlsl/generator_impl_identifier_test.cc +++ b/src/tint/writer/hlsl/generator_impl_identifier_test.cc @@ -20,7 +20,7 @@ namespace { using HlslGeneratorImplTest_Identifier = TestHelper; TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) { - GlobalVar("foo", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("foo", ty.i32(), type::AddressSpace::kPrivate); auto* i = Expr("foo"); WrapInFunction(i); diff --git a/src/tint/writer/hlsl/generator_impl_if_test.cc b/src/tint/writer/hlsl/generator_impl_if_test.cc index 37c9ea969e..c599648c62 100644 --- a/src/tint/writer/hlsl/generator_impl_if_test.cc +++ b/src/tint/writer/hlsl/generator_impl_if_test.cc @@ -20,7 +20,7 @@ namespace { using HlslGeneratorImplTest_If = TestHelper; TEST_F(HlslGeneratorImplTest_If, Emit_If) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); auto* cond = Expr("cond"); auto* body = Block(Return()); @@ -38,8 +38,8 @@ TEST_F(HlslGeneratorImplTest_If, Emit_If) { } TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("else_cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_cond = Expr("else_cond"); auto* else_body = Block(Return()); @@ -65,7 +65,7 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) { } TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_body = Block(Return()); @@ -88,8 +88,8 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) { } TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("else_cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_cond = Expr("else_cond"); diff --git a/src/tint/writer/hlsl/generator_impl_import_test.cc b/src/tint/writer/hlsl/generator_impl_import_test.cc index 3e9e5911ba..9d00c3f4b0 100644 --- a/src/tint/writer/hlsl/generator_impl_import_test.cc +++ b/src/tint/writer/hlsl/generator_impl_import_test.cc @@ -254,7 +254,7 @@ INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import, testing::Values(HlslImportData{"clamp", "clamp"})); TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) { - GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = Call("determinant", "var"); WrapInFunction(expr); @@ -267,7 +267,7 @@ TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) { } TEST_F(HlslGeneratorImplTest_Import, HlslImportData_QuantizeToF16_Scalar) { - GlobalVar("v", Expr(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate); auto* expr = Call("quantizeToF16", "v"); WrapInFunction(expr); @@ -280,7 +280,7 @@ TEST_F(HlslGeneratorImplTest_Import, HlslImportData_QuantizeToF16_Scalar) { } TEST_F(HlslGeneratorImplTest_Import, HlslImportData_QuantizeToF16_Vector) { - GlobalVar("v", vec3(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", vec3(2_f), type::AddressSpace::kPrivate); auto* expr = Call("quantizeToF16", "v"); WrapInFunction(expr); diff --git a/src/tint/writer/hlsl/generator_impl_loop_test.cc b/src/tint/writer/hlsl/generator_impl_loop_test.cc index 4249f1e049..620543d12b 100644 --- a/src/tint/writer/hlsl/generator_impl_loop_test.cc +++ b/src/tint/writer/hlsl/generator_impl_loop_test.cc @@ -93,8 +93,8 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopWithContinuing_BreakIf) { TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopNestedWithContinuing) { Func("a_statement", {}, ty.void_(), {}); - GlobalVar("lhs", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate); auto* body = Block(Break()); auto* continuing = Block(CallStmt(Call("a_statement"))); @@ -142,7 +142,7 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) { // } // } - GlobalVar("rhs", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate); auto* body = Block(Decl(Var("lhs", ty.f32(), Expr(2.4_f))), // Decl(Var("other", ty.f32())), // diff --git a/src/tint/writer/hlsl/generator_impl_member_accessor_test.cc b/src/tint/writer/hlsl/generator_impl_member_accessor_test.cc index b3440b8efb..3377035a99 100644 --- a/src/tint/writer/hlsl/generator_impl_member_accessor_test.cc +++ b/src/tint/writer/hlsl/generator_impl_member_accessor_test.cc @@ -93,7 +93,7 @@ class HlslGeneratorImplTest_MemberAccessorBase : public BASE { ProgramBuilder& b = *this; auto* s = b.Structure("Data", members); - b.GlobalVar("data", b.ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, + b.GlobalVar("data", b.ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(1_a), b.Binding(0_a)); } @@ -101,7 +101,7 @@ class HlslGeneratorImplTest_MemberAccessorBase : public BASE { ProgramBuilder& b = *this; auto* s = b.Structure("Data", members); - b.GlobalVar("data", b.ty.Of(s), ast::AddressSpace::kUniform, ast::Access::kUndefined, + b.GlobalVar("data", b.ty.Of(s), type::AddressSpace::kUniform, ast::Access::kUndefined, b.Group(1_a), b.Binding(1_a)); } @@ -122,7 +122,7 @@ using HlslGeneratorImplTest_MemberAccessorWithParam = TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) { auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())}); - GlobalVar("str", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate); auto* expr = MemberAccessor("str", "mem"); WrapInFunction(Var("expr", ty.f32(), expr)); diff --git a/src/tint/writer/hlsl/generator_impl_sanitizer_test.cc b/src/tint/writer/hlsl/generator_impl_sanitizer_test.cc index 761eb82de6..e39ea02895 100644 --- a/src/tint/writer/hlsl/generator_impl_sanitizer_test.cc +++ b/src/tint/writer/hlsl/generator_impl_sanitizer_test.cc @@ -26,7 +26,7 @@ using HlslSanitizerTest = TestHelper; TEST_F(HlslSanitizerTest, Call_ArrayLength) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -60,7 +60,7 @@ TEST_F(HlslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) { Member(0, "z", ty.f32()), Member(4, "a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -92,7 +92,7 @@ void a_func() { TEST_F(HlslSanitizerTest, Call_ArrayLength_ViaLets) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* p = Let("p", AddressOf("b")); @@ -129,9 +129,9 @@ void a_func() { TEST_F(HlslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniform) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); - GlobalVar("c", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(2_a), + GlobalVar("c", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(2_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -242,7 +242,7 @@ TEST_F(HlslSanitizerTest, InlinePtrLetsBasic) { // let p : ptr = &v; // let x : i32 = *p; auto* v = Var("v", ty.i32()); - auto* p = Let("p", ty.pointer(ast::AddressSpace::kFunction), AddressOf(v)); + auto* p = Let("p", ty.pointer(type::AddressSpace::kFunction), AddressOf(v)); auto* x = Var("x", ty.i32(), Deref(p)); Func("main", utils::Empty, ty.void_(), @@ -276,11 +276,11 @@ TEST_F(HlslSanitizerTest, InlinePtrLetsComplexChain) { // let vp : ptr> = &(*mp)[2i]; // let v : vec4 = *vp; auto* a = Var("a", ty.array(ty.mat4x4(), 4_u)); - auto* ap = Let("ap", ty.pointer(ty.array(ty.mat4x4(), 4_u), ast::AddressSpace::kFunction), + auto* ap = Let("ap", ty.pointer(ty.array(ty.mat4x4(), 4_u), type::AddressSpace::kFunction), AddressOf(a)); - auto* mp = Let("mp", ty.pointer(ty.mat4x4(), ast::AddressSpace::kFunction), + auto* mp = Let("mp", ty.pointer(ty.mat4x4(), type::AddressSpace::kFunction), AddressOf(IndexAccessor(Deref(ap), 3_i))); - auto* vp = Let("vp", ty.pointer(ty.vec4(), ast::AddressSpace::kFunction), + auto* vp = Let("vp", ty.pointer(ty.vec4(), type::AddressSpace::kFunction), AddressOf(IndexAccessor(Deref(mp), 2_i))); auto* v = Var("v", ty.vec4(), Deref(vp)); diff --git a/src/tint/writer/hlsl/generator_impl_switch_test.cc b/src/tint/writer/hlsl/generator_impl_switch_test.cc index a84e632ca1..698083a03e 100644 --- a/src/tint/writer/hlsl/generator_impl_switch_test.cc +++ b/src/tint/writer/hlsl/generator_impl_switch_test.cc @@ -22,7 +22,7 @@ namespace { using HlslGeneratorImplTest_Switch = TestHelper; TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); auto* s = Switch( // Expr("cond"), // Case(CaseSelector(5_i), Block(Break())), // @@ -46,7 +46,7 @@ TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) { } TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch_MixedDefault) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); auto* s = Switch( // Expr("cond"), // Case(utils::Vector{CaseSelector(5_i), DefaultCaseSelector()}, Block(Break()))); @@ -67,8 +67,8 @@ TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch_MixedDefault) { } TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch_OnlyDefaultCase) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); - GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); + GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); auto* s = Switch( // Expr("cond"), // DefaultCase(Block(Assign(Expr("a"), Expr(42_i))))); diff --git a/src/tint/writer/hlsl/generator_impl_type_test.cc b/src/tint/writer/hlsl/generator_impl_type_test.cc index 715df9a9e3..ec072292e2 100644 --- a/src/tint/writer/hlsl/generator_impl_type_test.cc +++ b/src/tint/writer/hlsl/generator_impl_type_test.cc @@ -34,12 +34,12 @@ using HlslGeneratorImplTest_Type = TestHelper; TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "ary")) << gen.error(); EXPECT_EQ(out.str(), "bool ary[4]"); @@ -47,12 +47,12 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) { TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArray) { auto* arr = ty.array(ty.array(), 5_u); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "ary")) << gen.error(); EXPECT_EQ(out.str(), "bool ary[5][4]"); @@ -60,12 +60,12 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArray) { TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) { auto* arr = ty.array(ty.array(ty.array(), 5_u), 6_u); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "ary")) << gen.error(); EXPECT_EQ(out.str(), "bool ary[6][5][4]"); @@ -73,12 +73,12 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) { TEST_F(HlslGeneratorImplTest_Type, EmitType_Array_WithoutName) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::AddressSpace::kNone, + ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "bool[4]"); @@ -90,7 +90,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Bool) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, bool_, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, bool_, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "bool"); } @@ -101,7 +101,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_F16) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, f16, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, f16, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "float16_t"); } @@ -112,7 +112,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_F32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, f32, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, f32, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "float"); } @@ -123,7 +123,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_I32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, i32, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, i32, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "int"); } @@ -136,7 +136,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Matrix_F16) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, mat2x3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, mat2x3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "matrix"); } @@ -149,7 +149,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Matrix_F32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, mat2x3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, mat2x3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "float2x3"); } @@ -159,7 +159,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_StructDecl) { Member("a", ty.i32()), Member("b", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -178,7 +178,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_StructDecl_OmittedIfStorageBuffer) { Member("a", ty.i32()), Member("b", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), + GlobalVar("g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -192,13 +192,13 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct) { Member("a", ty.i32()), Member("b", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); auto* sem_s = program->TypeOf(s)->As(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, sem_s, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, sem_s, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "S"); } @@ -208,7 +208,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) { Member("double", ty.i32()), Member("float", ty.f32()), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = SanitizeAndBuild(); @@ -225,7 +225,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct_WithOffsetAttributes) { Member("a", ty.i32(), utils::Vector{MemberOffset(0_a)}), Member("b", ty.f32(), utils::Vector{MemberOffset(8_a)}), }); - GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -245,7 +245,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_U32) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, u32, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, u32, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "uint"); } @@ -257,7 +257,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Vector) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, vec3, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, vec3, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "float3"); } @@ -268,7 +268,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Void) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, void_, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, void_, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "void"); } @@ -279,7 +279,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitSampler) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, sampler, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, sampler, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "SamplerState"); } @@ -290,7 +290,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitSamplerComparison) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, sampler, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, sampler, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "SamplerComparisonState"); } @@ -500,7 +500,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitMultisampledTexture) { GeneratorImpl& gen = Build(); std::stringstream out; - ASSERT_TRUE(gen.EmitType(out, s, ast::AddressSpace::kNone, ast::Access::kReadWrite, "")) + ASSERT_TRUE(gen.EmitType(out, s, type::AddressSpace::kNone, ast::Access::kReadWrite, "")) << gen.error(); EXPECT_EQ(out.str(), "Texture2DMS"); } diff --git a/src/tint/writer/hlsl/generator_impl_unary_op_test.cc b/src/tint/writer/hlsl/generator_impl_unary_op_test.cc index c7f03363cc..93a61dcc60 100644 --- a/src/tint/writer/hlsl/generator_impl_unary_op_test.cc +++ b/src/tint/writer/hlsl/generator_impl_unary_op_test.cc @@ -20,7 +20,7 @@ namespace { using HlslUnaryOpTest = TestHelper; TEST_F(HlslUnaryOpTest, AddressOf) { - GlobalVar("expr", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kAddressOf, Expr("expr")); WrapInFunction(op); @@ -32,7 +32,7 @@ TEST_F(HlslUnaryOpTest, AddressOf) { } TEST_F(HlslUnaryOpTest, Complement) { - GlobalVar("expr", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.u32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kComplement, Expr("expr")); WrapInFunction(op); @@ -44,7 +44,7 @@ TEST_F(HlslUnaryOpTest, Complement) { } TEST_F(HlslUnaryOpTest, Indirection) { - GlobalVar("G", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate); auto* p = Let("expr", create(ast::UnaryOp::kAddressOf, Expr("G"))); auto* op = create(ast::UnaryOp::kIndirection, Expr("expr")); WrapInFunction(p, op); @@ -57,7 +57,7 @@ TEST_F(HlslUnaryOpTest, Indirection) { } TEST_F(HlslUnaryOpTest, Not) { - GlobalVar("expr", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNot, Expr("expr")); WrapInFunction(op); @@ -69,7 +69,7 @@ TEST_F(HlslUnaryOpTest, Not) { } TEST_F(HlslUnaryOpTest, Negation) { - GlobalVar("expr", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNegation, Expr("expr")); WrapInFunction(op); diff --git a/src/tint/writer/hlsl/generator_impl_variable_decl_statement_test.cc b/src/tint/writer/hlsl/generator_impl_variable_decl_statement_test.cc index 5df476a9f2..11bf3173c3 100644 --- a/src/tint/writer/hlsl/generator_impl_variable_decl_statement_test.cc +++ b/src/tint/writer/hlsl/generator_impl_variable_decl_statement_test.cc @@ -357,7 +357,7 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) { } TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); WrapInFunction(Expr("a")); diff --git a/src/tint/writer/hlsl/generator_impl_workgroup_var_test.cc b/src/tint/writer/hlsl/generator_impl_workgroup_var_test.cc index 4ec7af2ba2..ea30962dd5 100644 --- a/src/tint/writer/hlsl/generator_impl_workgroup_var_test.cc +++ b/src/tint/writer/hlsl/generator_impl_workgroup_var_test.cc @@ -27,7 +27,7 @@ namespace { using HlslGeneratorImplTest_WorkgroupVar = TestHelper; TEST_F(HlslGeneratorImplTest_WorkgroupVar, Basic) { - GlobalVar("wg", ty.f32(), ast::AddressSpace::kWorkgroup); + GlobalVar("wg", ty.f32(), type::AddressSpace::kWorkgroup); Func("main", utils::Empty, ty.void_(), utils::Vector{Assign("wg", 1.2_f)}, utils::Vector{ @@ -43,7 +43,7 @@ TEST_F(HlslGeneratorImplTest_WorkgroupVar, Basic) { TEST_F(HlslGeneratorImplTest_WorkgroupVar, Aliased) { auto* alias = Alias("F32", ty.f32()); - GlobalVar("wg", ty.Of(alias), ast::AddressSpace::kWorkgroup); + GlobalVar("wg", ty.Of(alias), type::AddressSpace::kWorkgroup); Func("main", utils::Empty, ty.void_(), utils::Vector{Assign("wg", 1.2_f)}, utils::Vector{ diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc index 771582a55a..f27c45c98e 100644 --- a/src/tint/writer/msl/generator_impl.cc +++ b/src/tint/writer/msl/generator_impl.cc @@ -205,7 +205,7 @@ SanitizedResult Sanitize(const Program* in, const Options& options) { // Use the SSBO binding numbers as the indices for the buffer size lookups. for (auto* var : in->AST().GlobalVariables()) { auto* global = in->Sem().Get(var); - if (global && global->AddressSpace() == ast::AddressSpace::kStorage) { + if (global && global->AddressSpace() == type::AddressSpace::kStorage) { array_length_from_uniform_cfg.bindpoint_to_size_index.emplace( global->BindingPoint(), global->BindingPoint().binding); } @@ -2035,12 +2035,12 @@ bool GeneratorImpl::EmitEntryPointFunction(const ast::Function* func) { } } else if (auto* ptr = param->type->As()) { auto sc = ptr->address_space; - if (sc == ast::AddressSpace::kWorkgroup) { + if (sc == type::AddressSpace::kWorkgroup) { auto& allocations = workgroup_allocations_[func_name]; out << " [[threadgroup(" << allocations.size() << ")]]"; allocations.push_back(program_->Sem().Get(ptr->type)->Size()); - } else if (TINT_LIKELY(sc == ast::AddressSpace::kStorage || - sc == ast::AddressSpace::kUniform)) { + } else if (TINT_LIKELY(sc == type::AddressSpace::kStorage || + sc == type::AddressSpace::kUniform)) { uint32_t binding = get_binding_index(param); if (binding == kInvalidBindingIndex) { return false; @@ -2735,20 +2735,20 @@ bool GeneratorImpl::EmitTypeAndName(std::ostream& out, return true; } -bool GeneratorImpl::EmitAddressSpace(std::ostream& out, ast::AddressSpace sc) { +bool GeneratorImpl::EmitAddressSpace(std::ostream& out, type::AddressSpace sc) { switch (sc) { - case ast::AddressSpace::kFunction: - case ast::AddressSpace::kPrivate: - case ast::AddressSpace::kHandle: + case type::AddressSpace::kFunction: + case type::AddressSpace::kPrivate: + case type::AddressSpace::kHandle: out << "thread"; return true; - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: out << "threadgroup"; return true; - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: out << "device"; return true; - case ast::AddressSpace::kUniform: + case type::AddressSpace::kUniform: out << "constant"; return true; default: @@ -3000,14 +3000,14 @@ bool GeneratorImpl::EmitVar(const ast::Var* var) { auto out = line(); switch (sem->AddressSpace()) { - case ast::AddressSpace::kFunction: - case ast::AddressSpace::kHandle: - case ast::AddressSpace::kNone: + case type::AddressSpace::kFunction: + case type::AddressSpace::kHandle: + case type::AddressSpace::kNone: break; - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: out << "thread "; break; - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: out << "threadgroup "; break; default: @@ -3029,9 +3029,9 @@ bool GeneratorImpl::EmitVar(const ast::Var* var) { if (!EmitExpression(out, var->initializer)) { return false; } - } else if (sem->AddressSpace() == ast::AddressSpace::kPrivate || - sem->AddressSpace() == ast::AddressSpace::kFunction || - sem->AddressSpace() == ast::AddressSpace::kNone) { + } else if (sem->AddressSpace() == type::AddressSpace::kPrivate || + sem->AddressSpace() == type::AddressSpace::kFunction || + sem->AddressSpace() == type::AddressSpace::kNone) { out << " = "; if (!EmitZeroValue(out, type)) { return false; @@ -3049,14 +3049,14 @@ bool GeneratorImpl::EmitLet(const ast::Let* let) { auto out = line(); switch (sem->AddressSpace()) { - case ast::AddressSpace::kFunction: - case ast::AddressSpace::kHandle: - case ast::AddressSpace::kNone: + case type::AddressSpace::kFunction: + case type::AddressSpace::kHandle: + case type::AddressSpace::kNone: break; - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: out << "thread "; break; - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: out << "threadgroup "; break; default: diff --git a/src/tint/writer/msl/generator_impl.h b/src/tint/writer/msl/generator_impl.h index 64c83afab2..f98350644a 100644 --- a/src/tint/writer/msl/generator_impl.h +++ b/src/tint/writer/msl/generator_impl.h @@ -326,7 +326,7 @@ class GeneratorImpl : public TextGenerator { /// @param out the output of the type stream /// @param sc the address space to generate /// @returns true if the address space is emitted - bool EmitAddressSpace(std::ostream& out, ast::AddressSpace sc); + bool EmitAddressSpace(std::ostream& out, type::AddressSpace sc); /// Handles generating a struct declaration. If the structure has already been emitted, then /// this function will simply return `true` without emitting anything. /// @param buffer the text buffer that the type declaration will be written to @@ -410,7 +410,7 @@ class GeneratorImpl : public TextGenerator { /// Name of atomicCompareExchangeWeak() helper for the given pointer storage /// class and struct return type using ACEWKeyType = - utils::UnorderedKeyWrapper>; + utils::UnorderedKeyWrapper>; std::unordered_map atomicCompareExchangeWeak_; /// Unique name of the 'TINT_INVARIANT' preprocessor define. diff --git a/src/tint/writer/msl/generator_impl_array_accessor_test.cc b/src/tint/writer/msl/generator_impl_array_accessor_test.cc index 771d537ba6..eae2c17bd8 100644 --- a/src/tint/writer/msl/generator_impl_array_accessor_test.cc +++ b/src/tint/writer/msl/generator_impl_array_accessor_test.cc @@ -34,7 +34,7 @@ TEST_F(MslGeneratorImplTest, IndexAccessor) { } TEST_F(MslGeneratorImplTest, IndexAccessor_OfDref) { - GlobalVar("ary", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("ary", ty.array(), type::AddressSpace::kPrivate); auto* p = Let("p", AddressOf("ary")); auto* expr = IndexAccessor(Deref("p"), 5_i); diff --git a/src/tint/writer/msl/generator_impl_builtin_test.cc b/src/tint/writer/msl/generator_impl_builtin_test.cc index 7a69a145cd..baaab18200 100644 --- a/src/tint/writer/msl/generator_impl_builtin_test.cc +++ b/src/tint/writer/msl/generator_impl_builtin_test.cc @@ -216,21 +216,21 @@ TEST_P(MslBuiltinTest, Emit) { if (param.type == CallParamType::kF16) { Enable(ast::Extension::kF16); - GlobalVar("h2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("h3", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("hm2x2", ty.mat2x2(), ast::AddressSpace::kPrivate); - GlobalVar("hm3x2", ty.mat3x2(), ast::AddressSpace::kPrivate); + GlobalVar("h2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("h3", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("hm2x2", ty.mat2x2(), type::AddressSpace::kPrivate); + GlobalVar("hm3x2", ty.mat3x2(), type::AddressSpace::kPrivate); } - GlobalVar("f2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("f3", ty.vec3(), ast::AddressSpace::kPrivate); - GlobalVar("f4", ty.vec4(), ast::AddressSpace::kPrivate); - GlobalVar("u1", ty.u32(), ast::AddressSpace::kPrivate); - GlobalVar("u2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("i2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("b2", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("m2x2", ty.mat2x2(), ast::AddressSpace::kPrivate); - GlobalVar("m3x2", ty.mat3x2(), ast::AddressSpace::kPrivate); + GlobalVar("f2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("f3", ty.vec3(), type::AddressSpace::kPrivate); + GlobalVar("f4", ty.vec4(), type::AddressSpace::kPrivate); + GlobalVar("u1", ty.u32(), type::AddressSpace::kPrivate); + GlobalVar("u2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("i2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("b2", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("m2x2", ty.mat2x2(), type::AddressSpace::kPrivate); + GlobalVar("m3x2", ty.mat3x2(), type::AddressSpace::kPrivate); auto* call = GenerateCall(param.builtin, param.type, this); ASSERT_NE(nullptr, call) << "Unhandled builtin"; @@ -370,8 +370,8 @@ INSTANTIATE_TEST_SUITE_P( "unpack_unorm2x16_to_float"})); TEST_F(MslGeneratorImplTest, Builtin_Call) { - GlobalVar("param1", ty.vec2(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.vec2(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.vec2(), type::AddressSpace::kPrivate); auto* call = Call("dot", "param1", "param2"); WrapInFunction(CallStmt(call)); @@ -1065,7 +1065,7 @@ kernel void test_function() { TEST_F(MslGeneratorImplTest, Pack2x16Float) { auto* call = Call("pack2x16float", "p1"); - GlobalVar("p1", ty.vec2(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.vec2(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1077,7 +1077,7 @@ TEST_F(MslGeneratorImplTest, Pack2x16Float) { TEST_F(MslGeneratorImplTest, Unpack2x16Float) { auto* call = Call("unpack2x16float", "p1"); - GlobalVar("p1", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(call)); GeneratorImpl& gen = Build(); @@ -1088,7 +1088,7 @@ TEST_F(MslGeneratorImplTest, Unpack2x16Float) { } TEST_F(MslGeneratorImplTest, DotI32) { - GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); WrapInFunction(CallStmt(Call("dot", "v", "v"))); GeneratorImpl& gen = SanitizeAndBuild(); diff --git a/src/tint/writer/msl/generator_impl_call_test.cc b/src/tint/writer/msl/generator_impl_call_test.cc index 75504fb527..4449c2b22b 100644 --- a/src/tint/writer/msl/generator_impl_call_test.cc +++ b/src/tint/writer/msl/generator_impl_call_test.cc @@ -45,8 +45,8 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) { utils::Vector{ Return(1.23_f), }); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("my_func", "param1", "param2"); WrapInFunction(call); @@ -65,8 +65,8 @@ TEST_F(MslGeneratorImplTest, EmitStatement_Call) { Param(Sym(), ty.f32()), }, ty.void_(), utils::Empty, utils::Empty); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("my_func", "param1", "param2"); auto* stmt = CallStmt(call); diff --git a/src/tint/writer/msl/generator_impl_function_test.cc b/src/tint/writer/msl/generator_impl_function_test.cc index 3fa5a21c43..c1b9b7af09 100644 --- a/src/tint/writer/msl/generator_impl_function_test.cc +++ b/src/tint/writer/msl/generator_impl_function_test.cc @@ -342,7 +342,7 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_EntryPoint_With_RW_StorageBu Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), Binding(0_a)); auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b")); @@ -381,7 +381,7 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_EntryPoint_With_RO_StorageBu Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), Binding(0_a)); auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b")); @@ -417,7 +417,7 @@ fragment void frag_main(const device Data* tint_symbol [[buffer(0)]]) { TEST_F(MslGeneratorImplTest, Emit_Attribute_Called_By_EntryPoint_With_Uniform) { auto* ubo_ty = Structure("UBO", utils::Vector{Member("coord", ty.vec4())}); auto* ubo = - GlobalVar("ubo", ty.Of(ubo_ty), ast::AddressSpace::kUniform, Group(0_a), Binding(0_a)); + GlobalVar("ubo", ty.Of(ubo_ty), type::AddressSpace::kUniform, Group(0_a), Binding(0_a)); Func("sub_func", utils::Vector{ @@ -467,7 +467,7 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_Called_By_EntryPoint_With_RW Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), Binding(0_a)); Func("sub_func", @@ -519,7 +519,7 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_Called_By_EntryPoint_With_RO Member("b", ty.f32()), }); - GlobalVar("coord", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), + GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), Binding(0_a)); Func("sub_func", @@ -657,7 +657,7 @@ TEST_F(MslGeneratorImplTest, Emit_Function_Multiple_EntryPoint_With_Same_ModuleV auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())}); - GlobalVar("data", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), + GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a), Binding(0_a)); { diff --git a/src/tint/writer/msl/generator_impl_import_test.cc b/src/tint/writer/msl/generator_impl_import_test.cc index 07f4acd496..6fd95ae5f1 100644 --- a/src/tint/writer/msl/generator_impl_import_test.cc +++ b/src/tint/writer/msl/generator_impl_import_test.cc @@ -234,7 +234,7 @@ INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest, MslImportData{"clamp", "clamp"})); TEST_F(MslGeneratorImplTest, MslImportData_Determinant) { - GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = Call("determinant", "var"); @@ -248,7 +248,7 @@ TEST_F(MslGeneratorImplTest, MslImportData_Determinant) { } TEST_F(MslGeneratorImplTest, MslImportData_QuantizeToF16_Scalar) { - GlobalVar("v", Expr(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate); auto* expr = Call("quantizeToF16", "v"); WrapInFunction(expr); @@ -261,7 +261,7 @@ TEST_F(MslGeneratorImplTest, MslImportData_QuantizeToF16_Scalar) { } TEST_F(MslGeneratorImplTest, MslImportData_QuantizeToF16_Vector) { - GlobalVar("v", vec3(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", vec3(2_f), type::AddressSpace::kPrivate); auto* expr = Call("quantizeToF16", "v"); WrapInFunction(expr); diff --git a/src/tint/writer/msl/generator_impl_loop_test.cc b/src/tint/writer/msl/generator_impl_loop_test.cc index 8926f2a34e..cac1306565 100644 --- a/src/tint/writer/msl/generator_impl_loop_test.cc +++ b/src/tint/writer/msl/generator_impl_loop_test.cc @@ -93,8 +93,8 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithContinuing_BreakIf) { TEST_F(MslGeneratorImplTest, Emit_LoopNestedWithContinuing) { Func("a_statement", {}, ty.void_(), utils::Empty); - GlobalVar("lhs", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("rhs", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("lhs", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate); auto* body = Block(Break()); auto* continuing = Block(CallStmt(Call("a_statement"))); @@ -139,7 +139,7 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithVarUsedInContinuing) { // } // - GlobalVar("rhs", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate); auto* body = Block(Decl(Var("lhs", ty.f32(), Expr(2.4_f))), // Decl(Var("other", ty.f32())), // @@ -216,7 +216,7 @@ TEST_F(MslGeneratorImplTest, Emit_ForLoopWithMultiStmtInit) { Func("f", utils::Vector{Param("i", ty.i32())}, ty.void_(), utils::Empty); auto f = [&](auto&& expr) { return CallStmt(Call("f", expr)); }; - GlobalVar("a", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(), type::AddressSpace::kWorkgroup); auto* multi_stmt = Block(f(1_i), f(2_i)); auto* loop = For(multi_stmt, nullptr, nullptr, // Block(Return())); @@ -292,7 +292,7 @@ TEST_F(MslGeneratorImplTest, Emit_ForLoopWithMultiStmtCont) { Func("f", utils::Vector{Param("i", ty.i32())}, ty.void_(), utils::Empty); auto f = [&](auto&& expr) { return CallStmt(Call("f", expr)); }; - GlobalVar("a", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(), type::AddressSpace::kWorkgroup); auto* multi_stmt = Block(f(1_i), f(2_i)); auto* loop = For(nullptr, nullptr, multi_stmt, // Block(Return())); @@ -347,7 +347,7 @@ TEST_F(MslGeneratorImplTest, Emit_ForLoopWithMultiStmtInitCondCont) { Func("f", utils::Vector{Param("i", ty.i32())}, ty.void_(), utils::Empty); auto f = [&](auto&& expr) { return CallStmt(Call("f", expr)); }; - GlobalVar("a", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(), type::AddressSpace::kWorkgroup); auto* multi_stmt_a = Block(f(1_i), f(2_i)); auto* multi_stmt_b = Block(f(3_i), f(4_i)); auto* loop = For(multi_stmt_a, Expr(true), multi_stmt_b, // diff --git a/src/tint/writer/msl/generator_impl_member_accessor_test.cc b/src/tint/writer/msl/generator_impl_member_accessor_test.cc index 2f16f4afa5..0b54a52f56 100644 --- a/src/tint/writer/msl/generator_impl_member_accessor_test.cc +++ b/src/tint/writer/msl/generator_impl_member_accessor_test.cc @@ -21,7 +21,7 @@ using MslGeneratorImplTest = TestHelper; TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) { GlobalVar("str", ty.Of(Structure("my_str", utils::Vector{Member("mem", ty.f32())})), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); auto* expr = MemberAccessor("str", "mem"); WrapInFunction(expr); @@ -33,7 +33,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) { } TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_xyz) { - GlobalVar("my_vec", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec4(), type::AddressSpace::kPrivate); auto* expr = MemberAccessor("my_vec", "xyz"); WrapInFunction(expr); @@ -45,7 +45,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_xyz) { } TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_gbr) { - GlobalVar("my_vec", ty.vec4(), ast::AddressSpace::kPrivate); + GlobalVar("my_vec", ty.vec4(), type::AddressSpace::kPrivate); auto* expr = MemberAccessor("my_vec", "gbr"); WrapInFunction(expr); diff --git a/src/tint/writer/msl/generator_impl_sanitizer_test.cc b/src/tint/writer/msl/generator_impl_sanitizer_test.cc index 71fe1f6048..e749f1a126 100644 --- a/src/tint/writer/msl/generator_impl_sanitizer_test.cc +++ b/src/tint/writer/msl/generator_impl_sanitizer_test.cc @@ -28,7 +28,7 @@ using MslSanitizerTest = TestHelper; TEST_F(MslSanitizerTest, Call_ArrayLength) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -82,7 +82,7 @@ TEST_F(MslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) { Member(0, "z", ty.f32()), Member(4, "a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -135,7 +135,7 @@ fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(30)]]) { TEST_F(MslSanitizerTest, Call_ArrayLength_ViaLets) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* p = Let("p", AddressOf("b")); @@ -192,9 +192,9 @@ fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(30)]]) { TEST_F(MslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniform) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(0_a)); - GlobalVar("c", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(2_a), + GlobalVar("c", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(2_a), Group(0_a)); Func("a_func", utils::Empty, ty.void_(), @@ -251,9 +251,9 @@ fragment void a_func(const constant tint_symbol* tint_symbol_2 [[buffer(29)]]) { TEST_F(MslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniformMissingBinding) { auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array(4))}); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(0_a)); - GlobalVar("c", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(2_a), + GlobalVar("c", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(2_a), Group(0_a)); Func("a_func", utils::Empty, ty.void_(), diff --git a/src/tint/writer/msl/generator_impl_test.cc b/src/tint/writer/msl/generator_impl_test.cc index 2299c19db3..ff3a4c997a 100644 --- a/src/tint/writer/msl/generator_impl_test.cc +++ b/src/tint/writer/msl/generator_impl_test.cc @@ -163,7 +163,7 @@ vertex Out vert_main() { } TEST_F(MslGeneratorImplTest, WorkgroupMatrix) { - GlobalVar("m", ty.mat2x2(), ast::AddressSpace::kWorkgroup); + GlobalVar("m", ty.mat2x2(), type::AddressSpace::kWorkgroup); Func("comp_main", utils::Empty, ty.void_(), utils::Vector{Decl(Let("x", Expr("m")))}, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -203,7 +203,7 @@ kernel void comp_main(threadgroup tint_symbol_3* tint_symbol_2 [[threadgroup(0)] } TEST_F(MslGeneratorImplTest, WorkgroupMatrixInArray) { - GlobalVar("m", ty.array(ty.mat2x2(), 4_i), ast::AddressSpace::kWorkgroup); + GlobalVar("m", ty.array(ty.mat2x2(), 4_i), type::AddressSpace::kWorkgroup); Func("comp_main", utils::Empty, ty.void_(), utils::Vector{Decl(Let("x", Expr("m")))}, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -264,7 +264,7 @@ TEST_F(MslGeneratorImplTest, WorkgroupMatrixInStruct) { Structure("S2", utils::Vector{ Member("s", ty.type_name("S1")), }); - GlobalVar("s", ty.type_name("S2"), ast::AddressSpace::kWorkgroup); + GlobalVar("s", ty.type_name("S2"), type::AddressSpace::kWorkgroup); Func("comp_main", utils::Empty, ty.void_(), utils::Vector{Decl(Let("x", Expr("s")))}, utils::Vector{ Stage(ast::PipelineStage::kCompute), @@ -314,15 +314,15 @@ kernel void comp_main(threadgroup tint_symbol_4* tint_symbol_3 [[threadgroup(0)] } TEST_F(MslGeneratorImplTest, WorkgroupMatrix_Multiples) { - GlobalVar("m1", ty.mat2x2(), ast::AddressSpace::kWorkgroup); - GlobalVar("m2", ty.mat2x3(), ast::AddressSpace::kWorkgroup); - GlobalVar("m3", ty.mat2x4(), ast::AddressSpace::kWorkgroup); - GlobalVar("m4", ty.mat3x2(), ast::AddressSpace::kWorkgroup); - GlobalVar("m5", ty.mat3x3(), ast::AddressSpace::kWorkgroup); - GlobalVar("m6", ty.mat3x4(), ast::AddressSpace::kWorkgroup); - GlobalVar("m7", ty.mat4x2(), ast::AddressSpace::kWorkgroup); - GlobalVar("m8", ty.mat4x3(), ast::AddressSpace::kWorkgroup); - GlobalVar("m9", ty.mat4x4(), ast::AddressSpace::kWorkgroup); + GlobalVar("m1", ty.mat2x2(), type::AddressSpace::kWorkgroup); + GlobalVar("m2", ty.mat2x3(), type::AddressSpace::kWorkgroup); + GlobalVar("m3", ty.mat2x4(), type::AddressSpace::kWorkgroup); + GlobalVar("m4", ty.mat3x2(), type::AddressSpace::kWorkgroup); + GlobalVar("m5", ty.mat3x3(), type::AddressSpace::kWorkgroup); + GlobalVar("m6", ty.mat3x4(), type::AddressSpace::kWorkgroup); + GlobalVar("m7", ty.mat4x2(), type::AddressSpace::kWorkgroup); + GlobalVar("m8", ty.mat4x3(), type::AddressSpace::kWorkgroup); + GlobalVar("m9", ty.mat4x4(), type::AddressSpace::kWorkgroup); Func("main1", utils::Empty, ty.void_(), utils::Vector{ Decl(Let("a1", Expr("m1"))), diff --git a/src/tint/writer/msl/generator_impl_type_test.cc b/src/tint/writer/msl/generator_impl_type_test.cc index ef3714828a..6ac4c84c41 100644 --- a/src/tint/writer/msl/generator_impl_type_test.cc +++ b/src/tint/writer/msl/generator_impl_type_test.cc @@ -90,7 +90,7 @@ using MslGeneratorImplTest = TestHelper; TEST_F(MslGeneratorImplTest, EmitType_Array) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -102,7 +102,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Array) { TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) { auto* a = ty.array(); auto* b = ty.array(a, 5_u); - GlobalVar("G", b, ast::AddressSpace::kPrivate); + GlobalVar("G", b, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -115,7 +115,7 @@ TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) { auto* a = ty.array(); auto* b = ty.array(a, 5_u); auto* c = ty.array(b, 6_u); - GlobalVar("G", c, ast::AddressSpace::kPrivate); + GlobalVar("G", c, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -126,7 +126,7 @@ TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) { TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -137,7 +137,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) { TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray) { auto* arr = ty.array(); - GlobalVar("G", arr, ast::AddressSpace::kPrivate); + GlobalVar("G", arr, type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -212,7 +212,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Matrix_F16) { TEST_F(MslGeneratorImplTest, EmitType_Pointer) { auto* f32 = create(); - auto* p = create(f32, ast::AddressSpace::kWorkgroup, ast::Access::kReadWrite); + auto* p = create(f32, type::AddressSpace::kWorkgroup, ast::Access::kReadWrite); GeneratorImpl& gen = Build(); @@ -283,7 +283,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_NonComposites) { Member("z", ty.f32()), }); - GlobalVar("G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -391,7 +391,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_Structures) { Member("e", ty.f32()), }); - GlobalVar("G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -482,7 +482,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_ArrayDefaultStride) { Member("f", array_z), }); - GlobalVar("G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -565,7 +565,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_ArrayVec3DefaultStride) { Member("c", ty.i32()), }); - GlobalVar("G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -626,7 +626,7 @@ TEST_F(MslGeneratorImplTest, AttemptTintPadSymbolCollision) { Member("tint_pad_21", ty.f32()), }); - GlobalVar("G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -684,7 +684,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_WithAttribute) { Member("b", ty.f32()), }); - GlobalVar("G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); diff --git a/src/tint/writer/msl/generator_impl_unary_op_test.cc b/src/tint/writer/msl/generator_impl_unary_op_test.cc index 0c234df591..ff4ac50dc7 100644 --- a/src/tint/writer/msl/generator_impl_unary_op_test.cc +++ b/src/tint/writer/msl/generator_impl_unary_op_test.cc @@ -20,7 +20,7 @@ namespace { using MslUnaryOpTest = TestHelper; TEST_F(MslUnaryOpTest, AddressOf) { - GlobalVar("expr", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kAddressOf, Expr("expr")); WrapInFunction(op); @@ -32,7 +32,7 @@ TEST_F(MslUnaryOpTest, AddressOf) { } TEST_F(MslUnaryOpTest, Complement) { - GlobalVar("expr", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kComplement, Expr("expr")); WrapInFunction(op); @@ -44,7 +44,7 @@ TEST_F(MslUnaryOpTest, Complement) { } TEST_F(MslUnaryOpTest, Indirection) { - GlobalVar("G", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate); auto* p = Let("expr", create(ast::UnaryOp::kAddressOf, Expr("G"))); auto* op = create(ast::UnaryOp::kIndirection, Expr("expr")); WrapInFunction(p, op); @@ -57,7 +57,7 @@ TEST_F(MslUnaryOpTest, Indirection) { } TEST_F(MslUnaryOpTest, Not) { - GlobalVar("expr", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNot, Expr("expr")); WrapInFunction(op); @@ -69,7 +69,7 @@ TEST_F(MslUnaryOpTest, Not) { } TEST_F(MslUnaryOpTest, Negation) { - GlobalVar("expr", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNegation, Expr("expr")); WrapInFunction(op); diff --git a/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc b/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc index b57a39ffd8..5ee1c33f0e 100644 --- a/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc +++ b/src/tint/writer/msl/generator_impl_variable_decl_statement_test.cc @@ -518,7 +518,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_ZeroMat_f16) } TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); WrapInFunction(Expr("a")); @@ -531,7 +531,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) { } TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Workgroup) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.f32(), type::AddressSpace::kWorkgroup); WrapInFunction(Expr("a")); diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc index 00901569db..d35a486053 100644 --- a/src/tint/writer/spirv/builder.cc +++ b/src/tint/writer/spirv/builder.cc @@ -506,8 +506,8 @@ bool Builder::GenerateEntryPoint(const ast::Function* func, uint32_t id) { for (const auto* var : func_sem->TransitivelyReferencedGlobals()) { // For SPIR-V 1.3 we only output Input/output variables. If we update to // SPIR-V 1.4 or later this should be all variables. - if (var->AddressSpace() != ast::AddressSpace::kIn && - var->AddressSpace() != ast::AddressSpace::kOut) { + if (var->AddressSpace() != type::AddressSpace::kIn && + var->AddressSpace() != type::AddressSpace::kOut) { continue; } @@ -717,7 +717,7 @@ bool Builder::GenerateFunctionVariable(const ast::Variable* v) { auto result = result_op(); auto var_id = std::get(result); - auto sc = ast::AddressSpace::kFunction; + auto sc = type::AddressSpace::kFunction; auto* type = sem->Type(); auto type_id = GenerateTypeIfNeeded(type); if (type_id == 0) { @@ -776,8 +776,8 @@ bool Builder::GenerateGlobalVariable(const ast::Variable* v) { auto result = result_op(); auto var_id = std::get(result); - auto sc = sem->AddressSpace() == ast::AddressSpace::kNone ? ast::AddressSpace::kPrivate - : sem->AddressSpace(); + auto sc = sem->AddressSpace() == type::AddressSpace::kNone ? type::AddressSpace::kPrivate + : sem->AddressSpace(); auto type_id = GenerateTypeIfNeeded(sem->Type()); if (type_id == 0) { @@ -815,10 +815,10 @@ bool Builder::GenerateGlobalVariable(const ast::Variable* v) { // If we're a Workgroup variable, and the // VK_KHR_zero_initialize_workgroup_memory extension is enabled, we should // also zero-initialize. - if (sem->AddressSpace() == ast::AddressSpace::kPrivate || - sem->AddressSpace() == ast::AddressSpace::kOut || + if (sem->AddressSpace() == type::AddressSpace::kPrivate || + sem->AddressSpace() == type::AddressSpace::kOut || (zero_initialize_workgroup_memory_ && - sem->AddressSpace() == ast::AddressSpace::kWorkgroup)) { + sem->AddressSpace() == type::AddressSpace::kWorkgroup)) { init_id = GenerateConstantNullIfNeeded(type); if (init_id == 0) { return 0; @@ -1903,10 +1903,10 @@ uint32_t Builder::GenerateShortCircuitBinaryExpression(const ast::BinaryExpressi uint32_t Builder::GenerateSplat(uint32_t scalar_id, const type::Type* vec_type) { // Create a new vector to splat scalar into auto splat_vector = result_op(); - auto* splat_vector_type = builder_.create(vec_type, ast::AddressSpace::kFunction, - ast::Access::kReadWrite); + auto* splat_vector_type = builder_.create( + vec_type, type::AddressSpace::kFunction, ast::Access::kReadWrite); push_function_var({Operand(GenerateTypeIfNeeded(splat_vector_type)), splat_vector, - U32Operand(ConvertAddressSpace(ast::AddressSpace::kFunction)), + U32Operand(ConvertAddressSpace(type::AddressSpace::kFunction)), Operand(GenerateConstantNullIfNeeded(vec_type))}); // Splat scalar into vector @@ -3073,11 +3073,11 @@ bool Builder::GenerateAtomicBuiltin(const sem::Call* call, uint32_t memory_id = 0; switch (builtin->Parameters()[0]->Type()->As()->AddressSpace()) { - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: memory_id = GenerateConstantIfNeeded( ScalarConstant::U32(static_cast(spv::Scope::Workgroup))); break; - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: memory_id = GenerateConstantIfNeeded( ScalarConstant::U32(static_cast(spv::Scope::Device))); break; @@ -3980,40 +3980,40 @@ bool Builder::GenerateVectorType(const type::Vector* vec, const Operand& result) return true; } -SpvStorageClass Builder::ConvertAddressSpace(ast::AddressSpace klass) const { +SpvStorageClass Builder::ConvertAddressSpace(type::AddressSpace klass) const { switch (klass) { - case ast::AddressSpace::kUndefined: + case type::AddressSpace::kUndefined: return SpvStorageClassMax; - case ast::AddressSpace::kIn: + case type::AddressSpace::kIn: return SpvStorageClassInput; - case ast::AddressSpace::kOut: + case type::AddressSpace::kOut: return SpvStorageClassOutput; - case ast::AddressSpace::kUniform: + case type::AddressSpace::kUniform: return SpvStorageClassUniform; - case ast::AddressSpace::kWorkgroup: + case type::AddressSpace::kWorkgroup: return SpvStorageClassWorkgroup; - case ast::AddressSpace::kPushConstant: + case type::AddressSpace::kPushConstant: return SpvStorageClassPushConstant; - case ast::AddressSpace::kHandle: + case type::AddressSpace::kHandle: return SpvStorageClassUniformConstant; - case ast::AddressSpace::kStorage: + case type::AddressSpace::kStorage: return SpvStorageClassStorageBuffer; - case ast::AddressSpace::kPrivate: + case type::AddressSpace::kPrivate: return SpvStorageClassPrivate; - case ast::AddressSpace::kFunction: + case type::AddressSpace::kFunction: return SpvStorageClassFunction; - case ast::AddressSpace::kNone: + case type::AddressSpace::kNone: break; } return SpvStorageClassMax; } -SpvBuiltIn Builder::ConvertBuiltin(ast::BuiltinValue builtin, ast::AddressSpace storage) { +SpvBuiltIn Builder::ConvertBuiltin(ast::BuiltinValue builtin, type::AddressSpace storage) { switch (builtin) { case ast::BuiltinValue::kPosition: - if (storage == ast::AddressSpace::kIn) { + if (storage == type::AddressSpace::kIn) { return SpvBuiltInFragCoord; - } else if (TINT_LIKELY(storage == ast::AddressSpace::kOut)) { + } else if (TINT_LIKELY(storage == type::AddressSpace::kOut)) { return SpvBuiltInPosition; } else { TINT_ICE(Writer, builder_.Diagnostics()) << "invalid address space for builtin"; diff --git a/src/tint/writer/spirv/builder.h b/src/tint/writer/spirv/builder.h index 0704074783..4455f28306 100644 --- a/src/tint/writer/spirv/builder.h +++ b/src/tint/writer/spirv/builder.h @@ -208,12 +208,12 @@ class Builder { /// Converts a address space to a SPIR-V address space. /// @param klass the address space to convert /// @returns the SPIR-V address space or SpvStorageClassMax on error. - SpvStorageClass ConvertAddressSpace(ast::AddressSpace klass) const; + SpvStorageClass ConvertAddressSpace(type::AddressSpace klass) const; /// Converts a builtin to a SPIR-V builtin and pushes a capability if needed. /// @param builtin the builtin to convert /// @param storage the address space that this builtin is being used with /// @returns the SPIR-V builtin or SpvBuiltInMax on error. - SpvBuiltIn ConvertBuiltin(ast::BuiltinValue builtin, ast::AddressSpace storage); + SpvBuiltIn ConvertBuiltin(ast::BuiltinValue builtin, type::AddressSpace storage); /// Converts an interpolate attribute to SPIR-V decorations and pushes a /// capability if needed. diff --git a/src/tint/writer/spirv/builder_assign_test.cc b/src/tint/writer/spirv/builder_assign_test.cc index 1e2cf65275..a82d4b9f76 100644 --- a/src/tint/writer/spirv/builder_assign_test.cc +++ b/src/tint/writer/spirv/builder_assign_test.cc @@ -23,7 +23,7 @@ namespace { using BuilderTest = TestHelper; TEST_F(BuilderTest, Assign_Var) { - auto* v = GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate); auto* assign = Assign("var", 1_f); @@ -51,7 +51,7 @@ TEST_F(BuilderTest, Assign_Var) { } TEST_F(BuilderTest, Assign_Var_OutsideFunction_IsError) { - auto* v = GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate); auto* assign = Assign("var", Expr(1_f)); @@ -70,7 +70,7 @@ TEST_F(BuilderTest, Assign_Var_OutsideFunction_IsError) { } TEST_F(BuilderTest, Assign_Var_ZeroInitializer) { - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate); auto* val = vec3(); auto* assign = Assign("var", val); @@ -101,7 +101,7 @@ TEST_F(BuilderTest, Assign_Var_ZeroInitializer) { TEST_F(BuilderTest, Assign_Var_Complex_InitializerNestedVector) { auto* init = vec3(vec2(1_f, 2_f), 3_f); - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate); auto* assign = Assign("var", init); @@ -134,7 +134,7 @@ TEST_F(BuilderTest, Assign_Var_Complex_InitializerNestedVector) { TEST_F(BuilderTest, Assign_Var_Complex_Initializer) { auto* init = vec3(1_f, 2_f, 3_f); - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate); auto* assign = Assign("var", init); @@ -209,7 +209,7 @@ OpStore %9 %10 } TEST_F(BuilderTest, Assign_Vector) { - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate); auto* val = vec3(1_f, 1_f, 3_f); auto* assign = Assign("var", val); @@ -243,7 +243,7 @@ TEST_F(BuilderTest, Assign_Vector) { TEST_F(BuilderTest, Assign_Vector_MemberByName) { // var.y = 1 - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate); auto* assign = Assign(MemberAccessor("var", "y"), Expr(1_f)); @@ -278,7 +278,7 @@ OpStore %9 %10 TEST_F(BuilderTest, Assign_Vector_MemberByIndex) { // var[1] = 1 - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate); auto* assign = Assign(IndexAccessor("var", 1_i), Expr(1_f)); diff --git a/src/tint/writer/spirv/builder_binary_expression_test.cc b/src/tint/writer/spirv/builder_binary_expression_test.cc index f0a5639d0b..77336134dc 100644 --- a/src/tint/writer/spirv/builder_binary_expression_test.cc +++ b/src/tint/writer/spirv/builder_binary_expression_test.cc @@ -1031,8 +1031,8 @@ OpBranch %17 } TEST_F(BuilderTest, Binary_LogicalAnd_WithLoads) { - auto* a_var = GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate, Expr(true)); - auto* b_var = GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate, Expr(false)); + auto* a_var = GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, Expr(true)); + auto* b_var = GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate, Expr(false)); auto* expr = create(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")); WrapInFunction(expr); @@ -1207,8 +1207,8 @@ OpBranch %17 } TEST_F(BuilderTest, Binary_LogicalOr_WithLoads) { - auto* a_var = GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate, Expr(true)); - auto* b_var = GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate, Expr(false)); + auto* a_var = GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, Expr(true)); + auto* b_var = GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate, Expr(false)); auto* expr = create(ast::BinaryOp::kLogicalOr, Expr("a"), Expr("b")); @@ -1251,19 +1251,19 @@ static const ast::Expression* MakeVectorExpr(ProgramBuilder* builder, Type type) switch (type) { case Type::f32: builder->GlobalVar(name, builder->ty.vec3(), builder->vec3(1_f, 1_f, 1_f), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::f16: builder->GlobalVar(name, builder->ty.vec3(), builder->vec3(1_h, 1_h, 1_h), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::i32: builder->GlobalVar(name, builder->ty.vec3(), builder->vec3(1_i, 1_i, 1_i), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::u32: builder->GlobalVar(name, builder->ty.vec3(), builder->vec3(1_u, 1_u, 1_u), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; } return builder->Expr(name); @@ -1273,19 +1273,19 @@ static const ast::Expression* MakeScalarExpr(ProgramBuilder* builder, Type type) switch (type) { case Type::f32: builder->GlobalVar(name, builder->ty.f32(), builder->Expr(1_f), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::f16: builder->GlobalVar(name, builder->ty.f16(), builder->Expr(1_h), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::i32: builder->GlobalVar(name, builder->ty.i32(), builder->Expr(1_i), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::u32: builder->GlobalVar(name, builder->ty.u32(), builder->Expr(1_u), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; } return builder->Expr(name); @@ -1580,11 +1580,11 @@ static const ast::Expression* MakeMat3x4Expr(ProgramBuilder* builder, Type type) switch (type) { case Type::f32: builder->GlobalVar(name, builder->ty.mat3x4(), builder->mat3x4(), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::f16: builder->GlobalVar(name, builder->ty.mat3x4(), builder->mat3x4(), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; } return builder->Expr(name); @@ -1594,11 +1594,11 @@ static const ast::Expression* MakeMat4x3Expr(ProgramBuilder* builder, Type type) switch (type) { case Type::f32: builder->GlobalVar(name, builder->ty.mat4x3(), builder->mat4x3(), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); break; case Type::f16: builder->GlobalVar(name, builder->ty.mat4x3(), builder->mat4x3(), - ast::AddressSpace::kPrivate); + type::AddressSpace::kPrivate); } return builder->Expr(name); } diff --git a/src/tint/writer/spirv/builder_builtin_test.cc b/src/tint/writer/spirv/builder_builtin_test.cc index 3262b35fa5..e15386cf34 100644 --- a/src/tint/writer/spirv/builder_builtin_test.cc +++ b/src/tint/writer/spirv/builder_builtin_test.cc @@ -98,7 +98,7 @@ TEST_F(BuiltinBuilderTest, Call_TextureSampleCompare_Twice) { } TEST_F(BuiltinBuilderTest, Call_GLSLMethod_WithLoad_f32) { - auto* var = GlobalVar("ident", ty.f32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("ident", ty.f32(), type::AddressSpace::kPrivate); auto* expr = Call("round", "ident"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -134,7 +134,7 @@ OpFunctionEnd TEST_F(BuiltinBuilderTest, Call_GLSLMethod_WithLoad_f16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("ident", ty.f16(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("ident", ty.f16(), type::AddressSpace::kPrivate); auto* expr = Call("round", "ident"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -173,7 +173,7 @@ namespace logical_builtin_tests { using BuiltinBoolTest = BuiltinBuilderTestWithParam; TEST_P(BuiltinBoolTest, Call_Bool_Scalar) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.bool_(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.bool_(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -199,7 +199,7 @@ TEST_P(BuiltinBoolTest, Call_Bool_Scalar) { TEST_P(BuiltinBoolTest, Call_Bool_Vector) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -232,9 +232,9 @@ INSTANTIATE_TEST_SUITE_P(BuiltinBuilderTest, testing::Values(BuiltinData{"any", "OpAny"}, BuiltinData{"all", "OpAll"})); TEST_F(BuiltinBuilderTest, Call_Select) { - auto* v3 = GlobalVar("v3", ty.vec3(), ast::AddressSpace::kPrivate); + auto* v3 = GlobalVar("v3", ty.vec3(), type::AddressSpace::kPrivate); - auto* bool_v3 = GlobalVar("bool_v3", ty.vec3(), ast::AddressSpace::kPrivate); + auto* bool_v3 = GlobalVar("bool_v3", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("select", "v3", "v3", "bool_v3"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -278,7 +278,7 @@ TEST_F(BuiltinBuilderTest, Call_ArrayLength) { auto* s = Structure("my_struct", utils::Vector{ Member("a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* expr = Call("arrayLength", AddressOf(MemberAccessor("b", "a"))); @@ -322,7 +322,7 @@ TEST_F(BuiltinBuilderTest, Call_ArrayLength_OtherMembersInStruct) { Member("z", ty.f32()), Member(4, "a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* expr = Call("arrayLength", AddressOf(MemberAccessor("b", "a"))); @@ -365,7 +365,7 @@ TEST_F(BuiltinBuilderTest, Call_ArrayLength_ViaLets) { auto* s = Structure("my_struct", utils::Vector{ Member("a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* p = Let("p", AddressOf("b")); @@ -424,7 +424,7 @@ TEST_F(BuiltinBuilderTest, Call_ArrayLength_ViaLets_WithPtrNoise) { auto* s = Structure("my_struct", utils::Vector{ Member("a", ty.array(4)), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a), Group(2_a)); auto* p = Let("p", AddressOf(Deref(AddressOf("b")))); @@ -2100,7 +2100,7 @@ OpFunctionEnd } TEST_F(BuiltinBuilderTest, Call_QuantizeToF16_Scalar) { - GlobalVar("v", Expr(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate); Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -2139,7 +2139,7 @@ OpFunctionEnd } TEST_F(BuiltinBuilderTest, Call_QuantizeToF16_Vector) { - GlobalVar("v", vec3(2_f), ast::AddressSpace::kPrivate); + GlobalVar("v", vec3(2_f), type::AddressSpace::kPrivate); Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -2206,7 +2206,7 @@ namespace integer_builtin_tests { using BuiltinIntTest = BuiltinBuilderTestWithParam; TEST_P(BuiltinIntTest, Call_SInt_Scalar) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -2236,7 +2236,7 @@ OpReturn TEST_P(BuiltinIntTest, Call_SInt_Vector) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -2267,7 +2267,7 @@ OpReturn TEST_P(BuiltinIntTest, Call_UInt_Scalar) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.u32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.u32(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -2297,7 +2297,7 @@ OpReturn TEST_P(BuiltinIntTest, Call_UInt_Vector) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3168,7 +3168,7 @@ OpFunctionEnd namespace matrix_builtin_tests { TEST_F(BuiltinBuilderTest, Call_Determinant_f32) { - auto* var = GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = Call("determinant", "var"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3205,7 +3205,7 @@ OpFunctionEnd TEST_F(BuiltinBuilderTest, Call_Determinant_f16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("var", ty.mat3x3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("var", ty.mat3x3(), type::AddressSpace::kPrivate); auto* expr = Call("determinant", "var"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3240,7 +3240,7 @@ OpFunctionEnd } TEST_F(BuiltinBuilderTest, Call_Transpose_f32) { - auto* var = GlobalVar("var", ty.mat2x3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* expr = Call("transpose", "var"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3278,7 +3278,7 @@ OpFunctionEnd TEST_F(BuiltinBuilderTest, Call_Transpose_f16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("var", ty.mat2x3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("var", ty.mat2x3(), type::AddressSpace::kPrivate); auto* expr = Call("transpose", "var"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3319,7 +3319,7 @@ OpFunctionEnd namespace vector_builtin_tests { TEST_F(BuiltinBuilderTest, Call_Dot_F32) { - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "v", "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3350,7 +3350,7 @@ OpReturn TEST_F(BuiltinBuilderTest, Call_Dot_F16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "v", "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3379,7 +3379,7 @@ OpReturn } TEST_F(BuiltinBuilderTest, Call_Dot_U32) { - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "v", "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3418,7 +3418,7 @@ OpReturn } TEST_F(BuiltinBuilderTest, Call_Dot_I32) { - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call("dot", "v", "v"); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -3464,7 +3464,7 @@ namespace derivative_builtin_tests { using BuiltinDeriveTest = BuiltinBuilderTestWithParam; TEST_P(BuiltinDeriveTest, Call_Derivative_Scalar) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.f32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.f32(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("func", utils::Empty, ty.void_(), utils::Vector{ @@ -3497,7 +3497,7 @@ OpReturn TEST_P(BuiltinDeriveTest, Call_Derivative_Vector) { auto param = GetParam(); - auto* var = GlobalVar("v", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.vec3(), type::AddressSpace::kPrivate); auto* expr = Call(param.name, "v"); auto* func = Func("func", utils::Empty, ty.void_(), utils::Vector{ @@ -3567,7 +3567,7 @@ TEST_F(BuiltinBuilderTest, Call_AtomicLoad) { Member("u", ty.atomic()), Member("i", ty.atomic()), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -3631,7 +3631,7 @@ TEST_F(BuiltinBuilderTest, Call_AtomicStore) { Member("u", ty.atomic()), Member("i", ty.atomic()), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -3703,7 +3703,7 @@ TEST_P(Builtin_Builder_AtomicRMW_i32, Test) { auto* s = Structure("S", utils::Vector{ Member("v", ty.atomic()), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -3776,7 +3776,7 @@ TEST_P(Builtin_Builder_AtomicRMW_u32, Test) { auto* s = Structure("S", utils::Vector{ Member("v", ty.atomic()), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -3851,7 +3851,7 @@ TEST_F(BuiltinBuilderTest, Call_AtomicExchange) { Member("u", ty.atomic()), Member("i", ty.atomic()), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), @@ -3927,7 +3927,7 @@ TEST_F(BuiltinBuilderTest, Call_AtomicCompareExchangeWeak) { Member("u", ty.atomic()), Member("i", ty.atomic()), }); - GlobalVar("b", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), + GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(1_a), Group(2_a)); Func("a_func", utils::Empty, ty.void_(), diff --git a/src/tint/writer/spirv/builder_entry_point_test.cc b/src/tint/writer/spirv/builder_entry_point_test.cc index a064ee37ba..f48c9759e3 100644 --- a/src/tint/writer/spirv/builder_entry_point_test.cc +++ b/src/tint/writer/spirv/builder_entry_point_test.cc @@ -15,7 +15,6 @@ #include #include "gtest/gtest.h" -#include "src/tint/ast/address_space.h" #include "src/tint/ast/builtin_attribute.h" #include "src/tint/ast/builtin_value.h" #include "src/tint/ast/location_attribute.h" @@ -23,6 +22,7 @@ #include "src/tint/ast/stage_attribute.h" #include "src/tint/ast/variable.h" #include "src/tint/program.h" +#include "src/tint/type/address_space.h" #include "src/tint/type/f32.h" #include "src/tint/type/vector.h" #include "src/tint/writer/spirv/builder.h" diff --git a/src/tint/writer/spirv/builder_function_test.cc b/src/tint/writer/spirv/builder_function_test.cc index efaefed18a..e6171f07dd 100644 --- a/src/tint/writer/spirv/builder_function_test.cc +++ b/src/tint/writer/spirv/builder_function_test.cc @@ -61,7 +61,7 @@ OpFunctionEnd } TEST_F(BuilderTest, Function_Terminator_ReturnValue) { - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); Func("a_func", utils::Empty, ty.f32(), utils::Vector{Return("a")}, utils::Empty); @@ -198,7 +198,7 @@ TEST_F(BuilderTest, Emit_Multiple_EntryPoint_With_Same_ModuleVar) { auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())}); - GlobalVar("data", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), + GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), Group(0_a)); { diff --git a/src/tint/writer/spirv/builder_function_variable_test.cc b/src/tint/writer/spirv/builder_function_variable_test.cc index 4f50388076..47f1ed2099 100644 --- a/src/tint/writer/spirv/builder_function_variable_test.cc +++ b/src/tint/writer/spirv/builder_function_variable_test.cc @@ -23,7 +23,7 @@ namespace { using BuilderTest = TestHelper; TEST_F(BuilderTest, FunctionVar_NoAddressSpace) { - auto* v = Var("var", ty.f32(), ast::AddressSpace::kFunction); + auto* v = Var("var", ty.f32(), type::AddressSpace::kFunction); WrapInFunction(v); spirv::Builder& b = Build(); @@ -45,7 +45,7 @@ TEST_F(BuilderTest, FunctionVar_NoAddressSpace) { TEST_F(BuilderTest, FunctionVar_WithConstantInitializer) { auto* init = vec3(1_f, 1_f, 3_f); - auto* v = Var("var", ty.vec3(), ast::AddressSpace::kFunction, init); + auto* v = Var("var", ty.vec3(), type::AddressSpace::kFunction, init); WrapInFunction(v); spirv::Builder& b = Build(); diff --git a/src/tint/writer/spirv/builder_global_variable_test.cc b/src/tint/writer/spirv/builder_global_variable_test.cc index 9732abb2d2..08892da17d 100644 --- a/src/tint/writer/spirv/builder_global_variable_test.cc +++ b/src/tint/writer/spirv/builder_global_variable_test.cc @@ -26,7 +26,7 @@ namespace { using BuilderTest = TestHelper; TEST_F(BuilderTest, GlobalVar_WithAddressSpace) { - auto* v = GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate); spirv::Builder& b = Build(); @@ -43,7 +43,7 @@ TEST_F(BuilderTest, GlobalVar_WithAddressSpace) { TEST_F(BuilderTest, GlobalVar_WithInitializer) { auto* init = vec3(1_f, 1_f, 3_f); - auto* v = GlobalVar("var", ty.vec3(), ast::AddressSpace::kPrivate, init); + auto* v = GlobalVar("var", ty.vec3(), type::AddressSpace::kPrivate, init); spirv::Builder& b = Build(); @@ -67,7 +67,7 @@ TEST_F(BuilderTest, GlobalConst) { // var v = c; auto* c = GlobalConst("c", Expr(42_a)); - GlobalVar("v", ast::AddressSpace::kPrivate, Expr(c)); + GlobalVar("v", type::AddressSpace::kPrivate, Expr(c)); spirv::Builder& b = SanitizeAndBuild(); @@ -92,7 +92,7 @@ TEST_F(BuilderTest, GlobalConst_Vec_Initializer) { // var v = c; auto* c = GlobalConst("c", vec3(1_f, 2_f, 3_f)); - GlobalVar("v", ast::AddressSpace::kPrivate, Expr(c)); + GlobalVar("v", type::AddressSpace::kPrivate, Expr(c)); spirv::Builder& b = SanitizeAndBuild(); @@ -122,7 +122,7 @@ TEST_F(BuilderTest, GlobalConst_Vec_F16_Initializer) { Enable(ast::Extension::kF16); auto* c = GlobalConst("c", vec3(1_h, 2_h, 3_h)); - GlobalVar("v", ast::AddressSpace::kPrivate, Expr(c)); + GlobalVar("v", type::AddressSpace::kPrivate, Expr(c)); spirv::Builder& b = SanitizeAndBuild(); @@ -151,7 +151,7 @@ TEST_F(BuilderTest, GlobalConst_Vec_AInt_Initializer) { // var v = c; auto* c = GlobalConst("c", Construct(ty.vec3(nullptr), 1_a, 2_a, 3_a)); - GlobalVar("v", ast::AddressSpace::kPrivate, Expr(c)); + GlobalVar("v", type::AddressSpace::kPrivate, Expr(c)); spirv::Builder& b = SanitizeAndBuild(); @@ -180,7 +180,7 @@ TEST_F(BuilderTest, GlobalConst_Vec_AFloat_Initializer) { // var v = c; auto* c = GlobalConst("c", Construct(ty.vec3(nullptr), 1._a, 2._a, 3._a)); - GlobalVar("v", ast::AddressSpace::kPrivate, Expr(c)); + GlobalVar("v", type::AddressSpace::kPrivate, Expr(c)); spirv::Builder& b = SanitizeAndBuild(); @@ -209,7 +209,7 @@ TEST_F(BuilderTest, GlobalConst_Nested_Vec_Initializer) { // var v = c; auto* c = GlobalConst("c", vec3(vec2(1_f, 2_f), 3_f)); - GlobalVar("v", ast::AddressSpace::kPrivate, Expr(c)); + GlobalVar("v", type::AddressSpace::kPrivate, Expr(c)); spirv::Builder& b = SanitizeAndBuild(); @@ -252,7 +252,7 @@ OpDecorate %1 DescriptorSet 3 struct BuiltinData { ast::BuiltinValue builtin; - ast::AddressSpace storage; + type::AddressSpace storage; SpvBuiltIn result; }; inline std::ostream& operator<<(std::ostream& out, BuiltinData data) { @@ -271,30 +271,32 @@ INSTANTIATE_TEST_SUITE_P( BuilderTest_Type, BuiltinDataTest, testing::Values( - BuiltinData{ast::BuiltinValue::kUndefined, ast::AddressSpace::kNone, SpvBuiltInMax}, - BuiltinData{ast::BuiltinValue::kPosition, ast::AddressSpace::kIn, SpvBuiltInFragCoord}, - BuiltinData{ast::BuiltinValue::kPosition, ast::AddressSpace::kOut, SpvBuiltInPosition}, + BuiltinData{ast::BuiltinValue::kUndefined, type::AddressSpace::kNone, SpvBuiltInMax}, + BuiltinData{ast::BuiltinValue::kPosition, type::AddressSpace::kIn, SpvBuiltInFragCoord}, + BuiltinData{ast::BuiltinValue::kPosition, type::AddressSpace::kOut, SpvBuiltInPosition}, BuiltinData{ ast::BuiltinValue::kVertexIndex, - ast::AddressSpace::kIn, + type::AddressSpace::kIn, SpvBuiltInVertexIndex, }, - BuiltinData{ast::BuiltinValue::kInstanceIndex, ast::AddressSpace::kIn, + BuiltinData{ast::BuiltinValue::kInstanceIndex, type::AddressSpace::kIn, SpvBuiltInInstanceIndex}, - BuiltinData{ast::BuiltinValue::kFrontFacing, ast::AddressSpace::kIn, SpvBuiltInFrontFacing}, - BuiltinData{ast::BuiltinValue::kFragDepth, ast::AddressSpace::kOut, SpvBuiltInFragDepth}, - BuiltinData{ast::BuiltinValue::kLocalInvocationId, ast::AddressSpace::kIn, + BuiltinData{ast::BuiltinValue::kFrontFacing, type::AddressSpace::kIn, + SpvBuiltInFrontFacing}, + BuiltinData{ast::BuiltinValue::kFragDepth, type::AddressSpace::kOut, SpvBuiltInFragDepth}, + BuiltinData{ast::BuiltinValue::kLocalInvocationId, type::AddressSpace::kIn, SpvBuiltInLocalInvocationId}, - BuiltinData{ast::BuiltinValue::kLocalInvocationIndex, ast::AddressSpace::kIn, + BuiltinData{ast::BuiltinValue::kLocalInvocationIndex, type::AddressSpace::kIn, SpvBuiltInLocalInvocationIndex}, - BuiltinData{ast::BuiltinValue::kGlobalInvocationId, ast::AddressSpace::kIn, + BuiltinData{ast::BuiltinValue::kGlobalInvocationId, type::AddressSpace::kIn, SpvBuiltInGlobalInvocationId}, - BuiltinData{ast::BuiltinValue::kWorkgroupId, ast::AddressSpace::kIn, SpvBuiltInWorkgroupId}, - BuiltinData{ast::BuiltinValue::kNumWorkgroups, ast::AddressSpace::kIn, + BuiltinData{ast::BuiltinValue::kWorkgroupId, type::AddressSpace::kIn, + SpvBuiltInWorkgroupId}, + BuiltinData{ast::BuiltinValue::kNumWorkgroups, type::AddressSpace::kIn, SpvBuiltInNumWorkgroups}, - BuiltinData{ast::BuiltinValue::kSampleIndex, ast::AddressSpace::kIn, SpvBuiltInSampleId}, - BuiltinData{ast::BuiltinValue::kSampleMask, ast::AddressSpace::kIn, SpvBuiltInSampleMask}, - BuiltinData{ast::BuiltinValue::kSampleMask, ast::AddressSpace::kOut, + BuiltinData{ast::BuiltinValue::kSampleIndex, type::AddressSpace::kIn, SpvBuiltInSampleId}, + BuiltinData{ast::BuiltinValue::kSampleMask, type::AddressSpace::kIn, SpvBuiltInSampleMask}, + BuiltinData{ast::BuiltinValue::kSampleMask, type::AddressSpace::kOut, SpvBuiltInSampleMask})); TEST_F(BuilderTest, GlobalVar_DeclReadOnly) { @@ -308,7 +310,7 @@ TEST_F(BuilderTest, GlobalVar_DeclReadOnly) { Member("b", ty.i32()), }); - GlobalVar("b", ty.Of(A), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("b", ty.Of(A), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); spirv::Builder& b = SanitizeAndBuild(); @@ -350,7 +352,7 @@ TEST_F(BuilderTest, GlobalVar_TypeAliasDeclReadOnly) { auto* A = Structure("A", utils::Vector{Member("a", ty.i32())}); auto* B = Alias("B", ty.Of(A)); - GlobalVar("b", ty.Of(B), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("b", ty.Of(B), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); spirv::Builder& b = SanitizeAndBuild(); @@ -390,7 +392,7 @@ TEST_F(BuilderTest, GlobalVar_TypeAliasAssignReadOnly) { auto* A = Structure("A", utils::Vector{Member("a", ty.i32())}); auto* B = Alias("B", ty.Of(A)); - GlobalVar("b", ty.Of(B), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), + GlobalVar("b", ty.Of(B), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); spirv::Builder& b = SanitizeAndBuild(); @@ -429,9 +431,9 @@ TEST_F(BuilderTest, GlobalVar_TwoVarDeclReadOnly) { // var c : A auto* A = Structure("A", utils::Vector{Member("a", ty.i32())}); - GlobalVar("b", ty.Of(A), ast::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), + GlobalVar("b", ty.Of(A), type::AddressSpace::kStorage, ast::Access::kRead, Group(0_a), Binding(0_a)); - GlobalVar("c", ty.Of(A), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(1_a), + GlobalVar("c", ty.Of(A), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(1_a), Binding(0_a)); spirv::Builder& b = SanitizeAndBuild(); @@ -492,16 +494,16 @@ OpDecorate %1 DescriptorSet 0 TEST_F(BuilderTest, GlobalVar_WorkgroupWithZeroInit) { auto* type_scalar = ty.i32(); - auto* var_scalar = GlobalVar("a", type_scalar, ast::AddressSpace::kWorkgroup); + auto* var_scalar = GlobalVar("a", type_scalar, type::AddressSpace::kWorkgroup); auto* type_array = ty.array(); - auto* var_array = GlobalVar("b", type_array, ast::AddressSpace::kWorkgroup); + auto* var_array = GlobalVar("b", type_array, type::AddressSpace::kWorkgroup); auto* type_struct = Structure("C", utils::Vector{ Member("a", ty.i32()), Member("b", ty.i32()), }); - auto* var_struct = GlobalVar("c", ty.Of(type_struct), ast::AddressSpace::kWorkgroup); + auto* var_struct = GlobalVar("c", ty.Of(type_struct), type::AddressSpace::kWorkgroup); program = std::make_unique(std::move(*this)); diff --git a/src/tint/writer/spirv/builder_ident_expression_test.cc b/src/tint/writer/spirv/builder_ident_expression_test.cc index 5d01db3875..4db5d425f7 100644 --- a/src/tint/writer/spirv/builder_ident_expression_test.cc +++ b/src/tint/writer/spirv/builder_ident_expression_test.cc @@ -41,7 +41,7 @@ TEST_F(BuilderTest, IdentifierExpression_GlobalConst) { } TEST_F(BuilderTest, IdentifierExpression_GlobalVar) { - auto* v = GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate); auto* expr = Expr("var"); WrapInFunction(expr); @@ -85,7 +85,7 @@ TEST_F(BuilderTest, IdentifierExpression_FunctionConst) { } TEST_F(BuilderTest, IdentifierExpression_FunctionVar) { - auto* v = Var("var", ty.f32(), ast::AddressSpace::kFunction); + auto* v = Var("var", ty.f32(), type::AddressSpace::kFunction); auto* expr = Expr("var"); WrapInFunction(v, expr); @@ -109,7 +109,7 @@ TEST_F(BuilderTest, IdentifierExpression_FunctionVar) { } TEST_F(BuilderTest, IdentifierExpression_Load) { - auto* var = GlobalVar("var", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("var", ty.i32(), type::AddressSpace::kPrivate); auto* expr = Add("var", "var"); WrapInFunction(expr); diff --git a/src/tint/writer/spirv/builder_if_test.cc b/src/tint/writer/spirv/builder_if_test.cc index a83b0cfb40..6462200c6e 100644 --- a/src/tint/writer/spirv/builder_if_test.cc +++ b/src/tint/writer/spirv/builder_if_test.cc @@ -68,7 +68,7 @@ TEST_F(BuilderTest, If_WithStatements) { // v = 2; // } - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* body = Block(Assign("v", 2_i)); auto* expr = If(true, body); WrapInFunction(expr); @@ -104,7 +104,7 @@ TEST_F(BuilderTest, If_WithElse) { // v = 3i; // } - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* body = Block(Assign("v", 2_i)); auto* else_body = Block(Assign("v", 3_i)); @@ -146,7 +146,7 @@ TEST_F(BuilderTest, If_WithElseIf) { // v = 3i; // } - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* body = Block(Assign("v", 2_i)); auto* else_body = Block(Assign("v", 3_i)); @@ -197,7 +197,7 @@ TEST_F(BuilderTest, If_WithMultiple) { // v = 5i; // } - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* body = Block(Assign("v", 2_i)); auto* elseif_1_body = Block(Assign("v", 3_i)); auto* elseif_2_body = Block(Assign("v", 4_i)); @@ -562,7 +562,7 @@ TEST_F(BuilderTest, If_WithLoad_Bug327) { // if (a) { // } - auto* var = GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate); auto* fn = Func("f", utils::Empty, ty.void_(), utils::Vector{ If("a", Block()), diff --git a/src/tint/writer/spirv/builder_initializer_expression_test.cc b/src/tint/writer/spirv/builder_initializer_expression_test.cc index 07277c5365..b8a1029c0d 100644 --- a/src/tint/writer/spirv/builder_initializer_expression_test.cc +++ b/src/tint/writer/spirv/builder_initializer_expression_test.cc @@ -24,7 +24,7 @@ using SpvBuilderInitializerTest = TestHelper; TEST_F(SpvBuilderInitializerTest, Const) { auto* c = Expr(42.2_f); - auto* g = GlobalVar("g", ty.f32(), c, ast::AddressSpace::kPrivate); + auto* g = GlobalVar("g", ty.f32(), c, type::AddressSpace::kPrivate); spirv::Builder& b = Build(); @@ -1935,7 +1935,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_F32_With_F32) { auto* ctor = Construct(2_f); - GlobalVar("g", ty.f32(), ast::AddressSpace::kPrivate, ctor); + GlobalVar("g", ty.f32(), type::AddressSpace::kPrivate, ctor); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -1954,7 +1954,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_F16_With_F16) { Enable(ast::Extension::kF16); auto* ctor = Construct(2_h); - GlobalVar("g", ty.f16(), ast::AddressSpace::kPrivate, ctor); + GlobalVar("g", ty.f16(), type::AddressSpace::kPrivate, ctor); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2015,7 +2015,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_U32_With_F32) { auto* ctor = Construct(1.5_f); - GlobalVar("g", ty.u32(), ast::AddressSpace::kPrivate, ctor); + GlobalVar("g", ty.u32(), type::AddressSpace::kPrivate, ctor); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2034,7 +2034,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_U32_With_F16) { Enable(ast::Extension::kF16); auto* ctor = Construct(1.5_h); - GlobalVar("g", ty.u32(), ast::AddressSpace::kPrivate, ctor); + GlobalVar("g", ty.u32(), type::AddressSpace::kPrivate, ctor); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2099,7 +2099,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec2_With_F32) { auto* cast = vec2(2_f); - auto* g = GlobalVar("g", ty.vec2(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec2(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2117,7 +2117,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec2_With_F16) { Enable(ast::Extension::kF16); auto* cast = vec2(2_h); - auto* g = GlobalVar("g", ty.vec2(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec2(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2181,7 +2181,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec2_F32_With_Vec2) { auto* cast = vec2(vec2(2_f, 2_f)); - GlobalVar("a", ty.vec2(), ast::AddressSpace::kPrivate, cast); + GlobalVar("a", ty.vec2(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2203,7 +2203,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec2_F16_With_Vec2) { Enable(ast::Extension::kF16); auto* cast = vec2(vec2(2_h, 2_h)); - GlobalVar("a", ty.vec2(), ast::AddressSpace::kPrivate, cast); + GlobalVar("a", ty.vec2(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2271,7 +2271,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_F32_With_Vec3) { auto* cast = vec3(vec3(2_f, 2_f, 2_f)); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate, cast); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2293,7 +2293,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_F16_With_Vec3) { Enable(ast::Extension::kF16); auto* cast = vec3(vec3(2_h, 2_h, 2_h)); - GlobalVar("a", ty.vec3(), ast::AddressSpace::kPrivate, cast); + GlobalVar("a", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2361,7 +2361,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_F32_With_Vec4) { auto* cast = vec4(vec4(2_f, 2_f, 2_f, 2_f)); - GlobalVar("a", ty.vec4(), ast::AddressSpace::kPrivate, cast); + GlobalVar("a", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2383,7 +2383,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_F16_With_Vec4) { Enable(ast::Extension::kF16); auto* cast = vec4(vec4(2_h, 2_h, 2_h, 2_h)); - GlobalVar("a", ty.vec4(), ast::AddressSpace::kPrivate, cast); + GlobalVar("a", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = SanitizeAndBuild(); ASSERT_TRUE(b.Build()); @@ -2451,7 +2451,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_F32) { auto* cast = vec3(2_f); - auto* g = GlobalVar("g", ty.vec3(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2469,7 +2469,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_F16) { Enable(ast::Extension::kF16); auto* cast = vec3(2_h); - auto* g = GlobalVar("g", ty.vec3(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2533,7 +2533,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_F32_Vec2) { auto* cast = vec3(2_f, vec2(2_f, 2_f)); - auto* g = GlobalVar("g", ty.vec3(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2551,7 +2551,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_F16_Vec2) { Enable(ast::Extension::kF16); auto* cast = vec3(2_h, vec2(2_h, 2_h)); - auto* g = GlobalVar("g", ty.vec3(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2615,7 +2615,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_Vec2_F32) { auto* cast = vec3(vec2(2_f, 2_f), 2_f); - auto* g = GlobalVar("g", ty.vec3(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2633,7 +2633,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_Vec2_F16) { Enable(ast::Extension::kF16); auto* cast = vec3(vec2(2_h, 2_h), 2_h); - auto* g = GlobalVar("g", ty.vec3(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec3(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2697,7 +2697,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32) { auto* cast = vec4(2_f); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2715,7 +2715,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F16) { Enable(ast::Extension::kF16); auto* cast = vec4(2_h); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2779,7 +2779,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32_F32_Vec2) { auto* cast = vec4(2_f, 2_f, vec2(2_f, 2_f)); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2797,7 +2797,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F16_F16_Vec2) { Enable(ast::Extension::kF16); auto* cast = vec4(2_h, 2_h, vec2(2_h, 2_h)); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2861,7 +2861,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32_Vec2_F32) { auto* cast = vec4(2_f, vec2(2_f, 2_f), 2_f); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2879,7 +2879,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F16_Vec2_F16) { Enable(ast::Extension::kF16); auto* cast = vec4(2_h, vec2(2_h, 2_h), 2_h); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2943,7 +2943,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_Vec2_F32_F32) { auto* cast = vec4(vec2(2_f, 2_f), 2_f, 2_f); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -2961,7 +2961,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_Vec2_F16_F16) { Enable(ast::Extension::kF16); auto* cast = vec4(vec2(2_h, 2_h), 2_h, 2_h); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -3025,7 +3025,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_F32_With_Vec2_Vec2) { auto* cast = vec4(vec2(2_f, 2_f), vec2(2_f, 2_f)); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -3043,7 +3043,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_F16_With_Vec2_Vec2) { Enable(ast::Extension::kF16); auto* cast = vec4(vec2(2_h, 2_h), vec2(2_h, 2_h)); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -3082,7 +3082,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32_Vec3) { auto* cast = vec4(2_f, vec3(2_f, 2_f, 2_f)); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -3100,7 +3100,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F16_Vec3) { Enable(ast::Extension::kF16); auto* cast = vec4(2_h, vec3(2_h, 2_h, 2_h)); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -3164,7 +3164,7 @@ OpReturn TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_Vec3_F32) { auto* cast = vec4(vec3(2_f, 2_f, 2_f), 2_f); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -3182,7 +3182,7 @@ TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_Vec3_F16) { Enable(ast::Extension::kF16); auto* cast = vec4(vec3(2_h, 2_h, 2_h), 2_h); - auto* g = GlobalVar("g", ty.vec4(), ast::AddressSpace::kPrivate, cast); + auto* g = GlobalVar("g", ty.vec4(), type::AddressSpace::kPrivate, cast); spirv::Builder& b = Build(); @@ -4204,7 +4204,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_F32_To_F16) { } TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_I32) { - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4230,7 +4230,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_I32) { } TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_I32) { - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4258,7 +4258,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_I32) { TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_I32) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4284,7 +4284,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_I32) { } TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_U32) { - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4310,7 +4310,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_U32) { } TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_U32) { - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4338,7 +4338,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_U32) { TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_U32) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4364,7 +4364,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_U32) { } TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_F32) { - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4390,7 +4390,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_F32) { } TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_F32) { - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4418,7 +4418,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_F32) { TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_F32) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4446,7 +4446,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_F32) { TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_F16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4474,7 +4474,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_F16) { TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_F16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4502,7 +4502,7 @@ TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_F16) { TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_F16) { Enable(ast::Extension::kF16); - auto* var = GlobalVar("i", ty.vec3(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("i", ty.vec3(), type::AddressSpace::kPrivate); auto* cast = vec3("i"); WrapInFunction(cast); @@ -4590,9 +4590,9 @@ TEST_F(SpvBuilderInitializerTest, IsInitializerConst_VectorWithAllConstInitializ TEST_F(SpvBuilderInitializerTest, IsInitializerConst_Vector_WithIdent) { // vec3(a, b, c) -> false - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("c", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("c", ty.f32(), type::AddressSpace::kPrivate); auto* t = vec3("a", "b", "c"); WrapInFunction(t); @@ -4662,8 +4662,8 @@ TEST_F(SpvBuilderInitializerTest, IsInitializerConst_Struct_WithIdentSubExpressi Member("b", ty.vec3()), }); - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("b", ty.vec3(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("b", ty.vec3(), type::AddressSpace::kPrivate); auto* t = Construct(ty.Of(s), "a", "b"); WrapInFunction(t); diff --git a/src/tint/writer/spirv/builder_loop_test.cc b/src/tint/writer/spirv/builder_loop_test.cc index 9d19bde420..ef8dfa8715 100644 --- a/src/tint/writer/spirv/builder_loop_test.cc +++ b/src/tint/writer/spirv/builder_loop_test.cc @@ -54,7 +54,7 @@ TEST_F(BuilderTest, Loop_WithoutContinuing) { // break; // } - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* body = Block(Assign("v", 2_i), // Break()); @@ -96,7 +96,7 @@ TEST_F(BuilderTest, Loop_WithContinuing) { // } // } - auto* var = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); + auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); auto* body = Block(Assign("v", 2_i), // Break()); auto* continuing = Block(Assign("v", 3_i)); diff --git a/src/tint/writer/spirv/builder_switch_test.cc b/src/tint/writer/spirv/builder_switch_test.cc index 6cf8fad535..a04a194906 100644 --- a/src/tint/writer/spirv/builder_switch_test.cc +++ b/src/tint/writer/spirv/builder_switch_test.cc @@ -56,8 +56,8 @@ TEST_F(BuilderTest, Switch_WithCase) { // default: {} // } - auto* v = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); - auto* a = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); + auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -113,8 +113,8 @@ TEST_F(BuilderTest, Switch_WithCase_Unsigned) { // default: {} // } - auto* v = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); - auto* a = GlobalVar("a", ty.u32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); + auto* a = GlobalVar("a", ty.u32(), type::AddressSpace::kPrivate); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -170,8 +170,8 @@ TEST_F(BuilderTest, Switch_WithDefault) { // v = 1i; // } - auto* v = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); - auto* a = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); + auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -220,8 +220,8 @@ TEST_F(BuilderTest, Switch_WithCaseAndDefault) { // v = 3i; // } - auto* v = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); - auto* a = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); + auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ @@ -280,8 +280,8 @@ TEST_F(BuilderTest, Switch_WithCaseAndMixedDefault) { // v = 2i; // } - auto* v = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); - auto* a = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); + auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{Switch(Expr("a"), // @@ -337,8 +337,8 @@ TEST_F(BuilderTest, Switch_WithNestedBreak) { // default: {} // } - auto* v = GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate); - auto* a = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate); + auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate); auto* func = Func("a_func", utils::Empty, ty.void_(), utils::Vector{ diff --git a/src/tint/writer/spirv/builder_type_test.cc b/src/tint/writer/spirv/builder_type_test.cc index e7cdd74beb..d49956db36 100644 --- a/src/tint/writer/spirv/builder_type_test.cc +++ b/src/tint/writer/spirv/builder_type_test.cc @@ -29,7 +29,7 @@ using BuilderTest_Type = TestHelper; TEST_F(BuilderTest_Type, GenerateRuntimeArray) { auto* ary = ty.array(ty.i32()); 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)); spirv::Builder& b = Build(); @@ -46,7 +46,7 @@ TEST_F(BuilderTest_Type, GenerateRuntimeArray) { TEST_F(BuilderTest_Type, ReturnsGeneratedRuntimeArray) { auto* ary = ty.array(ty.i32()); 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)); spirv::Builder& b = Build(); @@ -62,7 +62,7 @@ TEST_F(BuilderTest_Type, ReturnsGeneratedRuntimeArray) { TEST_F(BuilderTest_Type, GenerateArray) { auto* ary = ty.array(ty.i32(), 4_u); - GlobalVar("a", ary, ast::AddressSpace::kPrivate); + GlobalVar("a", ary, type::AddressSpace::kPrivate); spirv::Builder& b = Build(); @@ -79,7 +79,7 @@ TEST_F(BuilderTest_Type, GenerateArray) { TEST_F(BuilderTest_Type, GenerateArray_WithStride) { auto* ary = ty.array(ty.i32(), 4_u, 16u); - GlobalVar("a", ary, ast::AddressSpace::kPrivate); + GlobalVar("a", ary, type::AddressSpace::kPrivate); spirv::Builder& b = Build(); @@ -99,7 +99,7 @@ TEST_F(BuilderTest_Type, GenerateArray_WithStride) { TEST_F(BuilderTest_Type, ReturnsGeneratedArray) { auto* ary = ty.array(ty.i32(), 4_u); - GlobalVar("a", ary, ast::AddressSpace::kPrivate); + GlobalVar("a", ary, type::AddressSpace::kPrivate); spirv::Builder& b = Build(); @@ -294,7 +294,7 @@ TEST_F(BuilderTest_Type, ReturnsGeneratedF16Matrix) { TEST_F(BuilderTest_Type, GeneratePtr) { auto* i32 = create(); - auto* ptr = create(i32, ast::AddressSpace::kOut, ast::Access::kReadWrite); + auto* ptr = create(i32, type::AddressSpace::kOut, ast::Access::kReadWrite); spirv::Builder& b = Build(); @@ -309,7 +309,7 @@ TEST_F(BuilderTest_Type, GeneratePtr) { TEST_F(BuilderTest_Type, ReturnsGeneratedPtr) { auto* i32 = create(); - auto* ptr = create(i32, ast::AddressSpace::kOut, ast::Access::kReadWrite); + auto* ptr = create(i32, type::AddressSpace::kOut, ast::Access::kReadWrite); spirv::Builder& b = Build(); @@ -603,7 +603,7 @@ TEST_F(BuilderTest_Type, ReturnsGeneratedVoid) { } struct PtrData { - ast::AddressSpace ast_class; + type::AddressSpace ast_class; SpvStorageClass result; }; inline std::ostream& operator<<(std::ostream& out, PtrData data) { @@ -621,15 +621,15 @@ TEST_P(PtrDataTest, ConvertAddressSpace) { INSTANTIATE_TEST_SUITE_P( BuilderTest_Type, PtrDataTest, - testing::Values(PtrData{ast::AddressSpace::kNone, SpvStorageClassMax}, - PtrData{ast::AddressSpace::kIn, SpvStorageClassInput}, - PtrData{ast::AddressSpace::kOut, SpvStorageClassOutput}, - PtrData{ast::AddressSpace::kUniform, SpvStorageClassUniform}, - PtrData{ast::AddressSpace::kWorkgroup, SpvStorageClassWorkgroup}, - PtrData{ast::AddressSpace::kHandle, SpvStorageClassUniformConstant}, - PtrData{ast::AddressSpace::kStorage, SpvStorageClassStorageBuffer}, - PtrData{ast::AddressSpace::kPrivate, SpvStorageClassPrivate}, - PtrData{ast::AddressSpace::kFunction, SpvStorageClassFunction})); + testing::Values(PtrData{type::AddressSpace::kNone, SpvStorageClassMax}, + PtrData{type::AddressSpace::kIn, SpvStorageClassInput}, + PtrData{type::AddressSpace::kOut, SpvStorageClassOutput}, + PtrData{type::AddressSpace::kUniform, SpvStorageClassUniform}, + PtrData{type::AddressSpace::kWorkgroup, SpvStorageClassWorkgroup}, + PtrData{type::AddressSpace::kHandle, SpvStorageClassUniformConstant}, + PtrData{type::AddressSpace::kStorage, SpvStorageClassStorageBuffer}, + PtrData{type::AddressSpace::kPrivate, SpvStorageClassPrivate}, + PtrData{type::AddressSpace::kFunction, SpvStorageClassFunction})); TEST_F(BuilderTest_Type, DepthTexture_Generate_2d) { auto* two_d = create(type::TextureDimension::k2d); diff --git a/src/tint/writer/wgsl/generator_impl.cc b/src/tint/writer/wgsl/generator_impl.cc index a5156311fd..863cf3f4a9 100644 --- a/src/tint/writer/wgsl/generator_impl.cc +++ b/src/tint/writer/wgsl/generator_impl.cc @@ -669,7 +669,7 @@ bool GeneratorImpl::EmitVariable(std::ostream& out, const ast::Variable* v) { out << "var"; auto address_space = var->declared_address_space; auto ac = var->declared_access; - if (address_space != ast::AddressSpace::kNone || ac != ast::Access::kUndefined) { + if (address_space != type::AddressSpace::kNone || ac != ast::Access::kUndefined) { out << "<" << address_space; if (ac != ast::Access::kUndefined) { out << ", "; diff --git a/src/tint/writer/wgsl/generator_impl_array_accessor_test.cc b/src/tint/writer/wgsl/generator_impl_array_accessor_test.cc index 652f598812..ed05a2d644 100644 --- a/src/tint/writer/wgsl/generator_impl_array_accessor_test.cc +++ b/src/tint/writer/wgsl/generator_impl_array_accessor_test.cc @@ -22,7 +22,7 @@ namespace { using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, IndexAccessor) { - GlobalVar("ary", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("ary", ty.array(), type::AddressSpace::kPrivate); auto* expr = IndexAccessor("ary", 5_i); WrapInFunction(expr); @@ -34,7 +34,7 @@ TEST_F(WgslGeneratorImplTest, IndexAccessor) { } TEST_F(WgslGeneratorImplTest, IndexAccessor_OfDref) { - GlobalVar("ary", ty.array(), ast::AddressSpace::kPrivate); + GlobalVar("ary", ty.array(), type::AddressSpace::kPrivate); auto* p = Let("p", AddressOf("ary")); auto* expr = IndexAccessor(Deref("p"), 5_i); diff --git a/src/tint/writer/wgsl/generator_impl_assign_test.cc b/src/tint/writer/wgsl/generator_impl_assign_test.cc index 85d4d901c2..3a6dd1aa72 100644 --- a/src/tint/writer/wgsl/generator_impl_assign_test.cc +++ b/src/tint/writer/wgsl/generator_impl_assign_test.cc @@ -20,8 +20,8 @@ namespace { using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, Emit_Assign) { - auto* lhs = GlobalVar("lhs", ty.i32(), ast::AddressSpace::kPrivate); - auto* rhs = GlobalVar("rhs", ty.i32(), ast::AddressSpace::kPrivate); + auto* lhs = GlobalVar("lhs", ty.i32(), type::AddressSpace::kPrivate); + auto* rhs = GlobalVar("rhs", ty.i32(), type::AddressSpace::kPrivate); auto* assign = Assign(lhs, rhs); WrapInFunction(assign); diff --git a/src/tint/writer/wgsl/generator_impl_binary_test.cc b/src/tint/writer/wgsl/generator_impl_binary_test.cc index d069fe6898..8368ad83ed 100644 --- a/src/tint/writer/wgsl/generator_impl_binary_test.cc +++ b/src/tint/writer/wgsl/generator_impl_binary_test.cc @@ -37,8 +37,8 @@ TEST_P(WgslBinaryTest, Emit) { } }; - GlobalVar("left", op_ty(), ast::AddressSpace::kPrivate); - GlobalVar("right", op_ty(), ast::AddressSpace::kPrivate); + GlobalVar("left", op_ty(), type::AddressSpace::kPrivate); + GlobalVar("right", op_ty(), type::AddressSpace::kPrivate); auto* left = Expr("left"); auto* right = Expr("right"); diff --git a/src/tint/writer/wgsl/generator_impl_call_test.cc b/src/tint/writer/wgsl/generator_impl_call_test.cc index 6b22d2a07a..39a287c59f 100644 --- a/src/tint/writer/wgsl/generator_impl_call_test.cc +++ b/src/tint/writer/wgsl/generator_impl_call_test.cc @@ -48,8 +48,8 @@ TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithParams) { utils::Vector{ Return(1.23_f), }); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("my_func", "param1", "param2"); WrapInFunction(call); @@ -68,8 +68,8 @@ TEST_F(WgslGeneratorImplTest, EmitStatement_Call) { Param(Sym(), ty.f32()), }, ty.void_(), utils::Empty, utils::Empty); - GlobalVar("param1", ty.f32(), ast::AddressSpace::kPrivate); - GlobalVar("param2", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate); + GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate); auto* call = Call("my_func", "param1", "param2"); auto* stmt = CallStmt(call); diff --git a/src/tint/writer/wgsl/generator_impl_function_test.cc b/src/tint/writer/wgsl/generator_impl_function_test.cc index e785520d63..a1eae5b688 100644 --- a/src/tint/writer/wgsl/generator_impl_function_test.cc +++ b/src/tint/writer/wgsl/generator_impl_function_test.cc @@ -179,7 +179,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_Multiple_EntryPoint_With_Same_Module Member("d", ty.f32()), }); - GlobalVar("data", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), + GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), Group(0_a)); { diff --git a/src/tint/writer/wgsl/generator_impl_global_decl_test.cc b/src/tint/writer/wgsl/generator_impl_global_decl_test.cc index cc331f01ac..65366c8a71 100644 --- a/src/tint/writer/wgsl/generator_impl_global_decl_test.cc +++ b/src/tint/writer/wgsl/generator_impl_global_decl_test.cc @@ -29,7 +29,7 @@ TEST_F(WgslGeneratorImplTest, Emit_GlobalDeclAfterFunction) { auto* func_var = Var("a", ty.f32()); WrapInFunction(func_var); - GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -46,7 +46,7 @@ TEST_F(WgslGeneratorImplTest, Emit_GlobalDeclAfterFunction) { } TEST_F(WgslGeneratorImplTest, Emit_GlobalsInterleaved) { - GlobalVar("a0", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a0", ty.f32(), type::AddressSpace::kPrivate); auto* s0 = Structure("S0", utils::Vector{ Member("a", ty.i32()), @@ -58,7 +58,7 @@ TEST_F(WgslGeneratorImplTest, Emit_GlobalsInterleaved) { }, utils::Empty); - GlobalVar("a1", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("a1", ty.f32(), type::AddressSpace::kPrivate); auto* s1 = Structure("S1", utils::Vector{ Member("a", ty.i32()), diff --git a/src/tint/writer/wgsl/generator_impl_identifier_test.cc b/src/tint/writer/wgsl/generator_impl_identifier_test.cc index 25e2a7a4b4..e0b167f663 100644 --- a/src/tint/writer/wgsl/generator_impl_identifier_test.cc +++ b/src/tint/writer/wgsl/generator_impl_identifier_test.cc @@ -20,7 +20,7 @@ namespace { using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) { - GlobalVar("glsl", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("glsl", ty.f32(), type::AddressSpace::kPrivate); auto* i = Expr("glsl"); WrapInFunction(i); diff --git a/src/tint/writer/wgsl/generator_impl_if_test.cc b/src/tint/writer/wgsl/generator_impl_if_test.cc index eeaa75f828..0831f8909a 100644 --- a/src/tint/writer/wgsl/generator_impl_if_test.cc +++ b/src/tint/writer/wgsl/generator_impl_if_test.cc @@ -20,7 +20,7 @@ namespace { using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, Emit_If) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); auto* cond = Expr("cond"); auto* body = Block(Return()); @@ -39,8 +39,8 @@ TEST_F(WgslGeneratorImplTest, Emit_If) { } TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("else_cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_cond = Expr("else_cond"); auto* else_body = Block(Return()); @@ -64,7 +64,7 @@ TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) { } TEST_F(WgslGeneratorImplTest, Emit_IfWithElse) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_body = Block(Return()); @@ -87,8 +87,8 @@ TEST_F(WgslGeneratorImplTest, Emit_IfWithElse) { } TEST_F(WgslGeneratorImplTest, Emit_IfWithMultiple) { - GlobalVar("cond", ty.bool_(), ast::AddressSpace::kPrivate); - GlobalVar("else_cond", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate); + GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate); auto* else_cond = Expr("else_cond"); diff --git a/src/tint/writer/wgsl/generator_impl_loop_test.cc b/src/tint/writer/wgsl/generator_impl_loop_test.cc index ac3f80849a..f4d6f46ff8 100644 --- a/src/tint/writer/wgsl/generator_impl_loop_test.cc +++ b/src/tint/writer/wgsl/generator_impl_loop_test.cc @@ -96,7 +96,7 @@ TEST_F(WgslGeneratorImplTest, Emit_ForLoopWithMultiStmtInit) { // for({ignore(1i); ignore(2i);}; ; ) { // return; // } - GlobalVar("a", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(), type::AddressSpace::kWorkgroup); auto* multi_stmt = Block(Ignore(1_i), Ignore(2_i)); auto* f = For(multi_stmt, nullptr, nullptr, Block(Return())); WrapInFunction(f); @@ -160,7 +160,7 @@ TEST_F(WgslGeneratorImplTest, Emit_ForLoopWithMultiStmtCont) { // return; // } - GlobalVar("a", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(), type::AddressSpace::kWorkgroup); auto* multi_stmt = Block(Ignore(1_i), Ignore(2_i)); auto* f = For(nullptr, nullptr, multi_stmt, Block(Return())); WrapInFunction(f); @@ -203,7 +203,7 @@ TEST_F(WgslGeneratorImplTest, Emit_ForLoopWithMultiStmtInitCondCont) { // for({ ignore(1i); ignore(2i); }; true; { ignore(3i); ignore(4i); }) { // return; // } - GlobalVar("a", ty.atomic(), ast::AddressSpace::kWorkgroup); + GlobalVar("a", ty.atomic(), type::AddressSpace::kWorkgroup); auto* multi_stmt_a = Block(Ignore(1_i), Ignore(2_i)); auto* multi_stmt_b = Block(Ignore(3_i), Ignore(4_i)); auto* f = For(multi_stmt_a, Expr(true), multi_stmt_b, Block(Return())); diff --git a/src/tint/writer/wgsl/generator_impl_member_accessor_test.cc b/src/tint/writer/wgsl/generator_impl_member_accessor_test.cc index 9bb695d21f..5f7ebb584a 100644 --- a/src/tint/writer/wgsl/generator_impl_member_accessor_test.cc +++ b/src/tint/writer/wgsl/generator_impl_member_accessor_test.cc @@ -21,7 +21,7 @@ using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) { auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())}); - GlobalVar("str", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate); auto* expr = MemberAccessor("str", "mem"); WrapInFunction(expr); @@ -35,7 +35,7 @@ TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) { TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor_OfDref) { auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())}); - GlobalVar("str", ty.Of(s), ast::AddressSpace::kPrivate); + GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate); auto* p = Let("p", AddressOf("str")); auto* expr = MemberAccessor(Deref("p"), "mem"); diff --git a/src/tint/writer/wgsl/generator_impl_switch_test.cc b/src/tint/writer/wgsl/generator_impl_switch_test.cc index 7a39079ba3..24dbae16c4 100644 --- a/src/tint/writer/wgsl/generator_impl_switch_test.cc +++ b/src/tint/writer/wgsl/generator_impl_switch_test.cc @@ -22,7 +22,7 @@ namespace { using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, Emit_Switch) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); auto* def_body = Block(create()); auto* def = Case(DefaultCaseSelector(), def_body); @@ -56,7 +56,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Switch) { } TEST_F(WgslGeneratorImplTest, Emit_Switch_MixedDefault) { - GlobalVar("cond", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate); auto* def_body = Block(create()); auto* def = Case(utils::Vector{CaseSelector(5_i), DefaultCaseSelector()}, def_body); diff --git a/src/tint/writer/wgsl/generator_impl_type_test.cc b/src/tint/writer/wgsl/generator_impl_type_test.cc index 0f0ab27cea..b19a088cd0 100644 --- a/src/tint/writer/wgsl/generator_impl_type_test.cc +++ b/src/tint/writer/wgsl/generator_impl_type_test.cc @@ -141,7 +141,7 @@ TEST_F(WgslGeneratorImplTest, EmitType_Matrix_F16) { } TEST_F(WgslGeneratorImplTest, EmitType_Pointer) { - auto* p = ty.pointer(ast::AddressSpace::kWorkgroup); + auto* p = ty.pointer(type::AddressSpace::kWorkgroup); Alias("make_type_reachable", p); GeneratorImpl& gen = Build(); @@ -152,7 +152,7 @@ TEST_F(WgslGeneratorImplTest, EmitType_Pointer) { } TEST_F(WgslGeneratorImplTest, EmitType_PointerAccessMode) { - auto* p = ty.pointer(ast::AddressSpace::kStorage, ast::Access::kReadWrite); + auto* p = ty.pointer(type::AddressSpace::kStorage, ast::Access::kReadWrite); Alias("make_type_reachable", p); GeneratorImpl& gen = Build(); diff --git a/src/tint/writer/wgsl/generator_impl_unary_op_test.cc b/src/tint/writer/wgsl/generator_impl_unary_op_test.cc index 0d5edd523d..544e1e3e87 100644 --- a/src/tint/writer/wgsl/generator_impl_unary_op_test.cc +++ b/src/tint/writer/wgsl/generator_impl_unary_op_test.cc @@ -20,7 +20,7 @@ namespace { using WgslUnaryOpTest = TestHelper; TEST_F(WgslUnaryOpTest, AddressOf) { - GlobalVar("expr", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kAddressOf, Expr("expr")); WrapInFunction(op); @@ -32,7 +32,7 @@ TEST_F(WgslUnaryOpTest, AddressOf) { } TEST_F(WgslUnaryOpTest, Complement) { - GlobalVar("expr", ty.u32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.u32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kComplement, Expr("expr")); WrapInFunction(op); @@ -44,7 +44,7 @@ TEST_F(WgslUnaryOpTest, Complement) { } TEST_F(WgslUnaryOpTest, Indirection) { - GlobalVar("G", ty.f32(), ast::AddressSpace::kPrivate); + GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate); auto* p = Let("expr", create(ast::UnaryOp::kAddressOf, Expr("G"))); auto* op = create(ast::UnaryOp::kIndirection, Expr("expr")); WrapInFunction(p, op); @@ -57,7 +57,7 @@ TEST_F(WgslUnaryOpTest, Indirection) { } TEST_F(WgslUnaryOpTest, Not) { - GlobalVar("expr", ty.bool_(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNot, Expr("expr")); WrapInFunction(op); @@ -69,7 +69,7 @@ TEST_F(WgslUnaryOpTest, Not) { } TEST_F(WgslUnaryOpTest, Negation) { - GlobalVar("expr", ty.i32(), ast::AddressSpace::kPrivate); + GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate); auto* op = create(ast::UnaryOp::kNegation, Expr("expr")); WrapInFunction(op); diff --git a/src/tint/writer/wgsl/generator_impl_variable_test.cc b/src/tint/writer/wgsl/generator_impl_variable_test.cc index fd6110a32c..075f46321b 100644 --- a/src/tint/writer/wgsl/generator_impl_variable_test.cc +++ b/src/tint/writer/wgsl/generator_impl_variable_test.cc @@ -22,7 +22,7 @@ namespace { using WgslGeneratorImplTest = TestHelper; TEST_F(WgslGeneratorImplTest, EmitVariable) { - auto* v = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -32,7 +32,7 @@ TEST_F(WgslGeneratorImplTest, EmitVariable) { } TEST_F(WgslGeneratorImplTest, EmitVariable_AddressSpace) { - auto* v = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate); + auto* v = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate); GeneratorImpl& gen = Build(); @@ -43,7 +43,7 @@ TEST_F(WgslGeneratorImplTest, EmitVariable_AddressSpace) { TEST_F(WgslGeneratorImplTest, EmitVariable_Access_Read) { auto* s = Structure("S", utils::Vector{Member("a", ty.i32())}); - auto* v = GlobalVar("a", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, + auto* v = GlobalVar("a", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -55,7 +55,7 @@ TEST_F(WgslGeneratorImplTest, EmitVariable_Access_Read) { TEST_F(WgslGeneratorImplTest, EmitVariable_Access_ReadWrite) { auto* s = Structure("S", utils::Vector{Member("a", ty.i32())}); - auto* v = GlobalVar("a", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, + auto* v = GlobalVar("a", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Binding(0_a), Group(0_a)); GeneratorImpl& gen = Build(); @@ -76,7 +76,7 @@ TEST_F(WgslGeneratorImplTest, EmitVariable_Decorated) { } TEST_F(WgslGeneratorImplTest, EmitVariable_Initializer) { - auto* v = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, Expr(1_f)); + auto* v = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, Expr(1_f)); GeneratorImpl& gen = Build();