Move type::AddressSpace to builtin/
This CL moves the AddressSpace enum from type:: to builtin::
Change-Id: Ie8d533be4dd42b34eef164b64e2c9e0843de5c3d
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/120401
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index b7022b3..58749a7 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -695,6 +695,8 @@
sources = [
"builtin/access.cc",
"builtin/access.h",
+ "builtin/address_space.cc",
+ "builtin/address_space.h",
"builtin/builtin_value.cc",
"builtin/builtin_value.h",
"builtin/extension.cc",
@@ -711,8 +713,6 @@
"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",
@@ -1295,6 +1295,7 @@
tint_unittests_source_set("tint_unittests_builtins_src") {
sources = [
"builtin/access_test.cc",
+ "builtin/address_space_test.cc",
"builtin/builtin_value_test.cc",
"builtin/extension_test.cc",
]
@@ -1413,7 +1414,6 @@
tint_unittests_source_set("tint_unittests_type_src") {
sources = [
- "type/address_space_test.cc",
"type/atomic_test.cc",
"type/bool_test.cc",
"type/builtin_test.cc",
@@ -1438,7 +1438,10 @@
"type/u32_test.cc",
"type/vector_test.cc",
]
- deps = [ ":libtint_base_src" ]
+ deps = [
+ ":libtint_base_src",
+ ":libtint_builtins_src",
+ ]
}
tint_unittests_source_set("tint_unittests_text_src") {
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 149505d..83ee256 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -549,6 +549,7 @@
)
tint_generated(builtin/access BENCH TEST)
+tint_generated(builtin/address_space BENCH TEST)
tint_generated(builtin/builtin_value BENCH TEST)
tint_generated(builtin/extension BENCH TEST)
tint_generated(ast/diagnostic_control BENCH TEST)
@@ -556,7 +557,6 @@
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/builtin BENCH TEST)
tint_generated(type/texel_format BENCH TEST)
diff --git a/src/tint/ast/module_test.cc b/src/tint/ast/module_test.cc
index 24faaee..d80033d 100644
--- a/src/tint/ast/module_test.cc
+++ b/src/tint/ast/module_test.cc
@@ -73,7 +73,7 @@
{
ProgramBuilder b1;
ProgramBuilder b2;
- b1.AST().AddGlobalVariable(b2.Var("var", b2.ty.i32(), type::AddressSpace::kPrivate));
+ b1.AST().AddGlobalVariable(b2.Var("var", b2.ty.i32(), builtin::AddressSpace::kPrivate));
},
"internal compiler error");
}
@@ -93,7 +93,7 @@
ProgramBuilder b;
b.Func("F", {}, b.ty.void_(), {});
b.Alias("A", b.ty.u32());
- b.GlobalVar("V", b.ty.i32(), type::AddressSpace::kPrivate);
+ b.GlobalVar("V", b.ty.i32(), builtin::AddressSpace::kPrivate);
return Program(std::move(b));
}();
diff --git a/src/tint/ast/variable.h b/src/tint/ast/variable.h
index 78e3b75..f8a17a3 100644
--- a/src/tint/ast/variable.h
+++ b/src/tint/ast/variable.h
@@ -24,7 +24,7 @@
#include "src/tint/ast/group_attribute.h"
#include "src/tint/ast/type.h"
#include "src/tint/builtin/access.h"
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/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 dcbf1e5..35fca4a 100644
--- a/src/tint/ast/variable_test.cc
+++ b/src/tint/ast/variable_test.cc
@@ -25,7 +25,7 @@
using VariableTest = TestHelper;
TEST_F(VariableTest, Creation) {
- auto* v = Var("my_var", ty.i32(), type::AddressSpace::kFunction);
+ auto* v = Var("my_var", ty.i32(), builtin::AddressSpace::kFunction);
CheckIdentifier(Symbols(), v->name, "my_var");
CheckIdentifier(Symbols(), v->declared_address_space, "function");
@@ -39,7 +39,7 @@
TEST_F(VariableTest, CreationWithSource) {
auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 5}}}, "i",
- ty.f32(), type::AddressSpace::kPrivate, utils::Empty);
+ ty.f32(), builtin::AddressSpace::kPrivate, utils::Empty);
CheckIdentifier(Symbols(), v->name, "i");
CheckIdentifier(Symbols(), v->declared_address_space, "private");
@@ -52,7 +52,7 @@
TEST_F(VariableTest, CreationEmpty) {
auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 7}}}, "a_var",
- ty.i32(), type::AddressSpace::kWorkgroup, utils::Empty);
+ ty.i32(), builtin::AddressSpace::kWorkgroup, utils::Empty);
CheckIdentifier(Symbols(), v->name, "a_var");
CheckIdentifier(Symbols(), v->declared_address_space, "workgroup");
@@ -93,7 +93,7 @@
}
TEST_F(VariableTest, WithAttributes) {
- auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Location(1_u),
+ auto* var = Var("my_var", ty.i32(), builtin::AddressSpace::kFunction, Location(1_u),
Builtin(builtin::BuiltinValue::kPosition), Id(1200_u));
auto& attributes = var->attributes;
@@ -108,22 +108,22 @@
}
TEST_F(VariableTest, HasBindingPoint_BothProvided) {
- auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Binding(2_a), Group(1_a));
+ auto* var = Var("my_var", ty.i32(), builtin::AddressSpace::kFunction, Binding(2_a), Group(1_a));
EXPECT_TRUE(var->HasBindingPoint());
}
TEST_F(VariableTest, HasBindingPoint_NeitherProvided) {
- auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, utils::Empty);
+ auto* var = Var("my_var", ty.i32(), builtin::AddressSpace::kFunction, utils::Empty);
EXPECT_FALSE(var->HasBindingPoint());
}
TEST_F(VariableTest, HasBindingPoint_MissingGroupAttribute) {
- auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Binding(2_a));
+ auto* var = Var("my_var", ty.i32(), builtin::AddressSpace::kFunction, Binding(2_a));
EXPECT_FALSE(var->HasBindingPoint());
}
TEST_F(VariableTest, HasBindingPoint_MissingBindingAttribute) {
- auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Group(1_a));
+ auto* var = Var("my_var", ty.i32(), builtin::AddressSpace::kFunction, Group(1_a));
EXPECT_FALSE(var->HasBindingPoint());
}
diff --git a/src/tint/type/address_space.cc b/src/tint/builtin/address_space.cc
similarity index 94%
rename from src/tint/type/address_space.cc
rename to src/tint/builtin/address_space.cc
index c3cfcc6..3b386b8 100644
--- a/src/tint/type/address_space.cc
+++ b/src/tint/builtin/address_space.cc
@@ -15,14 +15,14 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
-// src/tint/type/address_space.cc.tmpl
+// src/tint/builtin/address_space.cc.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
-namespace tint::type {
+namespace tint::builtin {
/// ParseAddressSpace parses a AddressSpace from a string.
/// @param str the string to parse
@@ -81,4 +81,4 @@
return out << "<unknown>";
}
-} // namespace tint::type
+} // namespace tint::builtin
diff --git a/src/tint/type/address_space.cc.tmpl b/src/tint/builtin/address_space.cc.tmpl
similarity index 85%
rename from src/tint/type/address_space.cc.tmpl
rename to src/tint/builtin/address_space.cc.tmpl
index f9036b7..a137718 100644
--- a/src/tint/type/address_space.cc.tmpl
+++ b/src/tint/builtin/address_space.cc.tmpl
@@ -14,12 +14,12 @@
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "address_space") -}}
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
-namespace tint::type {
+namespace tint::builtin {
{{ Eval "ParseEnum" $enum}}
{{ Eval "EnumOStream" $enum}}
-} // namespace tint::type
+} // namespace tint::builtin
diff --git a/src/tint/type/address_space.h b/src/tint/builtin/address_space.h
similarity index 89%
rename from src/tint/type/address_space.h
rename to src/tint/builtin/address_space.h
index f0b0224..55b1557 100644
--- a/src/tint/type/address_space.h
+++ b/src/tint/builtin/address_space.h
@@ -15,17 +15,17 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
-// src/tint/type/address_space.h.tmpl
+// src/tint/builtin/address_space.h.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
-#ifndef SRC_TINT_TYPE_ADDRESS_SPACE_H_
-#define SRC_TINT_TYPE_ADDRESS_SPACE_H_
+#ifndef SRC_TINT_BUILTIN_ADDRESS_SPACE_H_
+#define SRC_TINT_BUILTIN_ADDRESS_SPACE_H_
#include <ostream>
-namespace tint::type {
+namespace tint::builtin {
/// Address space of a given pointer.
enum class AddressSpace {
@@ -63,6 +63,6 @@
address_space == AddressSpace::kPushConstant;
}
-} // namespace tint::type
+} // namespace tint::builtin
-#endif // SRC_TINT_TYPE_ADDRESS_SPACE_H_
+#endif // SRC_TINT_BUILTIN_ADDRESS_SPACE_H_
diff --git a/src/tint/type/address_space.h.tmpl b/src/tint/builtin/address_space.h.tmpl
similarity index 84%
rename from src/tint/type/address_space.h.tmpl
rename to src/tint/builtin/address_space.h.tmpl
index 70e308a..1dd7d35 100644
--- a/src/tint/type/address_space.h.tmpl
+++ b/src/tint/builtin/address_space.h.tmpl
@@ -14,12 +14,12 @@
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "address_space") -}}
-#ifndef SRC_TINT_TYPE_ADDRESS_SPACE_H_
-#define SRC_TINT_TYPE_ADDRESS_SPACE_H_
+#ifndef SRC_TINT_BUILTIN_ADDRESS_SPACE_H_
+#define SRC_TINT_BUILTIN_ADDRESS_SPACE_H_
#include <ostream>
-namespace tint::type {
+namespace tint::builtin {
/// Address space of a given pointer.
{{ Eval "DeclareEnum" $enum}}
@@ -33,6 +33,6 @@
address_space == AddressSpace::kPushConstant;
}
-} // namespace tint::type
+} // namespace tint::builtin
-#endif // SRC_TINT_TYPE_ADDRESS_SPACE_H_
+#endif // SRC_TINT_BUILTIN_ADDRESS_SPACE_H_
diff --git a/src/tint/type/address_space_bench.cc b/src/tint/builtin/address_space_bench.cc
similarity index 93%
rename from src/tint/type/address_space_bench.cc
rename to src/tint/builtin/address_space_bench.cc
index 6f33497..18cc9d2 100644
--- a/src/tint/type/address_space_bench.cc
+++ b/src/tint/builtin/address_space_bench.cc
@@ -15,18 +15,18 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
-// src/tint/type/address_space_bench.cc.tmpl
+// src/tint/builtin/address_space_bench.cc.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
#include <array>
#include "benchmark/benchmark.h"
-namespace tint::type {
+namespace tint::builtin {
namespace {
void AddressSpaceParser(::benchmark::State& state) {
@@ -99,4 +99,4 @@
BENCHMARK(AddressSpaceParser);
} // namespace
-} // namespace tint::type
+} // namespace tint::builtin
diff --git a/src/tint/type/address_space_bench.cc.tmpl b/src/tint/builtin/address_space_bench.cc.tmpl
similarity index 86%
rename from src/tint/type/address_space_bench.cc.tmpl
rename to src/tint/builtin/address_space_bench.cc.tmpl
index 554b2b2d..34f7869 100644
--- a/src/tint/type/address_space_bench.cc.tmpl
+++ b/src/tint/builtin/address_space_bench.cc.tmpl
@@ -14,16 +14,16 @@
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "address_space") -}}
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
#include <array>
#include "benchmark/benchmark.h"
-namespace tint::type {
+namespace tint::builtin {
namespace {
{{ Eval "BenchmarkParseEnum" $enum }}
} // namespace
-} // namespace tint::type
+} // namespace tint::builtin
diff --git a/src/tint/type/address_space_test.cc b/src/tint/builtin/address_space_test.cc
similarity index 94%
rename from src/tint/type/address_space_test.cc
rename to src/tint/builtin/address_space_test.cc
index 7909f0e..1ca7023 100644
--- a/src/tint/type/address_space_test.cc
+++ b/src/tint/builtin/address_space_test.cc
@@ -15,19 +15,20 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
-// src/tint/type/address_space_test.cc.tmpl
+// src/tint/builtin/address_space_test.cc.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
+
+#include <gtest/gtest.h>
#include <string>
-#include "src/tint/type/test_helper.h"
#include "src/tint/utils/string.h"
-namespace tint::type {
+namespace tint::builtin {
namespace {
namespace parse_print_tests {
@@ -91,4 +92,4 @@
} // namespace parse_print_tests
} // namespace
-} // namespace tint::type
+} // namespace tint::builtin
diff --git a/src/tint/type/address_space_test.cc.tmpl b/src/tint/builtin/address_space_test.cc.tmpl
similarity index 83%
rename from src/tint/type/address_space_test.cc.tmpl
rename to src/tint/builtin/address_space_test.cc.tmpl
index 75f16f2..5f7a437 100644
--- a/src/tint/type/address_space_test.cc.tmpl
+++ b/src/tint/builtin/address_space_test.cc.tmpl
@@ -14,17 +14,18 @@
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "address_space") -}}
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
+
+#include <gtest/gtest.h>
#include <string>
-#include "src/tint/type/test_helper.h"
#include "src/tint/utils/string.h"
-namespace tint::type {
+namespace tint::builtin {
namespace {
{{ Eval "TestParsePrintEnum" $enum}}
} // namespace
-} // namespace tint::type
+} // namespace tint::builtin
diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc
index 396d0e5..0863db3 100644
--- a/src/tint/inspector/inspector.cc
+++ b/src/tint/inspector/inspector.cc
@@ -587,7 +587,7 @@
uint32_t total_size = 0;
auto* func_sem = program_->Sem().Get(func);
for (const sem::Variable* var : func_sem->TransitivelyReferencedGlobals()) {
- if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
+ if (var->AddressSpace() == builtin::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 22f1332..44e13b0 100644
--- a/src/tint/inspector/inspector_test.cc
+++ b/src/tint/inspector/inspector_test.cc
@@ -743,7 +743,7 @@
TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly_ViaPrivateInitializer) {
Override("foo", ty.f32());
- GlobalVar("bar", type::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "foo"));
+ GlobalVar("bar", builtin::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, OverrideReferencedByArraySize) {
Override("size", ty.u32());
- GlobalVar("v", type::AddressSpace::kWorkgroup, ty.array(ty.f32(), "size"));
+ GlobalVar("v", builtin::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, OverrideReferencedByArraySizeIndirectly) {
Override("foo", ty.u32());
Override("bar", ty.u32(), Mul(2_a, "foo"));
- GlobalVar("v", type::AddressSpace::kWorkgroup, ty.array(ty.f32(), Mul(2_a, Expr("bar"))));
+ GlobalVar("v", builtin::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 @@
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", type::AddressSpace::kWorkgroup, ty("MyArray"));
+ GlobalVar("v", builtin::AddressSpace::kWorkgroup, ty("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 1de6dd3..b1c8dd4 100644
--- a/src/tint/inspector/test_inspector_builder.cc
+++ b/src/tint/inspector/test_inspector_builder.cc
@@ -125,11 +125,12 @@
ast::Type type,
uint32_t group,
uint32_t binding) {
- GlobalVar(name, type, type::AddressSpace::kUniform, Binding(AInt(binding)), Group(AInt(group)));
+ GlobalVar(name, type, builtin::AddressSpace::kUniform, Binding(AInt(binding)),
+ Group(AInt(group)));
}
void InspectorBuilder::AddWorkgroupStorage(const std::string& name, ast::Type type) {
- GlobalVar(name, type, type::AddressSpace::kWorkgroup);
+ GlobalVar(name, type, builtin::AddressSpace::kWorkgroup);
}
void InspectorBuilder::AddStorageBuffer(const std::string& name,
@@ -137,7 +138,7 @@
builtin::Access access,
uint32_t group,
uint32_t binding) {
- GlobalVar(name, type, type::AddressSpace::kStorage, access, Binding(AInt(binding)),
+ GlobalVar(name, type, builtin::AddressSpace::kStorage, access, Binding(AInt(binding)),
Group(AInt(group)));
}
@@ -189,7 +190,7 @@
}
void InspectorBuilder::AddGlobalVariable(const std::string& name, ast::Type type) {
- GlobalVar(name, type, type::AddressSpace::kPrivate);
+ GlobalVar(name, type, builtin::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 6430c58..ccf0ccf 100644
--- a/src/tint/ir/builder_impl_test.cc
+++ b/src/tint/ir/builder_impl_test.cc
@@ -1468,7 +1468,7 @@
TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) {
auto* expr = Expr(true);
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, expr);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr);
@@ -1482,7 +1482,7 @@
TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) {
auto* expr = Expr(false);
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, expr);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr);
@@ -1496,7 +1496,7 @@
TEST_F(IR_BuilderImplTest, EmitLiteral_F32) {
auto* expr = Expr(1.2_f);
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, expr);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr);
@@ -1511,7 +1511,7 @@
TEST_F(IR_BuilderImplTest, EmitLiteral_F16) {
Enable(builtin::Extension::kF16);
auto* expr = Expr(1.2_h);
- GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate, expr);
+ GlobalVar("a", ty.f16(), builtin::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr);
@@ -1525,7 +1525,7 @@
TEST_F(IR_BuilderImplTest, EmitLiteral_I32) {
auto* expr = Expr(-2_i);
- GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate, expr);
+ GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate, expr);
auto& b = CreateBuilder();
auto r = b.EmitLiteral(expr);
@@ -1539,7 +1539,7 @@
TEST_F(IR_BuilderImplTest, EmitLiteral_U32) {
auto* expr = Expr(2_u);
- GlobalVar("a", ty.u32(), type::AddressSpace::kPrivate, expr);
+ GlobalVar("a", ty.u32(), builtin::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 4816567..4444428 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -232,8 +232,8 @@
private:
void Set(ProgramBuilder&, ast::Type t) { type = t; }
- void Set(ProgramBuilder& b, type::AddressSpace addr_space) {
- if (addr_space != type::AddressSpace::kUndefined) {
+ void Set(ProgramBuilder& b, builtin::AddressSpace addr_space) {
+ if (addr_space != builtin::AddressSpace::kUndefined) {
address_space = b.Expr(addr_space);
}
}
@@ -1199,9 +1199,9 @@
/// @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 type::AddressSpace
+ /// @return the pointer to `type` with the given builtin::AddressSpace
ast::Type pointer(ast::Type type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
return pointer(builder->source_, type, address_space, access);
}
@@ -1210,10 +1210,10 @@
/// @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 type::AddressSpace
+ /// @return the pointer to `type` with the given builtin::AddressSpace
ast::Type pointer(const Source& source,
ast::Type type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
if (access != builtin::Access::kUndefined) {
return (*this)(source, "ptr", address_space, type, access);
@@ -1224,9 +1224,9 @@
/// @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 type::AddressSpace.
+ /// @return the pointer to type `T` with the given builtin::AddressSpace.
template <typename T>
- ast::Type pointer(type::AddressSpace address_space,
+ ast::Type pointer(builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
return pointer<T>(builder->source_, address_space, access);
}
@@ -1234,10 +1234,10 @@
/// @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 type::AddressSpace.
+ /// @return the pointer to type `T` with the given builtin::AddressSpace.
template <typename T>
ast::Type pointer(const Source& source,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
if (access != builtin::Access::kUndefined) {
return (*this)(source, "ptr", address_space, Of<T>(), access);
@@ -2066,7 +2066,7 @@
/// @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's type
- /// * type::AddressSpace - specifies the variable's address space
+ /// * builtin::AddressSpace - specifies the variable's address space
/// * builtin::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)
@@ -2083,7 +2083,7 @@
/// @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's type
- /// * type::AddressSpace - specifies the variable's address space
+ /// * builtin::AddressSpace - specifies the variable's address space
/// * builtin::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)
@@ -2185,7 +2185,7 @@
/// @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's type
- /// * type::AddressSpace - specifies the variable address space
+ /// * builtin::AddressSpace - specifies the variable address space
/// * builtin::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)
@@ -2202,7 +2202,7 @@
/// @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's type
- /// * type::AddressSpace - specifies the variable address space
+ /// * builtin::AddressSpace - specifies the variable address space
/// * builtin::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 f856504..0267bcc 100644
--- a/src/tint/program_test.cc
+++ b/src/tint/program_test.cc
@@ -46,7 +46,7 @@
}
TEST_F(ProgramTest, Assert_GlobalVariable) {
- GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.f32(), builtin::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 4f9e07b..1aeaf88 100644
--- a/src/tint/reader/spirv/enum_converter.cc
+++ b/src/tint/reader/spirv/enum_converter.cc
@@ -38,30 +38,30 @@
return ast::PipelineStage::kNone;
}
-type::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) {
+builtin::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) {
switch (sc) {
case spv::StorageClass::Input:
- return type::AddressSpace::kIn;
+ return builtin::AddressSpace::kIn;
case spv::StorageClass::Output:
- return type::AddressSpace::kOut;
+ return builtin::AddressSpace::kOut;
case spv::StorageClass::Uniform:
- return type::AddressSpace::kUniform;
+ return builtin::AddressSpace::kUniform;
case spv::StorageClass::Workgroup:
- return type::AddressSpace::kWorkgroup;
+ return builtin::AddressSpace::kWorkgroup;
case spv::StorageClass::UniformConstant:
- return type::AddressSpace::kUndefined;
+ return builtin::AddressSpace::kUndefined;
case spv::StorageClass::StorageBuffer:
- return type::AddressSpace::kStorage;
+ return builtin::AddressSpace::kStorage;
case spv::StorageClass::Private:
- return type::AddressSpace::kPrivate;
+ return builtin::AddressSpace::kPrivate;
case spv::StorageClass::Function:
- return type::AddressSpace::kFunction;
+ return builtin::AddressSpace::kFunction;
default:
break;
}
Fail() << "unknown SPIR-V storage class: " << uint32_t(sc);
- return type::AddressSpace::kUndefined;
+ return builtin::AddressSpace::kUndefined;
}
builtin::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 7cdbfac..12b50af 100644
--- a/src/tint/reader/spirv/enum_converter.h
+++ b/src/tint/reader/spirv/enum_converter.h
@@ -18,9 +18,9 @@
#include "spirv/unified1/spirv.h"
#include "spirv/unified1/spirv.hpp11"
#include "src/tint/ast/pipeline_stage.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/builtin/builtin_value.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 @@
/// On failure, logs an error and returns kNone
/// @param sc the SPIR-V storage class
/// @returns a Tint AST address space
- type::AddressSpace ToAddressSpace(const spv::StorageClass sc);
+ builtin::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 66e99ff..c5da495 100644
--- a/src/tint/reader/spirv/enum_converter_test.cc
+++ b/src/tint/reader/spirv/enum_converter_test.cc
@@ -85,7 +85,7 @@
struct StorageClassCase {
spv::StorageClass sc;
bool expect_success;
- type::AddressSpace expected;
+ builtin::AddressSpace expected;
};
inline std::ostream& operator<<(std::ostream& out, StorageClassCase scc) {
out << "StorageClassCase{ spv::StorageClass:::" << int(scc.sc)
@@ -126,19 +126,21 @@
EnumConverterGood,
SpvStorageClassTest,
testing::Values(
- 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::kUndefined},
- StorageClassCase{spv::StorageClass::StorageBuffer, true, type::AddressSpace::kStorage},
- StorageClassCase{spv::StorageClass::Private, true, type::AddressSpace::kPrivate},
- StorageClassCase{spv::StorageClass::Function, true, type::AddressSpace::kFunction}));
+ StorageClassCase{spv::StorageClass::Input, true, builtin::AddressSpace::kIn},
+ StorageClassCase{spv::StorageClass::Output, true, builtin::AddressSpace::kOut},
+ StorageClassCase{spv::StorageClass::Uniform, true, builtin::AddressSpace::kUniform},
+ StorageClassCase{spv::StorageClass::Workgroup, true, builtin::AddressSpace::kWorkgroup},
+ StorageClassCase{spv::StorageClass::UniformConstant, true,
+ builtin::AddressSpace::kUndefined},
+ StorageClassCase{spv::StorageClass::StorageBuffer, true, builtin::AddressSpace::kStorage},
+ StorageClassCase{spv::StorageClass::Private, true, builtin::AddressSpace::kPrivate},
+ StorageClassCase{spv::StorageClass::Function, true, builtin::AddressSpace::kFunction}));
INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
SpvStorageClassTest,
testing::Values(StorageClassCase{static_cast<spv::StorageClass>(9999),
- false, type::AddressSpace::kUndefined}));
+ false,
+ builtin::AddressSpace::kUndefined}));
// Builtin
diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index ca35917..12c46c1 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -2521,12 +2521,12 @@
return false;
}
}
- auto* var = parser_impl_.MakeVar(inst.result_id(), type::AddressSpace::kUndefined,
+ auto* var = parser_impl_.MakeVar(inst.result_id(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, var_store_type, initializer,
AttributeList{});
auto* var_decl_stmt = create<ast::VariableDeclStatement>(Source{}, var);
AddStatement(var_decl_stmt);
- auto* var_type = ty_.Reference(var_store_type, type::AddressSpace::kUndefined);
+ auto* var_type = ty_.Reference(var_store_type, builtin::AddressSpace::kUndefined);
identifier_types_.emplace(inst.result_id(), var_type);
}
return success();
@@ -3369,9 +3369,9 @@
auto* store_type = parser_impl_.ConvertType(def_inst->type_id());
AddStatement(create<ast::VariableDeclStatement>(
Source{},
- parser_impl_.MakeVar(id, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ parser_impl_.MakeVar(id, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
store_type, nullptr, AttributeList{})));
- auto* type = ty_.Reference(store_type, type::AddressSpace::kUndefined);
+ auto* type = ty_.Reference(store_type, builtin::AddressSpace::kUndefined);
identifier_types_.emplace(id, type);
}
@@ -4842,7 +4842,8 @@
}
// Local variables are always Function storage class, with default
// access mode.
- return DefInfo::Pointer{type::AddressSpace::kFunction, builtin::Access::kUndefined};
+ return DefInfo::Pointer{builtin::AddressSpace::kFunction,
+ builtin::Access::kUndefined};
}
case spv::Op::OpFunctionParameter: {
const auto* type = As<Pointer>(parser_impl_.ConvertType(inst.type_id()));
@@ -5082,7 +5083,7 @@
// 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 == type::AddressSpace::kUndefined) &&
+ if ((def_info->pointer.address_space == builtin::AddressSpace::kUndefined) &&
local_def.used_in_another_construct) {
should_hoist_to_let = true;
}
@@ -6192,7 +6193,7 @@
var_name = namer_.MakeDerivedName(original_value_name);
auto* temp_var = builder_.Var(var_name, type->Build(builder_),
- type::AddressSpace::kUndefined, src_vector.expr);
+ builtin::AddressSpace::kUndefined, src_vector.expr);
AddStatement(builder_.Decl({}, temp_var));
}
@@ -6262,7 +6263,7 @@
// API in parser_impl_.
var_name = namer_.MakeDerivedName(original_value_name);
auto* temp_var = builder_.Var(var_name, type->Build(builder_),
- type::AddressSpace::kUndefined, src_composite.expr);
+ builtin::AddressSpace::kUndefined, 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 5879859..345896a 100644
--- a/src/tint/reader/spirv/function.h
+++ b/src/tint/reader/spirv/function.h
@@ -331,7 +331,7 @@
/// 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.
- type::AddressSpace address_space = type::AddressSpace::kUndefined;
+ builtin::AddressSpace address_space = builtin::AddressSpace::kUndefined;
/// The declared access mode.
builtin::Access access = builtin::Access::kUndefined;
@@ -368,7 +368,7 @@
}
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 != type::AddressSpace::kUndefined) {
+ if (di.pointer.address_space != builtin::AddressSpace::kUndefined) {
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 282e285..a34d14a 100644
--- a/src/tint/reader/spirv/parser_impl.cc
+++ b/src/tint/reader/spirv/parser_impl.cc
@@ -1222,16 +1222,16 @@
}
auto ast_address_space = enum_converter_.ToAddressSpace(storage_class);
- if (ast_address_space == type::AddressSpace::kUniform &&
+ if (ast_address_space == builtin::AddressSpace::kUniform &&
remap_buffer_block_type_.count(pointee_type_id)) {
- ast_address_space = type::AddressSpace::kStorage;
+ ast_address_space = builtin::AddressSpace::kStorage;
remap_buffer_block_type_.insert(type_id);
}
// Pipeline input and output variables map to private variables.
- if (ast_address_space == type::AddressSpace::kIn ||
- ast_address_space == type::AddressSpace::kOut) {
- ast_address_space = type::AddressSpace::kPrivate;
+ if (ast_address_space == builtin::AddressSpace::kIn ||
+ ast_address_space == builtin::AddressSpace::kOut) {
+ ast_address_space = builtin::AddressSpace::kPrivate;
}
switch (ptr_as) {
case PtrAs::Ref:
@@ -1454,14 +1454,14 @@
continue;
}
switch (enum_converter_.ToAddressSpace(spirv_storage_class)) {
- case type::AddressSpace::kUndefined:
- 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:
+ case builtin::AddressSpace::kUndefined:
+ case builtin::AddressSpace::kIn:
+ case builtin::AddressSpace::kOut:
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kHandle:
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kPrivate:
break;
default:
return Fail() << "invalid SPIR-V storage class " << int(spirv_storage_class)
@@ -1471,7 +1471,7 @@
return false;
}
const Type* ast_store_type = nullptr;
- type::AddressSpace ast_address_space = type::AddressSpace::kUndefined;
+ builtin::AddressSpace ast_address_space = builtin::AddressSpace::kUndefined;
if (spirv_storage_class == spv::StorageClass::UniformConstant) {
// These are opaque handles: samplers or textures
ast_store_type = GetHandleTypeForSpirvHandle(var);
@@ -1576,8 +1576,9 @@
return size->AsIntConstant();
}
-builtin::Access ParserImpl::VarAccess(const Type* storage_type, type::AddressSpace address_space) {
- if (address_space != type::AddressSpace::kStorage) {
+builtin::Access ParserImpl::VarAccess(const Type* storage_type,
+ builtin::AddressSpace address_space) {
+ if (address_space != builtin::AddressSpace::kStorage) {
return builtin::Access::kUndefined;
}
@@ -1591,7 +1592,7 @@
}
const ast::Var* ParserImpl::MakeVar(uint32_t id,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const Type* storage_type,
const ast::Expression* initializer,
@@ -1603,12 +1604,12 @@
// Handle variables (textures and samplers) are always in the handle
// address space, so we don't mention the address space.
- if (address_space == type::AddressSpace::kHandle) {
- address_space = type::AddressSpace::kUndefined;
+ if (address_space == builtin::AddressSpace::kHandle) {
+ address_space = builtin::AddressSpace::kUndefined;
}
if (!ConvertDecorationsForVariable(id, &storage_type, &decorations,
- address_space != type::AddressSpace::kPrivate)) {
+ address_space != builtin::AddressSpace::kPrivate)) {
return nullptr;
}
diff --git a/src/tint/reader/spirv/parser_impl.h b/src/tint/reader/spirv/parser_impl.h
index 7f93497..12b852a 100644
--- a/src/tint/reader/spirv/parser_impl.h
+++ b/src/tint/reader/spirv/parser_impl.h
@@ -424,12 +424,12 @@
/// @param address_space the 'var' address space
/// @returns the access mode for a 'var' declaration with the given storage type and address
/// space.
- builtin::Access VarAccess(const Type* storage_type, type::AddressSpace address_space);
+ builtin::Access VarAccess(const Type* storage_type, builtin::AddressSpace address_space);
/// 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 type::AddressSpace::kUndefined
+ /// @param address_space the address space, which cannot be builtin::AddressSpace::kUndefined
/// @param access the access
/// @param storage_type the storage type of the variable
/// @param initializer the variable initializer
@@ -437,7 +437,7 @@
/// @returns a new Variable node, or null in the ignorable variable case and
/// in the error case
const ast::Var* MakeVar(uint32_t id,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const Type* storage_type,
const ast::Expression* initializer,
@@ -672,7 +672,7 @@
/// The AST variable node.
const ast::Var* var = nullptr;
/// The address space of the var
- type::AddressSpace address_space = type::AddressSpace::kUndefined;
+ builtin::AddressSpace address_space = builtin::AddressSpace::kUndefined;
/// The access mode of the var
builtin::Access access = builtin::Access::kUndefined;
};
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 8530b77..fd9a406 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 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kPrivate);
EXPECT_TRUE(p->error().empty());
}
@@ -747,7 +747,7 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kPrivate);
EXPECT_TRUE(p->error().empty());
}
@@ -763,7 +763,7 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kUniform);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kUniform);
EXPECT_TRUE(p->error().empty());
}
@@ -779,7 +779,7 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kWorkgroup);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(p->error().empty());
}
@@ -795,7 +795,7 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kStorage);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kStorage);
EXPECT_TRUE(p->error().empty());
}
@@ -811,7 +811,7 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kPrivate);
EXPECT_TRUE(p->error().empty());
}
@@ -827,7 +827,7 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
EXPECT_TRUE(ptr_ty->type->Is<F32>());
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kFunction);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kFunction);
EXPECT_TRUE(p->error().empty());
}
@@ -846,12 +846,12 @@
auto* ptr_ty = type->As<Pointer>();
EXPECT_NE(ptr_ty, nullptr);
- EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
+ EXPECT_EQ(ptr_ty->address_space, builtin::AddressSpace::kPrivate);
EXPECT_TRUE(ptr_ty->type->Is<Pointer>());
auto* ptr_ptr_ty = ptr_ty->type->As<Pointer>();
EXPECT_NE(ptr_ptr_ty, nullptr);
- EXPECT_EQ(ptr_ptr_ty->address_space, type::AddressSpace::kPrivate);
+ EXPECT_EQ(ptr_ptr_ty->address_space, builtin::AddressSpace::kPrivate);
EXPECT_TRUE(ptr_ptr_ty->type->Is<F32>());
EXPECT_TRUE(p->error().empty());
diff --git a/src/tint/reader/spirv/parser_type.cc b/src/tint/reader/spirv/parser_type.cc
index 3164c6e..acfaa88 100644
--- a/src/tint/reader/spirv/parser_type.cc
+++ b/src/tint/reader/spirv/parser_type.cc
@@ -175,7 +175,7 @@
Texture::~Texture() = default;
-Pointer::Pointer(const Type* t, type::AddressSpace s, builtin::Access a)
+Pointer::Pointer(const Type* t, builtin::AddressSpace s, builtin::Access a)
: type(t), address_space(s), access(a) {}
Pointer::Pointer(const Pointer&) = default;
@@ -189,7 +189,7 @@
return b.ty.pointer(type->Build(b), address_space, access);
}
-Reference::Reference(const Type* t, type::AddressSpace s, builtin::Access a)
+Reference::Reference(const Type* t, builtin::AddressSpace s, builtin::Access a)
: type(t), address_space(s), access(a) {}
Reference::Reference(const Reference&) = default;
@@ -474,13 +474,13 @@
}
const spirv::Pointer* TypeManager::Pointer(const Type* el,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access) {
return state->pointers_.Get(el, address_space, access);
}
const spirv::Reference* TypeManager::Reference(const Type* el,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::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 18f47d3..54991dc 100644
--- a/src/tint/reader/spirv/parser_type.h
+++ b/src/tint/reader/spirv/parser_type.h
@@ -21,9 +21,9 @@
#include "src/tint/ast/type.h"
#include "src/tint/builtin/access.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/castable.h"
#include "src/tint/symbol.h"
-#include "src/tint/type/address_space.h"
#include "src/tint/type/sampler_kind.h"
#include "src/tint/type/texel_format.h"
#include "src/tint/type/texture_dimension.h"
@@ -162,7 +162,7 @@
/// @param ty the store type
/// @param sc the pointer address space
/// @param access the declared access mode
- Pointer(const Type* ty, type::AddressSpace sc, builtin::Access access);
+ Pointer(const Type* ty, builtin::AddressSpace sc, builtin::Access access);
/// Copy constructor
/// @param other the other type to copy
@@ -180,7 +180,7 @@
/// the store type
Type const* const type;
/// the pointer address space
- type::AddressSpace const address_space;
+ builtin::AddressSpace const address_space;
/// the pointer declared access mode
builtin::Access const access;
};
@@ -193,7 +193,7 @@
/// @param ty the referenced type
/// @param sc the reference address space
/// @param access the reference declared access mode
- Reference(const Type* ty, type::AddressSpace sc, builtin::Access access);
+ Reference(const Type* ty, builtin::AddressSpace sc, builtin::Access access);
/// Copy constructor
/// @param other the other type to copy
@@ -211,7 +211,7 @@
/// the store type
Type const* const type;
/// the pointer address space
- type::AddressSpace const address_space;
+ builtin::AddressSpace const address_space;
/// the pointer declared access mode
builtin::Access const access;
};
@@ -549,7 +549,7 @@
/// @return a Pointer type. Repeated calls with the same arguments will return
/// the same pointer.
const spirv::Pointer* Pointer(const Type* ty,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined);
/// @param ty the referenced type
/// @param address_space the reference address space
@@ -557,7 +557,7 @@
/// @return a Reference type. Repeated calls with the same arguments will
/// return the same pointer.
const spirv::Reference* Reference(const Type* ty,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access = builtin::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 560b24e..68492bb 100644
--- a/src/tint/reader/spirv/parser_type_test.cc
+++ b/src/tint/reader/spirv/parser_type_test.cc
@@ -29,8 +29,8 @@
EXPECT_EQ(ty.U32(), ty.U32());
EXPECT_EQ(ty.F32(), ty.F32());
EXPECT_EQ(ty.I32(), ty.I32());
- EXPECT_EQ(ty.Pointer(ty.I32(), type::AddressSpace::kUndefined),
- ty.Pointer(ty.I32(), type::AddressSpace::kUndefined));
+ EXPECT_EQ(ty.Pointer(ty.I32(), builtin::AddressSpace::kUndefined),
+ ty.Pointer(ty.I32(), builtin::AddressSpace::kUndefined));
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 @@
Symbol sym_b(Symbol(2, {}));
TypeManager ty;
- EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kUndefined),
- ty.Pointer(ty.U32(), type::AddressSpace::kUndefined));
- EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kUndefined),
- ty.Pointer(ty.I32(), type::AddressSpace::kIn));
+ EXPECT_NE(ty.Pointer(ty.I32(), builtin::AddressSpace::kUndefined),
+ ty.Pointer(ty.U32(), builtin::AddressSpace::kUndefined));
+ EXPECT_NE(ty.Pointer(ty.I32(), builtin::AddressSpace::kUndefined),
+ ty.Pointer(ty.I32(), builtin::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_variable_qualifier_test.cc b/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
index 9708f0d..3c25d85 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_qualifier_test.cc
@@ -20,7 +20,7 @@
struct VariableStorageData {
const char* input;
- type::AddressSpace address_space;
+ builtin::AddressSpace address_space;
builtin::Access access;
};
inline std::ostream& operator<<(std::ostream& out, VariableStorageData data) {
@@ -38,7 +38,7 @@
EXPECT_FALSE(p->has_error());
EXPECT_FALSE(sc.errored);
EXPECT_TRUE(sc.matched);
- if (params.address_space != type::AddressSpace::kUndefined) {
+ if (params.address_space != builtin::AddressSpace::kUndefined) {
ast::CheckIdentifier(p->builder().Symbols(), sc->address_space,
utils::ToString(params.address_space));
} else {
@@ -56,18 +56,22 @@
INSTANTIATE_TEST_SUITE_P(
ParserImplTest,
VariableQualifierTest,
- testing::Values(
- VariableStorageData{"uniform", type::AddressSpace::kUniform, builtin::Access::kUndefined},
- VariableStorageData{"workgroup", type::AddressSpace::kWorkgroup,
- builtin::Access::kUndefined},
- VariableStorageData{"storage", type::AddressSpace::kStorage, builtin::Access::kUndefined},
- VariableStorageData{"private", type::AddressSpace::kPrivate, builtin::Access::kUndefined},
- VariableStorageData{"function", type::AddressSpace::kFunction, builtin::Access::kUndefined},
- VariableStorageData{"storage, read", type::AddressSpace::kStorage, builtin::Access::kRead},
- VariableStorageData{"storage, write", type::AddressSpace::kStorage,
- builtin::Access::kWrite},
- VariableStorageData{"storage, read_write", type::AddressSpace::kStorage,
- builtin::Access::kReadWrite}));
+ testing::Values(VariableStorageData{"uniform", builtin::AddressSpace::kUniform,
+ builtin::Access::kUndefined},
+ VariableStorageData{"workgroup", builtin::AddressSpace::kWorkgroup,
+ builtin::Access::kUndefined},
+ VariableStorageData{"storage", builtin::AddressSpace::kStorage,
+ builtin::Access::kUndefined},
+ VariableStorageData{"private", builtin::AddressSpace::kPrivate,
+ builtin::Access::kUndefined},
+ VariableStorageData{"function", builtin::AddressSpace::kFunction,
+ builtin::Access::kUndefined},
+ VariableStorageData{"storage, read", builtin::AddressSpace::kStorage,
+ builtin::Access::kRead},
+ VariableStorageData{"storage, write", builtin::AddressSpace::kStorage,
+ builtin::Access::kWrite},
+ VariableStorageData{"storage, read_write", builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite}));
TEST_F(ParserImplTest, VariableQualifier_Empty) {
auto p = parser("var<> name");
diff --git a/src/tint/resolver/address_space_layout_validation_test.cc b/src/tint/resolver/address_space_layout_validation_test.cc
index 041e566..48d0633 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 @@
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)}),
});
- GlobalVar(Source{{78, 90}}, "a", ty("S"), type::AddressSpace::kStorage, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("S"), builtin::AddressSpace::kStorage, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -69,7 +69,7 @@
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(4_i)}),
});
- GlobalVar(Source{{78, 90}}, "a", ty("S"), type::AddressSpace::kStorage, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("S"), builtin::AddressSpace::kStorage, Group(0_a),
Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -100,7 +100,7 @@
Member(Source{{56, 78}}, "inner", ty("Inner")),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -144,7 +144,7 @@
Member(Source{{56, 78}}, "inner", ty("Inner"), utils::Vector{MemberAlign(16_i)}),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -169,7 +169,7 @@
Member(Source{{56, 78}}, "inner", ty("Inner")),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -202,7 +202,7 @@
Member(Source{{34, 56}}, "inner", ty("Inner"), utils::Vector{MemberAlign(16_i)}),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -234,7 +234,7 @@
Member(Source{{78, 90}}, "scalar", ty.i32()),
});
- GlobalVar(Source{{22, 24}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{22, 24}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -286,7 +286,7 @@
Member(Source{{78, 90}}, "scalar", ty.i32()),
});
- GlobalVar(Source{{22, 24}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{22, 24}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -334,7 +334,7 @@
Member(Source{{78, 90}}, "scalar", ty.i32(), utils::Vector{MemberAlign(16_i)}),
});
- GlobalVar(Source{{22, 34}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{22, 34}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -355,7 +355,7 @@
Member("s", ty.f32()),
});
- GlobalVar(Source{{78, 90}}, "a", ty("ScalarPackedAtEndOfVec3"), type::AddressSpace::kUniform,
+ GlobalVar(Source{{78, 90}}, "a", ty("ScalarPackedAtEndOfVec3"), builtin::AddressSpace::kUniform,
Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -378,7 +378,7 @@
Member("s", ty.f16()),
});
- GlobalVar(Source{{78, 90}}, "a", ty("ScalarPackedAtEndOfVec3"), type::AddressSpace::kUniform,
+ GlobalVar(Source{{78, 90}}, "a", ty("ScalarPackedAtEndOfVec3"), builtin::AddressSpace::kUniform,
Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -404,7 +404,7 @@
Member("scalar", ty.i32()),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -438,7 +438,7 @@
Member("scalar", ty.i32()),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -481,7 +481,7 @@
Member("scalar", ty.i32()),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -500,7 +500,7 @@
// @group(0) @binding(0)
// var<uniform> a : array<f32, 4u>;
GlobalVar(Source{{78, 90}}, "a", ty.array(Source{{34, 56}}, ty.f32(), 4_u),
- type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
+ builtin::AddressSpace::kUniform, Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -521,7 +521,7 @@
Member("inner", ty.array(Source{{34, 56}}, ty.array<f32, 4>(), 4_u)),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -554,7 +554,7 @@
Member("scalar", ty.i32()),
});
- GlobalVar(Source{{78, 90}}, "a", ty("Outer"), type::AddressSpace::kUniform, Group(0_a),
+ GlobalVar(Source{{78, 90}}, "a", ty("Outer"), builtin::AddressSpace::kUniform, Group(0_a),
Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -573,7 +573,7 @@
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("S"), type::AddressSpace::kPushConstant);
+ GlobalVar(Source{{78, 90}}, "a", ty("S"), builtin::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -598,7 +598,7 @@
Enable(builtin::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("S"), type::AddressSpace::kPushConstant);
+ GlobalVar("a", ty("S"), builtin::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 b0c27e7..3078d89 100644
--- a/src/tint/resolver/address_space_validation_test.cc
+++ b/src/tint/resolver/address_space_validation_test.cc
@@ -47,7 +47,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_Fail) {
// var<private> g : f32;
- GlobalVar(Source{{12, 34}}, "g", ty.f32(), type::AddressSpace::kFunction);
+ GlobalVar(Source{{12, 34}}, "g", ty.f32(), builtin::AddressSpace::kFunction);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -57,7 +57,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray) {
// var<private> v : array<i32>;
GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -68,7 +68,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArray) {
// type t : ptr<private, array<i32>>;
Alias("t", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()),
- type::AddressSpace::kPrivate));
+ builtin::AddressSpace::kPrivate));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -80,7 +80,7 @@
// struct S { m : array<i32> };
// var<private> v : S;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
- GlobalVar(Source{{56, 78}}, "v", ty("S"), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "v", ty("S"), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -93,7 +93,7 @@
// struct S { m : array<i32> };
// type t = ptr<private, S>;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
- Alias("t", ty.pointer(ty("S"), type::AddressSpace::kPrivate));
+ Alias("t", ty.pointer(ty("S"), builtin::AddressSpace::kPrivate));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -105,7 +105,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray) {
// var<workgroup> v : array<i32>;
GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()),
- type::AddressSpace::kWorkgroup);
+ builtin::AddressSpace::kWorkgroup);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -115,7 +115,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArray) {
// type t = ptr<workgroup, array<i32>>;
- Alias("t", ty.pointer(ty.array(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup));
+ Alias("t", ty.pointer(ty.array(Source{{12, 34}}, ty.i32()), builtin::AddressSpace::kWorkgroup));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -127,7 +127,7 @@
// struct S { m : array<i32> };
// var<workgroup> v : S;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
- GlobalVar(Source{{56, 78}}, "v", ty("S"), type::AddressSpace::kWorkgroup);
+ GlobalVar(Source{{56, 78}}, "v", ty("S"), builtin::AddressSpace::kWorkgroup);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -140,7 +140,7 @@
// struct S { m : array<i32> };
// type t = ptr<workgroup, S>;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
- Alias(Source{{56, 78}}, "t", ty.pointer(ty("S"), type::AddressSpace::kWorkgroup));
+ Alias(Source{{56, 78}}, "t", ty.pointer(ty("S"), builtin::AddressSpace::kWorkgroup));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -151,7 +151,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) {
// var<storage> g : bool;
- GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kStorage,
+ GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), builtin::AddressSpace::kStorage,
Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -165,7 +165,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Bool) {
// type t = ptr<storage, bool>;
Alias(Source{{56, 78}}, "t",
- ty.pointer(ty.bool_(Source{{12, 34}}), type::AddressSpace::kStorage));
+ ty.pointer(ty.bool_(Source{{12, 34}}), builtin::AddressSpace::kStorage));
ASSERT_FALSE(r()->Resolve());
@@ -179,7 +179,7 @@
// type a = bool;
// @binding(0) @group(0) var<storage, read> g : a;
Alias("a", ty.bool_());
- GlobalVar(Source{{56, 78}}, "g", ty(Source{{12, 34}}, "a"), type::AddressSpace::kStorage,
+ GlobalVar(Source{{56, 78}}, "g", ty(Source{{12, 34}}, "a"), builtin::AddressSpace::kStorage,
Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -195,7 +195,7 @@
// type t = ptr<storage, a>;
Alias("a", ty.bool_());
Alias(Source{{56, 78}}, "t",
- ty.pointer(ty(Source{{12, 34}}, "a"), type::AddressSpace::kStorage));
+ ty.pointer(ty(Source{{12, 34}}, "a"), builtin::AddressSpace::kStorage));
ASSERT_FALSE(r()->Resolve());
@@ -208,8 +208,8 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) {
// var<storage> g : ptr<private, f32>;
GlobalVar(Source{{56, 78}}, "g",
- ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
- type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ ty.pointer(Source{{12, 34}}, ty.f32(), builtin::AddressSpace::kPrivate),
+ builtin::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -222,8 +222,8 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) {
// type t = ptr<storage, ptr<private, f32>>;
Alias("t", ty.pointer(Source{{56, 78}},
- ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
- type::AddressSpace::kStorage));
+ ty.pointer(Source{{12, 34}}, ty.f32(), builtin::AddressSpace::kPrivate),
+ builtin::AddressSpace::kStorage));
ASSERT_FALSE(r()->Resolve());
@@ -235,14 +235,14 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_IntScalar) {
// var<storage> g : i32;
- GlobalVar("g", ty.i32(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.i32(), builtin::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_IntScalar) {
// type t = ptr<storage, i32;
- Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage));
+ Alias("t", ty.pointer(ty.i32(), builtin::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -252,7 +252,7 @@
// var<storage> g : f16;
Enable(builtin::Extension::kF16);
- GlobalVar("g", ty.f16(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.f16(), builtin::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -262,7 +262,7 @@
// type t = ptr<storage, f16>;
Enable(builtin::Extension::kF16);
- Alias("t", ty.pointer(ty.f16(), type::AddressSpace::kStorage));
+ Alias("t", ty.pointer(ty.f16(), builtin::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -274,7 +274,7 @@
Enable(builtin::Extension::kF16);
Alias("a", ty.f16());
- GlobalVar("g", ty("a"), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty("a"), builtin::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -286,21 +286,21 @@
Enable(builtin::Extension::kF16);
Alias("a", ty.f16());
- Alias("t", ty.pointer(ty("a"), type::AddressSpace::kStorage));
+ Alias("t", ty.pointer(ty("a"), builtin::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF32) {
// var<storage> g : vec4<f32>;
- GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) {
// type t = ptr<storage, vec4<f32>>;
- Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kStorage));
+ Alias("t", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -308,7 +308,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) {
// var<storage> g : vec4<f16>;
Enable(builtin::Extension::kF16);
- GlobalVar("g", ty.vec(ty.f16(), 4u), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.vec(ty.f16(), 4u), builtin::AddressSpace::kStorage, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -316,7 +316,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF16) {
// type t = ptr<storage, vec4<f16>>;
Enable(builtin::Extension::kF16);
- Alias("t", ty.pointer(ty.vec(ty.f16(), 4u), type::AddressSpace::kStorage));
+ Alias("t", ty.pointer(ty.vec(ty.f16(), 4u), builtin::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -325,7 +325,7 @@
// struct S{ a : f32 };
// var<storage, read> g : array<S, 3u>;
Structure("S", utils::Vector{Member("a", ty.f32())});
- GlobalVar("g", ty.array(ty("S"), 3_u), type::AddressSpace::kStorage, builtin::Access::kRead,
+ GlobalVar("g", ty.array(ty("S"), 3_u), builtin::AddressSpace::kStorage, builtin::Access::kRead,
Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -335,7 +335,7 @@
// struct S{ a : f32 };
// type t = ptr<storage, array<S, 3u>>;
Structure("S", utils::Vector{Member("a", ty.f32())});
- Alias("t", ty.pointer(ty.array(ty("S"), 3_u), type::AddressSpace::kStorage));
+ Alias("t", ty.pointer(ty.array(ty("S"), 3_u), builtin::AddressSpace::kStorage));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -347,7 +347,7 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16())});
- GlobalVar("g", ty.array(ty("S"), 3_u), type::AddressSpace::kStorage, builtin::Access::kRead,
+ GlobalVar("g", ty.array(ty("S"), 3_u), builtin::AddressSpace::kStorage, builtin::Access::kRead,
Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -360,8 +360,8 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16())});
- Alias("t",
- ty.pointer(ty.array(ty("S"), 3_u), type::AddressSpace::kStorage, builtin::Access::kRead));
+ Alias("t", ty.pointer(ty.array(ty("S"), 3_u), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -370,7 +370,7 @@
// struct S { x : i32 };
// var<storage, read> g : S;
Structure("S", utils::Vector{Member("x", ty.i32())});
- GlobalVar("g", ty("S"), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("g", ty("S"), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -380,7 +380,7 @@
// struct S { x : i32 };
// type t = ptr<storage, read, S>;
Structure("S", utils::Vector{Member("x", ty.i32())});
- Alias("t", ty.pointer(ty("S"), type::AddressSpace::kStorage, builtin::Access::kRead));
+ Alias("t", ty.pointer(ty("S"), builtin::AddressSpace::kStorage, builtin::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -392,7 +392,7 @@
Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty("S"));
Alias("a2", ty("a1"));
- GlobalVar("g", ty("a2"), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("g", ty("a2"), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -405,7 +405,7 @@
Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty("S"));
Alias("a2", ty("a1"));
- Alias("t", ty.pointer(ty("a2"), type::AddressSpace::kStorage, builtin::Access::kRead));
+ Alias("t", ty.pointer(ty("a2"), builtin::AddressSpace::kStorage, builtin::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -416,7 +416,7 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())});
- GlobalVar("g", ty("S"), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("g", ty("S"), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -428,7 +428,7 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())});
- Alias("t", ty.pointer(ty("S"), type::AddressSpace::kStorage, builtin::Access::kRead));
+ Alias("t", ty.pointer(ty("S"), builtin::AddressSpace::kStorage, builtin::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -442,7 +442,7 @@
Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty("S"));
Alias("a2", ty("a1"));
- GlobalVar("g", ty("a2"), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("g", ty("a2"), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -457,14 +457,14 @@
Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty("S"));
Alias("a2", ty("a1"));
- Alias("g", ty.pointer(ty("a2"), type::AddressSpace::kStorage, builtin::Access::kRead));
+ Alias("g", ty.pointer(ty("a2"), builtin::AddressSpace::kStorage, builtin::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode) {
// var<private, read> g : a;
- GlobalVar(Source{{12, 34}}, "g", ty.i32(), type::AddressSpace::kPrivate,
+ GlobalVar(Source{{12, 34}}, "g", ty.i32(), builtin::AddressSpace::kPrivate,
builtin::Access::kRead);
ASSERT_FALSE(r()->Resolve());
@@ -476,7 +476,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) {
// type t = ptr<private, i32, read>;
- Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kPrivate,
+ Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), builtin::AddressSpace::kPrivate,
builtin::Access::kRead));
ASSERT_FALSE(r()->Resolve());
@@ -488,7 +488,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode) {
// @group(0) @binding(0) var<storage, read> a : i32;
- GlobalVar("a", ty.i32(), type::AddressSpace::kStorage, builtin::Access::kRead, Group(0_a),
+ GlobalVar("a", ty.i32(), builtin::AddressSpace::kStorage, builtin::Access::kRead, Group(0_a),
Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -496,29 +496,29 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadAccessMode) {
// type t = ptr<storage, read, i32>;
- Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage, builtin::Access::kRead));
+ Alias("t", ty.pointer(ty.i32(), builtin::AddressSpace::kStorage, builtin::Access::kRead));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAccessMode) {
// @group(0) @binding(0) var<storage, read_write> a : i32;
- GlobalVar("a", ty.i32(), type::AddressSpace::kStorage, builtin::Access::kReadWrite, Group(0_a),
- Binding(0_a));
+ GlobalVar("a", ty.i32(), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ Group(0_a), Binding(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadWriteAccessMode) {
// type t = ptr<storage, read_write, i32>;
- Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage, builtin::Access::kReadWrite));
+ Alias("t", ty.pointer(ty.i32(), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMode) {
// @group(0) @binding(0) var<storage, read_write> a : i32;
- GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage,
+ GlobalVar(Source{{12, 34}}, "a", ty.i32(), builtin::AddressSpace::kStorage,
builtin::Access::kWrite, Group(0_a), Binding(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -529,7 +529,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_WriteAccessMode) {
// type t = ptr<storage, read_write, i32>;
- Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kStorage,
+ Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), builtin::AddressSpace::kStorage,
builtin::Access::kWrite));
ASSERT_FALSE(r()->Resolve());
@@ -545,7 +545,7 @@
Structure("S",
utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))});
- GlobalVar(Source{{90, 12}}, "svar", ty("S"), type::AddressSpace::kUniform, Binding(0_a),
+ GlobalVar(Source{{90, 12}}, "svar", ty("S"), builtin::AddressSpace::kUniform, Binding(0_a),
Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -562,7 +562,7 @@
Structure("S",
utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))});
- Alias("t", ty.pointer(Source{{90, 12}}, ty("S"), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(Source{{90, 12}}, ty("S"), builtin::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -577,7 +577,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) {
// var<uniform> g : bool;
- GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kUniform,
+ GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), builtin::AddressSpace::kUniform,
Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -590,8 +590,8 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBool) {
// type t = ptr<uniform, bool>;
- Alias("t",
- ty.pointer(Source{{56, 78}}, ty.bool_(Source{{12, 34}}), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(Source{{56, 78}}, ty.bool_(Source{{12, 34}}),
+ builtin::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve());
@@ -605,7 +605,7 @@
// type a = bool;
// var<uniform> g : a;
Alias("a", ty.bool_());
- GlobalVar(Source{{56, 78}}, "g", ty(Source{{12, 34}}, "a"), type::AddressSpace::kUniform,
+ GlobalVar(Source{{56, 78}}, "g", ty(Source{{12, 34}}, "a"), builtin::AddressSpace::kUniform,
Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -621,7 +621,7 @@
// type t = ptr<uniform, a>;
Alias("a", ty.bool_());
Alias("t",
- ty.pointer(Source{{56, 78}}, ty(Source{{12, 34}}, "a"), type::AddressSpace::kUniform));
+ ty.pointer(Source{{56, 78}}, ty(Source{{12, 34}}, "a"), builtin::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve());
@@ -634,8 +634,8 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) {
// var<uniform> g : ptr<private, f32>;
GlobalVar(Source{{56, 78}}, "g",
- ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
- type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ ty.pointer(Source{{12, 34}}, ty.f32(), builtin::AddressSpace::kPrivate),
+ builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -648,8 +648,8 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) {
// type t = ptr<uniform, ptr<private, f32>>;
Alias("t", ty.pointer(Source{{56, 78}},
- ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
- type::AddressSpace::kUniform));
+ ty.pointer(Source{{12, 34}}, ty.f32(), builtin::AddressSpace::kPrivate),
+ builtin::AddressSpace::kUniform));
ASSERT_FALSE(r()->Resolve());
@@ -661,7 +661,7 @@
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar) {
// var<uniform> g : i32;
- GlobalVar(Source{{56, 78}}, "g", ty.i32(), type::AddressSpace::kUniform, Binding(0_a),
+ GlobalVar(Source{{56, 78}}, "g", ty.i32(), builtin::AddressSpace::kUniform, Binding(0_a),
Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -669,7 +669,7 @@
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferIntScalar) {
// type t = ptr<uniform, i32>;
- Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty.i32(), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -679,7 +679,7 @@
// var<uniform> g : f16;
Enable(builtin::Extension::kF16);
- GlobalVar("g", ty.f16(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.f16(), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -689,21 +689,21 @@
// type t = ptr<uniform, f16>;
Enable(builtin::Extension::kF16);
- Alias("t", ty.pointer(ty.f16(), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty.f16(), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF32) {
// var<uniform> g : vec4<f32>;
- GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF32) {
// type t = ptr<uniform, vec4<f32>>;
- Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -713,7 +713,7 @@
// var<uniform> g : vec4<f16>;
Enable(builtin::Extension::kF16);
- GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -723,7 +723,7 @@
// type t = ptr<uniform, vec4<f16>>;
Enable(builtin::Extension::kF16);
- Alias("t", ty.pointer(ty.vec4<f16>(), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty.vec4<f16>(), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -734,7 +734,8 @@
// }
// var<uniform> g : array<S, 3u>;
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})});
- GlobalVar("g", ty.array(ty("S"), 3_u), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.array(ty("S"), 3_u), builtin::AddressSpace::kUniform, Binding(0_a),
+ Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -745,7 +746,7 @@
// }
// type t = ptr<uniform, array<S, 3u>>;
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})});
- Alias("t", ty.pointer(ty.array(ty("S"), 3_u), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty.array(ty("S"), 3_u), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -759,7 +760,8 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})});
- GlobalVar("g", ty.array(ty("S"), 3_u), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty.array(ty("S"), 3_u), builtin::AddressSpace::kUniform, Binding(0_a),
+ Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -773,7 +775,7 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})});
- Alias("t", ty.pointer(ty.array(ty("S"), 3_u), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty.array(ty("S"), 3_u), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -782,7 +784,7 @@
// struct S { x : i32 };
// var<uniform> g : S;
Structure("S", utils::Vector{Member("x", ty.i32())});
- GlobalVar("g", ty("S"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty("S"), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -791,7 +793,7 @@
// struct S { x : i32 };
// type t = ptr<uniform, S>;
Structure("S", utils::Vector{Member("x", ty.i32())});
- Alias("t", ty.pointer(ty("S"), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty("S"), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -802,7 +804,7 @@
// var<uniform> g : a1;
Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty("S"));
- GlobalVar("g", ty("a1"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty("a1"), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -813,7 +815,7 @@
// type t = ptr<uniform, a1>;
Structure("S", utils::Vector{Member("x", ty.i32())});
Alias("a1", ty("S"));
- Alias("t", ty.pointer(ty("a1"), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty("a1"), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -825,7 +827,7 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())});
- GlobalVar("g", ty("S"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty("S"), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -837,7 +839,7 @@
Enable(builtin::Extension::kF16);
Structure("S", utils::Vector{Member("x", ty.f16())});
- Alias("t", ty.pointer(ty("S"), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty("S"), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -851,7 +853,7 @@
Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty("S"));
- GlobalVar("g", ty("a1"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("g", ty("a1"), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -865,7 +867,7 @@
Structure("S", utils::Vector{Member("x", ty.f16())});
Alias("a1", ty("S"));
- Alias("t", ty.pointer(ty("a1"), type::AddressSpace::kUniform));
+ Alias("t", ty.pointer(ty("a1"), builtin::AddressSpace::kUniform));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -874,7 +876,8 @@
// enable chromium_experimental_push_constant;
// var<push_constant> g : bool;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kPushConstant);
+ GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}),
+ builtin::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -888,7 +891,7 @@
// type t = ptr<push_constant, bool>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
Alias(Source{{56, 78}}, "t",
- ty.pointer(ty.bool_(Source{{12, 34}}), type::AddressSpace::kPushConstant));
+ ty.pointer(ty.bool_(Source{{12, 34}}), builtin::AddressSpace::kPushConstant));
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -903,7 +906,7 @@
// var<push_constant> g : f16;
Enable(builtin::Extension::kF16);
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar("g", ty.f16(Source{{56, 78}}), type::AddressSpace::kPushConstant);
+ GlobalVar("g", ty.f16(Source{{56, 78}}), builtin::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -916,7 +919,7 @@
// type t = ptr<push_constant, f16>;
Enable(builtin::Extension::kF16);
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- Alias("t", ty.pointer(ty.f16(Source{{56, 78}}), type::AddressSpace::kPushConstant));
+ Alias("t", ty.pointer(ty.f16(Source{{56, 78}}), builtin::AddressSpace::kPushConstant));
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -928,8 +931,8 @@
// var<push_constant> g : ptr<private, f32>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
GlobalVar(Source{{56, 78}}, "g",
- ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
- type::AddressSpace::kPushConstant);
+ ty.pointer(Source{{12, 34}}, ty.f32(), builtin::AddressSpace::kPrivate),
+ builtin::AddressSpace::kPushConstant);
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -943,8 +946,8 @@
// type t = ptr<push_constant, ptr<private, f32>>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
Alias(Source{{56, 78}}, "t",
- ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
- type::AddressSpace::kPushConstant));
+ ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), builtin::AddressSpace::kPrivate),
+ builtin::AddressSpace::kPushConstant));
ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -957,7 +960,7 @@
// enable chromium_experimental_push_constant;
// var<push_constant> g : i32;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar("g", ty.i32(), type::AddressSpace::kPushConstant);
+ GlobalVar("g", ty.i32(), builtin::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -966,7 +969,7 @@
// enable chromium_experimental_push_constant;
// type t = ptr<push_constant, i32>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kPushConstant));
+ Alias("t", ty.pointer(ty.i32(), builtin::AddressSpace::kPushConstant));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -975,7 +978,7 @@
// enable chromium_experimental_push_constant;
// var<push_constant> g : vec4<f32>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPushConstant);
+ GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -984,7 +987,7 @@
// enable chromium_experimental_push_constant;
// var<push_constant> g : vec4<f32>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kPushConstant));
+ Alias("t", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kPushConstant));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -995,7 +998,7 @@
// var<push_constant> g : array<S, 3u>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
Structure("S", utils::Vector{Member("a", ty.f32())});
- GlobalVar("g", ty.array(ty("S"), 3_u), type::AddressSpace::kPushConstant);
+ GlobalVar("g", ty.array(ty("S"), 3_u), builtin::AddressSpace::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -1006,7 +1009,7 @@
// type t = ptr<push_constant, array<S, 3u>>;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
Structure("S", utils::Vector{Member("a", ty.f32())});
- Alias("t", ty.pointer(ty.array(ty("S"), 3_u), type::AddressSpace::kPushConstant));
+ Alias("t", ty.pointer(ty.array(ty("S"), 3_u), builtin::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 cc55f0b..e1e8630 100644
--- a/src/tint/resolver/alias_analysis_test.cc
+++ b/src/tint/resolver/alias_analysis_test.cc
@@ -35,19 +35,19 @@
// target(&v1, aliased ? &v1 : &v2);
// }
struct TwoPointerConfig {
- type::AddressSpace address_space; // The address space for the pointers.
- bool aliased; // Whether the pointers alias or not.
+ builtin::AddressSpace address_space; // The address space for the pointers.
+ bool aliased; // Whether the pointers alias or not.
};
class TwoPointers : public ResolverTestWithParam<TwoPointerConfig> {
protected:
void SetUp() override {
utils::Vector<const ast::Statement*, 4> body;
- if (GetParam().address_space == type::AddressSpace::kFunction) {
+ if (GetParam().address_space == builtin::AddressSpace::kFunction) {
body.Push(Decl(Var("v1", ty.i32())));
body.Push(Decl(Var("v2", ty.i32())));
} else {
- GlobalVar("v1", type::AddressSpace::kPrivate, ty.i32());
- GlobalVar("v2", type::AddressSpace::kPrivate, ty.i32());
+ GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.i32());
+ GlobalVar("v2", builtin::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,11 @@
INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest,
TwoPointers,
- ::testing::Values(TwoPointerConfig{type::AddressSpace::kFunction, false},
- TwoPointerConfig{type::AddressSpace::kFunction, true},
- TwoPointerConfig{type::AddressSpace::kPrivate, false},
- TwoPointerConfig{type::AddressSpace::kPrivate, true}),
+ ::testing::Values(TwoPointerConfig{builtin::AddressSpace::kFunction,
+ false},
+ TwoPointerConfig{builtin::AddressSpace::kFunction, true},
+ TwoPointerConfig{builtin::AddressSpace::kPrivate, false},
+ TwoPointerConfig{builtin::AddressSpace::kPrivate, true}),
[](const ::testing::TestParamInfo<TwoPointers::ParamType>& p) {
std::stringstream ss;
ss << (p.param.aliased ? "Aliased" : "Unaliased") << "_"
@@ -214,8 +215,8 @@
class OnePointerOneModuleScope : public ResolverTestWithParam<bool> {
protected:
void SetUp() override {
- GlobalVar("global_1", type::AddressSpace::kPrivate, ty.i32());
- GlobalVar("global_2", type::AddressSpace::kPrivate, ty.i32());
+ GlobalVar("global_1", builtin::AddressSpace::kPrivate, ty.i32());
+ GlobalVar("global_2", builtin::AddressSpace::kPrivate, ty.i32());
Func("caller", utils::Empty, ty.void_(),
utils::Vector{
CallStmt(Call("target",
@@ -226,7 +227,7 @@
void Run(utils::Vector<const ast::Statement*, 4>&& body, const char* err = nullptr) {
Func("target",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(), std::move(body));
if (GetParam() && err) {
@@ -295,7 +296,7 @@
// f1(p1);
Func("f2",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -303,7 +304,7 @@
});
Func("f1",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -330,7 +331,7 @@
// f1(p1);
Func("f2",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -339,7 +340,7 @@
});
Func("f1",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -365,7 +366,7 @@
// f1(p1);
Func("f2",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -373,7 +374,7 @@
});
Func("f1",
utils::Vector<const ast::Parameter*, 4>{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -400,7 +401,7 @@
// f1(p1);
Func("f2",
utils::Vector{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -409,7 +410,7 @@
});
Func("f1",
utils::Vector{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -435,7 +436,7 @@
// f2();
Func("f1",
utils::Vector{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(),
utils::Vector{
@@ -487,8 +488,8 @@
void Run(const ast::Statement* stmt, const char* err = nullptr) {
Func("target",
utils::Vector{
- Param("p1", ty.pointer<i32>(type::AddressSpace::kFunction)),
- Param("p2", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p1", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
+ Param("p2", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -531,7 +532,7 @@
TEST_P(Use, Read_CompoundAssignment_RHS) {
// var<private> global : i32;
// global += *p2;
- GlobalVar("global", type::AddressSpace::kPrivate, ty.i32());
+ GlobalVar("global", builtin::AddressSpace::kPrivate, ty.i32());
Run(CompoundAssign("global", Deref("p2"), ast::BinaryOp::kAdd),
R"(56:78 error: invalid aliased pointer argument
12:34 note: aliases with another argument passed here)");
@@ -578,7 +579,7 @@
TEST_P(Use, Read_IndexAccessor) {
// var<private> data : array<f32, 4>;
// _ = data[*p2];
- GlobalVar("data", type::AddressSpace::kPrivate, ty.array<f32, 4>());
+ GlobalVar("data", builtin::AddressSpace::kPrivate, ty.array<f32, 4>());
Run(Assign(Phony(), IndexAccessor("data", Deref("p2"))),
R"(56:78 error: invalid aliased pointer argument
12:34 note: aliases with another argument passed here)");
@@ -592,7 +593,7 @@
TEST_P(Use, Read_VarInitializer) {
// var x = *p2;
- Run(Decl(Var("x", type::AddressSpace::kFunction, Deref("p2"))),
+ Run(Decl(Var("x", builtin::AddressSpace::kFunction, Deref("p2"))),
R"(56:78 error: invalid aliased pointer argument
12:34 note: aliases with another argument passed here)");
}
@@ -602,7 +603,7 @@
// foo(p2);
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.i32(),
utils::Vector{
@@ -659,8 +660,8 @@
void Run(const ast::Statement* stmt, const char* err = nullptr) {
Func("target",
utils::Vector{
- Param("p1", ty.pointer<bool>(type::AddressSpace::kFunction)),
- Param("p2", ty.pointer<bool>(type::AddressSpace::kFunction)),
+ Param("p1", ty.pointer<bool>(builtin::AddressSpace::kFunction)),
+ Param("p2", ty.pointer<bool>(builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -724,8 +725,8 @@
Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2",
utils::Vector{
- Param("p1", ty.pointer(ty("S"), type::AddressSpace::kFunction)),
- Param("p2", ty.pointer(ty("S"), type::AddressSpace::kFunction)),
+ Param("p1", ty.pointer(ty("S"), builtin::AddressSpace::kFunction)),
+ Param("p2", ty.pointer(ty("S"), builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -753,8 +754,8 @@
Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2",
utils::Vector{
- Param("p1", ty.pointer(ty("S"), type::AddressSpace::kFunction)),
- Param("p2", ty.pointer(ty("S"), type::AddressSpace::kFunction)),
+ Param("p1", ty.pointer(ty("S"), builtin::AddressSpace::kFunction)),
+ Param("p2", ty.pointer(ty("S"), builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -785,8 +786,8 @@
Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2",
utils::Vector{
- Param("p1", ty.pointer(ty("S"), type::AddressSpace::kFunction)),
- Param("p2", ty.pointer(ty("S"), type::AddressSpace::kFunction)),
+ Param("p1", ty.pointer(ty("S"), builtin::AddressSpace::kFunction)),
+ Param("p2", ty.pointer(ty("S"), builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -816,8 +817,8 @@
Structure("S", utils::Vector{Member("a", ty.i32())});
Func("f2",
utils::Vector{
- Param("p1", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction)),
- Param("p2", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction)),
+ Param("p1", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction)),
+ Param("p2", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -848,7 +849,7 @@
// }
Func("f1",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -901,7 +902,7 @@
// }
Func("f2",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -909,7 +910,7 @@
});
Func("f3",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::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 fc7bdeb..e18a618 100644
--- a/src/tint/resolver/array_accessor_test.cc
+++ b/src/tint/resolver/array_accessor_test.cc
@@ -27,7 +27,7 @@
using ResolverIndexAccessorTest = ResolverTest;
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) {
- GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.mat2x3<f32>(), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1_f));
WrapInFunction(acc);
@@ -36,7 +36,7 @@
}
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) {
- GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.mat2x3<f32>(), builtin::AddressSpace::kPrivate);
auto* idx = Var("idx", ty.i32(), Call<i32>());
auto* acc = IndexAccessor("my_var", idx);
WrapInFunction(Decl(idx), acc);
@@ -50,7 +50,7 @@
}
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) {
- GlobalVar("my_var", ty.mat4x4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.mat4x4<f32>(), builtin::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) {
- GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.mat2x3<f32>(), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 1_i);
WrapInFunction(acc);
@@ -118,7 +118,7 @@
}
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
- GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.mat2x3<f32>(), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor(IndexAccessor("my_var", 0_i), 1_i);
WrapInFunction(acc);
@@ -135,7 +135,7 @@
}
TEST_F(ResolverIndexAccessorTest, Vector_F32) {
- GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2_f));
WrapInFunction(acc);
@@ -144,7 +144,7 @@
}
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) {
- GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec3<f32>(), builtin::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) {
- GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc);
@@ -184,7 +184,7 @@
}
TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) {
- GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.array<f32, 3>(), builtin::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_u32) {
- GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.array<f32, 3>(), builtin::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_AInt) {
- GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.array<f32, 3>(), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_a);
WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -225,7 +225,7 @@
TEST_F(ResolverIndexAccessorTest, Alias_Array) {
auto* aary = Alias("myarrty", ty.array<f32, 3>());
- GlobalVar("my_var", ty.Of(aary), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.Of(aary), builtin::AddressSpace::kPrivate);
auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc);
@@ -316,7 +316,7 @@
// let x: f32 = (*p)[idx];
// return x;
// }
- auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
+ auto* p = Param("p", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction));
auto* idx = Let("idx", ty.u32(), Call<u32>());
auto* star_p = Deref(p);
auto* acc = IndexAccessor(Source{{12, 34}}, star_p, idx);
@@ -337,7 +337,7 @@
// let x: f32 = *p[idx];
// return x;
// }
- auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
+ auto* p = Param("p", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction));
auto* idx = Let("idx", ty.u32(), Call<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 f8f663b..b549daf 100644
--- a/src/tint/resolver/assignment_validation_test.cc
+++ b/src/tint/resolver/assignment_validation_test.cc
@@ -33,8 +33,8 @@
auto* s = Structure("S", utils::Vector{
Member("m", ty.i32()),
});
- GlobalVar(Source{{12, 34}}, "a", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a));
+ GlobalVar(Source{{12, 34}}, "a", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a));
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i));
@@ -193,7 +193,7 @@
// var a : i32;
// let b : ptr<function,i32> = &a;
// *b = 2i;
- const auto func = type::AddressSpace::kFunction;
+ const auto func = builtin::AddressSpace::kFunction;
WrapInFunction(Var("a", ty.i32(), func, Expr(2_i)), //
Let("b", ty.pointer<i32>(func), AddressOf(Expr("a"))), //
Assign(Deref("b"), 2_i));
@@ -205,7 +205,7 @@
// var a : i32;
// let b : ptr<function,i32> = &a;
// *b = 2;
- const auto func = type::AddressSpace::kFunction;
+ const auto func = builtin::AddressSpace::kFunction;
auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b, Assign(Deref("b"), 2_a));
@@ -252,7 +252,7 @@
auto* s = Structure("S", utils::Vector{
Member("a", ty.atomic(ty.i32())),
});
- GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage,
+ GlobalVar(Source{{12, 34}}, "v", ty.Of(s), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Binding(0_a), Group(0_a));
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));
@@ -269,7 +269,7 @@
auto* s = Structure("S", utils::Vector{
Member("a", ty.array(ty.f32())),
});
- GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage,
+ GlobalVar(Source{{12, 34}}, "v", ty.Of(s), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Binding(0_a), Group(0_a));
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));
@@ -289,7 +289,7 @@
auto* s = Structure("S", utils::Vector{
Member("arr", ty.array<i32>()),
});
- GlobalVar("s", ty.Of(s), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
+ GlobalVar("s", ty.Of(s), builtin::AddressSpace::kStorage, Group(0_a), Binding(0_a));
WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s")));
@@ -311,7 +311,7 @@
auto* s = Structure("S", utils::Vector{
Member("arr", ty.array<i32>()),
});
- GlobalVar("s", ty.Of(s), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
+ GlobalVar("s", ty.Of(s), builtin::AddressSpace::kStorage, Group(0_a), Binding(0_a));
WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr")));
@@ -364,9 +364,9 @@
GlobalVar("tex", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
Binding(0_a));
GlobalVar("smp", ty.sampler(type::SamplerKind::kSampler), Group(0_a), Binding(1_a));
- 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<f32, 10>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("u", ty.Of(U), builtin::AddressSpace::kUniform, Group(0_a), Binding(2_a));
+ GlobalVar("s", ty.Of(S), builtin::AddressSpace::kStorage, Group(0_a), Binding(3_a));
+ GlobalVar("wg", ty.array<f32, 10>(), builtin::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 45d56bf..f079159 100644
--- a/src/tint/resolver/atomics_test.cc
+++ b/src/tint/resolver/atomics_test.cc
@@ -27,7 +27,8 @@
struct ResolverAtomicTest : public resolver::TestHelper, public testing::Test {};
TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) {
- auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup);
+ auto* g =
+ GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
@@ -37,7 +38,8 @@
}
TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
- auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), type::AddressSpace::kWorkgroup);
+ auto* g =
+ GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
@@ -48,7 +50,7 @@
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), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ auto* g = GlobalVar("g", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 919722b..a557956 100644
--- a/src/tint/resolver/atomics_validation_test.cc
+++ b/src/tint/resolver/atomics_validation_test.cc
@@ -27,13 +27,13 @@
struct ResolverAtomicValidationTest : public resolver::TestHelper, public testing::Test {};
TEST_F(ResolverAtomicValidationTest, AddressSpace_WorkGroup) {
- GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve());
}
TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) {
- GlobalVar("g", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kStorage,
+ GlobalVar("g", ty.atomic(Source{{12, 34}}, ty.i32()), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Group(0_a), Binding(0_a));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -41,21 +41,21 @@
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), type::AddressSpace::kStorage, builtin::Access::kReadWrite, Group(0_a),
- Binding(0_a));
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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}})), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic(ty.f32(Source{{12, 34}})), builtin::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()), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -63,7 +63,7 @@
}
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) {
- GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -72,7 +72,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(s), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -88,7 +88,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -104,7 +104,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -118,7 +118,7 @@
auto* atomic_array =
Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32()));
- GlobalVar(Source{{56, 78}}, "v", ty.Of(atomic_array), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "v", ty.Of(atomic_array), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -132,7 +132,7 @@
// var<private> v: array<S, 5u>;
auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic<u32>())});
- GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -149,7 +149,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -188,7 +188,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(s0), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -198,8 +198,8 @@
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), type::AddressSpace::kStorage, builtin::Access::kRead,
- Group(0_a), Binding(0_a));
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -210,8 +210,8 @@
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), type::AddressSpace::kStorage, builtin::Access::kRead,
- Group(0_a), Binding(0_a));
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -228,7 +228,7 @@
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), type::AddressSpace::kStorage,
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), builtin::AddressSpace::kStorage,
builtin::Access::kRead, Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve());
@@ -246,7 +246,7 @@
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), type::AddressSpace::kStorage,
+ GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), builtin::AddressSpace::kStorage,
builtin::Access::kRead, Group(0_a), Binding(0_a));
EXPECT_FALSE(r()->Resolve());
@@ -287,7 +287,7 @@
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), type::AddressSpace::kStorage,
+ GlobalVar(Source{{12, 34}}, "g", ty.Of(s0), builtin::AddressSpace::kStorage,
builtin::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 85257f9..fa7664b 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -734,7 +734,7 @@
}
TEST_F(StructMemberAttributeTest, Align_Attribute_Var) {
- GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate,
+ GlobalVar(Source{{1, 2}}, "val", ty.f32(), builtin::AddressSpace::kPrivate,
builtin::Access::kUndefined, Expr(1.23_f));
Structure(Source{{6, 4}}, "mystruct",
@@ -808,7 +808,7 @@
}
TEST_F(StructMemberAttributeTest, Size_Attribute_Var) {
- GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate,
+ GlobalVar(Source{{1, 2}}, "val", ty.f32(), builtin::AddressSpace::kPrivate,
builtin::Access::kUndefined, Expr(1.23_f));
Structure(Source{{6, 4}}, "mystruct",
@@ -888,7 +888,7 @@
if (IsBindingAttribute(params.kind)) {
GlobalVar("a", ty.sampler(type::SamplerKind::kSampler), attrs);
} else {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, attrs);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, attrs);
}
if (params.should_pass) {
@@ -1157,7 +1157,7 @@
create<ast::StrideAttribute>(Source{{12, 34}}, params.stride),
});
- GlobalVar("myarray", arr, type::AddressSpace::kPrivate);
+ GlobalVar("myarray", arr, builtin::AddressSpace::kPrivate);
if (params.should_pass) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1240,7 +1240,7 @@
create<ast::StrideAttribute>(Source{{56, 78}}, 4u),
});
- GlobalVar("myarray", arr, type::AddressSpace::kPrivate);
+ GlobalVar("myarray", arr, builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1259,7 +1259,7 @@
auto* s = Structure("S", utils::Vector{
Member("x", ty.i32()),
});
- GlobalVar(Source{{12, 34}}, "G", ty.Of(s), type::AddressSpace::kUniform);
+ GlobalVar(Source{{12, 34}}, "G", ty.Of(s), builtin::AddressSpace::kUniform);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1270,7 +1270,7 @@
auto* s = Structure("S", utils::Vector{
Member("x", ty.i32()),
});
- GlobalVar(Source{{12, 34}}, "G", ty.Of(s), type::AddressSpace::kStorage,
+ GlobalVar(Source{{12, 34}}, "G", ty.Of(s), builtin::AddressSpace::kStorage,
builtin::Access::kRead);
EXPECT_FALSE(r()->Resolve());
@@ -1357,7 +1357,7 @@
}
TEST_F(ResourceAttributeTest, BindingPointOnNonResource) {
- GlobalVar(Source{{12, 34}}, "G", ty.f32(), type::AddressSpace::kPrivate, Binding(1_a),
+ GlobalVar(Source{{12, 34}}, "G", ty.f32(), builtin::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 475fd4d..0193596 100644
--- a/src/tint/resolver/builtin_test.cc
+++ b/src/tint/resolver/builtin_test.cc
@@ -81,7 +81,7 @@
TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) {
auto name = GetParam();
- GlobalVar("my_var", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = Call(name, "my_var");
WrapInFunction(expr);
@@ -94,7 +94,7 @@
TEST_P(ResolverBuiltinTest_BoolMethod, Vector) {
auto name = GetParam();
- GlobalVar("my_var", ty.vec3<bool>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec3<bool>(), builtin::AddressSpace::kPrivate);
auto* expr = Call(name, "my_var");
WrapInFunction(expr);
@@ -109,9 +109,9 @@
testing::Values("any", "all"));
TEST_F(ResolverBuiltinTest, Select) {
- GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
- GlobalVar("bool_var", ty.vec3<bool>(), type::AddressSpace::kPrivate);
+ GlobalVar("bool_var", ty.vec3<bool>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("select", "my_var", "my_var", "bool_var");
WrapInFunction(expr);
@@ -215,8 +215,8 @@
TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) {
auto ary = ty.array<i32>();
auto* str = Structure("S", utils::Vector{Member("x", ary)});
- GlobalVar("a", ty.Of(str), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
- Group(0_a));
+ GlobalVar("a", ty.Of(str), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Binding(0_a), Group(0_a));
auto* call = Call("arrayLength", AddressOf(MemberAccessor("a", "x")));
WrapInFunction(call);
@@ -228,7 +228,7 @@
}
TEST_F(ResolverBuiltinArrayTest, ArrayLength_Error_ArraySized) {
- GlobalVar("arr", ty.array<i32, 4>(), type::AddressSpace::kPrivate);
+ GlobalVar("arr", ty.array<i32, 4>(), builtin::AddressSpace::kPrivate);
auto* call = Call("arrayLength", AddressOf("arr"));
WrapInFunction(call);
@@ -1048,7 +1048,7 @@
}
TEST_F(ResolverBuiltinFloatTest, Frexp_Error_FirstParamInt) {
- GlobalVar("v", ty.i32(), type::AddressSpace::kWorkgroup);
+ GlobalVar("v", ty.i32(), builtin::AddressSpace::kWorkgroup);
auto* call = Call("frexp", 1_i, AddressOf("v"));
WrapInFunction(call);
@@ -1297,7 +1297,7 @@
}
TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) {
- GlobalVar("whole", ty.f32(), type::AddressSpace::kWorkgroup);
+ GlobalVar("whole", ty.f32(), builtin::AddressSpace::kWorkgroup);
auto* call = Call("modf", 1_i, AddressOf("whole"));
WrapInFunction(call);
@@ -1313,7 +1313,7 @@
}
TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamIntPtr) {
- GlobalVar("whole", ty.i32(), type::AddressSpace::kWorkgroup);
+ GlobalVar("whole", ty.i32(), builtin::AddressSpace::kWorkgroup);
auto* call = Call("modf", 1_f, AddressOf("whole"));
WrapInFunction(call);
@@ -1343,7 +1343,7 @@
}
TEST_F(ResolverBuiltinFloatTest, Modf_Error_VectorSizesDontMatch) {
- GlobalVar("whole", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("whole", ty.vec4<f32>(), builtin::AddressSpace::kWorkgroup);
auto* call = Call("modf", vec2<f32>(1_f, 2_f), AddressOf("whole"));
WrapInFunction(call);
@@ -1823,7 +1823,7 @@
namespace matrix_builtin_tests {
TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) {
- GlobalVar("var", ty.mat2x2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat2x2<f32>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1837,7 +1837,7 @@
TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("var", ty.mat2x2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat2x2<f16>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1849,7 +1849,7 @@
}
TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) {
- GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1863,7 +1863,7 @@
TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("var", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1875,7 +1875,7 @@
}
TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) {
- GlobalVar("var", ty.mat4x4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat4x4<f32>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1889,7 +1889,7 @@
TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("var", ty.mat4x4<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat4x4<f16>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1901,7 +1901,7 @@
}
TEST_F(ResolverBuiltinTest, Determinant_NotSquare) {
- GlobalVar("var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat2x3<f32>(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1916,7 +1916,7 @@
}
TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) {
- GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.f32(), builtin::AddressSpace::kPrivate);
auto* call = Call("determinant", "var");
WrapInFunction(call);
@@ -1936,7 +1936,7 @@
namespace vector_builtin_tests {
TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) {
- GlobalVar("my_var", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr);
@@ -1950,7 +1950,7 @@
TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("my_var", ty.vec2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec2<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr);
@@ -1962,7 +1962,7 @@
}
TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) {
- GlobalVar("my_var", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr);
@@ -1974,7 +1974,7 @@
}
TEST_F(ResolverBuiltinTest, Dot_Vec4_u32) {
- GlobalVar("my_var", ty.vec4<u32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_var", ty.vec4<u32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "my_var", "my_var");
WrapInFunction(expr);
@@ -2009,7 +2009,7 @@
TEST_P(ResolverBuiltinDerivativeTest, Scalar) {
auto name = GetParam();
- GlobalVar("ident", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = Call(name, "ident");
Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
@@ -2023,7 +2023,7 @@
TEST_P(ResolverBuiltinDerivativeTest, Vector) {
auto name = GetParam();
- GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call(name, "ident");
Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
@@ -2119,7 +2119,7 @@
if (utils::HasPrefix(type_name, "texture") || utils::HasPrefix(type_name, "sampler")) {
GlobalVar(name, type, Binding(0_a), Group(0_a));
} else {
- GlobalVar(name, type, type::AddressSpace::kPrivate);
+ GlobalVar(name, type, builtin::AddressSpace::kPrivate);
}
call_params->Push(Expr(name));
diff --git a/src/tint/resolver/builtin_validation_test.cc b/src/tint/resolver/builtin_validation_test.cc
index 4158bf1..bfa61c3 100644
--- a/src/tint/resolver/builtin_validation_test.cc
+++ b/src/tint/resolver/builtin_validation_test.cc
@@ -132,7 +132,7 @@
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable) {
auto* mix =
- GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), builtin::AddressSpace::kPrivate);
auto* use = Expr("mix");
WrapInFunction(Decl(Var("v", use)));
@@ -410,7 +410,7 @@
overload.BuildSamplerVariable(this);
// Build the module-scope var 'G' with the offset value
- GlobalVar("G", expr({}, *this), type::AddressSpace::kPrivate);
+ GlobalVar("G", expr({}, *this), builtin::AddressSpace::kPrivate);
auto args = overload.args(this);
auto*& arg_to_replace = (param.position == Position::kFirst) ? args.Front() : args.Back();
@@ -581,7 +581,7 @@
// fn foo() {
// workgroupUniformLoad(&v);
// }
- GlobalVar("v", ty.i32(), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("v", ty.i32(), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
utils::Vector{Group(0_a), Binding(0_a)});
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
@@ -599,7 +599,7 @@
// fn foo() {
// workgroupUniformLoad(&v);
// }
- GlobalVar("v", ty.atomic<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("v", ty.atomic<i32>(), builtin::AddressSpace::kWorkgroup);
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
EXPECT_FALSE(r()->Resolve());
@@ -613,7 +613,7 @@
// fn foo() {
// workgroupUniformLoad(&v);
// }
- GlobalVar("v", ty.array(ty.atomic<i32>(), 4_a), type::AddressSpace::kWorkgroup);
+ GlobalVar("v", ty.array(ty.atomic<i32>(), 4_a), builtin::AddressSpace::kWorkgroup);
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
EXPECT_FALSE(r()->Resolve());
@@ -631,7 +631,7 @@
// }
Structure("Inner", utils::Vector{Member("a", ty.array(ty.atomic<i32>(), 4_a))});
Structure("S", utils::Vector{Member("i", ty("Inner"))});
- GlobalVar(Source{{12, 34}}, "v", ty.array(ty("S"), 4_a), type::AddressSpace::kWorkgroup);
+ GlobalVar(Source{{12, 34}}, "v", ty.array(ty("S"), 4_a), builtin::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 0921c2e..a6f5889 100644
--- a/src/tint/resolver/builtins_validation_test.cc
+++ b/src/tint/resolver/builtins_validation_test.cc
@@ -112,7 +112,7 @@
TEST_P(ResolverBuiltinsStageTest, All_input) {
const Params& params = GetParam();
- auto* p = GlobalVar("p", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ auto* p = GlobalVar("p", ty.vec4<f32>(), builtin::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 b0b8cce..549bf96 100644
--- a/src/tint/resolver/call_validation_test.cc
+++ b/src/tint/resolver/call_validation_test.cc
@@ -103,7 +103,7 @@
// var z: i32 = 1i;
// foo(&z);
// }
- auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
+ auto* param = Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
@@ -120,7 +120,7 @@
// let z: i32 = 1i;
// foo(&z);
// }
- auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
+ auto* param = Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
@@ -142,7 +142,7 @@
auto* S = Structure("S", utils::Vector{
Member("m", ty.i32()),
});
- auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
+ auto* param = Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
@@ -169,7 +169,7 @@
auto* S = Structure("S", utils::Vector{
Member("m", ty.i32()),
});
- auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
+ auto* param = Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
@@ -189,7 +189,7 @@
auto* S = Structure("S", utils::Vector{
Member("m", ty.i32()),
});
- auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
+ auto* param = Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction));
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
@@ -208,12 +208,12 @@
// }
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("bar",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -235,12 +235,12 @@
// }
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("bar",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(),
utils::Vector{
@@ -268,13 +268,13 @@
// }
Func("x",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::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(), type::AddressSpace::kFunction), AddressOf("v"))),
+ Decl(Let("p", ty.pointer(ty.i32(), builtin::AddressSpace::kFunction), AddressOf("v"))),
CallStmt(Call("x", "p")),
},
utils::Vector{
@@ -293,13 +293,13 @@
// }
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
},
ty.void_(), utils::Empty);
- GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
- Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kPrivate), AddressOf("v"))),
+ Decl(Let("p", ty.pointer(ty.i32(), builtin::AddressSpace::kPrivate), AddressOf("v"))),
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
},
utils::Vector{
@@ -318,13 +318,13 @@
// }
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
Decl(Var("v", ty.array<i32, 4>())),
- Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction),
+ Decl(Let("p", ty.pointer(ty.i32(), builtin::AddressSpace::kFunction),
AddressOf(IndexAccessor("v", 0_a)))),
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
},
@@ -349,13 +349,13 @@
Enable(builtin::Extension::kChromiumExperimentalFullPtrParameters);
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
utils::Vector{
Decl(Var("v", ty.array<i32, 4>())),
- Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction),
+ Decl(Let("p", ty.pointer(ty.i32(), builtin::AddressSpace::kFunction),
AddressOf(IndexAccessor("v", 0_a)))),
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
},
@@ -377,7 +377,7 @@
// }
Func("foo",
utils::Vector{
- Param("p", ty.pointer(ty.array<i32, 4>(), type::AddressSpace::kFunction)),
+ Param("p", ty.pointer(ty.array<i32, 4>(), builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
@@ -406,7 +406,7 @@
// }
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
@@ -440,7 +440,7 @@
Enable(builtin::Extension::kChromiumExperimentalFullPtrParameters);
Func("foo",
utils::Vector{
- Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
+ Param("p", ty.pointer<i32>(builtin::AddressSpace::kFunction)),
},
ty.void_(), utils::Empty);
Func("main", utils::Empty, ty.void_(),
diff --git a/src/tint/resolver/compound_assignment_validation_test.cc b/src/tint/resolver/compound_assignment_validation_test.cc
index 58f479d..cb42ade 100644
--- a/src/tint/resolver/compound_assignment_validation_test.cc
+++ b/src/tint/resolver/compound_assignment_validation_test.cc
@@ -51,7 +51,7 @@
// var a : i32;
// let b : ptr<function,i32> = &a;
// *b += 2;
- const auto func = type::AddressSpace::kFunction;
+ const auto func = builtin::AddressSpace::kFunction;
auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b,
@@ -233,8 +233,8 @@
// {
// a += 1i;
// }
- GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, builtin::Access::kRead,
- Group(0_a), Binding(0_a));
+ GlobalVar(Source{{12, 34}}, "a", ty.i32(), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Group(0_a), Binding(0_a));
WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1_i, ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve());
@@ -264,7 +264,7 @@
TEST_F(ResolverCompoundAssignmentValidationTest, LhsAtomic) {
// var<workgroup> a : atomic<i32>;
// a += a;
- GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
+ GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), builtin::AddressSpace::kWorkgroup);
WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", "a", ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/resolver/const_assert_test.cc b/src/tint/resolver/const_assert_test.cc
index fb08b8b..9b072f9 100644
--- a/src/tint/resolver/const_assert_test.cc
+++ b/src/tint/resolver/const_assert_test.cc
@@ -84,7 +84,7 @@
}
TEST_F(ResolverConstAssertTest, Local_NonConst) {
- GlobalVar("V", ty.bool_(), Expr(true), type::AddressSpace::kPrivate);
+ GlobalVar("V", ty.bool_(), Expr(true), builtin::AddressSpace::kPrivate);
WrapInFunction(ConstAssert(Expr(Source{{12, 34}}, "V")));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
diff --git a/src/tint/resolver/const_eval_indexing_test.cc b/src/tint/resolver/const_eval_indexing_test.cc
index cfd7aa1..4d8c8cb 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, RuntimeArray_vec3_f32_Index_OOB_Low) {
auto* sb = GlobalVar("sb", ty.array(ty.vec3<f32>()), Group(0_a), Binding(0_a),
- type::AddressSpace::kStorage);
+ builtin::AddressSpace::kStorage);
auto* expr = IndexAccessor(sb, Expr(Source{{12, 34}}, -2_i));
WrapInFunction(expr);
diff --git a/src/tint/resolver/dependency_graph.cc b/src/tint/resolver/dependency_graph.cc
index 37a2244..7fddf16 100644
--- a/src/tint/resolver/dependency_graph.cc
+++ b/src/tint/resolver/dependency_graph.cc
@@ -479,7 +479,8 @@
graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_ty));
return;
}
- if (auto addr = type::ParseAddressSpace(s); addr != type::AddressSpace::kUndefined) {
+ if (auto addr = builtin::ParseAddressSpace(s);
+ addr != builtin::AddressSpace::kUndefined) {
graph_.resolved_identifiers.Add(from, ResolvedIdentifier(addr));
return;
}
@@ -864,7 +865,7 @@
if (auto access = Access(); access != builtin::Access::kUndefined) {
return "access '" + utils::ToString(access) + "'";
}
- if (auto addr = AddressSpace(); addr != type::AddressSpace::kUndefined) {
+ if (auto addr = AddressSpace(); addr != builtin::AddressSpace::kUndefined) {
return "address space '" + utils::ToString(addr) + "'";
}
if (auto fmt = TexelFormat(); fmt != type::TexelFormat::kUndefined) {
diff --git a/src/tint/resolver/dependency_graph.h b/src/tint/resolver/dependency_graph.h
index 189e7c2..9cf8819 100644
--- a/src/tint/resolver/dependency_graph.h
+++ b/src/tint/resolver/dependency_graph.h
@@ -36,7 +36,7 @@
/// - const ast::Function* (as const ast::Node*)
/// - sem::BuiltinType
/// - builtin::Access
-/// - type::AddressSpace
+/// - builtin::AddressSpace
/// - type::Builtin
/// - type::TexelFormat
class ResolvedIdentifier {
@@ -77,13 +77,13 @@
return builtin::Access::kUndefined;
}
- /// @return the address space if the ResolvedIdentifier holds type::AddressSpace, otherwise
- /// type::AddressSpace::kUndefined
- type::AddressSpace AddressSpace() const {
- if (auto n = std::get_if<type::AddressSpace>(&value_)) {
+ /// @return the address space if the ResolvedIdentifier holds builtin::AddressSpace, otherwise
+ /// builtin::AddressSpace::kUndefined
+ builtin::AddressSpace AddressSpace() const {
+ if (auto n = std::get_if<builtin::AddressSpace>(&value_)) {
return *n;
}
- return type::AddressSpace::kUndefined;
+ return builtin::AddressSpace::kUndefined;
}
/// @return the builtin type if the ResolvedIdentifier holds type::Builtin, otherwise
@@ -131,7 +131,7 @@
const ast::Node*,
sem::BuiltinType,
builtin::Access,
- type::AddressSpace,
+ builtin::AddressSpace,
type::Builtin,
type::TexelFormat>
value_;
diff --git a/src/tint/resolver/dependency_graph_test.cc b/src/tint/resolver/dependency_graph_test.cc
index e9ef46b..03d1a69 100644
--- a/src/tint/resolver/dependency_graph_test.cc
+++ b/src/tint/resolver/dependency_graph_test.cc
@@ -17,6 +17,7 @@
#include <utility>
#include "gmock/gmock.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/resolver/dependency_graph.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/type/texture_dimension.h"
@@ -425,7 +426,7 @@
auto& b = *builder;
switch (kind) {
case SymbolDeclKind::GlobalVar:
- return b.GlobalVar(source, symbol, b.ty.i32(), type::AddressSpace::kPrivate);
+ return b.GlobalVar(source, symbol, b.ty.i32(), builtin::AddressSpace::kPrivate);
case SymbolDeclKind::GlobalConst:
return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1_i));
case SymbolDeclKind::Alias:
@@ -470,27 +471,27 @@
switch (kind) {
case SymbolUseKind::GlobalVarType: {
auto node = b.ty(source, symbol);
- b.GlobalVar(b.Sym(), node, type::AddressSpace::kPrivate);
+ b.GlobalVar(b.Sym(), node, builtin::AddressSpace::kPrivate);
return node->identifier;
}
case SymbolUseKind::GlobalVarArrayElemType: {
auto node = b.ty(source, symbol);
- b.GlobalVar(b.Sym(), b.ty.array(node, 4_i), type::AddressSpace::kPrivate);
+ b.GlobalVar(b.Sym(), b.ty.array(node, 4_i), builtin::AddressSpace::kPrivate);
return node->identifier;
}
case SymbolUseKind::GlobalVarArraySizeValue: {
auto* node = b.Expr(source, symbol);
- b.GlobalVar(b.Sym(), b.ty.array(b.ty.i32(), node), type::AddressSpace::kPrivate);
+ b.GlobalVar(b.Sym(), b.ty.array(b.ty.i32(), node), builtin::AddressSpace::kPrivate);
return node->identifier;
}
case SymbolUseKind::GlobalVarVectorElemType: {
auto node = b.ty(source, symbol);
- b.GlobalVar(b.Sym(), b.ty.vec3(node), type::AddressSpace::kPrivate);
+ b.GlobalVar(b.Sym(), b.ty.vec3(node), builtin::AddressSpace::kPrivate);
return node->identifier;
}
case SymbolUseKind::GlobalVarMatrixElemType: {
ast::Type node = b.ty(source, symbol);
- b.GlobalVar(b.Sym(), b.ty.mat3x4(node), type::AddressSpace::kPrivate);
+ b.GlobalVar(b.Sym(), b.ty.mat3x4(node), builtin::AddressSpace::kPrivate);
return node->identifier;
}
case SymbolUseKind::GlobalVarSampledTexElemType: {
@@ -505,7 +506,7 @@
}
case SymbolUseKind::GlobalVarValue: {
auto* node = b.Expr(source, symbol);
- b.GlobalVar(b.Sym(), b.ty.i32(), type::AddressSpace::kPrivate, node);
+ b.GlobalVar(b.Sym(), b.ty.i32(), builtin::AddressSpace::kPrivate, node);
return node->identifier;
}
case SymbolUseKind::GlobalConstType: {
@@ -726,7 +727,7 @@
Block(Assign(Expr(Source{{12, 34}}, "G"), 3.14_f)),
});
- GlobalVar(Source{{56, 78}}, "G", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
+ GlobalVar(Source{{56, 78}}, "G", ty.f32(), builtin::AddressSpace::kPrivate, Expr(2.1_f));
Build();
}
@@ -1268,7 +1269,7 @@
const auto symbol = Symbols().New(name);
auto* decl =
- GlobalVar(symbol, name == "i32" ? ty.u32() : ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar(symbol, name == "i32" ? ty.u32() : ty.i32(), builtin::AddressSpace::kPrivate);
SymbolTestHelper helper(this);
auto* ident = helper.Add(use, symbol);
@@ -1415,7 +1416,7 @@
} // namespace resolve_to_access
////////////////////////////////////////////////////////////////////////////////
-// Resolve to type::AddressSpace tests
+// Resolve to builtin::AddressSpace tests
////////////////////////////////////////////////////////////////////////////////
namespace resolve_to_address_space {
@@ -1433,7 +1434,7 @@
auto resolved = Build().resolved_identifiers.Get(ident);
ASSERT_TRUE(resolved);
- EXPECT_EQ(resolved->AddressSpace(), type::ParseAddressSpace(name))
+ EXPECT_EQ(resolved->AddressSpace(), builtin::ParseAddressSpace(name))
<< resolved->String(Symbols(), Diagnostics());
}
@@ -1485,17 +1486,17 @@
INSTANTIATE_TEST_SUITE_P(Types,
ResolverDependencyGraphResolveToAddressSpace,
testing::Combine(testing::ValuesIn(kTypeUseKinds),
- testing::ValuesIn(type::kAddressSpaceStrings)));
+ testing::ValuesIn(builtin::kAddressSpaceStrings)));
INSTANTIATE_TEST_SUITE_P(Values,
ResolverDependencyGraphResolveToAddressSpace,
testing::Combine(testing::ValuesIn(kValueUseKinds),
- testing::ValuesIn(type::kAddressSpaceStrings)));
+ testing::ValuesIn(builtin::kAddressSpaceStrings)));
INSTANTIATE_TEST_SUITE_P(Functions,
ResolverDependencyGraphResolveToAddressSpace,
testing::Combine(testing::ValuesIn(kFuncUseKinds),
- testing::ValuesIn(type::kAddressSpaceStrings)));
+ testing::ValuesIn(builtin::kAddressSpaceStrings)));
} // namespace resolve_to_address_space
@@ -1649,7 +1650,7 @@
const auto type_sym = Sym("TYPE");
const auto func_sym = Sym("FUNC");
- const auto* value_decl = GlobalVar(value_sym, ty.i32(), type::AddressSpace::kPrivate);
+ const auto* value_decl = GlobalVar(value_sym, ty.i32(), builtin::AddressSpace::kPrivate);
const auto* type_decl = Alias(type_sym, ty.i32());
const auto* func_decl = Func(func_sym, utils::Empty, ty.void_(), utils::Empty);
@@ -1728,7 +1729,7 @@
GlobalVar(Sym(), ty.array(T, V));
GlobalVar(Sym(), ty.vec3(T));
GlobalVar(Sym(), ty.mat3x2(T));
- GlobalVar(Sym(), ty.pointer(T, type::AddressSpace::kPrivate));
+ GlobalVar(Sym(), ty.pointer(T, builtin::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 98012ad..be027d8 100644
--- a/src/tint/resolver/entry_point_validation_test.cc
+++ b/src/tint/resolver/entry_point_validation_test.cc
@@ -456,14 +456,14 @@
// enable chromium_experimental_push_constant;
// var<push_constant> a : u32;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
+ GlobalVar("a", ty.u32(), builtin::AddressSpace::kPushConstant);
EXPECT_TRUE(r()->Resolve());
}
TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) {
// var<push_constant> a : u32;
- GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
+ GlobalVar(Source{{1, 2}}, "a", ty.u32(), builtin::AddressSpace::kPushConstant);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -473,7 +473,7 @@
TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithIgnoreAddressSpaceAttribute) {
// var<push_constant> a : u32; // With ast::DisabledValidation::kIgnoreAddressSpace
- GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant,
+ GlobalVar("a", ty.u32(), builtin::AddressSpace::kPushConstant,
utils::Vector{Disable(ast::DisabledValidation::kIgnoreAddressSpace)});
EXPECT_TRUE(r()->Resolve());
@@ -486,7 +486,7 @@
// _ = a;
// }
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
+ GlobalVar("a", ty.u32(), builtin::AddressSpace::kPushConstant);
Func("main", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")},
utils::Vector{Stage(ast::PipelineStage::kCompute),
@@ -504,8 +504,8 @@
// _ = b;
// }
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
- GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant);
+ GlobalVar(Source{{1, 2}}, "a", ty.u32(), builtin::AddressSpace::kPushConstant);
+ GlobalVar(Source{{3, 4}}, "b", ty.u32(), builtin::AddressSpace::kPushConstant);
Func(Source{{5, 6}}, "main", {}, ty.void_(),
utils::Vector{Assign(Phony(), "a"), Assign(Phony(), "b")},
@@ -535,8 +535,8 @@
// uses_b();
// }
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
- GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant);
+ GlobalVar(Source{{1, 2}}, "a", ty.u32(), builtin::AddressSpace::kPushConstant);
+ GlobalVar(Source{{3, 4}}, "b", ty.u32(), builtin::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")});
@@ -568,8 +568,8 @@
// _ = a;
// }
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
- GlobalVar("b", ty.u32(), type::AddressSpace::kPushConstant);
+ GlobalVar("a", ty.u32(), builtin::AddressSpace::kPushConstant);
+ GlobalVar("b", ty.u32(), builtin::AddressSpace::kPushConstant);
Func("uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")},
utils::Vector{Stage(ast::PipelineStage::kCompute),
diff --git a/src/tint/resolver/expression_kind_test.cc b/src/tint/resolver/expression_kind_test.cc
index 1835971..c3b14f2 100644
--- a/src/tint/resolver/expression_kind_test.cc
+++ b/src/tint/resolver/expression_kind_test.cc
@@ -135,9 +135,9 @@
sym = Sym("workgroup");
check_expr = [](const sem::Expression* expr) {
ASSERT_NE(expr, nullptr);
- auto* enum_expr = expr->As<sem::BuiltinEnumExpression<type::AddressSpace>>();
+ auto* enum_expr = expr->As<sem::BuiltinEnumExpression<builtin::AddressSpace>>();
ASSERT_NE(enum_expr, nullptr);
- EXPECT_EQ(enum_expr->Value(), type::AddressSpace::kWorkgroup);
+ EXPECT_EQ(enum_expr->Value(), builtin::AddressSpace::kWorkgroup);
};
break;
}
@@ -231,7 +231,7 @@
Func("f", utils::Empty, ty.void_(), CallStmt(Call(expr)));
break;
case Use::kBinaryOp:
- GlobalVar("v", type::AddressSpace::kPrivate, Mul(1_a, expr));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Mul(1_a, expr));
break;
case Use::kFunctionReturnType:
Func("f", utils::Empty, ty(expr), Return(Call(sym)));
@@ -243,13 +243,13 @@
GlobalVar("v", ty("texture_storage_2d", ty(expr), "write"), Group(0_u), Binding(0_u));
break;
case Use::kValueExpression:
- GlobalVar("v", type::AddressSpace::kPrivate, expr);
+ GlobalVar("v", builtin::AddressSpace::kPrivate, expr);
break;
case Use::kVariableType:
- GlobalVar("v", type::AddressSpace::kPrivate, ty(expr));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, ty(expr));
break;
case Use::kUnaryOp:
- GlobalVar("v", type::AddressSpace::kPrivate, Negation(expr));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Negation(expr));
break;
}
diff --git a/src/tint/resolver/f16_extension_test.cc b/src/tint/resolver/f16_extension_test.cc
index d767919..0868208 100644
--- a/src/tint/resolver/f16_extension_test.cc
+++ b/src/tint/resolver/f16_extension_test.cc
@@ -29,14 +29,14 @@
// var<private> v : f16;
Enable(builtin::Extension::kF16);
- GlobalVar("v", ty.f16(), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.f16(), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverF16ExtensionTest, TypeUsedWithoutExtension) {
// var<private> v : f16;
- GlobalVar("v", ty.f16(Source{{12, 34}}), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.f16(Source{{12, 34}}), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@@ -47,14 +47,14 @@
// var<private> v : vec2<f16>;
Enable(builtin::Extension::kF16);
- GlobalVar("v", ty.vec2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.vec2<f16>(), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithoutExtension) {
// var<private> v : vec2<f16>;
- GlobalVar("v", ty.vec2(ty.f16(Source{{12, 34}})), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.vec2(ty.f16(Source{{12, 34}})), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@@ -65,14 +65,14 @@
// var<private> v = vec2<f16>();
Enable(builtin::Extension::kF16);
- GlobalVar("v", vec2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec2<f16>(), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithoutExtension) {
// var<private> v = vec2<f16>();
- GlobalVar("v", Call(ty.vec2(ty.f16(Source{{12, 34}}))), type::AddressSpace::kPrivate);
+ GlobalVar("v", Call(ty.vec2(ty.f16(Source{{12, 34}}))), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@@ -83,14 +83,14 @@
// var<private> v = vec2<f16>(vec2<f32>());
Enable(builtin::Extension::kF16);
- GlobalVar("v", vec2<f16>(vec2<f32>()), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec2<f16>(vec2<f32>()), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithoutExtension) {
// var<private> v = vec2<f16>(vec2<f32>());
- GlobalVar("v", vec2(ty.f16(Source{{12, 34}}), vec2<f32>()), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec2(ty.f16(Source{{12, 34}}), vec2<f32>()), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@@ -101,14 +101,14 @@
// var<private> v = 16h;
Enable(builtin::Extension::kF16);
- GlobalVar("v", Expr(16_h), type::AddressSpace::kPrivate);
+ GlobalVar("v", Expr(16_h), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithoutExtension) {
// var<private> v = 16h;
- GlobalVar("v", Expr(Source{{12, 34}}, 16_h), type::AddressSpace::kPrivate);
+ GlobalVar("v", Expr(Source{{12, 34}}, 16_h), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
@@ -121,14 +121,14 @@
// var<private> v : vec2h;
Enable(builtin::Extension::kF16);
- GlobalVar("v", ty(Source{{12, 34}}, GetParam()), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty(Source{{12, 34}}, GetParam()), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_P(ResolverF16ExtensionBuiltinTypeAliasTest, Vec2hTypeUsedWithoutExtension) {
// var<private> v : vec2h;
- GlobalVar("v", ty(Source{{12, 34}}, GetParam()), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty(Source{{12, 34}}, GetParam()), builtin::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 1062958..b6b5ed6 100644
--- a/src/tint/resolver/function_validation_test.cc
+++ b/src/tint/resolver/function_validation_test.cc
@@ -39,7 +39,7 @@
TEST_F(ResolverFunctionValidationTest, ParameterMayShadowGlobal) {
// var<private> common_name : f32;
// fn func(common_name : f32) { }
- GlobalVar("common_name", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("common_name", ty.f32(), builtin::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 @@
utils::Vector{
Return(1_i),
});
- GlobalVar("x", Call(Source{{12, 34}}, "F"), type::AddressSpace::kPrivate);
+ GlobalVar("x", Call(Source{{12, 34}}, "F"), builtin::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 @@
// var<private> x = 64i;
// @compute @workgroup_size(x)
// fn main() {}
- GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(64_i));
+ GlobalVar("x", ty.i32(), builtin::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_InvalidExpr_x) {
// @compute @workgroup_size(1 << 2 + 4)
// fn main() {}
- GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
+ GlobalVar("x", ty.i32(), builtin::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_y) {
// @compute @workgroup_size(1, 1 << 2 + 4)
// fn main() {}
- GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
+ GlobalVar("x", ty.i32(), builtin::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_z) {
// @compute @workgroup_size(1, 1, 1 << 2 + 4)
// fn main() {}
- GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
+ GlobalVar("x", ty.i32(), builtin::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, ReturnIsConstructible_NonPlain) {
- auto ret_type = ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kFunction);
+ auto ret_type = ty.pointer(Source{{12, 34}}, ty.i32(), builtin::AddressSpace::kFunction);
Func("f", utils::Empty, ret_type, utils::Empty);
EXPECT_FALSE(r()->Resolve());
@@ -1049,7 +1049,7 @@
kInvalid,
};
struct TestParams {
- type::AddressSpace address_space;
+ builtin::AddressSpace address_space;
Expectation expectation;
};
@@ -1102,16 +1102,18 @@
INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverFunctionParameterValidationTest,
- testing::Values(
- TestParams{type::AddressSpace::kUndefined, Expectation::kInvalid},
- 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::kInvalid},
- TestParams{type::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension},
- TestParams{type::AddressSpace::kPrivate, Expectation::kAlwaysPass},
- TestParams{type::AddressSpace::kFunction, Expectation::kAlwaysPass}));
+ testing::Values(TestParams{builtin::AddressSpace::kUndefined, Expectation::kInvalid},
+ TestParams{builtin::AddressSpace::kIn, Expectation::kAlwaysFail},
+ TestParams{builtin::AddressSpace::kOut, Expectation::kAlwaysFail},
+ TestParams{builtin::AddressSpace::kUniform,
+ Expectation::kPassWithFullPtrParameterExtension},
+ TestParams{builtin::AddressSpace::kWorkgroup,
+ Expectation::kPassWithFullPtrParameterExtension},
+ TestParams{builtin::AddressSpace::kHandle, Expectation::kInvalid},
+ TestParams{builtin::AddressSpace::kStorage,
+ Expectation::kPassWithFullPtrParameterExtension},
+ TestParams{builtin::AddressSpace::kPrivate, Expectation::kAlwaysPass},
+ TestParams{builtin::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 059a3e5..b32c669 100644
--- a/src/tint/resolver/host_shareable_validation_test.cc
+++ b/src/tint/resolver/host_shareable_validation_test.cc
@@ -29,8 +29,8 @@
auto* s =
Structure("S", utils::Vector{Member(Source{{56, 78}}, "x", ty.bool_(Source{{12, 34}}))});
- GlobalVar(Source{{90, 12}}, "g", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a));
+ GlobalVar(Source{{90, 12}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -45,8 +45,8 @@
auto* s = Structure(
"S", utils::Vector{Member(Source{{56, 78}}, "x", ty.vec3<bool>(Source{{12, 34}}))});
- GlobalVar(Source{{90, 12}}, "g", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a));
+ GlobalVar(Source{{90, 12}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -62,7 +62,7 @@
auto* s =
Structure("S", utils::Vector{Member(Source{{56, 78}}, "x", ty(Source{{12, 34}}, "a1"))});
auto* a2 = Alias("a2", ty.Of(s));
- GlobalVar(Source{{90, 12}}, "g", ty.Of(a2), type::AddressSpace::kStorage,
+ GlobalVar(Source{{90, 12}}, "g", ty.Of(a2), builtin::AddressSpace::kStorage,
builtin::Access::kRead, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -81,8 +81,8 @@
auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))});
- GlobalVar(Source{{9, 10}}, "g", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a));
+ GlobalVar(Source{{9, 10}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a));
ASSERT_FALSE(r()->Resolve());
@@ -120,8 +120,8 @@
auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))});
- GlobalVar(Source{{9, 10}}, "g", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a));
+ GlobalVar(Source{{9, 10}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::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 7848daa..c5a6c98 100644
--- a/src/tint/resolver/increment_decrement_validation_test.cc
+++ b/src/tint/resolver/increment_decrement_validation_test.cc
@@ -64,8 +64,8 @@
// var a : i32;
// let b : ptr<function,i32> = &a;
// *b++;
- auto* var_a = Var("a", ty.i32(), type::AddressSpace::kFunction);
- auto* var_b = Let("b", ty.pointer<i32>(type::AddressSpace::kFunction), AddressOf(Expr("a")));
+ auto* var_a = Var("a", ty.i32(), builtin::AddressSpace::kFunction);
+ auto* var_b = Let("b", ty.pointer<i32>(builtin::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, Atomic) {
// var<workgroup> a : atomic<i32>;
// a++;
- GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
+ GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), builtin::AddressSpace::kWorkgroup);
WrapInFunction(Increment(Expr(Source{{56, 78}}, "a")));
EXPECT_FALSE(r()->Resolve());
@@ -193,8 +193,8 @@
// {
// a++;
// }
- GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, builtin::Access::kRead,
- Group(0_a), Binding(0_a));
+ GlobalVar(Source{{12, 34}}, "a", ty.i32(), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Group(0_a), Binding(0_a));
WrapInFunction(Increment(Source{{56, 78}}, "a"));
EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/resolver/inferred_type_test.cc b/src/tint/resolver/inferred_type_test.cc
index 8a609d2..ab2478b 100644
--- a/src/tint/resolver/inferred_type_test.cc
+++ b/src/tint/resolver/inferred_type_test.cc
@@ -97,7 +97,7 @@
// var a = <type initializer>;
auto* ctor_expr = params.create_value(*this, 0);
- auto* var = GlobalVar("a", type::AddressSpace::kPrivate, ctor_expr);
+ auto* var = GlobalVar("a", builtin::AddressSpace::kPrivate, ctor_expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_EQ(TypeOf(var)->UnwrapRef(), expected_type);
@@ -124,7 +124,7 @@
// var a = <type initializer>;
auto* ctor_expr = params.create_value(*this, 0);
- auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
+ auto* var = Var("a", builtin::AddressSpace::kFunction, ctor_expr);
WrapInFunction(var);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -139,7 +139,7 @@
create<type::U32>(), create<type::ConstantArrayCount>(10u), 4u, 4u * 10u, 4u, 4u);
auto* ctor_expr = Call(type);
- auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
+ auto* var = Var("a", builtin::AddressSpace::kFunction, ctor_expr);
WrapInFunction(var);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -158,7 +158,7 @@
auto* ctor_expr = Call(ty.Of(str));
- auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
+ auto* var = Var("a", builtin::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 12d07ac..febd610 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -330,7 +330,7 @@
////////////////////////////////////////////////////////////////////////////////
using TexelFormat = type::TexelFormat;
using Access = builtin::Access;
-using AddressSpace = type::AddressSpace;
+using AddressSpace = builtin::AddressSpace;
using ParameterUsage = sem::ParameterUsage;
using PipelineStage = ast::PipelineStage;
@@ -560,7 +560,7 @@
}
const type::Pointer* build_ptr(MatchState& state, Number S, const type::Type* T, Number& A) {
- return state.builder.create<type::Pointer>(T, static_cast<type::AddressSpace>(S.Value()),
+ return state.builder.create<type::Pointer>(T, static_cast<builtin::AddressSpace>(S.Value()),
static_cast<builtin::Access>(A.Value()));
}
@@ -1276,7 +1276,7 @@
for (auto& p : match.parameters) {
params.Push(builder.create<sem::Parameter>(
nullptr, static_cast<uint32_t>(params.Length()), p.type,
- type::AddressSpace::kUndefined, builtin::Access::kUndefined, p.usage));
+ builtin::AddressSpace::kUndefined, builtin::Access::kUndefined, p.usage));
}
sem::PipelineStageSet supported_stages;
if (match.overload->flags.Contains(OverloadFlag::kSupportsVertexPipeline)) {
@@ -1477,7 +1477,7 @@
for (auto& p : match.parameters) {
params.Push(builder.create<sem::Parameter>(
nullptr, static_cast<uint32_t>(params.Length()), p.type,
- type::AddressSpace::kUndefined, builtin::Access::kUndefined, p.usage));
+ builtin::AddressSpace::kUndefined, builtin::Access::kUndefined, p.usage));
}
auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
: sem::EvaluationStage::kRuntime;
@@ -1491,7 +1491,7 @@
// Conversion.
auto* target = converters.GetOrCreate(match, [&]() {
auto param = builder.create<sem::Parameter>(
- nullptr, 0u, match.parameters[0].type, type::AddressSpace::kUndefined,
+ nullptr, 0u, match.parameters[0].type, builtin::AddressSpace::kUndefined,
builtin::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 624a208..d1b5530 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -231,7 +231,7 @@
TEST_F(IntrinsicTableTest, MatchPointer) {
auto* i32 = create<type::I32>();
auto* atomicI32 = create<type::Atomic>(i32);
- auto* ptr = create<type::Pointer>(atomicI32, type::AddressSpace::kWorkgroup,
+ auto* ptr = create<type::Pointer>(atomicI32, builtin::AddressSpace::kWorkgroup,
builtin::Access::kReadWrite);
auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr},
sem::EvaluationStage::kConstant, Source{});
@@ -256,7 +256,7 @@
auto* arr =
create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
auto* arr_ptr =
- create<type::Pointer>(arr, type::AddressSpace::kStorage, builtin::Access::kReadWrite);
+ create<type::Pointer>(arr, builtin::AddressSpace::kStorage, builtin::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 @@
auto* f32 = create<type::F32>();
auto result = table->Lookup(BuiltinType::kCos,
utils::Vector{
- create<type::Reference>(f32, type::AddressSpace::kFunction,
+ create<type::Reference>(f32, builtin::AddressSpace::kFunction,
builtin::Access::kReadWrite),
},
sem::EvaluationStage::kConstant, Source{});
@@ -549,7 +549,7 @@
TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_RuntimeEval) {
auto* af = create<type::AbstractFloat>();
- auto* bool_ref = create<type::Reference>(create<type::Bool>(), type::AddressSpace::kFunction,
+ auto* bool_ref = create<type::Reference>(create<type::Bool>(), builtin::AddressSpace::kFunction,
builtin::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 0d65111..4570d4d 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, Pointer) {
- auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
+ auto* ptr = create<type::Pointer>(create<type::I32>(), builtin::AddressSpace::kPrivate,
builtin::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 af48077..43abdbc 100644
--- a/src/tint/resolver/is_storeable_test.cc
+++ b/src/tint/resolver/is_storeable_test.cc
@@ -78,7 +78,7 @@
}
TEST_F(ResolverIsStorableTest, Pointer) {
- auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
+ auto* ptr = create<type::Pointer>(create<type::I32>(), builtin::AddressSpace::kPrivate,
builtin::Access::kReadWrite);
EXPECT_FALSE(r()->IsStorable(ptr));
}
@@ -112,7 +112,7 @@
TEST_F(ResolverIsStorableTest, Struct_SomeMembersNonStorable) {
Structure("S", utils::Vector{
Member("a", ty.i32()),
- Member("b", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Member("b", ty.pointer<i32>(builtin::AddressSpace::kPrivate)),
});
EXPECT_FALSE(r()->Resolve());
@@ -138,7 +138,7 @@
auto* non_storable =
Structure("nonstorable", utils::Vector{
Member("a", ty.i32()),
- Member("b", ty.pointer<i32>(type::AddressSpace::kPrivate)),
+ Member("b", ty.pointer<i32>(builtin::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 4824549..3a4fdbb 100644
--- a/src/tint/resolver/materialize_test.cc
+++ b/src/tint/resolver/materialize_test.cc
@@ -929,7 +929,7 @@
break;
}
case Method::kIndex: {
- GlobalVar("arr", ty.array<i32, 4>(), type::AddressSpace::kPrivate);
+ GlobalVar("arr", ty.array<i32, 4>(), builtin::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 a9518d2..fd0f649 100644
--- a/src/tint/resolver/override_test.cc
+++ b/src/tint/resolver/override_test.cc
@@ -159,7 +159,7 @@
TEST_F(ResolverOverrideTest, TransitiveReferences_ViaPrivateInit) {
auto* a = Override("a", ty.f32());
- auto* b = GlobalVar("b", type::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "a"));
+ auto* b = GlobalVar("b", builtin::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{
@@ -208,7 +208,8 @@
TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize) {
auto* a = Override("a", ty.i32());
auto* b = Override("b", ty.i32(), Mul(2_a, "a"));
- auto* arr = GlobalVar("arr", type::AddressSpace::kWorkgroup, ty.array(ty.i32(), Mul(2_a, "b")));
+ auto* arr =
+ GlobalVar("arr", builtin::AddressSpace::kWorkgroup, ty.array(ty.i32(), Mul(2_a, "b")));
auto arr_ty = arr->type;
Override("unused", ty.i32(), Expr(1_a));
auto* func = Func("foo", utils::Empty, ty.void_(),
@@ -249,7 +250,7 @@
auto* a = Override("a", ty.i32());
auto* b = Override("b", ty.i32(), Mul(2_a, "a"));
Alias("arr_ty", ty.array(ty.i32(), Mul(2_a, "b")));
- auto* arr = GlobalVar("arr", type::AddressSpace::kWorkgroup, ty("arr_ty"));
+ auto* arr = GlobalVar("arr", builtin::AddressSpace::kWorkgroup, ty("arr_ty"));
auto arr_ty = arr->type;
Override("unused", ty.i32(), Expr(1_a));
auto* func = Func("foo", utils::Empty, ty.void_(),
@@ -295,8 +296,8 @@
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", type::AddressSpace::kWorkgroup, ty("arr_ty1"));
- auto* arr2 = GlobalVar("arr2", type::AddressSpace::kWorkgroup, ty("arr_ty2"));
+ auto* arr1 = GlobalVar("arr1", builtin::AddressSpace::kWorkgroup, ty("arr_ty1"));
+ auto* arr2 = GlobalVar("arr2", builtin::AddressSpace::kWorkgroup, ty("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 7f9c957..1e702a5 100644
--- a/src/tint/resolver/ptr_ref_test.cc
+++ b/src/tint/resolver/ptr_ref_test.cc
@@ -39,7 +39,7 @@
ASSERT_TRUE(TypeOf(expr)->Is<type::Pointer>());
EXPECT_TRUE(TypeOf(expr)->As<type::Pointer>()->StoreType()->Is<type::I32>());
- EXPECT_EQ(TypeOf(expr)->As<type::Pointer>()->AddressSpace(), type::AddressSpace::kFunction);
+ EXPECT_EQ(TypeOf(expr)->As<type::Pointer>()->AddressSpace(), builtin::AddressSpace::kFunction);
}
TEST_F(ResolverPtrRefTest, AddressOfThenDeref) {
@@ -68,23 +68,23 @@
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
auto* function = Var("f", ty.i32());
- auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate);
- auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup);
+ auto* private_ = GlobalVar("p", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* workgroup = GlobalVar("w", ty.i32(), builtin::AddressSpace::kWorkgroup);
auto* uniform =
- GlobalVar("ub", ty.Of(buf), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("ub", ty.Of(buf), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
auto* storage =
- GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage, Binding(1_a), Group(0_a));
+ GlobalVar("sb", ty.Of(buf), builtin::AddressSpace::kStorage, Binding(1_a), Group(0_a));
auto* function_ptr =
- Let("f_ptr", ty.pointer(ty.i32(), type::AddressSpace::kFunction), AddressOf(function));
+ Let("f_ptr", ty.pointer(ty.i32(), builtin::AddressSpace::kFunction), AddressOf(function));
auto* private_ptr =
- Let("p_ptr", ty.pointer(ty.i32(), type::AddressSpace::kPrivate), AddressOf(private_));
+ Let("p_ptr", ty.pointer(ty.i32(), builtin::AddressSpace::kPrivate), AddressOf(private_));
auto* workgroup_ptr =
- Let("w_ptr", ty.pointer(ty.i32(), type::AddressSpace::kWorkgroup), AddressOf(workgroup));
+ Let("w_ptr", ty.pointer(ty.i32(), builtin::AddressSpace::kWorkgroup), AddressOf(workgroup));
auto* uniform_ptr =
- Let("ub_ptr", ty.pointer(ty.Of(buf), type::AddressSpace::kUniform), AddressOf(uniform));
+ Let("ub_ptr", ty.pointer(ty.Of(buf), builtin::AddressSpace::kUniform), AddressOf(uniform));
auto* storage_ptr =
- Let("sb_ptr", ty.pointer(ty.Of(buf), type::AddressSpace::kStorage), AddressOf(storage));
+ Let("sb_ptr", ty.pointer(ty.Of(buf), builtin::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 078782c..d042402 100644
--- a/src/tint/resolver/ptr_ref_validation_test.cc
+++ b/src/tint/resolver/ptr_ref_validation_test.cc
@@ -143,12 +143,12 @@
// }
auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))});
- auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage,
+ auto* storage = GlobalVar("s", ty.Of(buf), builtin::AddressSpace::kStorage,
builtin::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<i32>(type::AddressSpace::kStorage), AddressOf(expr));
+ auto* ptr = Let(Source{{12, 34}}, "p", ty.pointer<i32>(builtin::AddressSpace::kStorage),
+ AddressOf(expr));
WrapInFunction(ptr);
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 5f4e89d..a664334 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -88,7 +88,7 @@
#include "src/tint/utils/vector.h"
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::builtin::Access>);
-TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::type::AddressSpace>);
+TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::builtin::AddressSpace>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::type::TexelFormat>);
namespace tint::resolver {
@@ -255,12 +255,12 @@
ty = rhs->Type()->UnwrapRef(); // Implicit load of RHS
}
- if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kUndefined, ty, rhs)) {
+ if (rhs && !validator_.VariableInitializer(v, builtin::AddressSpace::kUndefined, ty, rhs)) {
return nullptr;
}
- if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kUndefined, const_cast<type::Type*>(ty),
- v->source)) {
+ if (!ApplyAddressSpaceUsageToType(builtin::AddressSpace::kUndefined,
+ const_cast<type::Type*>(ty), v->source)) {
AddNote("while instantiating 'let' " + builder_->Symbols().NameFor(v->name->symbol),
v->source);
return nullptr;
@@ -269,12 +269,12 @@
sem::Variable* sem = nullptr;
if (is_global) {
sem = builder_->create<sem::GlobalVariable>(
- v, ty, sem::EvaluationStage::kRuntime, type::AddressSpace::kUndefined,
+ v, ty, sem::EvaluationStage::kRuntime, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined,
/* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
} else {
sem = builder_->create<sem::LocalVariable>(v, ty, sem::EvaluationStage::kRuntime,
- type::AddressSpace::kUndefined,
+ builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, current_statement_,
/* constant_value */ nullptr);
}
@@ -318,19 +318,19 @@
return nullptr;
}
- if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kUndefined, ty, rhs)) {
+ if (rhs && !validator_.VariableInitializer(v, builtin::AddressSpace::kUndefined, ty, rhs)) {
return nullptr;
}
- if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kUndefined, const_cast<type::Type*>(ty),
- v->source)) {
+ if (!ApplyAddressSpaceUsageToType(builtin::AddressSpace::kUndefined,
+ const_cast<type::Type*>(ty), v->source)) {
AddNote("while instantiating 'override' " + builder_->Symbols().NameFor(v->name->symbol),
v->source);
return nullptr;
}
auto* sem = builder_->create<sem::GlobalVariable>(
- v, ty, sem::EvaluationStage::kOverride, type::AddressSpace::kUndefined,
+ v, ty, sem::EvaluationStage::kOverride, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined,
/* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
sem->SetInitializer(rhs);
@@ -412,12 +412,12 @@
ty = rhs->Type();
}
- if (!validator_.VariableInitializer(c, type::AddressSpace::kUndefined, ty, rhs)) {
+ if (!validator_.VariableInitializer(c, builtin::AddressSpace::kUndefined, ty, rhs)) {
return nullptr;
}
- if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kUndefined, const_cast<type::Type*>(ty),
- c->source)) {
+ if (!ApplyAddressSpaceUsageToType(builtin::AddressSpace::kUndefined,
+ const_cast<type::Type*>(ty), c->source)) {
AddNote("while instantiating 'const' " + builder_->Symbols().NameFor(c->name->symbol),
c->source);
return nullptr;
@@ -426,10 +426,10 @@
const auto value = rhs->ConstantValue();
auto* sem = is_global
? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>(
- c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kUndefined,
+ c, ty, sem::EvaluationStage::kConstant, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, value, sem::BindingPoint{}, std::nullopt))
: static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>(
- c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kUndefined,
+ c, ty, sem::EvaluationStage::kConstant, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, current_statement_, value));
sem->SetInitializer(rhs);
@@ -473,7 +473,7 @@
return nullptr;
}
- auto address_space = type::AddressSpace::kUndefined;
+ auto address_space = builtin::AddressSpace::kUndefined;
if (var->declared_address_space) {
auto expr = AddressSpaceExpression(var->declared_address_space);
if (!expr) {
@@ -483,17 +483,17 @@
} else {
// No declared address space. Infer from usage / type.
if (!is_global) {
- address_space = type::AddressSpace::kFunction;
+ address_space = builtin::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 = type::AddressSpace::kHandle;
+ address_space = builtin::AddressSpace::kHandle;
}
}
- if (!is_global && address_space != type::AddressSpace::kFunction &&
+ if (!is_global && address_space != builtin::AddressSpace::kFunction &&
validator_.IsValidationEnabled(var->attributes,
ast::DisabledValidation::kIgnoreAddressSpace)) {
AddError("function-scope 'var' declaration must use 'function' address space", var->source);
@@ -622,7 +622,7 @@
return nullptr;
}
- if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kUndefined, ty, param->type->source)) {
+ if (!ApplyAddressSpaceUsageToType(builtin::AddressSpace::kUndefined, ty, param->type->source)) {
add_note();
return nullptr;
}
@@ -673,7 +673,7 @@
}
auto* sem = builder_->create<sem::Parameter>(
- param, index, ty, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ param, index, ty, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
sem::ParameterUsage::kNone, binding_point, location);
builder_->Sem().Add(param, sem);
return sem;
@@ -703,12 +703,12 @@
return static_cast<uint32_t>(value);
}
-builtin::Access Resolver::DefaultAccessForAddressSpace(type::AddressSpace address_space) {
+builtin::Access Resolver::DefaultAccessForAddressSpace(builtin::AddressSpace address_space) {
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class
switch (address_space) {
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kHandle:
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kHandle:
return builtin::Access::kRead;
default:
break;
@@ -933,7 +933,7 @@
}
if (auto* str = return_type->As<sem::Struct>()) {
- if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kUndefined, str, decl->source)) {
+ if (!ApplyAddressSpaceUsageToType(builtin::AddressSpace::kUndefined, str, decl->source)) {
AddNote("while instantiating return type for " +
builder_->Symbols().NameFor(decl->name->symbol),
decl->source);
@@ -1497,7 +1497,7 @@
return const_cast<type::Type*>(type_expr->Type());
}
-sem::BuiltinEnumExpression<type::AddressSpace>* Resolver::AddressSpaceExpression(
+sem::BuiltinEnumExpression<builtin::AddressSpace>* Resolver::AddressSpaceExpression(
const ast::Expression* expr) {
return sem_.AsAddressSpace(Expression(expr));
}
@@ -2024,10 +2024,10 @@
[&]() -> sem::TypeInitializer* {
auto params = utils::Transform(args, [&](auto, size_t i) {
return builder_->create<sem::Parameter>(
- nullptr, // declaration
- static_cast<uint32_t>(i), // index
- arr->ElemType(), // type
- type::AddressSpace::kUndefined, // address_space
+ nullptr, // declaration
+ static_cast<uint32_t>(i), // index
+ arr->ElemType(), // type
+ builtin::AddressSpace::kUndefined, // address_space
builtin::Access::kUndefined);
});
return builder_->create<sem::TypeInitializer>(arr, std::move(params),
@@ -2053,11 +2053,11 @@
params.Resize(std::min(args.Length(), str->Members().Length()));
for (size_t i = 0, n = params.Length(); i < n; i++) {
params[i] = builder_->create<sem::Parameter>(
- nullptr, // declaration
- static_cast<uint32_t>(i), // index
- str->Members()[i]->Type(), // type
- type::AddressSpace::kUndefined, // address_space
- builtin::Access::kUndefined); // access
+ nullptr, // declaration
+ static_cast<uint32_t>(i), // index
+ str->Members()[i]->Type(), // type
+ builtin::AddressSpace::kUndefined, // address_space
+ builtin::Access::kUndefined); // access
}
return builder_->create<sem::TypeInitializer>(str, std::move(params),
args_stage);
@@ -2982,8 +2982,8 @@
expr, current_statement_, access);
}
- if (auto addr = resolved->AddressSpace(); addr != type::AddressSpace::kUndefined) {
- return builder_->create<sem::BuiltinEnumExpression<type::AddressSpace>>(
+ if (auto addr = resolved->AddressSpace(); addr != builtin::AddressSpace::kUndefined) {
+ return builder_->create<sem::BuiltinEnumExpression<builtin::AddressSpace>>(
expr, current_statement_, addr);
}
@@ -3980,7 +3980,7 @@
});
}
-bool Resolver::ApplyAddressSpaceUsageToType(type::AddressSpace address_space,
+bool Resolver::ApplyAddressSpaceUsageToType(builtin::AddressSpace address_space,
type::Type* ty,
const Source& usage) {
ty = const_cast<type::Type*>(ty->UnwrapRef());
@@ -4008,7 +4008,7 @@
}
if (auto* arr = ty->As<type::Array>()) {
- if (address_space != type::AddressSpace::kStorage) {
+ if (address_space != builtin::AddressSpace::kStorage) {
if (arr->Count()->Is<type::RuntimeArrayCount>()) {
AddError("runtime-sized arrays can only be used in the <storage> address space",
usage);
@@ -4027,7 +4027,7 @@
usage);
}
- if (type::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) {
+ if (builtin::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 4057f73..b94467d 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -138,10 +138,11 @@
/// @returns the resolved type from an expression, or nullptr on error
type::Type* Type(const ast::Expression* ast);
- /// @returns the call of Expression() cast to a sem::BuiltinEnumExpression<type::AddressSpace>.
- /// If the sem::Expression is not a sem::BuiltinEnumExpression<type::AddressSpace>, then an
- /// error diagnostic is raised and nullptr is returned.
- sem::BuiltinEnumExpression<type::AddressSpace>* AddressSpaceExpression(
+ /// @returns the call of Expression() cast to a
+ /// sem::BuiltinEnumExpression<builtin::AddressSpace>. If the sem::Expression is not a
+ /// sem::BuiltinEnumExpression<builtin::AddressSpace>, then an error diagnostic is raised and
+ /// nullptr is returned.
+ sem::BuiltinEnumExpression<builtin::AddressSpace>* AddressSpaceExpression(
const ast::Expression* expr);
/// @returns the call of Expression() cast to a sem::BuiltinEnumExpression<type::TexelFormat>.
@@ -401,11 +402,13 @@
/// given type and address space. Used for generating sensible error
/// messages.
/// @returns true on success, false on error
- bool ApplyAddressSpaceUsageToType(type::AddressSpace sc, type::Type* ty, const Source& usage);
+ bool ApplyAddressSpaceUsageToType(builtin::AddressSpace sc,
+ type::Type* ty,
+ const Source& usage);
/// @param address_space the address space
/// @returns the default access control for the given address space
- builtin::Access DefaultAccessForAddressSpace(type::AddressSpace address_space);
+ builtin::Access DefaultAccessForAddressSpace(builtin::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 1d14498..87bb8d0 100644
--- a/src/tint/resolver/resolver_test.cc
+++ b/src/tint/resolver/resolver_test.cc
@@ -325,7 +325,7 @@
TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) {
auto* init = Expr(2_i);
- GlobalVar("my_var", ty.i32(), type::AddressSpace::kPrivate, init);
+ GlobalVar("my_var", ty.i32(), builtin::AddressSpace::kPrivate, init);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -405,7 +405,7 @@
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(), type::AddressSpace::kPrivate, Expr(2_f));
+ auto* mod_f32 = Var("foo", ty.f32(), builtin::AddressSpace::kPrivate, Expr(2_f));
auto* mod_init = mod_f32->initializer;
AST().AddGlobalVariable(mod_f32);
@@ -433,7 +433,7 @@
TEST_F(ResolverTest, ArraySize_UnsignedLiteral) {
// var<private> a : array<f32, 10u>;
- auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_u)), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_u)), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -446,7 +446,7 @@
TEST_F(ResolverTest, ArraySize_SignedLiteral) {
// var<private> a : array<f32, 10i>;
- auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_i)), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_i)), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -461,7 +461,7 @@
// const size = 10u;
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(10_u));
- auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -476,7 +476,7 @@
// const size = 0;
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(10_i));
- auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -491,7 +491,7 @@
// override size = 10i;
// var<workgroup> a : array<f32, size>;
auto* override = Override("size", Expr(10_i));
- auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -509,8 +509,8 @@
// var<workgroup> a : array<f32, size>;
// var<workgroup> b : array<f32, size>;
auto* override = Override("size", Expr(10_i));
- 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);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), builtin::AddressSpace::kWorkgroup);
+ auto* b = GlobalVar("b", ty.array(ty.f32(), Expr("size")), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -536,7 +536,7 @@
// var<workgroup> a : array<f32, size*2>;
auto* override = Override("size", Expr(10_i));
auto* cnt = Mul("size", 2_a);
- auto* a = GlobalVar("a", ty.array(ty.f32(), cnt), type::AddressSpace::kWorkgroup);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), cnt), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -556,8 +556,8 @@
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), type::AddressSpace::kWorkgroup);
- auto* b = GlobalVar("b", ty.array(ty.f32(), b_cnt), type::AddressSpace::kWorkgroup);
+ auto* a = GlobalVar("a", ty.array(ty.f32(), a_cnt), builtin::AddressSpace::kWorkgroup);
+ auto* b = GlobalVar("b", ty.array(ty.f32(), b_cnt), builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -579,7 +579,7 @@
}
TEST_F(ResolverTest, Expr_Bitcast) {
- GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("name", ty.f32(), builtin::AddressSpace::kPrivate);
auto* bitcast = Bitcast<f32>(Expr("name"));
WrapInFunction(bitcast);
@@ -642,7 +642,7 @@
}
TEST_F(ResolverTest, Expr_Cast) {
- GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("name", ty.f32(), builtin::AddressSpace::kPrivate);
auto* cast = Call<f32>("name");
WrapInFunction(cast);
@@ -700,7 +700,7 @@
}
TEST_F(ResolverTest, Expr_Identifier_GlobalVariable) {
- auto* my_var = GlobalVar("my_var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* my_var = GlobalVar("my_var", ty.f32(), builtin::AddressSpace::kPrivate);
auto* ident = Expr("my_var");
WrapInFunction(ident);
@@ -801,7 +801,7 @@
auto* v = Expr("v");
auto* p = Expr("p");
auto* v_decl = Decl(Var("v", ty.f32()));
- auto* p_decl = Decl(Let("p", ty.pointer<f32>(type::AddressSpace::kFunction), AddressOf(v)));
+ auto* p_decl = Decl(Let("p", ty.pointer<f32>(builtin::AddressSpace::kFunction), AddressOf(v)));
auto* assign = Assign(Deref(p), 1.23_f);
Func("my_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -877,7 +877,7 @@
Param("b", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kVertexIndex)});
auto* param_c = Param("c", ty.u32(), utils::Vector{Location(1_a)});
- GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* func = Func("my_func",
utils::Vector{
param_a,
@@ -907,7 +907,7 @@
TEST_F(ResolverTest, Function_GlobalVariable_Location) {
auto* var = GlobalVar(
- "my_vec", ty.vec4<f32>(), type::AddressSpace::kIn,
+ "my_vec", ty.vec4<f32>(), builtin::AddressSpace::kIn,
utils::Vector{Location(3_a), Disable(ast::DisabledValidation::kIgnoreAddressSpace)});
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -920,10 +920,10 @@
TEST_F(ResolverTest, Function_RegisterInputOutputVariables) {
auto* s = Structure("S", utils::Vector{Member("m", ty.u32())});
- auto* sb_var = GlobalVar("sb_var", ty.Of(s), type::AddressSpace::kStorage,
+ auto* sb_var = GlobalVar("sb_var", ty.Of(s), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Binding(0_a), Group(0_a));
- auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup);
- auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* wg_var = GlobalVar("wg_var", ty.f32(), builtin::AddressSpace::kWorkgroup);
+ auto* priv_var = GlobalVar("priv_var", ty.f32(), builtin::AddressSpace::kPrivate);
auto* func = Func("my_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -966,7 +966,7 @@
}
TEST_F(ResolverTest, Function_ReturnType_NoLocation) {
- GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* func = Func("my_func", utils::Empty, ty.vec4<f32>(),
utils::Vector{
Return("my_vec"),
@@ -988,10 +988,10 @@
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), type::AddressSpace::kStorage,
+ auto* sb_var = GlobalVar("sb_var", ty.Of(s), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Binding(0_a), Group(0_a));
- auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup);
- auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* wg_var = GlobalVar("wg_var", ty.f32(), builtin::AddressSpace::kWorkgroup);
+ auto* priv_var = GlobalVar("priv_var", ty.f32(), builtin::AddressSpace::kPrivate);
Func("my_func", utils::Empty, ty.f32(),
utils::Vector{Assign("wg_var", "wg_var"), Assign("sb_var", "sb_var"),
@@ -1240,7 +1240,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar("my_struct", ty.Of(st), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_struct", "second_member");
WrapInFunction(mem);
@@ -1261,7 +1261,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar("my_struct", ty.Of(alias), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_struct", "second_member");
WrapInFunction(mem);
@@ -1278,7 +1278,7 @@
}
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
- GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", "xzyw");
WrapInFunction(mem);
@@ -1296,7 +1296,7 @@
}
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle_SingleElement) {
- GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", "b");
WrapInFunction(mem);
@@ -1329,7 +1329,7 @@
auto* stB = Structure("B", utils::Vector{Member("foo", ty.vec4<f32>())});
auto* stA = Structure("A", utils::Vector{Member("mem", ty.array(ty.Of(stB), 3_i))});
- GlobalVar("c", ty.Of(stA), type::AddressSpace::kPrivate);
+ GlobalVar("c", ty.Of(stA), builtin::AddressSpace::kPrivate);
auto* mem =
MemberAccessor(MemberAccessor(IndexAccessor(MemberAccessor("c", "mem"), 0_i), "foo"), "yx");
@@ -1347,7 +1347,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar("my_struct", ty.Of(st), builtin::AddressSpace::kPrivate);
auto* expr = Add(MemberAccessor("my_struct", "first_member"),
MemberAccessor("my_struct", "second_member"));
@@ -1650,8 +1650,8 @@
ss << FriendlyName(lhs_type) << " " << params.op << " " << FriendlyName(rhs_type);
SCOPED_TRACE(ss.str());
- GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
- GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
+ GlobalVar("lhs", lhs_type, builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", rhs_type, builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -1685,8 +1685,8 @@
<< FriendlyName(rhs_type);
SCOPED_TRACE(ss.str());
- GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
- GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
+ GlobalVar("lhs", lhs_type, builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", rhs_type, builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -1731,8 +1731,8 @@
ss << FriendlyName(lhs_type) << " " << op << " " << FriendlyName(rhs_type);
SCOPED_TRACE(ss.str());
- GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
- GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
+ GlobalVar("lhs", lhs_type, builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", rhs_type, builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(Source{{12, 34}}, op, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -1771,8 +1771,8 @@
is_valid_expr = vec_size == mat_cols;
}
- GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
- GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
+ GlobalVar("lhs", lhs_type, builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", rhs_type, builtin::AddressSpace::kPrivate);
auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -1808,8 +1808,8 @@
auto* col = create<type::Vector>(f32, lhs_mat_rows);
auto* result_type = create<type::Matrix>(col, rhs_mat_cols);
- GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
- GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
+ GlobalVar("lhs", lhs_type, builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", rhs_type, builtin::AddressSpace::kPrivate);
auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -1837,11 +1837,11 @@
auto op = GetParam();
if (op == ast::UnaryOp::kNot) {
- GlobalVar("ident", ty.vec4<bool>(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.vec4<bool>(), builtin::AddressSpace::kPrivate);
} else if (op == ast::UnaryOp::kNegation || op == ast::UnaryOp::kComplement) {
- GlobalVar("ident", ty.vec4<i32>(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.vec4<i32>(), builtin::AddressSpace::kPrivate);
} else {
- GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
}
auto* der = create<ast::UnaryOpExpression>(op, Expr("ident"));
WrapInFunction(der);
@@ -1873,7 +1873,7 @@
EXPECT_TRUE(r()->Resolve()) << r()->error();
- EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kFunction);
+ EXPECT_EQ(Sem().Get(var)->AddressSpace(), builtin::AddressSpace::kFunction);
}
TEST_F(ResolverTest, AddressSpace_SetForSampler) {
@@ -1882,7 +1882,7 @@
EXPECT_TRUE(r()->Resolve()) << r()->error();
- EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kHandle);
+ EXPECT_EQ(Sem().Get(var)->AddressSpace(), builtin::AddressSpace::kHandle);
}
TEST_F(ResolverTest, AddressSpace_SetForTexture) {
@@ -1891,7 +1891,7 @@
EXPECT_TRUE(r()->Resolve()) << r()->error();
- EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kHandle);
+ EXPECT_EQ(Sem().Get(var)->AddressSpace(), builtin::AddressSpace::kHandle);
}
TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) {
@@ -1901,14 +1901,14 @@
EXPECT_TRUE(r()->Resolve()) << r()->error();
- EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kUndefined);
+ EXPECT_EQ(Sem().Get(var)->AddressSpace(), builtin::AddressSpace::kUndefined);
}
TEST_F(ResolverTest, Access_SetForStorageBuffer) {
// struct S { x : i32 };
// var<storage> 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), type::AddressSpace::kStorage,
+ auto* var = GlobalVar(Source{{56, 78}}, "g", ty.Of(s), builtin::AddressSpace::kStorage,
Binding(0_a), Group(0_a));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1941,11 +1941,11 @@
// ep_1 -> {}
// ep_2 -> {}
- 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);
+ GlobalVar("first", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("second", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("call_a", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("call_b", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("call_c", ty.f32(), builtin::AddressSpace::kPrivate);
auto* func_b = Func("b", utils::Empty, ty.f32(),
utils::Vector{
@@ -2085,8 +2085,8 @@
{
ProgramBuilder b;
auto* expr = b.Expr(1_i);
- b.GlobalVar("a", b.ty.i32(), type::AddressSpace::kPrivate, expr);
- b.GlobalVar("b", b.ty.i32(), type::AddressSpace::kPrivate, expr);
+ b.GlobalVar("a", b.ty.i32(), builtin::AddressSpace::kPrivate, expr);
+ b.GlobalVar("b", b.ty.i32(), builtin::AddressSpace::kPrivate, expr);
Resolver(&b).Resolve();
},
"internal compiler error: AST node 'tint::ast::IntLiteralExpression' was encountered twice "
@@ -2094,7 +2094,7 @@
}
TEST_F(ResolverTest, UnaryOp_Not) {
- GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* der = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr(Source{{12, 34}}, "ident"));
WrapInFunction(der);
@@ -2103,7 +2103,7 @@
}
TEST_F(ResolverTest, UnaryOp_Complement) {
- GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* der =
create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr(Source{{12, 34}}, "ident"));
WrapInFunction(der);
@@ -2113,7 +2113,7 @@
}
TEST_F(ResolverTest, UnaryOp_Negation) {
- GlobalVar("ident", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("ident", ty.u32(), builtin::AddressSpace::kPrivate);
auto* der =
create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr(Source{{12, 34}}, "ident"));
WrapInFunction(der);
@@ -2272,7 +2272,7 @@
GlobalVar("s", ty.sampler(type::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<f32>(), type::AddressSpace::kUniform, Group(0_a), Binding(2_a));
+ GlobalVar("c", ty.vec2<f32>(), builtin::AddressSpace::kUniform, Group(0_a), Binding(2_a));
Func("main", utils::Empty, ty.vec4<f32>(),
utils::Vector{
@@ -2288,9 +2288,9 @@
Func("helper",
utils::Vector{
Param("sl", ty.pointer(ty.sampler(type::SamplerKind::kSampler),
- type::AddressSpace::kFunction)),
+ builtin::AddressSpace::kFunction)),
Param("tl", ty.pointer(ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
- type::AddressSpace::kFunction)),
+ builtin::AddressSpace::kFunction)),
},
ty.vec4<f32>(),
utils::Vector{
@@ -2303,15 +2303,15 @@
TEST_F(ResolverTest, ModuleDependencyOrderedDeclarations) {
auto* f0 = Func("f0", utils::Empty, ty.void_(), utils::Empty);
- auto* v0 = GlobalVar("v0", ty.i32(), type::AddressSpace::kPrivate);
+ auto* v0 = GlobalVar("v0", ty.i32(), builtin::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(), type::AddressSpace::kPrivate);
+ auto* v1 = GlobalVar("v1", ty.i32(), builtin::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(), type::AddressSpace::kPrivate);
+ auto* v2 = GlobalVar("v2", ty.i32(), builtin::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 7f68f25..0e1b7d5 100644
--- a/src/tint/resolver/resolver_test_helper.h
+++ b/src/tint/resolver/resolver_test_helper.h
@@ -628,13 +628,13 @@
/// @param b the ProgramBuilder
/// @return a new AST alias type
static inline ast::Type AST(ProgramBuilder& b) {
- return b.ty.pointer(DataType<T>::AST(b), type::AddressSpace::kPrivate,
+ return b.ty.pointer(DataType<T>::AST(b), builtin::AddressSpace::kPrivate,
builtin::Access::kUndefined);
}
/// @param b the ProgramBuilder
/// @return the semantic aliased type
static inline const type::Type* Sem(ProgramBuilder& b) {
- return b.create<type::Pointer>(DataType<T>::Sem(b), type::AddressSpace::kPrivate,
+ return b.create<type::Pointer>(DataType<T>::Sem(b), builtin::AddressSpace::kPrivate,
builtin::Access::kReadWrite);
}
@@ -643,7 +643,7 @@
static inline const ast::Expression* Expr(ProgramBuilder& b,
utils::VectorRef<Scalar> /*unused*/) {
auto sym = b.Symbols().New("global_for_ptr");
- b.GlobalVar(sym, DataType<T>::AST(b), type::AddressSpace::kPrivate);
+ b.GlobalVar(sym, DataType<T>::AST(b), builtin::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 4f4a420..0353ff5 100644
--- a/src/tint/resolver/root_identifier_test.cc
+++ b/src/tint/resolver/root_identifier_test.cc
@@ -27,7 +27,7 @@
class ResolverRootIdentifierTest : public ResolverTest {};
TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) {
- auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = Expr(a);
WrapInFunction(expr);
@@ -38,7 +38,7 @@
}
TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) {
- auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kWorkgroup);
+ auto* a = GlobalVar("a", ty.f32(), builtin::AddressSpace::kWorkgroup);
auto* expr = Expr(a);
WrapInFunction(expr);
@@ -49,7 +49,7 @@
}
TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) {
- auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
+ auto* a = GlobalVar("a", ty.f32(), builtin::AddressSpace::kStorage, Group(0_a), Binding(0_a));
auto* expr = Expr(a);
WrapInFunction(expr);
@@ -60,7 +60,7 @@
}
TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) {
- auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
+ auto* a = GlobalVar("a", ty.f32(), builtin::AddressSpace::kUniform, Group(0_a), Binding(0_a));
auto* expr = Expr(a);
WrapInFunction(expr);
@@ -72,7 +72,7 @@
TEST_F(ResolverRootIdentifierTest, GlobalTextureVar) {
auto* a = GlobalVar("a", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
- type::AddressSpace::kUndefined, Group(0_a), Binding(0_a));
+ builtin::AddressSpace::kUndefined, Group(0_a), Binding(0_a));
auto* expr = Expr(a);
WrapInFunction(Call("textureDimensions", expr));
@@ -142,7 +142,7 @@
// {
// let b = a;
// }
- auto* param = Param("a", ty.pointer(ty.f32(), type::AddressSpace::kFunction));
+ auto* param = Param("a", ty.pointer(ty.f32(), builtin::AddressSpace::kFunction));
auto* expr_param = Expr(param);
auto* let = Let("b", expr_param);
auto* expr_let = Expr("b");
@@ -199,7 +199,7 @@
// {
// a[2i]
// }
- auto* a = GlobalVar("a", ty.array<f32, 4>(), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.array<f32, 4>(), builtin::AddressSpace::kPrivate);
auto* expr = IndexAccessor(a, 2_i);
WrapInFunction(expr);
@@ -216,7 +216,7 @@
// a.f
// }
auto* S = Structure("S", utils::Vector{Member("f", ty.f32())});
- auto* a = GlobalVar("a", ty.Of(S), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.Of(S), builtin::AddressSpace::kPrivate);
auto* expr = MemberAccessor(a, "f");
WrapInFunction(expr);
@@ -232,7 +232,7 @@
// let a_ptr1 = &*&a;
// let a_ptr2 = &*a_ptr1;
// }
- auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.f32(), builtin::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/sem_helper.cc b/src/tint/resolver/sem_helper.cc
index 1515812..87f506b 100644
--- a/src/tint/resolver/sem_helper.cc
+++ b/src/tint/resolver/sem_helper.cc
@@ -79,7 +79,7 @@
std::string(wanted),
access->Declaration()->source);
},
- [&](const sem::BuiltinEnumExpression<type::AddressSpace>* addr) {
+ [&](const sem::BuiltinEnumExpression<builtin::AddressSpace>* addr) {
AddError("cannot use address space '" + utils::ToString(addr->Value()) + "' as " +
std::string(wanted),
addr->Declaration()->source);
diff --git a/src/tint/resolver/sem_helper.h b/src/tint/resolver/sem_helper.h
index a1de91b..9aedcd1 100644
--- a/src/tint/resolver/sem_helper.h
+++ b/src/tint/resolver/sem_helper.h
@@ -105,11 +105,11 @@
/// @param expr the semantic node
/// @returns nullptr if @p expr is nullptr, or @p expr cast to
- /// sem::BuiltinEnumExpression<type::AddressSpace> if the cast is successful, otherwise an error
- /// diagnostic is raised.
- sem::BuiltinEnumExpression<type::AddressSpace>* AsAddressSpace(sem::Expression* expr) const {
+ /// sem::BuiltinEnumExpression<builtin::AddressSpace> if the cast is successful, otherwise an
+ /// error diagnostic is raised.
+ sem::BuiltinEnumExpression<builtin::AddressSpace>* AsAddressSpace(sem::Expression* expr) const {
if (TINT_LIKELY(expr)) {
- auto* enum_expr = expr->As<sem::BuiltinEnumExpression<type::AddressSpace>>();
+ auto* enum_expr = expr->As<sem::BuiltinEnumExpression<builtin::AddressSpace>>();
if (TINT_LIKELY(enum_expr)) {
return enum_expr;
}
diff --git a/src/tint/resolver/side_effects_test.cc b/src/tint/resolver/side_effects_test.cc
index 90fcdb9..88c51ef 100644
--- a/src/tint/resolver/side_effects_test.cc
+++ b/src/tint/resolver/side_effects_test.cc
@@ -15,6 +15,7 @@
#include "src/tint/resolver/resolver.h"
#include "gtest/gtest.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/builtin/extension.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/index_accessor_expression.h"
@@ -32,7 +33,7 @@
template <typename T>
void MakeSideEffectFunc(const char* name) {
auto global = Sym();
- GlobalVar(global, ty.Of<T>(), type::AddressSpace::kPrivate);
+ GlobalVar(global, ty.Of<T>(), builtin::AddressSpace::kPrivate);
auto local = Sym();
Func(name, utils::Empty, ty.Of<T>(),
utils::Vector{
@@ -45,7 +46,7 @@
template <typename MAKE_TYPE_FUNC>
void MakeSideEffectFunc(const char* name, MAKE_TYPE_FUNC make_type) {
auto global = Sym();
- GlobalVar(global, make_type(), type::AddressSpace::kPrivate);
+ GlobalVar(global, make_type(), builtin::AddressSpace::kPrivate);
auto local = Sym();
Func(name, utils::Empty, make_type(),
utils::Vector{
@@ -90,7 +91,7 @@
}
TEST_F(SideEffectsTest, Call_Builtin_NoSE) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dpdx", "a");
Func("f", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
utils::Vector{create<ast::StageAttribute>(ast::PipelineStage::kFragment)});
@@ -116,7 +117,7 @@
}
TEST_F(SideEffectsTest, Call_Builtin_SE) {
- GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic(ty.i32()), builtin::AddressSpace::kWorkgroup);
auto* expr = Call("atomicAdd", AddressOf("a"), 1_i);
WrapInFunction(expr);
@@ -165,21 +166,21 @@
auto& c = GetParam();
uint32_t next_binding = 0;
- 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<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("vf2", ty.vec2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("vi2", ty.vec2<i32>(), type::AddressSpace::kPrivate);
- GlobalVar("vf4", ty.vec4<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("vb", ty.vec3<bool>(), type::AddressSpace::kPrivate);
- GlobalVar("m", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("arr", ty.array<f32, 10>(), type::AddressSpace::kPrivate);
- GlobalVar("storage_arr", ty.array<f32>(), type::AddressSpace::kStorage, Group(0_a),
+ GlobalVar("f", ty.f32(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("i", ty.i32(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("u", ty.u32(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("vf", ty.vec3<f32>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("vf2", ty.vec2<f32>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("vi2", ty.vec2<i32>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("vf4", ty.vec4<f32>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("vb", ty.vec3<bool>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("m", ty.mat3x3<f32>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("arr", ty.array<f32, 10>(), tint::builtin::AddressSpace::kPrivate);
+ GlobalVar("storage_arr", ty.array<f32>(), tint::builtin::AddressSpace::kStorage, Group(0_a),
Binding(AInt(next_binding++)));
- GlobalVar("workgroup_arr", ty.array<f32, 4>(), type::AddressSpace::kWorkgroup);
- GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kStorage,
+ GlobalVar("workgroup_arr", ty.array<f32, 4>(), tint::builtin::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic(ty.i32()), tint::builtin::AddressSpace::kStorage,
tint::builtin::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/struct_address_space_use_test.cc b/src/tint/resolver/struct_address_space_use_test.cc
index 1b42e75..aeb5c31 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 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kUndefined));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kUndefined));
}
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) {
@@ -58,55 +58,55 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kUndefined));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kUndefined));
}
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromGlobal) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::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), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(a), builtin::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::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), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(o), builtin::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::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, type::AddressSpace::kPrivate);
+ GlobalVar("g", a, builtin::AddressSpace::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kPrivate));
}
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) {
@@ -118,7 +118,7 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
}
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) {
@@ -130,7 +130,7 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
}
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) {
@@ -142,7 +142,7 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
}
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) {
@@ -154,13 +154,13 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
}
TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) {
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
- GlobalVar("x", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
- GlobalVar("y", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("x", ty.Of(s), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("y", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(0_a));
WrapInFunction(Var("g", ty.Of(s)));
@@ -168,9 +168,9 @@
auto* sem = TypeOf(s)->As<sem::Struct>();
ASSERT_NE(sem, nullptr);
- EXPECT_THAT(sem->AddressSpaceUsage(),
- UnorderedElementsAre(type::AddressSpace::kUniform, type::AddressSpace::kStorage,
- type::AddressSpace::kFunction));
+ EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kUniform,
+ builtin::AddressSpace::kStorage,
+ builtin::AddressSpace::kFunction));
}
} // namespace
diff --git a/src/tint/resolver/type_initializer_validation_test.cc b/src/tint/resolver/type_initializer_validation_test.cc
index f269aa2..10d6ae4 100644
--- a/src/tint/resolver/type_initializer_validation_test.cc
+++ b/src/tint/resolver/type_initializer_validation_test.cc
@@ -70,11 +70,11 @@
ASSERT_TRUE(TypeOf(a_ident)->Is<type::Reference>());
EXPECT_TRUE(TypeOf(a_ident)->As<type::Reference>()->StoreType()->Is<type::I32>());
EXPECT_EQ(TypeOf(a_ident)->As<type::Reference>()->AddressSpace(),
- type::AddressSpace::kFunction);
+ builtin::AddressSpace::kFunction);
ASSERT_TRUE(TypeOf(b_ident)->Is<type::Reference>());
EXPECT_TRUE(TypeOf(b_ident)->As<type::Reference>()->StoreType()->Is<type::I32>());
EXPECT_EQ(TypeOf(b_ident)->As<type::Reference>()->AddressSpace(),
- type::AddressSpace::kFunction);
+ builtin::AddressSpace::kFunction);
}
using InferTypeTest_FromInitializerExpression = ResolverTestWithParam<Params>;
@@ -98,7 +98,7 @@
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* got = TypeOf(a_ident);
auto* expected =
- create<type::Reference>(params.create_rhs_sem_type(*this), type::AddressSpace::kFunction,
+ create<type::Reference>(params.create_rhs_sem_type(*this), builtin::AddressSpace::kFunction,
builtin::Access::kReadWrite);
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
<< "expected: " << FriendlyName(expected) << "\n";
@@ -153,7 +153,7 @@
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* got = TypeOf(a_ident);
auto* expected =
- create<type::Reference>(params.create_rhs_sem_type(*this), type::AddressSpace::kFunction,
+ create<type::Reference>(params.create_rhs_sem_type(*this), builtin::AddressSpace::kFunction,
builtin::Access::kReadWrite);
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
<< "expected: " << FriendlyName(expected) << "\n";
@@ -202,7 +202,7 @@
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* got = TypeOf(a_ident);
auto* expected =
- create<type::Reference>(params.create_rhs_sem_type(*this), type::AddressSpace::kFunction,
+ create<type::Reference>(params.create_rhs_sem_type(*this), builtin::AddressSpace::kFunction,
builtin::Access::kReadWrite);
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
<< "expected: " << FriendlyName(expected) << "\n";
@@ -1971,7 +1971,7 @@
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) {
auto* alias = Alias("UnsignedInt", ty.u32());
- GlobalVar("uint_var", ty.Of(alias), type::AddressSpace::kPrivate);
+ GlobalVar("uint_var", ty.Of(alias), builtin::AddressSpace::kPrivate);
auto* tc = vec2<f32>(Source{{12, 34}}, "uint_var");
WrapInFunction(tc);
@@ -1983,8 +1983,8 @@
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Success) {
auto* f32_alias = Alias("Float32", ty.f32());
auto* vec2_alias = Alias("VectorFloat2", ty.vec2<f32>());
- GlobalVar("my_f32", ty.Of(f32_alias), type::AddressSpace::kPrivate);
- GlobalVar("my_vec2", ty.Of(vec2_alias), type::AddressSpace::kPrivate);
+ GlobalVar("my_f32", ty.Of(f32_alias), builtin::AddressSpace::kPrivate);
+ GlobalVar("my_vec2", ty.Of(vec2_alias), builtin::AddressSpace::kPrivate);
auto* tc = vec3<f32>("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 8559b9a..5e46134 100644
--- a/src/tint/resolver/type_validation_test.cc
+++ b/src/tint/resolver/type_validation_test.cc
@@ -95,7 +95,7 @@
TEST_F(ResolverTypeValidationTest, GlobalVariableWithAddressSpace_Pass) {
// var<private> global_var: f32;
- GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -111,9 +111,10 @@
// var global_var0 : f32 = 0.1;
// var global_var1 : i32 = 0;
- GlobalVar("global_var0", ty.f32(), type::AddressSpace::kPrivate, Expr(0.1_f));
+ GlobalVar("global_var0", ty.f32(), builtin::AddressSpace::kPrivate, Expr(0.1_f));
- GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), type::AddressSpace::kPrivate, Expr(1_f));
+ GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), builtin::AddressSpace::kPrivate,
+ Expr(1_f));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -129,7 +130,7 @@
Decl(Var("a", ty.f32(), Expr(2_f))),
});
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, Expr(2.1_f));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -193,19 +194,22 @@
TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Pass) {
// var<private> a : array<f32, 4>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)),
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) {
// var<private> a : array<f32, 4u>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)),
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) {
// var<private> a : array<f32, 4i>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)),
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -214,7 +218,7 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(4_u));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -223,34 +227,38 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(4_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Zero) {
// var<private> a : array<f32, 0>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)),
+ builtin::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<private> a : array<f32, 0u>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)),
+ builtin::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<private> a : array<f32, 0i>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)),
+ builtin::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<private> a : array<f32, -10i>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10_i)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10_i)),
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0");
}
@@ -260,7 +268,7 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(0_u));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
}
@@ -270,7 +278,7 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(0_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
}
@@ -280,14 +288,15 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(-10_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::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<private> a : array<f32, 10.0>;
- GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)),
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
r()->error(),
@@ -298,7 +307,7 @@
TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) {
// var<private> a : array<f32, vec2<i32>(10, 10)>;
GlobalVar("a", ty.array(ty.f32(), Call(Source{{12, 34}}, ty.vec2<i32>(), 10_i, 10_i)),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
r()->error(),
@@ -311,7 +320,7 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Expr(10_f));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
r()->error(),
@@ -324,7 +333,7 @@
// var<private> a : array<f32, size>;
GlobalConst("size", Call(ty.vec2<i32>(), 100_i, 100_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
r()->error(),
@@ -335,14 +344,14 @@
TEST_F(ResolverTypeValidationTest, ArraySize_UnderElementCountLimit) {
// var<private> a : array<f32, 65535>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a)),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) {
// var<private> a : array<f32, 65536>;
GlobalVar(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.f32(), Expr(65536_a)),
- type::AddressSpace::kPrivate);
+ builtin::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)");
@@ -351,7 +360,7 @@
TEST_F(ResolverTypeValidationTest, ArraySize_StorageBufferLargeArray) {
// var<storage> a : array<f32, 65536>;
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)),
- type::AddressSpace::kStorage, utils::Vector{Binding(0_u), Group(0_u)});
+ builtin::AddressSpace::kStorage, utils::Vector{Binding(0_u), Group(0_u)});
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -362,7 +371,7 @@
// var<storage> a : S;
Structure("S", utils::Vector{Member(Source{{12, 34}}, "a",
ty.array(Source{{12, 20}}, ty.f32(), 65536_a))});
- GlobalVar("a", ty(Source{{12, 30}}, "S"), type::AddressSpace::kStorage,
+ GlobalVar("a", ty(Source{{12, 30}}, "S"), builtin::AddressSpace::kStorage,
utils::Vector{Binding(0_u), Group(0_u)});
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -375,7 +384,7 @@
Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", ty.f32(),
utils::Vector{MemberOffset(800000_a)})});
GlobalVar("a", ty.array(ty(Source{{12, 30}}, "S"), Expr(Source{{12, 34}}, 65535_a)),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: array byte size (0xc34f7cafc) must not exceed 0xffffffff bytes");
@@ -385,7 +394,7 @@
// var<private> a : @stride(8000000) array<f32, 65535>;
GlobalVar("a",
ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a), utils::Vector{Stride(8000000)}),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: array byte size (0x7a1185ee00) must not exceed 0xffffffff bytes");
@@ -395,7 +404,7 @@
// override size = 10i;
// var<private> a : array<f32, size>;
Override("size", Expr(10_i));
- GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), builtin::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 "
@@ -407,7 +416,7 @@
// var<workgroup> a : array<array<f32, size>, 4>;
Override("size", Expr(10_i));
GlobalVar("a", ty.array(ty.array(Source{{12, 34}}, ty.f32(), "size"), 4_a),
- type::AddressSpace::kWorkgroup);
+ builtin::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 "
@@ -466,7 +475,7 @@
// var a = w;
// }
Override("size", Expr(10_i));
- GlobalVar("w", ty.array(ty.f32(), "size"), type::AddressSpace::kWorkgroup);
+ GlobalVar("w", ty.array(ty.f32(), "size"), builtin::AddressSpace::kWorkgroup);
Func("f", utils::Empty, ty.void_(),
utils::Vector{
Decl(Var("a", Expr(Source{{12, 34}}, "w"))),
@@ -484,7 +493,7 @@
// let a = w;
// }
Override("size", Expr(10_i));
- GlobalVar("w", ty.array(ty.f32(), "size"), type::AddressSpace::kWorkgroup);
+ GlobalVar("w", ty.array(ty.f32(), "size"), builtin::AddressSpace::kWorkgroup);
Func("f", utils::Empty, ty.void_(),
utils::Vector{
Decl(Let("a", Expr(Source{{12, 34}}, "w"))),
@@ -503,8 +512,8 @@
// a = b;
// }
Override("size", Expr(10_i));
- 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);
+ GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("b", ty.array(ty.f32(), Add("size", 1_i)), builtin::AddressSpace::kWorkgroup);
WrapInFunction(Assign(Source{{12, 34}}, "a", "b"));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -538,16 +547,16 @@
// var<workgroup> a : array<f32, size>;
Override("size", Expr(10_i));
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kWorkgroup);
+ builtin::AddressSpace::kWorkgroup);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) {
// var<private> size : i32 = 10i;
// var<private> a : array<f32, size>;
- GlobalVar("size", ty.i32(), Expr(10_i), type::AddressSpace::kPrivate);
+ GlobalVar("size", ty.i32(), Expr(10_i), builtin::AddressSpace::kPrivate);
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
R"(12:34 error: var 'size' cannot be referenced at module-scope
@@ -704,7 +713,7 @@
// var<private> a : array<Foo, 4>;
Structure("Foo", utils::Vector{Member("rt", ty.array<f32>())});
- GlobalVar("v", ty.array(ty(Source{{12, 34}}, "Foo"), 4_u), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.array(ty(Source{{12, 34}}, "Foo"), 4_u), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve()) << r()->error();
EXPECT_EQ(r()->error(),
@@ -750,7 +759,7 @@
TEST_F(ResolverTypeValidationTest, RuntimeArrayAsGlobalVariable) {
GlobalVar(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32()),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
ASSERT_FALSE(r()->Resolve());
@@ -799,7 +808,7 @@
// fn func(a : ptr<workgroup, array<u32>>) {}
auto* param = Param("a", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()),
- type::AddressSpace::kWorkgroup));
+ builtin::AddressSpace::kWorkgroup));
Func("func", utils::Vector{param}, ty.void_(),
utils::Vector{
@@ -864,7 +873,7 @@
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), type::AddressSpace::kPrivate);
+ GlobalVar("arr", ty.array(tex_ty, 4_i), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -872,9 +881,9 @@
}
TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) {
- auto ptr_ty = ty.pointer<u32>(Source{{12, 34}}, type::AddressSpace::kUniform);
+ auto ptr_ty = ty.pointer<u32>(Source{{12, 34}}, builtin::AddressSpace::kUniform);
GlobalVar("arr", ty.array(ptr_ty, 4_i, utils::Vector{Stride(16)}),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1235,7 +1244,7 @@
ast::Type el_ty = params.elem_ty(*this);
- GlobalVar("a", ty.mat(el_ty, params.columns, params.rows), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.mat(el_ty, params.columns, params.rows), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
@@ -1276,7 +1285,7 @@
ast::Type el_ty = params.elem_ty(*this);
GlobalVar("a", ty.mat(Source{{12, 34}}, el_ty, params.columns, params.rows),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: matrix element type must be 'f32' or 'f16'");
}
@@ -1318,7 +1327,7 @@
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), builtin::AddressSpace::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
@@ -1353,7 +1362,7 @@
Enable(builtin::Extension::kF16);
GlobalVar("a", ty.vec(Source{{12, 34}}, params.elem_ty(*this), params.width),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: vector element type must be 'bool', 'f32', 'f16', 'i32' "
@@ -1450,7 +1459,7 @@
// var<private> v : f32<true>;
Enable(builtin::Extension::kF16);
- GlobalVar("v", type::AddressSpace::kPrivate, ty(Source{{12, 34}}, GetParam(), true));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, ty(Source{{12, 34}}, GetParam(), true));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: type '" + std::string(GetParam()) +
@@ -1464,7 +1473,7 @@
Enable(builtin::Extension::kF16);
Alias(Source{{56, 78}}, "A", ty(GetParam()));
- GlobalVar("v", type::AddressSpace::kPrivate, ty(Source{{12, 34}}, "A", true));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, ty(Source{{12, 34}}, "A", true));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1517,7 +1526,7 @@
// var<private> v : S<true>;
Structure(Source{{56, 78}}, "S", utils::Vector{Member("i", ty.i32())});
- GlobalVar("v", type::AddressSpace::kPrivate, ty(Source{{12, 34}}, "S", true));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, ty(Source{{12, 34}}, "S", true));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
diff --git a/src/tint/resolver/uniformity.cc b/src/tint/resolver/uniformity.cc
index 1fe67c8..35763ef 100644
--- a/src/tint/resolver/uniformity.cc
+++ b/src/tint/resolver/uniformity.cc
@@ -1749,11 +1749,11 @@
auto var_type = [&](const sem::Variable* var) {
switch (var->AddressSpace()) {
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
return "read_write storage buffer ";
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
return "workgroup storage variable ";
- case type::AddressSpace::kPrivate:
+ case builtin::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 fbd0912..26154a7 100644
--- a/src/tint/resolver/uniformity_test.cc
+++ b/src/tint/resolver/uniformity_test.cc
@@ -5301,8 +5301,8 @@
}
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(), type::AddressSpace::kFunction)));
+ params.Push(b.Param("p" + std::to_string(i),
+ ty.pointer(ty.i32(), builtin::AddressSpace::kFunction)));
if (i > 0) {
foo_body.Push(b.Assign(b.Deref("p" + std::to_string(i)), "rhs"));
}
@@ -5321,7 +5321,7 @@
// workgroupBarrier();
// }
// }
- b.GlobalVar("non_uniform_global", ty.i32(), type::AddressSpace::kPrivate);
+ b.GlobalVar("non_uniform_global", ty.i32(), builtin::AddressSpace::kPrivate);
utils::Vector<const ast::Statement*, 8> main_body;
utils::Vector<const ast::Expression*, 8> args;
for (int i = 0; i < 255; i++) {
@@ -7847,7 +7847,7 @@
// workgroupBarrier();
// }
// }
- b.GlobalVar("v0", ty.i32(), type::AddressSpace::kPrivate, b.Expr(0_i));
+ b.GlobalVar("v0", ty.i32(), builtin::AddressSpace::kPrivate, b.Expr(0_i));
utils::Vector<const ast::Statement*, 8> 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 8ee795c..0e239dd 100644
--- a/src/tint/resolver/validation_test.cc
+++ b/src/tint/resolver/validation_test.cc
@@ -62,8 +62,8 @@
};
TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) {
- GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("dst", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("dst", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg"));
Func(Source{{9, 10}}, "f0", utils::Empty, ty.vec4<f32>(),
@@ -94,8 +94,8 @@
// f1();
//}
- GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("dst", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("dst", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg"));
Func(Source{{5, 6}}, "f2", utils::Empty, ty.void_(), utils::Vector{stmt});
@@ -192,7 +192,7 @@
// return;
// }
- GlobalVar("global_var", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
+ GlobalVar("global_var", ty.f32(), builtin::AddressSpace::kPrivate, Expr(2.1_f));
Func("my_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -266,7 +266,7 @@
}
TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) {
- auto* var = Var("var", ty.i32(), type::AddressSpace::kWorkgroup);
+ auto* var = Var("var", ty.i32(), builtin::AddressSpace::kWorkgroup);
Func("func", utils::Empty, ty.void_(),
utils::Vector{
@@ -280,7 +280,7 @@
}
TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) {
- auto* var = Var("s", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = Var("s", ty.i32(), builtin::AddressSpace::kPrivate);
Func("func", utils::Empty, ty.void_(),
utils::Vector{
@@ -295,7 +295,8 @@
TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) {
auto t = ty.sampler(type::SamplerKind::kSampler);
- GlobalVar(Source{{12, 34}}, "var", t, type::AddressSpace::kPrivate, Binding(0_a), Group(0_a));
+ GlobalVar(Source{{12, 34}}, "var", t, builtin::AddressSpace::kPrivate, Binding(0_a),
+ Group(0_a));
EXPECT_FALSE(r()->Resolve());
@@ -305,7 +306,8 @@
TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) {
auto t = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
- GlobalVar(Source{{12, 34}}, "var", t, type::AddressSpace::kFunction, Binding(0_a), Group(0_a));
+ GlobalVar(Source{{12, 34}}, "var", t, builtin::AddressSpace::kFunction, Binding(0_a),
+ Group(0_a));
EXPECT_FALSE(r()->Resolve()) << r()->error();
@@ -315,7 +317,7 @@
}
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) {
- GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", Ident(Source{{{3, 3}, {3, 7}}}, "xyqz"));
WrapInFunction(mem);
@@ -325,7 +327,7 @@
}
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_MixedChars) {
- GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", Ident(Source{{{3, 3}, {3, 7}}}, "rgyw"));
WrapInFunction(mem);
@@ -336,7 +338,7 @@
}
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) {
- GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", Ident(Source{{{3, 3}, {3, 8}}}, "zzzzz"));
WrapInFunction(mem);
@@ -346,7 +348,7 @@
}
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadIndex) {
- GlobalVar("my_vec", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
auto* mem = MemberAccessor("my_vec", Ident(Source{{3, 3}}, "z"));
WrapInFunction(mem);
@@ -377,7 +379,7 @@
// let x: f32 = (*p).z;
// return x;
// }
- auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
+ auto* p = Param("p", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction));
auto* star_p = Deref(p);
auto* accessor_expr = MemberAccessor(star_p, "z");
auto* x = Var("x", ty.f32(), accessor_expr);
@@ -394,7 +396,7 @@
// let x: f32 = *p.z;
// return x;
// }
- auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
+ auto* p = Param("p", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction));
auto* accessor_expr = MemberAccessor(p, Ident(Source{{12, 34}}, "z"));
auto* star_p = Deref(accessor_expr);
auto* x = Var("x", ty.f32(), star_p);
@@ -1231,8 +1233,9 @@
TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) {
auto* vf = Var("vf", ty.f32());
- auto* c = Call(Source{{12, 34}}, ty.pointer<i32>(type::AddressSpace::kFunction), ExprList(vf));
- auto* ip = Let("ip", ty.pointer<i32>(type::AddressSpace::kFunction), c);
+ auto* c =
+ Call(Source{{12, 34}}, ty.pointer<i32>(builtin::AddressSpace::kFunction), ExprList(vf));
+ auto* ip = Let("ip", ty.pointer<i32>(builtin::AddressSpace::kFunction), c);
WrapInFunction(Decl(vf), Decl(ip));
EXPECT_FALSE(r()->Resolve());
@@ -1240,21 +1243,22 @@
}
TEST_F(ResolverTest, I32_Overflow) {
- GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a));
+ GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(12:24 error: value 2147483648 cannot be represented as 'i32')");
}
TEST_F(ResolverTest, I32_Underflow) {
- GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, -2147483649_a));
+ GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate,
+ Expr(Source{{12, 24}}, -2147483649_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(12:24 error: value -2147483649 cannot be represented as 'i32')");
}
TEST_F(ResolverTest, U32_Overflow) {
- GlobalVar("v", ty.u32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a));
+ GlobalVar("v", ty.u32(), builtin::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(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 c7f790b..242a462 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -288,7 +288,7 @@
}
bool Validator::Pointer(const ast::TemplatedIdentifier* a, const type::Pointer* s) const {
- if (s->AddressSpace() == type::AddressSpace::kUndefined) {
+ if (s->AddressSpace() == builtin::AddressSpace::kUndefined) {
AddError("ptr missing address space", a->source);
return false;
}
@@ -298,7 +298,7 @@
// 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 (s->AddressSpace() != type::AddressSpace::kStorage) {
+ if (s->AddressSpace() != builtin::AddressSpace::kStorage) {
AddError("only pointers in <storage> address space may specify an access mode",
a->source);
return false;
@@ -373,7 +373,7 @@
}
bool Validator::VariableInitializer(const ast::Variable* v,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
const type::Type* storage_ty,
const sem::ValueExpression* initializer) const {
auto* initializer_ty = initializer->Type();
@@ -390,8 +390,8 @@
if (v->Is<ast::Var>()) {
switch (address_space) {
- case type::AddressSpace::kPrivate:
- case type::AddressSpace::kFunction:
+ case builtin::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kFunction:
break; // Allowed an initializer
default:
// https://gpuweb.github.io/gpuweb/wgsl/#var-and-let
@@ -409,17 +409,17 @@
}
bool Validator::AddressSpaceLayout(const type::Type* store_ty,
- type::AddressSpace address_space,
+ builtin::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 == type::AddressSpace::kUniform &&
+ return address_space == builtin::AddressSpace::kUniform &&
ty->IsAnyOf<type::Array, sem::Struct>();
};
auto is_uniform_struct = [address_space](const type::Type* ty) {
- return address_space == type::AddressSpace::kUniform && ty->Is<sem::Struct>();
+ return address_space == builtin::AddressSpace::kUniform && ty->Is<sem::Struct>();
};
auto required_alignment_of = [&](const type::Type* ty) {
@@ -440,7 +440,7 @@
return true;
}
- if (!type::IsHostShareable(address_space)) {
+ if (!builtin::IsHostShareable(address_space)) {
return true;
}
@@ -453,7 +453,7 @@
// 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::F16>(type::Type::DeepestElementOf(store_ty)) &&
- address_space == type::AddressSpace::kPushConstant) {
+ address_space == builtin::AddressSpace::kPushConstant) {
AddError("using f16 types in 'push_constant' address space is not implemented yet", source);
return false;
}
@@ -530,7 +530,7 @@
return false;
}
- if (address_space == type::AddressSpace::kUniform) {
+ if (address_space == builtin::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) {
@@ -596,7 +596,7 @@
const sem::GlobalVariable* global,
const utils::Hashmap<OverrideId, const sem::Variable*, 8>& override_ids) const {
auto* decl = global->Declaration();
- if (global->AddressSpace() != type::AddressSpace::kWorkgroup &&
+ if (global->AddressSpace() != builtin::AddressSpace::kWorkgroup &&
IsArrayWithOverrideCount(global->Type())) {
RaiseArrayWithOverrideCountError(decl->type ? decl->type->source
: decl->initializer->source);
@@ -624,8 +624,8 @@
bool is_shader_io_attribute =
attr->IsAnyOf<ast::BuiltinAttribute, ast::InterpolateAttribute,
ast::InvariantAttribute, ast::LocationAttribute>();
- bool has_io_address_space = global->AddressSpace() == type::AddressSpace::kIn ||
- global->AddressSpace() == type::AddressSpace::kOut;
+ bool has_io_address_space = global->AddressSpace() == builtin::AddressSpace::kIn ||
+ global->AddressSpace() == builtin::AddressSpace::kOut;
if (!attr->IsAnyOf<ast::BindingAttribute, ast::GroupAttribute,
ast::InternalAttribute>() &&
(!is_shader_io_attribute || !has_io_address_space)) {
@@ -657,15 +657,15 @@
return false;
}
- if (global->AddressSpace() == type::AddressSpace::kFunction) {
+ if (global->AddressSpace() == builtin::AddressSpace::kFunction) {
AddError("module-scope 'var' must not use address space 'function'", decl->source);
return false;
}
switch (global->AddressSpace()) {
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kHandle: {
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kStorage:
+ case builtin::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()) {
@@ -714,7 +714,7 @@
// 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 (v->AddressSpace() != type::AddressSpace::kStorage) {
+ if (v->AddressSpace() != builtin::AddressSpace::kStorage) {
AddError("only variables in <storage> address space may specify an access mode",
var->source);
return false;
@@ -727,8 +727,8 @@
}
if (IsValidationEnabled(var->attributes, ast::DisabledValidation::kIgnoreAddressSpace) &&
- (v->AddressSpace() == type::AddressSpace::kIn ||
- v->AddressSpace() == type::AddressSpace::kOut)) {
+ (v->AddressSpace() == builtin::AddressSpace::kIn ||
+ v->AddressSpace() == builtin::AddressSpace::kOut)) {
AddError("invalid use of input/output address space", var->source);
return false;
}
@@ -822,13 +822,13 @@
auto sc = ref->AddressSpace();
switch (sc) {
- case type::AddressSpace::kFunction:
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kFunction:
+ case builtin::AddressSpace::kPrivate:
ok = true;
break;
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kWorkgroup:
ok = enabled_extensions_.Contains(
builtin::Extension::kChromiumExperimentalFullPtrParameters);
break;
@@ -1883,7 +1883,7 @@
auto stage = entry_point->Declaration()->PipelineStage();
if (stage != ast::PipelineStage::kCompute) {
for (auto* var : func->DirectlyReferencedGlobals()) {
- if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
+ if (var->AddressSpace() == builtin::AddressSpace::kWorkgroup) {
std::stringstream stage_name;
stage_name << stage;
for (auto* user : var->Users()) {
@@ -1969,7 +1969,7 @@
auto check_push_constant = [&](const sem::Function* func, const sem::Function* ep) {
for (auto* var : func->DirectlyReferencedGlobals()) {
- if (var->AddressSpace() != type::AddressSpace::kPushConstant ||
+ if (var->AddressSpace() != builtin::AddressSpace::kPushConstant ||
var == push_constant_var) {
continue;
}
@@ -2506,14 +2506,14 @@
bool Validator::CheckTypeAccessAddressSpace(
const type::Type* store_ty,
builtin::Access access,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
utils::VectorRef<const tint::ast::Attribute*> attributes,
const Source& source) const {
if (!AddressSpaceLayout(store_ty, address_space, source)) {
return false;
}
- if (address_space == type::AddressSpace::kPushConstant &&
+ if (address_space == builtin::AddressSpace::kPushConstant &&
!enabled_extensions_.Contains(builtin::Extension::kChromiumExperimentalPushConstant) &&
IsValidationEnabled(attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
AddError(
@@ -2523,7 +2523,7 @@
return false;
}
- if (address_space == type::AddressSpace::kStorage && access == builtin::Access::kWrite) {
+ if (address_space == builtin::AddressSpace::kStorage && access == builtin::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);
@@ -2531,11 +2531,11 @@
}
auto atomic_error = [&]() -> const char* {
- if (address_space != type::AddressSpace::kStorage &&
- address_space != type::AddressSpace::kWorkgroup) {
+ if (address_space != builtin::AddressSpace::kStorage &&
+ address_space != builtin::AddressSpace::kWorkgroup) {
return "atomic variables must have <storage> or <workgroup> address space";
}
- if (address_space == type::AddressSpace::kStorage &&
+ if (address_space == builtin::AddressSpace::kStorage &&
access != builtin::Access::kReadWrite) {
return "atomic variables in <storage> address space must have read_write access "
"mode";
diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h
index 55be986..6757c06 100644
--- a/src/tint/resolver/validator.h
+++ b/src/tint/resolver/validator.h
@@ -75,7 +75,7 @@
/// The type
const type::Type* type;
/// The address space
- type::AddressSpace address_space;
+ builtin::AddressSpace address_space;
/// Equality operator
/// @param other the other TypeAndAddressSpace to compare this TypeAndAddressSpace to
@@ -435,7 +435,7 @@
/// @param initializer the RHS initializer expression
/// @returns true on succes, false otherwise
bool VariableInitializer(const ast::Variable* v,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
const type::Type* storage_type,
const sem::ValueExpression* initializer) const;
@@ -488,7 +488,7 @@
/// @param sc the address space
/// @param source the source of the type
/// @returns true on success, false otherwise
- bool AddressSpaceLayout(const type::Type* type, type::AddressSpace sc, Source source) const;
+ bool AddressSpaceLayout(const type::Type* type, builtin::AddressSpace sc, Source source) const;
/// @returns true if the attribute list contains a
/// ast::DisableValidationAttribute with the validation mode equal to
@@ -543,7 +543,7 @@
/// @returns true on success, false if an error was raised.
bool CheckTypeAccessAddressSpace(const type::Type* store_ty,
builtin::Access access,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
utils::VectorRef<const tint::ast::Attribute*> 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 558953e..d01d21c 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, Pointer) {
- auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
+ auto* ptr = create<type::Pointer>(create<type::I32>(), builtin::AddressSpace::kPrivate,
builtin::Access::kReadWrite);
EXPECT_FALSE(v()->IsStorable(ptr));
}
diff --git a/src/tint/resolver/variable_test.cc b/src/tint/resolver/variable_test.cc
index dbfc94f..7af6027 100644
--- a/src/tint/resolver/variable_test.cc
+++ b/src/tint/resolver/variable_test.cc
@@ -238,7 +238,7 @@
// var a = a;
// }
- auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* g = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* v = Var("a", Expr("a"));
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(v)});
@@ -421,7 +421,7 @@
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<i32>(type::AddressSpace::kFunction), p_c);
+ auto* p = Let("p", ty.pointer<i32>(builtin::AddressSpace::kFunction), p_c);
Func("F", utils::Empty, ty.void_(),
utils::Vector{
@@ -472,7 +472,7 @@
// }
auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))});
- auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage,
+ auto* storage = GlobalVar("s", ty.Of(buf), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Binding(0_a), Group(0_a));
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 3_i);
@@ -554,7 +554,7 @@
// let a = a;
// }
- auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* g = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* l = Let("a", Expr("a"));
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(l)});
@@ -766,7 +766,7 @@
// const a = 1i;
// }
- auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* g = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* c = Const("a", Expr(1_i));
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(c)});
@@ -1037,12 +1037,12 @@
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
- auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate);
- auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup);
+ auto* private_ = GlobalVar("p", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* workgroup = GlobalVar("w", ty.i32(), builtin::AddressSpace::kWorkgroup);
auto* uniform =
- GlobalVar("ub", ty.Of(buf), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
+ GlobalVar("ub", ty.Of(buf), builtin::AddressSpace::kUniform, Binding(0_a), Group(0_a));
auto* storage =
- GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage, Binding(1_a), Group(0_a));
+ GlobalVar("sb", ty.Of(buf), builtin::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 @@
// 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), type::AddressSpace::kStorage,
+ auto* storage = GlobalVar("sb", ty.Of(buf), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite, Binding(1_a), Group(0_a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -1222,7 +1222,7 @@
// fn F(a : bool) {
// }
- auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* g = GlobalVar("a", ty.i32(), builtin::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 1d0837d..6ca3a08 100644
--- a/src/tint/resolver/variable_validation_test.cc
+++ b/src/tint/resolver/variable_validation_test.cc
@@ -61,8 +61,8 @@
TEST_F(ResolverVariableValidationTest, GlobalVarUsedAtModuleScope) {
// var<private> a : i32;
// var<private> b : i32 = a;
- GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a"));
+ GlobalVar(Source{{12, 34}}, "a", ty.i32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.i32(), builtin::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 @@
// var i : i32;
// var p : pointer<function, i32> = &v;
auto* i = Var("i", ty.i32());
- auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, type::AddressSpace::kFunction),
- type::AddressSpace::kUndefined, AddressOf(Source{{12, 34}}, "i"));
+ auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, builtin::AddressSpace::kFunction),
+ builtin::AddressSpace::kUndefined, AddressOf(Source{{12, 34}}, "i"));
WrapInFunction(i, p);
EXPECT_FALSE(r()->Resolve());
@@ -205,7 +205,7 @@
TEST_F(ResolverVariableValidationTest, LetOfPtrConstructedWithRef) {
// var a : f32;
// let b : ptr<function,f32> = a;
- const auto priv = type::AddressSpace::kFunction;
+ const auto priv = builtin::AddressSpace::kFunction;
auto* var_a = Var("a", ty.f32(), priv);
auto* var_b = Let(Source{{12, 34}}, "b", ty.pointer<f32>(priv), Expr("a"));
WrapInFunction(var_a, var_b);
@@ -236,7 +236,7 @@
// return 0;
// }
- GlobalVar("v", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
+ GlobalVar("v", ty.f32(), builtin::AddressSpace::kPrivate, Expr(2.1_f));
WrapInFunction(Var(Source{{12, 34}}, "v", ty.f32(), Expr(2_f)));
@@ -295,11 +295,11 @@
Member("inner", ty.Of(inner)),
});
auto* storage =
- GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
+ GlobalVar("s", ty.Of(buf), builtin::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<i32>(type::AddressSpace::kStorage, builtin::Access::kReadWrite),
+ ty.pointer<i32>(builtin::AddressSpace::kStorage, builtin::Access::kReadWrite),
AddressOf(expr));
WrapInFunction(ptr);
@@ -359,7 +359,7 @@
TEST_F(ResolverVariableValidationTest, InvalidAddressSpaceForInitializer) {
// var<workgroup> v : f32 = 1.23;
- GlobalVar(Source{{12, 34}}, "v", ty.f32(), type::AddressSpace::kWorkgroup, Expr(1.23_f));
+ GlobalVar(Source{{12, 34}}, "v", ty.f32(), builtin::AddressSpace::kWorkgroup, Expr(1.23_f));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -489,7 +489,7 @@
// enable chromium_experimental_push_constant;
// var<push_constant> a : u32 = 0u;
Enable(builtin::Extension::kChromiumExperimentalPushConstant);
- GlobalVar(Source{{1u, 2u}}, "a", ty.u32(), type::AddressSpace::kPushConstant,
+ GlobalVar(Source{{1u, 2u}}, "a", ty.u32(), builtin::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 e7bf889..5191c5f 100644
--- a/src/tint/sem/function.cc
+++ b/src/tint/sem/function.cc
@@ -69,7 +69,7 @@
VariableBindings ret;
for (auto* global : TransitivelyReferencedGlobals()) {
- if (global->AddressSpace() != type::AddressSpace::kUniform) {
+ if (global->AddressSpace() != builtin::AddressSpace::kUniform) {
continue;
}
@@ -84,7 +84,7 @@
VariableBindings ret;
for (auto* global : TransitivelyReferencedGlobals()) {
- if (global->AddressSpace() != type::AddressSpace::kStorage) {
+ if (global->AddressSpace() != builtin::AddressSpace::kStorage) {
continue;
}
diff --git a/src/tint/sem/struct.h b/src/tint/sem/struct.h
index 42a1117..d1d20cc 100644
--- a/src/tint/sem/struct.h
+++ b/src/tint/sem/struct.h
@@ -18,8 +18,8 @@
#include <optional>
#include "src/tint/ast/struct.h"
+#include "src/tint/builtin/address_space.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 e3f5f75..8f8248c 100644
--- a/src/tint/sem/variable.cc
+++ b/src/tint/sem/variable.cc
@@ -31,7 +31,7 @@
Variable::Variable(const ast::Variable* declaration,
const type::Type* type,
EvaluationStage stage,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const constant::Value* constant_value)
: declaration_(declaration),
@@ -46,7 +46,7 @@
LocalVariable::LocalVariable(const ast::Variable* declaration,
const type::Type* type,
EvaluationStage stage,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const sem::Statement* statement,
const constant::Value* constant_value)
@@ -58,7 +58,7 @@
GlobalVariable::GlobalVariable(const ast::Variable* declaration,
const type::Type* type,
EvaluationStage stage,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const constant::Value* constant_value,
sem::BindingPoint binding_point,
@@ -72,7 +72,7 @@
Parameter::Parameter(const ast::Parameter* declaration,
uint32_t index,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::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 fcaf145..701a3f1 100644
--- a/src/tint/sem/variable.h
+++ b/src/tint/sem/variable.h
@@ -23,10 +23,10 @@
#include "src/tint/ast/parameter.h"
#include "src/tint/builtin/access.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/sem/binding_point.h"
#include "src/tint/sem/parameter_usage.h"
#include "src/tint/sem/value_expression.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 @@
Variable(const ast::Variable* declaration,
const type::Type* type,
EvaluationStage stage,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const constant::Value* constant_value);
@@ -74,7 +74,7 @@
EvaluationStage Stage() const { return stage_; }
/// @returns the address space for the variable
- type::AddressSpace AddressSpace() const { return address_space_; }
+ builtin::AddressSpace AddressSpace() const { return address_space_; }
/// @returns the access control for the variable
builtin::Access Access() const { return access_; }
@@ -100,7 +100,7 @@
const ast::Variable* const declaration_;
const type::Type* const type_;
const EvaluationStage stage_;
- const type::AddressSpace address_space_;
+ const builtin::AddressSpace address_space_;
const builtin::Access access_;
const constant::Value* constant_value_;
const ValueExpression* initializer_ = nullptr;
@@ -121,7 +121,7 @@
LocalVariable(const ast::Variable* declaration,
const type::Type* type,
EvaluationStage stage,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const sem::Statement* statement,
const constant::Value* constant_value);
@@ -162,7 +162,7 @@
GlobalVariable(const ast::Variable* declaration,
const type::Type* type,
EvaluationStage stage,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const constant::Value* constant_value,
sem::BindingPoint binding_point = {},
@@ -205,7 +205,7 @@
Parameter(const ast::Parameter* declaration,
uint32_t index,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::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 2b1ec31..c63bd04 100644
--- a/src/tint/transform/add_block_attribute.cc
+++ b/src/tint/transform/add_block_attribute.cc
@@ -47,7 +47,7 @@
bool made_changes = false;
for (auto* global : src->AST().GlobalVariables()) {
auto* var = sem.Get(global);
- if (!type::IsHostShareable(var->AddressSpace())) {
+ if (!builtin::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 444a328..78535f1 100644
--- a/src/tint/transform/array_length_from_uniform.cc
+++ b/src/tint/transform/array_length_from_uniform.cc
@@ -106,10 +106,10 @@
b.ty.array(b.ty.vec4(b.ty.u32()),
u32((max_buffer_size_index / 4) + 1))),
});
- buffer_size_ubo =
- 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)));
+ buffer_size_ubo = b.GlobalVar(b.Sym(), b.ty.Of(buffer_size_struct),
+ builtin::AddressSpace::kUniform,
+ b.Group(AInt(cfg->ubo_binding.group)),
+ b.Binding(AInt(cfg->ubo_binding.binding)));
}
return buffer_size_ubo;
};
diff --git a/src/tint/transform/binding_remapper.cc b/src/tint/transform/binding_remapper.cc
index e4f2e6e..ecbd5cd 100644
--- a/src/tint/transform/binding_remapper.cc
+++ b/src/tint/transform/binding_remapper.cc
@@ -131,7 +131,7 @@
return Program(std::move(b));
}
auto* sem = src->Sem().Get(var);
- if (sem->AddressSpace() != type::AddressSpace::kStorage) {
+ if (sem->AddressSpace() != builtin::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 917d418..2da1a84 100644
--- a/src/tint/transform/builtin_polyfill.cc
+++ b/src/tint/transform/builtin_polyfill.cc
@@ -679,7 +679,7 @@
auto name = b.Symbols().New("tint_workgroupUniformLoad");
b.Func(name,
utils::Vector{
- b.Param("p", b.ty.pointer(T(type), type::AddressSpace::kWorkgroup)),
+ b.Param("p", b.ty.pointer(T(type), builtin::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 5ed6547..a25c89e 100644
--- a/src/tint/transform/calculate_array_length.cc
+++ b/src/tint/transform/calculate_array_length.cc
@@ -112,7 +112,7 @@
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(), type::AddressSpace::kFunction)),
+ b.Param("result", b.ty.pointer(b.ty.u32(), builtin::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 049e9ca..2df7966 100644
--- a/src/tint/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/transform/canonicalize_entry_point_io.cc
@@ -234,7 +234,7 @@
auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attributes);
if (cfg.shader_style == ShaderStyle::kGlsl && builtin) {
name = GLSLBuiltinToString(builtin->builtin, func_ast->PipelineStage(),
- type::AddressSpace::kIn);
+ builtin::AddressSpace::kIn);
}
auto symbol = ctx.dst->Symbols().New(name);
@@ -251,7 +251,7 @@
value = ctx.dst->IndexAccessor(value, 0_i);
}
}
- ctx.dst->GlobalVar(symbol, ast_type, type::AddressSpace::kIn, std::move(attributes));
+ ctx.dst->GlobalVar(symbol, ast_type, builtin::AddressSpace::kIn, std::move(attributes));
return value;
} else if (cfg.shader_style == ShaderStyle::kMsl &&
ast::HasAttribute<ast::BuiltinAttribute>(attributes)) {
@@ -300,7 +300,7 @@
if (cfg.shader_style == ShaderStyle::kGlsl) {
if (auto* b = ast::GetAttribute<ast::BuiltinAttribute>(attributes)) {
name = GLSLBuiltinToString(b->builtin, func_ast->PipelineStage(),
- type::AddressSpace::kOut);
+ builtin::AddressSpace::kOut);
value = ToGLSLBuiltin(b->builtin, value, type);
}
}
@@ -532,7 +532,7 @@
type = ctx.dst->ty.array(type, 1_u);
lhs = ctx.dst->IndexAccessor(lhs, 0_i);
}
- ctx.dst->GlobalVar(name, type, type::AddressSpace::kOut, std::move(attributes));
+ ctx.dst->GlobalVar(name, type, builtin::AddressSpace::kOut, std::move(attributes));
wrapper_body.Push(ctx.dst->Assign(lhs, outval.value));
}
}
@@ -677,7 +677,7 @@
/// @returns the gl_ string corresponding to that builtin
const char* GLSLBuiltinToString(builtin::BuiltinValue builtin,
ast::PipelineStage stage,
- type::AddressSpace address_space) {
+ builtin::AddressSpace address_space) {
switch (builtin) {
case builtin::BuiltinValue::kPosition:
switch (stage) {
@@ -709,7 +709,7 @@
case builtin::BuiltinValue::kSampleIndex:
return "gl_SampleID";
case builtin::BuiltinValue::kSampleMask:
- if (address_space == type::AddressSpace::kIn) {
+ if (address_space == builtin::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 8d84ed3..951dc30 100644
--- a/src/tint/transform/clamp_frag_depth.cc
+++ b/src/tint/transform/clamp_frag_depth.cc
@@ -89,7 +89,7 @@
for (auto* global : src->AST().GlobalVariables()) {
if (auto* var = global->As<ast::Var>()) {
auto* v = src->Sem().Get(var);
- if (TINT_UNLIKELY(v->AddressSpace() == type::AddressSpace::kPushConstant)) {
+ if (TINT_UNLIKELY(v->AddressSpace() == builtin::AddressSpace::kPushConstant)) {
TINT_ICE(Transform, b.Diagnostics())
<< "ClampFragDepth doesn't know how to handle module that already use push "
"constants";
@@ -124,7 +124,7 @@
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("FragDepthClampArgs"), type::AddressSpace::kPushConstant);
+ b.GlobalVar(args_sym, b.ty("FragDepthClampArgs"), builtin::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 47cefcf..b3c2292 100644
--- a/src/tint/transform/decompose_memory_access.cc
+++ b/src/tint/transform/decompose_memory_access.cc
@@ -49,8 +49,8 @@
bool ShouldRun(const Program* program) {
for (auto* decl : program->AST().GlobalDeclarations()) {
if (auto* var = program->Sem().Get<sem::Variable>(decl)) {
- if (var->AddressSpace() == type::AddressSpace::kStorage ||
- var->AddressSpace() == type::AddressSpace::kUniform) {
+ if (var->AddressSpace() == builtin::AddressSpace::kStorage ||
+ var->AddressSpace() == builtin::AddressSpace::kUniform) {
return true;
}
}
@@ -108,10 +108,10 @@
/// LoadStoreKey is the unordered map key to a load or store intrinsic.
struct LoadStoreKey {
- type::AddressSpace const address_space; // buffer address space
- builtin::Access const access; // buffer access
- type::Type const* buf_ty = nullptr; // buffer type
- type::Type const* el_ty = nullptr; // element type
+ builtin::AddressSpace const address_space; // buffer address space
+ builtin::Access const access; // buffer access
+ type::Type const* buf_ty = nullptr; // buffer type
+ type::Type const* el_ty = nullptr; // element type
bool operator==(const LoadStoreKey& rhs) const {
return address_space == rhs.address_space && access == rhs.access && buf_ty == rhs.buf_ty &&
el_ty == rhs.el_ty;
@@ -222,7 +222,7 @@
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied
/// to a stub function to load the type `ty`.
DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
const type::Type* ty) {
DecomposeMemoryAccess::Intrinsic::DataType type;
if (!IntrinsicDataTypeFor(ty, type)) {
@@ -236,7 +236,7 @@
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied
/// to a stub function to store the type `ty`.
DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
const type::Type* ty) {
DecomposeMemoryAccess::Intrinsic::DataType type;
if (!IntrinsicDataTypeFor(ty, type)) {
@@ -299,7 +299,7 @@
return nullptr;
}
return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
- builder->ID(), builder->AllocateNodeID(), op, type::AddressSpace::kStorage, type);
+ builder->ID(), builder->AllocateNodeID(), op, builtin::AddressSpace::kStorage, type);
}
/// BufferAccess describes a single storage or uniform buffer access
@@ -465,7 +465,7 @@
const sem::VariableUser* var_user) {
auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access();
- if (address_space != type::AddressSpace::kStorage) {
+ if (address_space != builtin::AddressSpace::kStorage) {
access = builtin::Access::kUndefined;
}
return utils::GetOrCreate(
@@ -561,7 +561,7 @@
const sem::VariableUser* var_user) {
auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access();
- if (address_space != type::AddressSpace::kStorage) {
+ if (address_space != builtin::AddressSpace::kStorage) {
access = builtin::Access::kUndefined;
}
return utils::GetOrCreate(
@@ -671,7 +671,7 @@
auto op = intrinsic->Type();
auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access();
- if (address_space != type::AddressSpace::kStorage) {
+ if (address_space != builtin::AddressSpace::kStorage) {
access = builtin::Access::kUndefined;
}
return utils::GetOrCreate(atomic_funcs, AtomicKey{access, buf_ty, el_ty, op}, [&] {
@@ -679,7 +679,7 @@
// atomic. This is replaced with two parameters: the buffer and offset.
utils::Vector params{
b.Param("buffer",
- b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), type::AddressSpace::kStorage,
+ b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), builtin::AddressSpace::kStorage,
access),
utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}),
b.Param("offset", b.ty.u32()),
@@ -734,7 +734,7 @@
DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid,
ast::NodeID nid,
Op o,
- type::AddressSpace sc,
+ builtin::AddressSpace sc,
DataType ty)
: Base(pid, nid), op(o), address_space(sc), type(ty) {}
DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default;
@@ -873,8 +873,8 @@
// X
if (auto* sem_ident = sem.GetVal(ident)) {
if (auto* var = sem_ident->UnwrapLoad()->As<sem::VariableUser>()) {
- if (var->Variable()->AddressSpace() == type::AddressSpace::kStorage ||
- var->Variable()->AddressSpace() == type::AddressSpace::kUniform) {
+ if (var->Variable()->AddressSpace() == builtin::AddressSpace::kStorage ||
+ var->Variable()->AddressSpace() == builtin::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 3a51035..b251ed8 100644
--- a/src/tint/transform/decompose_memory_access.h
+++ b/src/tint/transform/decompose_memory_access.h
@@ -81,7 +81,7 @@
/// @param o the op of the intrinsic
/// @param sc the address space of the buffer
/// @param ty the data type of the intrinsic
- Intrinsic(ProgramID pid, ast::NodeID nid, Op o, type::AddressSpace sc, DataType ty);
+ Intrinsic(ProgramID pid, ast::NodeID nid, Op o, builtin::AddressSpace sc, DataType ty);
/// Destructor
~Intrinsic() override;
@@ -101,7 +101,7 @@
const Op op;
/// The address space of the buffer this intrinsic operates on
- type::AddressSpace const address_space;
+ builtin::AddressSpace const address_space;
/// The type of the intrinsic
const DataType type;
diff --git a/src/tint/transform/decompose_strided_array_test.cc b/src/tint/transform/decompose_strided_array_test.cc
index bd4b49f..54c00b7 100644
--- a/src/tint/transform/decompose_strided_array_test.cc
+++ b/src/tint/transform/decompose_strided_array_test.cc
@@ -39,7 +39,7 @@
// var<private> arr : array<f32, 4u>
ProgramBuilder b;
- b.GlobalVar("arr", b.ty.array<f32, 4u>(), type::AddressSpace::kPrivate);
+ b.GlobalVar("arr", b.ty.array<f32, 4u>(), builtin::AddressSpace::kPrivate);
EXPECT_FALSE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
}
@@ -51,7 +51,7 @@
b.ty.array<f32, 4u>(utils::Vector{
b.Stride(4),
}),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
}
@@ -63,7 +63,7 @@
b.ty.array<f32, 4u>(utils::Vector{
b.Stride(16),
}),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
}
@@ -90,7 +90,7 @@
b.ty.array<f32, 4u>(utils::Vector{
b.Stride(4),
}),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
b.Decl(b.Let("a",
@@ -134,7 +134,7 @@
b.ty.array<f32, 4u>(utils::Vector{
b.Stride(32),
}),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
b.Decl(b.Let("a",
@@ -184,7 +184,7 @@
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(utils::Vector{
b.Stride(32),
}))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::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",
@@ -239,7 +239,7 @@
utils::Vector{
b.Stride(16),
}))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func(
"f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -292,7 +292,7 @@
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(utils::Vector{
b.Stride(32),
}))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::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",
@@ -346,7 +346,7 @@
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(utils::Vector{
b.Stride(4),
}))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::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",
@@ -396,7 +396,7 @@
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(utils::Vector{
b.Stride(32),
}))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -458,7 +458,7 @@
b.Stride(4),
})),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -516,7 +516,7 @@
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(utils::Vector{
b.Stride(32),
}))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -582,7 +582,7 @@
b.Stride(32),
}));
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty("ARR"))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -658,7 +658,7 @@
b.Stride(128),
}));
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty("ARR_B"))});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
diff --git a/src/tint/transform/decompose_strided_matrix.cc b/src/tint/transform/decompose_strided_matrix.cc
index 4642c57..dd03dc2 100644
--- a/src/tint/transform/decompose_strided_matrix.cc
+++ b/src/tint/transform/decompose_strided_matrix.cc
@@ -74,8 +74,8 @@
for (auto* node : src->ASTNodes().Objects()) {
if (auto* str = node->As<ast::Struct>()) {
auto* str_ty = src->Sem().Get(str);
- if (!str_ty->UsedAs(type::AddressSpace::kUniform) &&
- !str_ty->UsedAs(type::AddressSpace::kStorage)) {
+ if (!str_ty->UsedAs(builtin::AddressSpace::kUniform) &&
+ !str_ty->UsedAs(builtin::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 0da9e71..12ca02e 100644
--- a/src/tint/transform/decompose_strided_matrix_test.cc
+++ b/src/tint/transform/decompose_strided_matrix_test.cc
@@ -76,7 +76,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::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<f32>(), b.MemberAccessor("s", "m"))),
@@ -133,7 +133,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
b.Func(
"f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -187,7 +187,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("s", b.ty.Of(S), builtin::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<f32>(), b.MemberAccessor("s", "m"))),
@@ -241,7 +241,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -299,7 +299,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func(
"f", utils::Empty, b.ty.void_(),
@@ -354,7 +354,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -413,7 +413,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -473,7 +473,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
b.Group(0_a), b.Binding(0_a));
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
@@ -545,7 +545,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kPrivate);
+ b.GlobalVar("s", b.ty.Of(S), builtin::AddressSpace::kPrivate);
b.Func("f", utils::Empty, b.ty.void_(),
utils::Vector{
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
@@ -599,7 +599,7 @@
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
}),
});
- b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kPrivate);
+ b.GlobalVar("s", b.ty.Of(S), builtin::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 dc5384b..ac3c15e 100644
--- a/src/tint/transform/demote_to_helper.cc
+++ b/src/tint/transform/demote_to_helper.cc
@@ -81,7 +81,7 @@
// Create a module-scope flag that indicates whether the current invocation has been discarded.
auto flag = b.Symbols().New("tint_discarded");
- b.GlobalVar(flag, type::AddressSpace::kPrivate, b.Expr(false));
+ b.GlobalVar(flag, builtin::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 @@
// Skip writes to invocation-private address spaces.
auto* ref = sem.GetVal(assign->lhs)->Type()->As<type::Reference>();
switch (ref->AddressSpace()) {
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
// Need to mask these.
break;
- case type::AddressSpace::kFunction:
- case type::AddressSpace::kPrivate:
- case type::AddressSpace::kOut:
+ case builtin::AddressSpace::kFunction:
+ case builtin::AddressSpace::kPrivate:
+ case builtin::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 8ae3e22..a6ef9d8 100644
--- a/src/tint/transform/direct_variable_access.cc
+++ b/src/tint/transform/direct_variable_access.cc
@@ -50,7 +50,7 @@
/// 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::type::AddressSpace address_space = tint::type::AddressSpace::kUndefined;
+ tint::builtin::AddressSpace address_space = tint::builtin::AddressSpace::kUndefined;
};
/// Inequality operator for AccessRoot
@@ -450,7 +450,7 @@
Switch(
variable->Declaration(),
[&](const ast::Var*) {
- if (variable->AddressSpace() != type::AddressSpace::kHandle) {
+ if (variable->AddressSpace() != builtin::AddressSpace::kHandle) {
// Start a new access chain for the non-handle 'var' access
create_new_chain();
}
@@ -749,15 +749,15 @@
/// @returns true if the address space @p address_space requires transforming given the
/// transform's options.
- bool AddressSpaceRequiresTransform(type::AddressSpace address_space) const {
+ bool AddressSpaceRequiresTransform(builtin::AddressSpace address_space) const {
switch (address_space) {
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kWorkgroup:
return true;
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kPrivate:
return opts.transform_private;
- case type::AddressSpace::kFunction:
+ case builtin::AddressSpace::kFunction:
return opts.transform_function;
default:
return false;
@@ -1180,9 +1180,9 @@
for (auto* param : fn->Parameters()) {
if (auto* ptr = param->Type()->As<type::Pointer>()) {
switch (ptr->AddressSpace()) {
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kWorkgroup:
return true;
default:
return false;
@@ -1193,8 +1193,8 @@
}
/// @returns true if the given address space is 'private' or 'function'.
- static bool IsPrivateOrFunction(const type::AddressSpace sc) {
- return sc == type::AddressSpace::kPrivate || sc == type::AddressSpace::kFunction;
+ static bool IsPrivateOrFunction(const builtin::AddressSpace sc) {
+ return sc == builtin::AddressSpace::kPrivate || sc == builtin::AddressSpace::kFunction;
}
};
diff --git a/src/tint/transform/first_index_offset.cc b/src/tint/transform/first_index_offset.cc
index e739fae..cac1299 100644
--- a/src/tint/transform/first_index_offset.cc
+++ b/src/tint/transform/first_index_offset.cc
@@ -130,7 +130,7 @@
// Create a global to hold the uniform buffer
Symbol buffer_name = b.Sym();
- b.GlobalVar(buffer_name, b.ty.Of(struct_), type::AddressSpace::kUniform,
+ b.GlobalVar(buffer_name, b.ty.Of(struct_), builtin::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 5f70731..f5f8744 100644
--- a/src/tint/transform/localize_struct_array_assignment.cc
+++ b/src/tint/transform/localize_struct_array_assignment.cc
@@ -60,8 +60,9 @@
continue;
}
auto og = GetOriginatingTypeAndAddressSpace(assign_stmt);
- if (!(og.first->Is<sem::Struct>() && (og.second == type::AddressSpace::kFunction ||
- og.second == type::AddressSpace::kPrivate))) {
+ if (!(og.first->Is<sem::Struct>() &&
+ (og.second == builtin::AddressSpace::kFunction ||
+ og.second == builtin::AddressSpace::kPrivate))) {
continue;
}
@@ -184,7 +185,7 @@
// 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<const type::Type*, type::AddressSpace> GetOriginatingTypeAndAddressSpace(
+ std::pair<const type::Type*, builtin::AddressSpace> GetOriginatingTypeAndAddressSpace(
const ast::AssignmentStatement* assign_stmt) {
auto* root_ident = src->Sem().GetVal(assign_stmt->lhs)->RootIdentifier();
if (TINT_UNLIKELY(!root_ident)) {
@@ -206,7 +207,7 @@
TINT_ICE(Transform, b.Diagnostics())
<< "Expecting to find variable of type pointer or reference on lhs "
"of assignment statement";
- return std::pair<const type::Type*, type::AddressSpace>{};
+ return std::pair<const type::Type*, builtin::AddressSpace>{};
});
}
};
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 47356e9..044133c 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
@@ -122,9 +122,9 @@
// Helper to create an AST node for the store type of the variable.
auto store_type = [&]() { return CreateASTTypeFor(ctx, ty); };
- type::AddressSpace sc = var->AddressSpace();
+ builtin::AddressSpace sc = var->AddressSpace();
switch (sc) {
- case type::AddressSpace::kHandle: {
+ case builtin::AddressSpace::kHandle: {
// For a texture or sampler variable, redeclare it as an entry point parameter.
// Disable entry point parameter validation.
auto* disable_validation =
@@ -136,8 +136,8 @@
break;
}
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kUniform: {
+ case builtin::AddressSpace::kStorage:
+ case builtin::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);
@@ -159,7 +159,7 @@
is_wrapped = true;
}
- param_type = sc == type::AddressSpace::kStorage
+ param_type = sc == builtin::AddressSpace::kStorage
? ctx.dst->ty.pointer(param_type, sc, var->Access())
: ctx.dst->ty.pointer(param_type, sc);
auto* param = ctx.dst->Param(new_var_symbol, param_type, attributes);
@@ -168,7 +168,7 @@
break;
}
- case type::AddressSpace::kWorkgroup: {
+ case builtin::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.
@@ -184,7 +184,7 @@
ctx.dst->MemberAccessor(ctx.dst->Deref(workgroup_param()), member));
auto* local_var = ctx.dst->Let(
new_var_symbol,
- ctx.dst->ty.pointer(store_type(), type::AddressSpace::kWorkgroup),
+ ctx.dst->ty.pointer(store_type(), builtin::AddressSpace::kWorkgroup),
member_ptr);
ctx.InsertFront(func->body->statements, ctx.dst->Decl(local_var));
is_pointer = true;
@@ -193,7 +193,7 @@
}
[[fallthrough]];
}
- case type::AddressSpace::kPrivate: {
+ case builtin::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 =
@@ -205,7 +205,7 @@
break;
}
- case type::AddressSpace::kPushConstant: {
+ case builtin::AddressSpace::kPushConstant: {
ctx.dst->Diagnostics().add_error(
diag::System::Transform,
"unhandled module-scope address space (" + utils::ToString(sc) + ")");
@@ -233,13 +233,13 @@
auto param_type = CreateASTTypeFor(ctx, ty);
auto sc = var->AddressSpace();
switch (sc) {
- case type::AddressSpace::kPrivate:
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kHandle:
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kHandle:
+ case builtin::AddressSpace::kWorkgroup:
break;
- case type::AddressSpace::kPushConstant: {
+ case builtin::AddressSpace::kPushConstant: {
ctx.dst->Diagnostics().add_error(
diag::System::Transform,
"unhandled module-scope address space (" + utils::ToString(sc) + ")");
@@ -254,7 +254,7 @@
// Use a pointer for non-handle types.
utils::Vector<const ast::Attribute*, 2> attributes;
if (!ty->is_handle()) {
- param_type = sc == type::AddressSpace::kStorage
+ param_type = sc == builtin::AddressSpace::kStorage
? ctx.dst->ty.pointer(param_type, sc, var->Access())
: ctx.dst->ty.pointer(param_type, sc);
is_pointer = true;
@@ -323,7 +323,7 @@
bool needs_processing = false;
for (auto* var : func_sem->TransitivelyReferencedGlobals()) {
- if (var->AddressSpace() != type::AddressSpace::kUndefined) {
+ if (var->AddressSpace() != builtin::AddressSpace::kUndefined) {
needs_processing = true;
break;
}
@@ -380,7 +380,7 @@
// Process and redeclare all variables referenced by the function.
for (auto* var : func_sem->TransitivelyReferencedGlobals()) {
- if (var->AddressSpace() == type::AddressSpace::kUndefined) {
+ if (var->AddressSpace() == builtin::AddressSpace::kUndefined) {
continue;
}
if (local_private_vars_.count(var)) {
@@ -398,7 +398,7 @@
// Check if this is a private variable that is only referenced by this function.
bool local_private = false;
- if (var->AddressSpace() == type::AddressSpace::kPrivate) {
+ if (var->AddressSpace() == builtin::AddressSpace::kPrivate) {
local_private = true;
for (auto* user : var->Users()) {
auto* stmt = user->Stmt();
@@ -416,7 +416,7 @@
auto* initializer = ctx.Clone(var->Declaration()->initializer);
auto* local_var = ctx.dst->Var(new_var_symbol,
CreateASTTypeFor(ctx, var->Type()->UnwrapRef()),
- type::AddressSpace::kPrivate, initializer,
+ builtin::AddressSpace::kPrivate, initializer,
utils::Vector{disable_validation});
ctx.InsertFront(func_ast->body->statements, ctx.dst->Decl(local_var));
local_private_vars_.insert(var);
@@ -428,7 +428,7 @@
is_wrapped);
} else {
ProcessVariableInUserFunction(func_ast, var, new_var_symbol, is_pointer);
- if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
+ if (var->AddressSpace() == builtin::AddressSpace::kWorkgroup) {
needs_pointer_aliasing = true;
}
}
@@ -453,7 +453,7 @@
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), type::AddressSpace::kWorkgroup);
+ ctx.dst->ty.pointer(ctx.dst->ty.Of(str), builtin::AddressSpace::kWorkgroup);
auto* param = ctx.dst->Param(
workgroup_param(), param_type,
utils::Vector{
@@ -472,7 +472,7 @@
// For entry points, pass non-handle types as pointers.
for (auto* target_var : target_sem->TransitivelyReferencedGlobals()) {
auto sc = target_var->AddressSpace();
- if (sc == type::AddressSpace::kUndefined) {
+ if (sc == builtin::AddressSpace::kUndefined) {
continue;
}
@@ -503,7 +503,7 @@
// 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() != type::AddressSpace::kUndefined) {
+ if (var_sem->AddressSpace() != builtin::AddressSpace::kUndefined) {
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 06dfba4..cf8092d 100644
--- a/src/tint/transform/multiplanar_external_texture.cc
+++ b/src/tint/transform/multiplanar_external_texture.cc
@@ -144,7 +144,7 @@
b.GlobalVar(syms.plane_1, b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32()),
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("ExternalTextureParams"), type::AddressSpace::kUniform,
+ b.GlobalVar(syms.params, b.ty("ExternalTextureParams"), builtin::AddressSpace::kUniform,
b.Group(AInt(bps.params.group)), b.Binding(AInt(bps.params.binding)));
// Replace the original texture_external binding with a texture_2d<f32> binding.
diff --git a/src/tint/transform/num_workgroups_from_uniform.cc b/src/tint/transform/num_workgroups_from_uniform.cc
index 35e59fb..a62cf42 100644
--- a/src/tint/transform/num_workgroups_from_uniform.cc
+++ b/src/tint/transform/num_workgroups_from_uniform.cc
@@ -158,9 +158,9 @@
binding = 0;
}
- num_workgroups_ubo =
- b.GlobalVar(b.Sym(), b.ty.Of(num_workgroups_struct), type::AddressSpace::kUniform,
- b.Group(AInt(group)), b.Binding(AInt(binding)));
+ num_workgroups_ubo = b.GlobalVar(b.Sym(), b.ty.Of(num_workgroups_struct),
+ builtin::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 954069c..eef67eb 100644
--- a/src/tint/transform/pad_structs.cc
+++ b/src/tint/transform/pad_structs.cc
@@ -80,7 +80,7 @@
new_members.Push(b.Member(name, type));
uint32_t size = ty->Size();
- if (ty->Is<sem::Struct>() && str->UsedAs(type::AddressSpace::kUniform)) {
+ if (ty->Is<sem::Struct>() && str->UsedAs(builtin::AddressSpace::kUniform)) {
// std140 structs should be padded out to 16 bytes.
size = utils::RoundUp(16u, size);
} else if (auto* array_ty = ty->As<type::Array>()) {
@@ -93,7 +93,7 @@
// 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(type::AddressSpace::kUniform)) {
+ if (str->UsedAs(builtin::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 1dbd2af..cb5a8ee 100644
--- a/src/tint/transform/preserve_padding.cc
+++ b/src/tint/transform/preserve_padding.cc
@@ -53,7 +53,8 @@
// Ignore phony assignment.
return;
}
- if (ty->As<type::Reference>()->AddressSpace() != type::AddressSpace::kStorage) {
+ if (ty->As<type::Reference>()->AddressSpace() !=
+ builtin::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 +121,7 @@
auto helper_name = b.Symbols().New("assign_and_preserve_padding");
utils::Vector<const ast::Parameter*, 2> params = {
b.Param(kDestParamName,
- b.ty.pointer(CreateASTTypeFor(ctx, ty), type::AddressSpace::kStorage,
+ b.ty.pointer(CreateASTTypeFor(ctx, ty), builtin::AddressSpace::kStorage,
builtin::Access::kReadWrite)),
b.Param(kValueParamName, CreateASTTypeFor(ctx, ty)),
};
diff --git a/src/tint/transform/renamer_test.cc b/src/tint/transform/renamer_test.cc
index d4b681c..04e2b99 100644
--- a/src/tint/transform/renamer_test.cc
+++ b/src/tint/transform/renamer_test.cc
@@ -1926,7 +1926,7 @@
for (auto* ident : type::kBuiltinStrings) {
out.push_back(ident);
}
- for (auto* ident : type::kAddressSpaceStrings) {
+ for (auto* ident : builtin::kAddressSpaceStrings) {
if (!utils::HasPrefix(ident, "_")) {
out.push_back(ident);
}
diff --git a/src/tint/transform/robustness.cc b/src/tint/transform/robustness.cc
index 579d684..c6bf218 100644
--- a/src/tint/transform/robustness.cc
+++ b/src/tint/transform/robustness.cc
@@ -38,7 +38,7 @@
/// Constructor
/// @param program the source program
/// @param omitted the omitted address spaces
- State(const Program* program, std::unordered_set<type::AddressSpace>&& omitted)
+ State(const Program* program, std::unordered_set<builtin::AddressSpace>&& omitted)
: src(program), omitted_address_spaces(std::move(omitted)) {}
/// Runs the transform
@@ -60,7 +60,7 @@
CloneContext ctx = {&b, src, /* auto_clone_symbols */ true};
/// Set of address spaces to not apply the transform to
- std::unordered_set<type::AddressSpace> omitted_address_spaces;
+ std::unordered_set<builtin::AddressSpace> 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 @@
cfg = *cfg_data;
}
- std::unordered_set<type::AddressSpace> omitted_address_spaces;
+ std::unordered_set<builtin::AddressSpace> omitted_address_spaces;
for (auto sc : cfg.omitted_address_spaces) {
switch (sc) {
case AddressSpace::kUniform:
- omitted_address_spaces.insert(type::AddressSpace::kUniform);
+ omitted_address_spaces.insert(builtin::AddressSpace::kUniform);
break;
case AddressSpace::kStorage:
- omitted_address_spaces.insert(type::AddressSpace::kStorage);
+ omitted_address_spaces.insert(builtin::AddressSpace::kStorage);
break;
}
}
diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc
index a19d78f..7a9cffc 100644
--- a/src/tint/transform/std140.cc
+++ b/src/tint/transform/std140.cc
@@ -144,7 +144,7 @@
// Scan structures for members that need forking
for (auto* ty : src->Types()) {
if (auto* str = ty->As<sem::Struct>()) {
- if (str->UsedAs(type::AddressSpace::kUniform)) {
+ if (str->UsedAs(builtin::AddressSpace::kUniform)) {
for (auto* member : str->Members()) {
if (needs_fork(member->Type())) {
return true;
@@ -157,7 +157,7 @@
// Scan uniform variables that have types that need forking
for (auto* decl : src->AST().GlobalVariables()) {
auto* global = src->Sem().Get(decl);
- if (global->AddressSpace() == type::AddressSpace::kUniform) {
+ if (global->AddressSpace() == builtin::AddressSpace::kUniform) {
if (needs_fork(global->Type()->UnwrapRef())) {
return true;
}
@@ -280,7 +280,7 @@
for (auto* global : src->Sem().Module()->DependencyOrderedDeclarations()) {
// Check to see if this is a structure used by a uniform buffer...
auto* str = sem.Get<sem::Struct>(global);
- if (str && str->UsedAs(type::AddressSpace::kUniform)) {
+ if (str && str->UsedAs(builtin::AddressSpace::kUniform)) {
// Should this uniform buffer be forked for std140 usage?
bool fork_std140 = false;
utils::Vector<const ast::StructMember*, 8> members;
@@ -351,7 +351,7 @@
for (auto* global : src->AST().GlobalVariables()) {
if (auto* var = global->As<ast::Var>()) {
auto* v = sem.Get(var);
- if (v->AddressSpace() == type::AddressSpace::kUniform) {
+ if (v->AddressSpace() == builtin::AddressSpace::kUniform) {
if (auto std140_ty = Std140Type(v->Type()->UnwrapRef())) {
ctx.Replace(global->type.expr, b.Expr(std140_ty));
std140_uniforms.Add(v);
diff --git a/src/tint/transform/vertex_pulling.cc b/src/tint/transform/vertex_pulling.cc
index 6a1b5b4..9faddb7 100644
--- a/src/tint/transform/vertex_pulling.cc
+++ b/src/tint/transform/vertex_pulling.cc
@@ -321,8 +321,8 @@
});
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), type::AddressSpace::kStorage,
- builtin::Access::kRead, b.Binding(AInt(i)),
+ b.GlobalVar(GetVertexBufferName(i), b.ty.Of(struct_type),
+ builtin::AddressSpace::kStorage, builtin::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 015a25b..2071abc 100644
--- a/src/tint/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/transform/zero_init_workgroup_memory.cc
@@ -37,7 +37,7 @@
for (auto* global : program->AST().GlobalVariables()) {
if (auto* var = global->As<ast::Var>()) {
auto* v = program->Sem().Get(var);
- if (v->AddressSpace() == type::AddressSpace::kWorkgroup) {
+ if (v->AddressSpace() == builtin::AddressSpace::kWorkgroup) {
return true;
}
}
@@ -140,7 +140,7 @@
// workgroup storage variables used by `fn`. This will populate #statements.
auto* func = sem.Get(fn);
for (auto* var : func->TransitivelyReferencedGlobals()) {
- if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
+ if (var->AddressSpace() == builtin::AddressSpace::kWorkgroup) {
auto get_expr = [&](uint32_t num_values) {
auto var_name = ctx.Clone(var->Declaration()->name->symbol);
return Expression{b.Expr(var_name), num_values, ArrayIndices{}};
diff --git a/src/tint/type/pointer.cc b/src/tint/type/pointer.cc
index 1175961..17bbe1a 100644
--- a/src/tint/type/pointer.cc
+++ b/src/tint/type/pointer.cc
@@ -24,7 +24,7 @@
namespace tint::type {
-Pointer::Pointer(const Type* subtype, type::AddressSpace address_space, builtin::Access access)
+Pointer::Pointer(const Type* subtype, builtin::AddressSpace address_space, builtin::Access access)
: Base(utils::Hash(TypeInfo::Of<Pointer>().full_hashcode, address_space, subtype, access),
type::Flags{}),
subtype_(subtype),
@@ -45,7 +45,7 @@
std::string Pointer::FriendlyName(const SymbolTable& symbols) const {
std::ostringstream out;
out << "ptr<";
- if (address_space_ != AddressSpace::kUndefined) {
+ if (address_space_ != builtin::AddressSpace::kUndefined) {
out << address_space_ << ", ";
}
out << subtype_->FriendlyName(symbols) << ", " << access_;
diff --git a/src/tint/type/pointer.h b/src/tint/type/pointer.h
index 8a4d1c9..6e73999 100644
--- a/src/tint/type/pointer.h
+++ b/src/tint/type/pointer.h
@@ -18,7 +18,7 @@
#include <string>
#include "src/tint/builtin/access.h"
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/type/type.h"
namespace tint::type {
@@ -30,7 +30,7 @@
/// @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, type::AddressSpace address_space, builtin::Access access);
+ Pointer(const Type* subtype, builtin::AddressSpace address_space, builtin::Access access);
/// Destructor
~Pointer() override;
@@ -43,7 +43,7 @@
const Type* StoreType() const { return subtype_; }
/// @returns the address space of the pointer
- type::AddressSpace AddressSpace() const { return address_space_; }
+ builtin::AddressSpace AddressSpace() const { return address_space_; }
/// @returns the access control of the reference
builtin::Access Access() const { return access_; }
@@ -59,7 +59,7 @@
private:
Type const* const subtype_;
- type::AddressSpace const address_space_;
+ builtin::AddressSpace const address_space_;
builtin::Access const access_;
};
diff --git a/src/tint/type/pointer_test.cc b/src/tint/type/pointer_test.cc
index 932548a..ff030cc 100644
--- a/src/tint/type/pointer_test.cc
+++ b/src/tint/type/pointer_test.cc
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "src/tint/builtin/address_space.h"
#include "src/tint/type/test_helper.h"
#include "src/tint/type/texture.h"
@@ -21,14 +22,19 @@
using PointerTest = TestHelper;
TEST_F(PointerTest, Creation) {
- auto* a = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* b = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* c = create<Pointer>(create<F32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* d = create<Pointer>(create<I32>(), AddressSpace::kPrivate, builtin::Access::kReadWrite);
- auto* e = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kRead);
+ auto* a = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* b = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* c = create<Pointer>(create<F32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* d = create<Pointer>(create<I32>(), builtin::AddressSpace::kPrivate,
+ builtin::Access::kReadWrite);
+ auto* e =
+ create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage, builtin::Access::kRead);
EXPECT_TRUE(a->StoreType()->Is<I32>());
- EXPECT_EQ(a->AddressSpace(), AddressSpace::kStorage);
+ EXPECT_EQ(a->AddressSpace(), builtin::AddressSpace::kStorage);
EXPECT_EQ(a->Access(), builtin::Access::kReadWrite);
EXPECT_EQ(a, b);
@@ -38,18 +44,25 @@
}
TEST_F(PointerTest, Hash) {
- auto* a = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* b = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
+ auto* a = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* b = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
EXPECT_EQ(a->unique_hash, b->unique_hash);
}
TEST_F(PointerTest, Equals) {
- auto* a = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* b = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* c = create<Pointer>(create<F32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* d = create<Pointer>(create<I32>(), AddressSpace::kPrivate, builtin::Access::kReadWrite);
- auto* e = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kRead);
+ auto* a = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* b = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* c = create<Pointer>(create<F32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* d = create<Pointer>(create<I32>(), builtin::AddressSpace::kPrivate,
+ builtin::Access::kReadWrite);
+ auto* e =
+ create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage, builtin::Access::kRead);
EXPECT_TRUE(a->Equals(*b));
EXPECT_FALSE(a->Equals(*c));
@@ -59,24 +72,27 @@
}
TEST_F(PointerTest, FriendlyName) {
- auto* r = create<Pointer>(create<I32>(), AddressSpace::kUndefined, builtin::Access::kRead);
+ auto* r =
+ create<Pointer>(create<I32>(), builtin::AddressSpace::kUndefined, builtin::Access::kRead);
EXPECT_EQ(r->FriendlyName(Symbols()), "ptr<i32, read>");
}
TEST_F(PointerTest, FriendlyNameWithAddressSpace) {
- auto* r = create<Pointer>(create<I32>(), AddressSpace::kWorkgroup, builtin::Access::kRead);
+ auto* r =
+ create<Pointer>(create<I32>(), builtin::AddressSpace::kWorkgroup, builtin::Access::kRead);
EXPECT_EQ(r->FriendlyName(Symbols()), "ptr<workgroup, i32, read>");
}
TEST_F(PointerTest, Clone) {
- auto* a = create<Pointer>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
+ auto* a = create<Pointer>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
type::Manager mgr;
type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
auto* ptr = a->Clone(ctx);
EXPECT_TRUE(ptr->StoreType()->Is<I32>());
- EXPECT_EQ(ptr->AddressSpace(), AddressSpace::kStorage);
+ EXPECT_EQ(ptr->AddressSpace(), builtin::AddressSpace::kStorage);
EXPECT_EQ(ptr->Access(), builtin::Access::kReadWrite);
}
diff --git a/src/tint/type/reference.cc b/src/tint/type/reference.cc
index ca676cc..5db6300 100644
--- a/src/tint/type/reference.cc
+++ b/src/tint/type/reference.cc
@@ -23,7 +23,9 @@
namespace tint::type {
-Reference::Reference(const Type* subtype, type::AddressSpace address_space, builtin::Access access)
+Reference::Reference(const Type* subtype,
+ builtin::AddressSpace address_space,
+ builtin::Access access)
: Base(utils::Hash(TypeInfo::Of<Reference>().full_hashcode, address_space, subtype, access),
type::Flags{}),
subtype_(subtype),
@@ -44,7 +46,7 @@
std::string Reference::FriendlyName(const SymbolTable& symbols) const {
std::ostringstream out;
out << "ref<";
- if (address_space_ != AddressSpace::kUndefined) {
+ if (address_space_ != builtin::AddressSpace::kUndefined) {
out << address_space_ << ", ";
}
out << subtype_->FriendlyName(symbols) << ", " << access_;
diff --git a/src/tint/type/reference.h b/src/tint/type/reference.h
index b1981ab..8bc5e33 100644
--- a/src/tint/type/reference.h
+++ b/src/tint/type/reference.h
@@ -18,7 +18,7 @@
#include <string>
#include "src/tint/builtin/access.h"
-#include "src/tint/type/address_space.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/type/type.h"
namespace tint::type {
@@ -30,7 +30,7 @@
/// @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, type::AddressSpace address_space, builtin::Access access);
+ Reference(const Type* subtype, builtin::AddressSpace address_space, builtin::Access access);
/// Destructor
~Reference() override;
@@ -43,7 +43,7 @@
const Type* StoreType() const { return subtype_; }
/// @returns the address space of the reference
- type::AddressSpace AddressSpace() const { return address_space_; }
+ builtin::AddressSpace AddressSpace() const { return address_space_; }
/// @returns the resolved access control of the reference.
builtin::Access Access() const { return access_; }
@@ -59,7 +59,7 @@
private:
Type const* const subtype_;
- type::AddressSpace const address_space_;
+ builtin::AddressSpace const address_space_;
builtin::Access const access_;
};
diff --git a/src/tint/type/reference_test.cc b/src/tint/type/reference_test.cc
index 65dde2b..634b17a 100644
--- a/src/tint/type/reference_test.cc
+++ b/src/tint/type/reference_test.cc
@@ -13,6 +13,7 @@
// limitations under the License.
#include "src/tint/type/reference.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/type/test_helper.h"
namespace tint::type {
@@ -21,14 +22,19 @@
using ReferenceTest = TestHelper;
TEST_F(ReferenceTest, Creation) {
- auto* a = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* b = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* c = create<Reference>(create<F32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* d = create<Reference>(create<I32>(), AddressSpace::kPrivate, builtin::Access::kReadWrite);
- auto* e = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kRead);
+ auto* a = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* b = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* c = create<Reference>(create<F32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* d = create<Reference>(create<I32>(), builtin::AddressSpace::kPrivate,
+ builtin::Access::kReadWrite);
+ auto* e =
+ create<Reference>(create<I32>(), builtin::AddressSpace::kStorage, builtin::Access::kRead);
EXPECT_TRUE(a->StoreType()->Is<I32>());
- EXPECT_EQ(a->AddressSpace(), AddressSpace::kStorage);
+ EXPECT_EQ(a->AddressSpace(), builtin::AddressSpace::kStorage);
EXPECT_EQ(a->Access(), builtin::Access::kReadWrite);
EXPECT_EQ(a, b);
@@ -38,18 +44,25 @@
}
TEST_F(ReferenceTest, Hash) {
- auto* a = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* b = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
+ auto* a = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* b = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
EXPECT_EQ(a->unique_hash, b->unique_hash);
}
TEST_F(ReferenceTest, Equals) {
- auto* a = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* b = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* c = create<Reference>(create<F32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto* d = create<Reference>(create<I32>(), AddressSpace::kPrivate, builtin::Access::kReadWrite);
- auto* e = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kRead);
+ auto* a = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* b = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* c = create<Reference>(create<F32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
+ auto* d = create<Reference>(create<I32>(), builtin::AddressSpace::kPrivate,
+ builtin::Access::kReadWrite);
+ auto* e =
+ create<Reference>(create<I32>(), builtin::AddressSpace::kStorage, builtin::Access::kRead);
EXPECT_TRUE(a->Equals(*b));
EXPECT_FALSE(a->Equals(*c));
@@ -59,24 +72,27 @@
}
TEST_F(ReferenceTest, FriendlyName) {
- auto* r = create<Reference>(create<I32>(), AddressSpace::kUndefined, builtin::Access::kRead);
+ auto* r =
+ create<Reference>(create<I32>(), builtin::AddressSpace::kUndefined, builtin::Access::kRead);
EXPECT_EQ(r->FriendlyName(Symbols()), "ref<i32, read>");
}
TEST_F(ReferenceTest, FriendlyNameWithAddressSpace) {
- auto* r = create<Reference>(create<I32>(), AddressSpace::kWorkgroup, builtin::Access::kRead);
+ auto* r =
+ create<Reference>(create<I32>(), builtin::AddressSpace::kWorkgroup, builtin::Access::kRead);
EXPECT_EQ(r->FriendlyName(Symbols()), "ref<workgroup, i32, read>");
}
TEST_F(ReferenceTest, Clone) {
- auto* a = create<Reference>(create<I32>(), AddressSpace::kStorage, builtin::Access::kReadWrite);
+ auto* a = create<Reference>(create<I32>(), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite);
type::Manager mgr;
type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
auto* ref = a->Clone(ctx);
EXPECT_TRUE(ref->StoreType()->Is<I32>());
- EXPECT_EQ(ref->AddressSpace(), AddressSpace::kStorage);
+ EXPECT_EQ(ref->AddressSpace(), builtin::AddressSpace::kStorage);
EXPECT_EQ(ref->Access(), builtin::Access::kReadWrite);
}
diff --git a/src/tint/type/struct.h b/src/tint/type/struct.h
index e80dcc1..0130111 100644
--- a/src/tint/type/struct.h
+++ b/src/tint/type/struct.h
@@ -21,8 +21,8 @@
#include <string>
#include <unordered_set>
+#include "src/tint/builtin/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 @@
/// Adds the AddressSpace usage to the structure.
/// @param usage the storage usage
- void AddUsage(AddressSpace usage) { address_space_usage_.emplace(usage); }
+ void AddUsage(builtin::AddressSpace usage) { address_space_usage_.emplace(usage); }
/// @returns the set of address space uses of this structure
- const std::unordered_set<AddressSpace>& AddressSpaceUsage() const {
+ const std::unordered_set<builtin::AddressSpace>& AddressSpaceUsage() const {
return address_space_usage_;
}
/// @param usage the AddressSpace usage type to query
/// @returns true iff this structure has been used as the given address space
- bool UsedAs(AddressSpace usage) const { return address_space_usage_.count(usage) > 0; }
+ bool UsedAs(builtin::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 (type::IsHostShareable(sc)) {
+ if (builtin::IsHostShareable(sc)) {
return true;
}
}
@@ -160,7 +160,7 @@
const uint32_t align_;
const uint32_t size_;
const uint32_t size_no_padding_;
- std::unordered_set<AddressSpace> address_space_usage_;
+ std::unordered_set<builtin::AddressSpace> address_space_usage_;
std::unordered_set<PipelineStageUsage> pipeline_stage_uses_;
utils::Vector<const Struct*, 2> concrete_types_;
};
diff --git a/src/tint/type/type_test.cc b/src/tint/type/type_test.cc
index f6adb93..1565e10 100644
--- a/src/tint/type/type_test.cc
+++ b/src/tint/type/type_test.cc
@@ -44,7 +44,7 @@
const Matrix* mat4x3_f16 = create<Matrix>(vec3_f16, 4u);
const Matrix* mat4x3_af = create<Matrix>(vec3_af, 4u);
const Reference* ref_u32 =
- create<Reference>(u32, AddressSpace::kPrivate, builtin::Access::kReadWrite);
+ create<Reference>(u32, builtin::AddressSpace::kPrivate, builtin::Access::kReadWrite);
const Struct* str_f32 = create<Struct>(Source{},
Sym("str_f32"),
utils::Vector{
diff --git a/src/tint/writer/append_vector.cc b/src/tint/writer/append_vector.cc
index 53f11db..c212378 100644
--- a/src/tint/writer/append_vector.cc
+++ b/src/tint/writer/append_vector.cc
@@ -137,7 +137,8 @@
auto* scalar_cast_target = b->create<sem::TypeConversion>(
packed_el_sem_ty,
b->create<sem::Parameter>(nullptr, 0u, scalar_sem->Type()->UnwrapRef(),
- type::AddressSpace::kUndefined, builtin::Access::kUndefined),
+ builtin::AddressSpace::kUndefined,
+ builtin::Access::kUndefined),
sem::EvaluationStage::kRuntime);
auto* scalar_cast_sem = b->create<sem::Call>(
scalar_cast_ast, scalar_cast_target, sem::EvaluationStage::kRuntime,
@@ -160,7 +161,7 @@
[&](const tint::sem::ValueExpression* arg, size_t i) -> const sem::Parameter* {
return b->create<sem::Parameter>(
nullptr, static_cast<uint32_t>(i), arg->Type()->UnwrapRef(),
- type::AddressSpace::kUndefined, builtin::Access::kUndefined);
+ builtin::AddressSpace::kUndefined, builtin::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 feded0c..8f24916 100644
--- a/src/tint/writer/append_vector_test.cc
+++ b/src/tint/writer/append_vector_test.cc
@@ -252,7 +252,7 @@
// AppendVector(vec_12, 3) -> vec3<i32>(vec_12, 3)
TEST_F(AppendVectorTest, Vec2i32Var_i32) {
- GlobalVar("vec_12", ty.vec2<i32>(), type::AddressSpace::kPrivate);
+ GlobalVar("vec_12", ty.vec2<i32>(), builtin::AddressSpace::kPrivate);
auto* vec_12 = Expr("vec_12");
auto* scalar_3 = Expr(3_i);
WrapInFunction(vec_12, scalar_3);
@@ -288,7 +288,7 @@
// AppendVector(1, 2, scalar_3) -> vec3<i32>(1, 2, scalar_3)
TEST_F(AppendVectorTest, Vec2i32_i32Var) {
- GlobalVar("scalar_3", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("scalar_3", ty.i32(), builtin::AddressSpace::kPrivate);
auto* scalar_1 = Expr(1_i);
auto* scalar_2 = Expr(2_i);
auto* scalar_3 = Expr("scalar_3");
@@ -329,8 +329,8 @@
// AppendVector(vec_12, scalar_3) -> vec3<i32>(vec_12, scalar_3)
TEST_F(AppendVectorTest, Vec2i32Var_i32Var) {
- GlobalVar("vec_12", ty.vec2<i32>(), type::AddressSpace::kPrivate);
- GlobalVar("scalar_3", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("vec_12", ty.vec2<i32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("scalar_3", ty.i32(), builtin::AddressSpace::kPrivate);
auto* vec_12 = Expr("vec_12");
auto* scalar_3 = Expr("scalar_3");
WrapInFunction(vec_12, scalar_3);
@@ -366,8 +366,8 @@
// AppendVector(vec_12, scalar_3) -> vec3<i32>(vec_12, i32(scalar_3))
TEST_F(AppendVectorTest, Vec2i32Var_f32Var) {
- GlobalVar("vec_12", ty.vec2<i32>(), type::AddressSpace::kPrivate);
- GlobalVar("scalar_3", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("vec_12", ty.vec2<i32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("scalar_3", ty.f32(), builtin::AddressSpace::kPrivate);
auto* vec_12 = Expr("vec_12");
auto* scalar_3 = Expr("scalar_3");
WrapInFunction(vec_12, scalar_3);
@@ -407,8 +407,8 @@
// AppendVector(vec_12, scalar_3) -> vec3<bool>(vec_12, scalar_3)
TEST_F(AppendVectorTest, Vec2boolVar_boolVar) {
- GlobalVar("vec_12", ty.vec2<bool>(), type::AddressSpace::kPrivate);
- GlobalVar("scalar_3", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("vec_12", ty.vec2<bool>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("scalar_3", ty.bool_(), builtin::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 3b0c7a6..53d1a7a 100644
--- a/src/tint/writer/flatten_bindings_test.cc
+++ b/src/tint/writer/flatten_bindings_test.cc
@@ -39,9 +39,9 @@
TEST_F(FlattenBindingsTest, AlreadyFlat) {
ProgramBuilder b;
- 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));
+ b.GlobalVar("a", b.ty.i32(), builtin::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("b", b.ty.i32(), builtin::AddressSpace::kUniform, b.Group(0_a), b.Binding(1_a));
+ b.GlobalVar("c", b.ty.i32(), builtin::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, NotFlat_SingleNamespace) {
ProgramBuilder b;
- 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.GlobalVar("a", b.ty.i32(), builtin::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
+ b.GlobalVar("b", b.ty.i32(), builtin::AddressSpace::kUniform, b.Group(1_a), b.Binding(1_a));
+ b.GlobalVar("c", b.ty.i32(), builtin::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,11 @@
ProgramBuilder b;
const size_t num_buffers = 3;
- 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, builtin::Access::kRead,
+ b.GlobalVar("buffer1", b.ty.i32(), builtin::AddressSpace::kUniform, b.Group(0_a),
+ b.Binding(0_a));
+ b.GlobalVar("buffer2", b.ty.i32(), builtin::AddressSpace::kStorage, b.Group(1_a),
+ b.Binding(1_a));
+ b.GlobalVar("buffer3", b.ty.i32(), builtin::AddressSpace::kStorage, builtin::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 e441517..d6b22ac 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 @@
using namespace tint::number_suffixes; // NOLINT
-constexpr auto kUniform = type::AddressSpace::kUniform;
+constexpr auto kUniform = builtin::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 76a0d18..c06d82f 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -374,7 +374,7 @@
dst_type->is_float_scalar_or_vector()) {
out << "uintBitsToFloat";
} else {
- if (!EmitType(out, dst_type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, dst_type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
@@ -438,13 +438,13 @@
auto* uint_type = BoolTypeToUint(bool_type);
// Cast result to bool scalar or vector type.
- if (!EmitType(out, bool_type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, bool_type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
ScopedParen outerCastParen(out);
// Cast LHS to uint scalar or vector type.
- if (!EmitType(out, uint_type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, uint_type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
@@ -465,7 +465,7 @@
return false;
}
// Cast RHS to uint scalar or vector type.
- if (!EmitType(out, uint_type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, uint_type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
@@ -493,20 +493,20 @@
std::vector<std::string> parameter_names;
{
auto decl = line(&b);
- if (!EmitTypeAndName(decl, ret_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, ret_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, fn_name)) {
return "";
}
{
ScopedParen sp(decl);
const auto* ty = TypeOf(expr->lhs)->UnwrapRef();
- if (!EmitTypeAndName(decl, ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "lhs")) {
return "";
}
decl << ", ";
ty = TypeOf(expr->rhs)->UnwrapRef();
- if (!EmitTypeAndName(decl, ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "rhs")) {
return "";
}
@@ -830,8 +830,8 @@
bool GeneratorImpl::EmitTypeConversion(std::ostream& out,
const sem::Call* call,
const sem::TypeConversion* conv) {
- if (!EmitType(out, conv->Target(), type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
- "")) {
+ if (!EmitType(out, conv->Target(), builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, "")) {
return false;
}
ScopedParen sp(out);
@@ -854,7 +854,7 @@
return EmitZeroValue(out, type);
}
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
return false;
}
ScopedParen sp(out);
@@ -924,7 +924,7 @@
{
auto pre = line();
- if (!EmitTypeAndName(pre, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(pre, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, result)) {
return false;
}
@@ -1062,7 +1062,7 @@
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(), type::AddressSpace::kUndefined,
+ if (!EmitType(out, TypeOf(expr)->UnwrapRef(), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "")) {
return false;
}
@@ -1134,7 +1134,7 @@
std::string v;
{
std::stringstream s;
- if (!EmitType(s, vec_ty->type(), type::AddressSpace::kUndefined,
+ if (!EmitType(s, vec_ty->type(), builtin::AddressSpace::kUndefined,
builtin::Access::kRead, "")) {
return "";
}
@@ -1142,17 +1142,17 @@
}
{ // (u)int tint_int_dot([i|u]vecN a, [i|u]vecN b) {
auto l = line(&b);
- if (!EmitType(l, vec_ty->type(), type::AddressSpace::kUndefined,
+ if (!EmitType(l, vec_ty->type(), builtin::AddressSpace::kUndefined,
builtin::Access::kRead, "")) {
return "";
}
l << " " << fn_name << "(";
- if (!EmitType(l, vec_ty, type::AddressSpace::kUndefined, builtin::Access::kRead,
+ if (!EmitType(l, vec_ty, builtin::AddressSpace::kUndefined, builtin::Access::kRead,
"")) {
return "";
}
l << " a, ";
- if (!EmitType(l, vec_ty, type::AddressSpace::kUndefined, builtin::Access::kRead,
+ if (!EmitType(l, vec_ty, builtin::AddressSpace::kUndefined, builtin::Access::kRead,
"")) {
return "";
}
@@ -1204,7 +1204,7 @@
{
auto l = line(b);
- if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitType(l, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return false;
}
@@ -1230,7 +1230,7 @@
{
auto l = line(b);
- if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitType(l, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return false;
}
@@ -1888,7 +1888,7 @@
{
auto out = line();
auto name = builder_.Symbols().NameFor(func->name->symbol);
- if (!EmitType(out, sem->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitType(out, sem->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "")) {
return false;
}
@@ -1944,20 +1944,20 @@
[&](const ast::Var* var) {
auto* sem = builder_.Sem().Get<sem::GlobalVariable>(global);
switch (sem->AddressSpace()) {
- case type::AddressSpace::kUniform:
+ case builtin::AddressSpace::kUniform:
return EmitUniformVariable(var, sem);
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
return EmitStorageVariable(var, sem);
- case type::AddressSpace::kHandle:
+ case builtin::AddressSpace::kHandle:
return EmitHandleVariable(var, sem);
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kPrivate:
return EmitPrivateVariable(sem);
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
return EmitWorkgroupVariable(sem);
- case type::AddressSpace::kIn:
- case type::AddressSpace::kOut:
+ case builtin::AddressSpace::kIn:
+ case builtin::AddressSpace::kOut:
return EmitIOVariable(sem);
- case type::AddressSpace::kPushConstant:
+ case builtin::AddressSpace::kPushConstant:
diagnostics_.add_error(
diag::System::Writer,
"unhandled address space " + utils::ToString(sem->AddressSpace()));
@@ -2265,7 +2265,7 @@
// Emit original entry point signature
{
auto out = line();
- if (!EmitTypeAndName(out, func_sem->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, func_sem->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined,
builder_.Symbols().NameFor(func->name->symbol))) {
return false;
@@ -2346,7 +2346,7 @@
return true;
},
[&](const type::Vector* v) {
- if (!EmitType(out, v, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitType(out, v, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
"")) {
return false;
}
@@ -2368,7 +2368,7 @@
return true;
},
[&](const type::Matrix* m) {
- if (!EmitType(out, m, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitType(out, m, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
"")) {
return false;
}
@@ -2386,7 +2386,7 @@
return true;
},
[&](const type::Array* a) {
- if (!EmitType(out, a, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitType(out, a, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
"")) {
return false;
}
@@ -2479,7 +2479,8 @@
} else if (type->Is<type::U32>()) {
out << "0u";
} else if (auto* vec = type->As<type::Vector>()) {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ "")) {
return false;
}
ScopedParen sp(out);
@@ -2492,7 +2493,8 @@
}
}
} else if (auto* mat = type->As<type::Matrix>()) {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ "")) {
return false;
}
ScopedParen sp(out);
@@ -2505,7 +2507,8 @@
}
}
} else if (auto* str = type->As<sem::Struct>()) {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ "")) {
return false;
}
bool first = true;
@@ -2519,7 +2522,8 @@
EmitZeroValue(out, member->Type());
}
} else if (auto* arr = type->As<type::Array>()) {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ "")) {
return false;
}
ScopedParen sp(out);
@@ -2844,7 +2848,7 @@
bool GeneratorImpl::EmitType(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const std::string& name,
bool* name_printed /* = nullptr */) {
@@ -2852,16 +2856,16 @@
*name_printed = false;
}
switch (address_space) {
- case type::AddressSpace::kIn: {
+ case builtin::AddressSpace::kIn: {
out << "in ";
break;
}
- case type::AddressSpace::kOut: {
+ case builtin::AddressSpace::kOut: {
out << "out ";
break;
}
- case type::AddressSpace::kUniform:
- case type::AddressSpace::kHandle: {
+ case builtin::AddressSpace::kUniform:
+ case builtin::AddressSpace::kHandle: {
out << "uniform ";
break;
}
@@ -3025,7 +3029,7 @@
bool GeneratorImpl::EmitTypeAndName(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const std::string& name) {
bool printed_name = false;
@@ -3062,8 +3066,8 @@
auto out = line(b);
- if (!EmitTypeAndName(out, ty, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
- name)) {
+ if (!EmitTypeAndName(out, ty, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, name)) {
return false;
}
out << ";";
@@ -3131,7 +3135,7 @@
auto out = line();
// TODO(senorblanco): handle const
- if (!EmitTypeAndName(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitTypeAndName(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
builder_.Symbols().NameFor(let->name->symbol))) {
return false;
}
@@ -3153,7 +3157,7 @@
auto out = line();
out << "const ";
- if (!EmitTypeAndName(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitTypeAndName(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
builder_.Symbols().NameFor(var->name->symbol))) {
return false;
}
@@ -3180,7 +3184,7 @@
std::vector<std::string> parameter_names;
{
auto decl = line(&b);
- if (!EmitTypeAndName(decl, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, fn_name)) {
return "";
}
@@ -3196,7 +3200,7 @@
decl << "inout ";
ty = ptr->StoreType();
}
- if (!EmitTypeAndName(decl, ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, param_name)) {
return "";
}
diff --git a/src/tint/writer/glsl/generator_impl.h b/src/tint/writer/glsl/generator_impl.h
index d015000..629566d 100644
--- a/src/tint/writer/glsl/generator_impl.h
+++ b/src/tint/writer/glsl/generator_impl.h
@@ -414,7 +414,7 @@
/// @returns true if the type is emitted
bool EmitType(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const std::string& name,
bool* name_printed = nullptr);
@@ -427,7 +427,7 @@
/// @returns true if the type is emitted
bool EmitTypeAndName(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::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 cee4506..bd405d3 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 @@
using GlslGeneratorImplTest_Expression = TestHelper;
TEST_F(GlslGeneratorImplTest_Expression, IndexAccessor) {
- GlobalVar("ary", ty.array<i32, 10>(), type::AddressSpace::kPrivate);
+ GlobalVar("ary", ty.array<i32, 10>(), builtin::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 73d950c..d53d39f 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 @@
using GlslGeneratorImplTest_Assign = TestHelper;
TEST_F(GlslGeneratorImplTest_Assign, Emit_Assign) {
- GlobalVar("lhs", ty.i32(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.i32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.i32(), builtin::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 72eddc7..f90a428 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 @@
return;
}
- GlobalVar("left", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.f32(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -71,8 +71,8 @@
Enable(builtin::Extension::kF16);
- GlobalVar("left", ty.f16(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.f16(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.f16(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.f16(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -90,8 +90,8 @@
TEST_P(GlslBinaryTest, Emit_u32) {
auto params = GetParam();
- GlobalVar("left", ty.u32(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.u32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.u32(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -114,8 +114,8 @@
return;
}
- GlobalVar("left", ty.i32(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.i32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.i32(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -151,7 +151,7 @@
BinaryData{"(left % right)", ast::BinaryOp::kModulo}));
TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar_f32) {
- GlobalVar("a", vec3<f32>(1_f, 1_f, 1_f), type::AddressSpace::kPrivate);
+ GlobalVar("a", vec3<f32>(1_f, 1_f, 1_f), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("a");
auto* rhs = Expr(1_f);
@@ -169,7 +169,7 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", vec3<f16>(1_h, 1_h, 1_h), type::AddressSpace::kPrivate);
+ GlobalVar("a", vec3<f16>(1_h, 1_h, 1_h), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("a");
auto* rhs = Expr(1_h);
@@ -185,7 +185,7 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector_f32) {
- GlobalVar("a", vec3<f32>(1_f, 1_f, 1_f), type::AddressSpace::kPrivate);
+ GlobalVar("a", vec3<f32>(1_f, 1_f, 1_f), builtin::AddressSpace::kPrivate);
auto* lhs = Expr(1_f);
auto* rhs = Expr("a");
@@ -203,7 +203,7 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", vec3<f16>(1_h, 1_h, 1_h), type::AddressSpace::kPrivate);
+ GlobalVar("a", vec3<f16>(1_h, 1_h, 1_h), builtin::AddressSpace::kPrivate);
auto* lhs = Expr(1_h);
auto* rhs = Expr("a");
@@ -219,7 +219,7 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = Expr(1_f);
@@ -236,7 +236,7 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = Expr(1_h);
@@ -251,7 +251,7 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr(1_f);
auto* rhs = Expr("mat");
@@ -268,7 +268,7 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr(1_h);
auto* rhs = Expr("mat");
@@ -283,7 +283,7 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = vec3<f32>(1_f, 1_f, 1_f);
@@ -300,7 +300,7 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = vec3<f16>(1_h, 1_h, 1_h);
@@ -315,7 +315,7 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = vec3<f32>(1_f, 1_f, 1_f);
auto* rhs = Expr("mat");
@@ -332,7 +332,7 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = vec3<f16>(1_h, 1_h, 1_h);
auto* rhs = Expr("mat");
@@ -347,8 +347,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f32) {
- GlobalVar("lhs", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -363,8 +363,8 @@
TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("lhs", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -377,8 +377,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, ModF32) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -393,8 +393,8 @@
TEST_F(GlslGeneratorImplTest_Binary, ModF16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f16(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f16(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f16(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -407,8 +407,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32) {
- GlobalVar("a", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -423,8 +423,8 @@
TEST_F(GlslGeneratorImplTest_Binary, ModVec3F16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -437,8 +437,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32ScalarF32) {
- GlobalVar("a", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -453,8 +453,8 @@
TEST_F(GlslGeneratorImplTest_Binary, ModVec3F16ScalarF16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f16(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f16(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -467,8 +467,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, ModScalarF32Vec3F32) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -483,8 +483,8 @@
TEST_F(GlslGeneratorImplTest_Binary, ModScalarF16Vec3F16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f16(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -497,8 +497,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, ModMixedVec3ScalarF32) {
- GlobalVar("a", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr_vec_mod_vec =
create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("a"));
@@ -541,8 +541,8 @@
TEST_F(GlslGeneratorImplTest_Binary, ModMixedVec3ScalarF16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f16(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f16(), builtin::AddressSpace::kPrivate);
auto* expr_vec_mod_vec =
create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("a"));
@@ -584,8 +584,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Logical_And) {
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -604,10 +604,10 @@
TEST_F(GlslGeneratorImplTest_Binary, Logical_Multi) {
// (a && b) || (c || d)
- 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);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
@@ -636,8 +636,8 @@
}
TEST_F(GlslGeneratorImplTest_Binary, Logical_Or) {
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -663,9 +663,9 @@
// return 3i;
// }
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr =
If(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")),
@@ -700,9 +700,9 @@
TEST_F(GlslGeneratorImplTest_Binary, Return_WithLogical) {
// return (a && b) || c;
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = Return(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
@@ -728,10 +728,10 @@
TEST_F(GlslGeneratorImplTest_Binary, Assign_WithLogical) {
// a = (b || c) && d;
- 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);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr =
Assign(Expr("a"),
@@ -759,9 +759,9 @@
TEST_F(GlslGeneratorImplTest_Binary, Decl_WithLogical) {
// var a : bool = (b && c) || d;
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* var =
Var("a", ty.bool_(),
@@ -798,10 +798,10 @@
Param(Sym(), ty.bool_()),
},
ty.void_(), utils::Empty, utils::Empty);
- 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);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
utils::Vector params{
create<ast::BinaryExpression>(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 7526494..dc6f28b 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 @@
if (param.type == CallParamType::kF16) {
Enable(builtin::Extension::kF16);
- GlobalVar("h2", ty.vec2<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("h3", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("hm2x2", ty.mat2x2<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("hm3x2", ty.mat3x2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("h2", ty.vec2<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("h3", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("hm2x2", ty.mat2x2<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("hm3x2", ty.mat3x2<f16>(), builtin::AddressSpace::kPrivate);
}
- GlobalVar("f2", ty.vec2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("f3", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("u2", ty.vec2<u32>(), type::AddressSpace::kPrivate);
- GlobalVar("i2", ty.vec2<i32>(), type::AddressSpace::kPrivate);
- GlobalVar("b2", ty.vec2<bool>(), type::AddressSpace::kPrivate);
- GlobalVar("m2x2", ty.mat2x2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("m3x2", ty.mat3x2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("f2", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("f3", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("u2", ty.vec2<u32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("i2", ty.vec2<i32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b2", ty.vec2<bool>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("m2x2", ty.mat2x2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("m3x2", ty.mat3x2<f32>(), builtin::AddressSpace::kPrivate);
auto* call = GenerateCall(param.builtin, param.type, this);
ASSERT_NE(nullptr, call) << "Unhandled builtin";
@@ -342,8 +342,8 @@
TEST_F(GlslGeneratorImplTest_Builtin, Builtin_Call) {
auto* call = Call("dot", "param1", "param2");
- GlobalVar("param1", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
@@ -356,8 +356,8 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, Select_Scalar) {
- GlobalVar("a", Expr(1_f), type::AddressSpace::kPrivate);
- GlobalVar("b", Expr(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("a", Expr(1_f), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", Expr(2_f), builtin::AddressSpace::kPrivate);
auto* call = Call("select", "a", "b", true);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -369,8 +369,8 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, Select_Vector) {
- GlobalVar("a", vec2<i32>(1_i, 2_i), type::AddressSpace::kPrivate);
- GlobalVar("b", vec2<i32>(3_i, 4_i), type::AddressSpace::kPrivate);
+ GlobalVar("a", vec2<i32>(1_i, 2_i), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", vec2<i32>(3_i, 4_i), builtin::AddressSpace::kPrivate);
auto* call = Call("select", "a", "b", vec2<bool>(true, false));
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -384,9 +384,9 @@
TEST_F(GlslGeneratorImplTest_Builtin, FMA_f32) {
auto* call = Call("fma", "a", "b", "c");
- GlobalVar("a", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
@@ -401,9 +401,9 @@
TEST_F(GlslGeneratorImplTest_Builtin, FMA_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("a", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* call = Call("fma", "a", "b", "c");
WrapInFunction(CallStmt(call));
@@ -1226,7 +1226,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Pack4x8Snorm) {
auto* call = Call("pack4x8snorm", "p1");
- GlobalVar("p1", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1244,7 +1244,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Pack4x8Unorm) {
auto* call = Call("pack4x8unorm", "p1");
- GlobalVar("p1", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1262,7 +1262,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Pack2x16Snorm) {
auto* call = Call("pack2x16snorm", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1280,7 +1280,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Pack2x16Unorm) {
auto* call = Call("pack2x16unorm", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1298,7 +1298,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Pack2x16Float) {
auto* call = Call("pack2x16float", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1316,7 +1316,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Unpack4x8Snorm) {
auto* call = Call("unpack4x8snorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1334,7 +1334,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Unpack4x8Unorm) {
auto* call = Call("unpack4x8unorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1352,7 +1352,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Unpack2x16Snorm) {
auto* call = Call("unpack2x16snorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1370,7 +1370,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Unpack2x16Unorm) {
auto* call = Call("unpack2x16unorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1388,7 +1388,7 @@
TEST_F(GlslGeneratorImplTest_Builtin, Unpack2x16Float) {
auto* call = Call("unpack2x16float", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1451,7 +1451,7 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, DotI32) {
- GlobalVar("v", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(Call("dot", "v", "v")));
GeneratorImpl& gen = SanitizeAndBuild();
@@ -1477,7 +1477,7 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, DotU32) {
- GlobalVar("v", ty.vec3<u32>(), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.vec3<u32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(Call("dot", "v", "v")));
GeneratorImpl& gen = SanitizeAndBuild();
@@ -1503,7 +1503,7 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Scalar) {
- GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", Expr(2_f), builtin::AddressSpace::kPrivate);
WrapInFunction(Call("quantizeToF16", "v"));
GeneratorImpl& gen = SanitizeAndBuild();
@@ -1530,7 +1530,7 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Vec2) {
- GlobalVar("v", vec2<f32>(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec2<f32>(2_f), builtin::AddressSpace::kPrivate);
WrapInFunction(Call("quantizeToF16", "v"));
GeneratorImpl& gen = SanitizeAndBuild();
@@ -1557,7 +1557,7 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Vec3) {
- GlobalVar("v", vec3<f32>(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec3<f32>(2_f), builtin::AddressSpace::kPrivate);
WrapInFunction(Call("quantizeToF16", "v"));
GeneratorImpl& gen = SanitizeAndBuild();
@@ -1586,7 +1586,7 @@
}
TEST_F(GlslGeneratorImplTest_Builtin, QuantizeToF16_Vec4) {
- GlobalVar("v", vec4<f32>(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec4<f32>(2_f), builtin::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 4ea3790..2f81463 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 @@
Param(Sym(), ty.f32()),
},
ty.f32(), utils::Vector{Return(1.23_f)});
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::AddressSpace::kPrivate);
auto* call = Call("my_func", "param1", "param2");
WrapInFunction(call);
@@ -62,8 +62,8 @@
Param(Sym(), ty.f32()),
},
ty.void_(), utils::Empty, utils::Empty);
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::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 be96c9b..05d1460 100644
--- a/src/tint/writer/glsl/generator_impl_function_test.cc
+++ b/src/tint/writer/glsl/generator_impl_function_test.cc
@@ -110,8 +110,8 @@
// fn f(foo : ptr<function, f32>) -> f32 {
// return *foo;
// }
- Func("f", utils::Vector{Param("foo", ty.pointer<f32>(type::AddressSpace::kFunction))}, ty.f32(),
- utils::Vector{Return(Deref("foo"))});
+ Func("f", utils::Vector{Param("foo", ty.pointer<f32>(builtin::AddressSpace::kFunction))},
+ ty.f32(), utils::Vector{Return(Deref("foo"))});
GeneratorImpl& gen = SanitizeAndBuild();
@@ -352,7 +352,7 @@
TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_Uniform) {
auto* ubo_ty = Structure("UBO", utils::Vector{Member("coord", ty.vec4<f32>())});
auto* ubo =
- GlobalVar("ubo", ty.Of(ubo_ty), type::AddressSpace::kUniform, Binding(0_a), Group(1_a));
+ GlobalVar("ubo", ty.Of(ubo_ty), builtin::AddressSpace::kUniform, Binding(0_a), Group(1_a));
Func("sub_func",
utils::Vector{
@@ -402,7 +402,7 @@
TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_UniformStruct) {
auto* s = Structure("Uniforms", utils::Vector{Member("coord", ty.vec4<f32>())});
- GlobalVar("uniforms", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(1_a));
+ GlobalVar("uniforms", ty.Of(s), builtin::AddressSpace::kUniform, Binding(0_a), Group(1_a));
auto* var = Var("v", ty.f32(), MemberAccessor(MemberAccessor("uniforms", "coord"), "x"));
@@ -442,7 +442,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b"));
@@ -489,8 +489,8 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
- Group(1_a));
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Binding(0_a), Group(1_a));
auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b"));
@@ -537,7 +537,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
Func("frag_main", utils::Empty, ty.void_(),
@@ -582,7 +582,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
Func("frag_main", utils::Empty, ty.void_(),
@@ -623,7 +623,7 @@
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), type::AddressSpace::kUniform, Binding(0_a), Group(1_a));
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kUniform, Binding(0_a), Group(1_a));
Func("sub_func", utils::Vector{Param("param", ty.f32())}, ty.f32(),
utils::Vector{
@@ -668,7 +668,7 @@
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), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
Func("sub_func", utils::Vector{Param("param", ty.f32())}, ty.f32(),
@@ -879,7 +879,7 @@
auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())});
- GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("data", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 7e528ac..cd0b109 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 @@
using GlslGeneratorImplTest_Identifier = TestHelper;
TEST_F(GlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
- GlobalVar("foo", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("foo", ty.i32(), builtin::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 a0957e1..0713ab7 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 @@
using GlslGeneratorImplTest_If = TestHelper;
TEST_F(GlslGeneratorImplTest_If, Emit_If) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* cond = Expr("cond");
auto* body = Block(Return());
@@ -38,8 +38,8 @@
}
TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElseIf) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("else_cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* else_cond = Expr("else_cond");
auto* else_body = Block(Return());
@@ -65,7 +65,7 @@
}
TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElse) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* else_body = Block(Return());
@@ -88,8 +88,8 @@
}
TEST_F(GlslGeneratorImplTest_If, Emit_IfWithMultiple) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("else_cond", ty.bool_(), builtin::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 adfebe4..10da8aa 100644
--- a/src/tint/writer/glsl/generator_impl_import_test.cc
+++ b/src/tint/writer/glsl/generator_impl_import_test.cc
@@ -251,7 +251,7 @@
testing::Values(GlslImportData{"clamp", "clamp"}));
TEST_F(GlslGeneratorImplTest_Import, GlslImportData_Determinant) {
- GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat3x3<f32>(), builtin::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 79374a2..0979f53 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_LoopNestedWithContinuing) {
Func("a_statement", {}, ty.void_(), {});
- GlobalVar("lhs", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.f32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Break());
auto* continuing = Block(CallStmt(Call("a_statement")));
@@ -142,7 +142,7 @@
// }
// }
- GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.f32(), builtin::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 37005e8..e551c75 100644
--- a/src/tint/writer/glsl/generator_impl_member_accessor_test.cc
+++ b/src/tint/writer/glsl/generator_impl_member_accessor_test.cc
@@ -91,8 +91,8 @@
auto* s = b.Structure("Data", members);
- b.GlobalVar("data", b.ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
- b.Group(1_a), b.Binding(0_a));
+ b.GlobalVar("data", b.ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite, b.Group(1_a), b.Binding(0_a));
}
void SetupFunction(utils::VectorRef<const ast::Statement*> statements) {
@@ -112,7 +112,7 @@
TEST_F(GlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())});
- GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("str", ty.Of(s), builtin::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 cd4d821..e85d050 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 @@
TEST_F(GlslSanitizerTest, Call_ArrayLength) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -66,7 +66,7 @@
Member(0, "z", ty.f32()),
Member(4, "a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -105,7 +105,7 @@
TEST_F(GlslSanitizerTest, Call_ArrayLength_ViaLets) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* p = Let("p", AddressOf("b"));
@@ -233,7 +233,7 @@
// let p : ptr<function, i32> = &v;
// let x : i32 = *p;
auto* v = Var("v", ty.i32());
- auto* p = Let("p", ty.pointer<i32>(type::AddressSpace::kFunction), AddressOf(v));
+ auto* p = Let("p", ty.pointer<i32>(builtin::AddressSpace::kFunction), AddressOf(v));
auto* x = Var("x", ty.i32(), Deref(p));
Func("main", utils::Empty, ty.void_(),
@@ -274,11 +274,12 @@
// let vp : ptr<function, vec4<f32>> = &(*mp)[2i];
// let v : vec4<f32> = *vp;
auto* a = Var("a", ty.array(ty.mat4x4<f32>(), 4_u));
- auto* ap = Let("ap", ty.pointer(ty.array(ty.mat4x4<f32>(), 4_u), type::AddressSpace::kFunction),
- AddressOf(a));
- auto* mp = Let("mp", ty.pointer(ty.mat4x4<f32>(), type::AddressSpace::kFunction),
+ auto* ap =
+ Let("ap", ty.pointer(ty.array(ty.mat4x4<f32>(), 4_u), builtin::AddressSpace::kFunction),
+ AddressOf(a));
+ auto* mp = Let("mp", ty.pointer(ty.mat4x4<f32>(), builtin::AddressSpace::kFunction),
AddressOf(IndexAccessor(Deref(ap), 3_i)));
- auto* vp = Let("vp", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction),
+ auto* vp = Let("vp", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction),
AddressOf(IndexAccessor(Deref(mp), 2_i)));
auto* v = Var("v", ty.vec4<f32>(), 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 3572da4..7513e94 100644
--- a/src/tint/writer/glsl/generator_impl_storage_buffer_test.cc
+++ b/src/tint/writer/glsl/generator_impl_storage_buffer_test.cc
@@ -37,8 +37,8 @@
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), type::AddressSpace::kStorage, ctx->Binding(0_a),
- ctx->Group(0_a));
+ ctx->GlobalVar("nephews", ctx->ty.Of(nephews), builtin::AddressSpace::kStorage,
+ ctx->Binding(0_a), ctx->Group(0_a));
}
TEST_F(GlslGeneratorImplTest_StorageBuffer, Align) {
diff --git a/src/tint/writer/glsl/generator_impl_switch_test.cc b/src/tint/writer/glsl/generator_impl_switch_test.cc
index 2f90c8f..b9ff49d 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 @@
using GlslGeneratorImplTest_Switch = TestHelper;
TEST_F(GlslGeneratorImplTest_Switch, Emit_Switch) {
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
auto* def_body = Block(create<ast::BreakStatement>());
auto* def = create<ast::CaseStatement>(utils::Vector{DefaultCaseSelector()}, def_body);
@@ -51,7 +51,7 @@
}
TEST_F(GlslGeneratorImplTest_Switch, Emit_Switch_MixedDefault) {
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
auto* def_body = Block(create<ast::BreakStatement>());
auto* def = create<ast::CaseStatement>(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 b449253..9a24471 100644
--- a/src/tint/writer/glsl/generator_impl_test.cc
+++ b/src/tint/writer/glsl/generator_impl_test.cc
@@ -62,7 +62,7 @@
Builtin(builtin::BuiltinValue::kSampleIndex),
Disable(ast::DisabledValidation::kIgnoreAddressSpace),
},
- type::AddressSpace::kIn);
+ builtin::AddressSpace::kIn);
Func("my_func", utils::Empty, ty.i32(),
utils::Vector{
Return(Expr("gl_SampleID")),
@@ -87,7 +87,7 @@
Builtin(builtin::BuiltinValue::kSampleIndex),
Disable(ast::DisabledValidation::kIgnoreAddressSpace),
},
- type::AddressSpace::kIn);
+ builtin::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 72c5048..84972d6 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 @@
TEST_F(GlslGeneratorImplTest_Type, EmitType_Array) {
auto arr = ty.array<bool, 4>();
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "ary"))
<< gen.error();
EXPECT_EQ(out.str(), "bool ary[4]");
@@ -47,12 +47,12 @@
TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArray) {
auto arr = ty.array(ty.array<bool, 4>(), 5_u);
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "ary"))
<< gen.error();
EXPECT_EQ(out.str(), "bool ary[5][4]");
@@ -60,12 +60,12 @@
TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) {
auto arr = ty.array(ty.array(ty.array<bool, 4>(), 5_u), 6_u);
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "ary"))
<< gen.error();
EXPECT_EQ(out.str(), "bool ary[6][5][4]");
@@ -73,12 +73,12 @@
TEST_F(GlslGeneratorImplTest_Type, EmitType_Array_WithoutName) {
auto arr = ty.array<bool, 4>();
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "bool[4]");
@@ -90,8 +90,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, bool_, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, bool_, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "bool");
}
@@ -103,7 +103,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, f32, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, f32, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "float");
}
@@ -117,7 +117,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, f16, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, f16, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "float16_t");
}
@@ -129,7 +129,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, i32, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, i32, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "int");
}
@@ -142,8 +142,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, mat2x3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, mat2x3, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "mat2x3");
}
@@ -158,8 +158,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, mat2x3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, mat2x3, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "f16mat2x3");
}
@@ -169,7 +169,7 @@
Member("a", ty.i32()),
Member("b", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -189,14 +189,14 @@
Member("a", ty.i32()),
Member("b", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, sem_s, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, sem_s, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "S");
}
@@ -206,7 +206,7 @@
Member("double", ty.i32()),
Member("float", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = SanitizeAndBuild();
@@ -223,7 +223,7 @@
Member("a", ty.i32(), utils::Vector{MemberOffset(0_a)}),
Member("b", ty.f32(), utils::Vector{MemberOffset(8_a)}),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -245,7 +245,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, u32, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, u32, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "uint");
}
@@ -258,7 +258,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, vec3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, vec3, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "vec3");
}
@@ -273,7 +273,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, vec3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, vec3, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "f16vec3");
}
@@ -284,8 +284,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, void_, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, void_, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "void");
}
@@ -296,8 +296,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_FALSE(
- gen.EmitType(out, sampler, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_FALSE(gen.EmitType(out, sampler, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
}
@@ -307,8 +307,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_FALSE(
- gen.EmitType(out, sampler, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_FALSE(gen.EmitType(out, sampler, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
}
@@ -515,7 +515,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, s, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, s, builtin::AddressSpace::kUndefined, builtin::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 c0eb7b1..18f180e 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 @@
using GlslUnaryOpTest = TestHelper;
TEST_F(GlslUnaryOpTest, AddressOf) {
- GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.f32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
WrapInFunction(op);
@@ -32,7 +32,7 @@
}
TEST_F(GlslUnaryOpTest, Complement) {
- GlobalVar("expr", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.u32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr("expr"));
WrapInFunction(op);
@@ -44,7 +44,7 @@
}
TEST_F(GlslUnaryOpTest, Indirection) {
- GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("G", ty.f32(), builtin::AddressSpace::kPrivate);
auto* p = Let("expr", create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
WrapInFunction(p, op);
@@ -57,7 +57,7 @@
}
TEST_F(GlslUnaryOpTest, Not) {
- GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
WrapInFunction(op);
@@ -69,7 +69,7 @@
}
TEST_F(GlslUnaryOpTest, Negation) {
- GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.i32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(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 48f635a..2ace33c 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 @@
TEST_F(GlslGeneratorImplTest_UniformBuffer, Simple) {
auto* simple = Structure("Simple", utils::Vector{Member("member", ty.f32())});
- GlobalVar("simple", ty.Of(simple), type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
+ GlobalVar("simple", ty.Of(simple), builtin::AddressSpace::kUniform, Group(0_a), Binding(0_a));
GeneratorImpl& gen = Build();
@@ -46,7 +46,7 @@
TEST_F(GlslGeneratorImplTest_UniformBuffer, Simple_Desktop) {
auto* simple = Structure("Simple", utils::Vector{Member("member", ty.f32())});
- GlobalVar("simple", ty.Of(simple), type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
+ GlobalVar("simple", ty.Of(simple), builtin::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 a4d11cb..5691312 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_Private) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::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 97f8cf8..676025c 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 @@
using GlslGeneratorImplTest_WorkgroupVar = TestHelper;
TEST_F(GlslGeneratorImplTest_WorkgroupVar, Basic) {
- GlobalVar("wg", ty.f32(), type::AddressSpace::kWorkgroup);
+ GlobalVar("wg", ty.f32(), builtin::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, Aliased) {
auto* alias = Alias("F32", ty.f32());
- GlobalVar("wg", ty.Of(alias), type::AddressSpace::kWorkgroup);
+ GlobalVar("wg", ty.Of(alias), builtin::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 f75cf06..4d07497 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -335,8 +335,8 @@
auto* ty = builder_.Sem().Get(str);
auto address_space_uses = ty->AddressSpaceUsage();
if (address_space_uses.size() !=
- (address_space_uses.count(type::AddressSpace::kStorage) +
- address_space_uses.count(type::AddressSpace::kUniform))) {
+ (address_space_uses.count(builtin::AddressSpace::kStorage) +
+ address_space_uses.count(builtin::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
@@ -377,7 +377,7 @@
std::string fn;
{
std::ostringstream ss;
- if (!EmitType(ss, vec, tint::type::AddressSpace::kUndefined,
+ if (!EmitType(ss, vec, tint::builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return "";
}
@@ -386,12 +386,12 @@
{
auto out = line(&helpers_);
out << "void " << fn << "(inout ";
- if (!EmitTypeAndName(out, vec, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, vec, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "vec")) {
return "";
}
out << ", int idx, ";
- if (!EmitTypeAndName(out, vec->type(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, vec->type(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "val")) {
return "";
}
@@ -451,7 +451,7 @@
std::string fn;
{
std::ostringstream ss;
- if (!EmitType(ss, mat, tint::type::AddressSpace::kUndefined,
+ if (!EmitType(ss, mat, tint::builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return "";
}
@@ -460,12 +460,12 @@
{
auto out = line(&helpers_);
out << "void " << fn << "(inout ";
- if (!EmitTypeAndName(out, mat, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, mat, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "mat")) {
return "";
}
out << ", int col, ";
- if (!EmitTypeAndName(out, mat->ColumnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, mat->ColumnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "val")) {
return "";
}
@@ -520,7 +520,7 @@
std::string fn;
{
std::ostringstream ss;
- if (!EmitType(ss, mat, tint::type::AddressSpace::kUndefined,
+ if (!EmitType(ss, mat, tint::builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return "";
}
@@ -529,12 +529,12 @@
{
auto out = line(&helpers_);
out << "void " << fn << "(inout ";
- if (!EmitTypeAndName(out, mat, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, mat, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "mat")) {
return "";
}
out << ", int col, int row, ";
- if (!EmitTypeAndName(out, mat->type(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, mat->type(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "val")) {
return "";
}
@@ -642,7 +642,7 @@
}
out << "as";
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
return false;
}
out << "(";
@@ -909,9 +909,9 @@
if (auto* intrinsic = ast::GetAttribute<transform::DecomposeMemoryAccess::Intrinsic>(
func->Declaration()->attributes)) {
switch (intrinsic->address_space) {
- case type::AddressSpace::kUniform:
+ case builtin::AddressSpace::kUniform:
return EmitUniformBufferAccess(out, expr, intrinsic);
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
if (!intrinsic->IsAtomic()) {
return EmitStorageBufferAccess(out, expr, intrinsic);
}
@@ -1030,8 +1030,8 @@
bool GeneratorImpl::EmitTypeConversion(std::ostream& out,
const sem::Call* call,
const sem::TypeConversion* conv) {
- if (!EmitType(out, conv->Target(), type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
- "")) {
+ if (!EmitType(out, conv->Target(), builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, "")) {
return false;
}
out << "(";
@@ -1076,7 +1076,8 @@
if (brackets) {
out << "{";
} else {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, "")) {
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ "")) {
return false;
}
out << "(";
@@ -1593,12 +1594,12 @@
auto rmw = [&](const char* hlsl) -> bool {
{
auto fn = line(&buf);
- if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, name)) {
return false;
}
fn << "(RWByteAddressBuffer buffer, uint offset, ";
- if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "value")) {
return false;
}
@@ -1614,7 +1615,7 @@
{
auto l = line(&buf);
- if (!EmitTypeAndName(l, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(l, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "original_value")) {
return false;
}
@@ -1663,7 +1664,7 @@
// InterlockedOr using 0 as the OR value
{
auto fn = line(&buf);
- if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, name)) {
return false;
}
@@ -1679,7 +1680,7 @@
{
auto l = line(&buf);
- if (!EmitTypeAndName(l, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(l, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "value")) {
return false;
}
@@ -1697,7 +1698,7 @@
{
auto fn = line(&buf);
fn << "void " << name << "(RWByteAddressBuffer buffer, uint offset, ";
- if (!EmitTypeAndName(fn, value_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "value")) {
return false;
}
@@ -1713,7 +1714,7 @@
{
auto l = line(&buf);
- if (!EmitTypeAndName(l, value_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(l, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "ignored")) {
return false;
}
@@ -1728,17 +1729,17 @@
auto* value_ty = params[2]->Type()->UnwrapRef();
{
auto fn = line(&buf);
- if (!EmitTypeAndName(fn, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, name)) {
return false;
}
fn << "(RWByteAddressBuffer buffer, uint offset, ";
- if (!EmitTypeAndName(fn, value_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "compare")) {
return false;
}
fn << ", ";
- if (!EmitTypeAndName(fn, value_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "value")) {
return false;
}
@@ -1754,7 +1755,7 @@
{ // T result = {0};
auto l = line(&buf);
- if (!EmitTypeAndName(l, result_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(l, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "result")) {
return false;
}
@@ -1789,7 +1790,7 @@
if (!builtin->ReturnType()->Is<type::Void>()) {
auto pre = line();
- if (!EmitTypeAndName(pre, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(pre, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, result)) {
return false;
}
@@ -1853,7 +1854,7 @@
{ // T result = 0;
auto pre = line();
auto* value_ty = builtin->Parameters()[1]->Type()->UnwrapRef();
- if (!EmitTypeAndName(pre, value_ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(pre, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, result)) {
return false;
}
@@ -1892,7 +1893,7 @@
{ // T compare_value = <compare_value>;
auto pre = line();
if (!EmitTypeAndName(pre, TypeOf(compare_value)->UnwrapRef(),
- type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
compare)) {
return false;
}
@@ -2002,7 +2003,7 @@
{
auto l = line(b);
- if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitType(l, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return false;
}
@@ -2044,7 +2045,7 @@
line(b) << member_type << " fract = frexp(" << in << ", exp);";
{
auto l = line(b);
- if (!EmitType(l, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitType(l, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "")) {
return false;
}
@@ -2082,7 +2083,7 @@
// 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(), type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, arg->Type(), builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
@@ -2863,7 +2864,7 @@
// Emit storage atomic helpers
if (auto* intrinsic =
ast::GetAttribute<transform::DecomposeMemoryAccess::Intrinsic>(func->attributes)) {
- if (intrinsic->address_space == type::AddressSpace::kStorage && intrinsic->IsAtomic()) {
+ if (intrinsic->address_space == builtin::AddressSpace::kStorage && intrinsic->IsAtomic()) {
if (!EmitStorageAtomicIntrinsic(func, intrinsic)) {
return false;
}
@@ -2885,14 +2886,14 @@
auto typedef_name = UniqueIdentifier(name + "_ret");
auto pre = line();
pre << "typedef ";
- if (!EmitTypeAndName(pre, sem->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(pre, sem->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, typedef_name)) {
return false;
}
pre << ";";
out << typedef_name;
} else {
- if (!EmitType(out, sem->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitType(out, sem->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "")) {
return false;
}
@@ -2909,14 +2910,14 @@
first = false;
auto const* type = v->Type();
- auto address_space = type::AddressSpace::kUndefined;
+ auto address_space = builtin::AddressSpace::kUndefined;
auto access = builtin::Access::kUndefined;
if (auto* ptr = type->As<type::Pointer>()) {
type = ptr->StoreType();
switch (ptr->AddressSpace()) {
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kUniform:
+ case builtin::AddressSpace::kStorage:
+ case builtin::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
@@ -2983,7 +2984,7 @@
auto name = builder_.Symbols().NameFor(builder_.Symbols().New("unused"));
{
auto out = line();
- if (!EmitTypeAndName(out, sem->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, sem->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, name)) {
return false;
}
@@ -3000,17 +3001,17 @@
[&](const ast::Var* var) {
auto* sem = builder_.Sem().Get(global);
switch (sem->AddressSpace()) {
- case type::AddressSpace::kUniform:
+ case builtin::AddressSpace::kUniform:
return EmitUniformVariable(var, sem);
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
return EmitStorageVariable(var, sem);
- case type::AddressSpace::kHandle:
+ case builtin::AddressSpace::kHandle:
return EmitHandleVariable(var, sem);
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kPrivate:
return EmitPrivateVariable(sem);
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
return EmitWorkgroupVariable(sem);
- case type::AddressSpace::kPushConstant:
+ case builtin::AddressSpace::kPushConstant:
diagnostics_.add_error(
diag::System::Writer,
"unhandled address space " + utils::ToString(sem->AddressSpace()));
@@ -3049,7 +3050,7 @@
{
ScopedIndent si(this);
auto out = line();
- if (!EmitTypeAndName(out, type, type::AddressSpace::kUniform, sem->Access(), name)) {
+ if (!EmitTypeAndName(out, type, builtin::AddressSpace::kUniform, sem->Access(), name)) {
return false;
}
out << ";";
@@ -3063,7 +3064,7 @@
bool GeneratorImpl::EmitStorageVariable(const ast::Var* var, const sem::Variable* sem) {
auto* type = sem->Type()->UnwrapRef();
auto out = line();
- if (!EmitTypeAndName(out, type, type::AddressSpace::kStorage, sem->Access(),
+ if (!EmitTypeAndName(out, type, builtin::AddressSpace::kStorage, sem->Access(),
builder_.Symbols().NameFor(var->name->symbol))) {
return false;
}
@@ -3241,7 +3242,7 @@
out << ")]" << std::endl;
}
- if (!EmitTypeAndName(out, func_sem->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, func_sem->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined,
builder_.Symbols().NameFor(func->name->symbol))) {
return false;
@@ -3337,7 +3338,7 @@
return true;
}
- if (!EmitType(out, v, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitType(out, v, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
"")) {
return false;
}
@@ -3355,7 +3356,7 @@
return true;
},
[&](const type::Matrix* m) {
- if (!EmitType(out, m, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitType(out, m, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
"")) {
return false;
}
@@ -3375,8 +3376,8 @@
[&](const type::Array* a) {
if (constant->AllZero()) {
out << "(";
- if (!EmitType(out, a, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
- "")) {
+ if (!EmitType(out, a, builtin::AddressSpace::kUndefined,
+ builtin::Access::kUndefined, "")) {
return false;
}
out << ")0";
@@ -3516,7 +3517,7 @@
return true;
},
[&](const type::Vector* vec) {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
@@ -3532,7 +3533,7 @@
return true;
},
[&](const type::Matrix* mat) {
- if (!EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kReadWrite,
+ if (!EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
"")) {
return false;
}
@@ -3550,14 +3551,14 @@
[&](const sem::Struct*) {
out << "(";
TINT_DEFER(out << ")" << value);
- return EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
- "");
+ return EmitType(out, type, builtin::AddressSpace::kUndefined,
+ builtin::Access::kUndefined, "");
},
[&](const type::Array*) {
out << "(";
TINT_DEFER(out << ")" << value);
- return EmitType(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
- "");
+ return EmitType(out, type, builtin::AddressSpace::kUndefined,
+ builtin::Access::kUndefined, "");
},
[&](Default) {
diagnostics_.add_error(
@@ -3931,7 +3932,7 @@
bool GeneratorImpl::EmitType(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const std::string& name,
bool* name_printed /* = nullptr */) {
@@ -3939,13 +3940,13 @@
*name_printed = false;
}
switch (address_space) {
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
if (access != builtin::Access::kRead) {
out << "RW";
}
out << "ByteAddressBuffer";
return true;
- case type::AddressSpace::kUniform: {
+ case builtin::AddressSpace::kUniform: {
auto array_length = (type->Size() + 15) / 16;
out << "uint4 " << name << "[" << array_length << "]";
if (name_printed) {
@@ -4158,7 +4159,7 @@
bool GeneratorImpl::EmitTypeAndName(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const std::string& name) {
bool name_printed = false;
@@ -4241,7 +4242,7 @@
}
out << pre;
- if (!EmitTypeAndName(out, ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(out, ty, builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, mem_name)) {
return false;
}
@@ -4311,7 +4312,7 @@
auto out = line();
out << "const ";
- if (!EmitTypeAndName(out, type, type::AddressSpace::kUndefined, builtin::Access::kUndefined,
+ if (!EmitTypeAndName(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
builder_.Symbols().NameFor(let->name->symbol))) {
return false;
}
@@ -4338,7 +4339,7 @@
std::vector<std::string> parameter_names;
{
auto decl = line(&b);
- if (!EmitTypeAndName(decl, builtin->ReturnType(), type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, builtin->ReturnType(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, fn_name)) {
return "";
}
@@ -4354,7 +4355,7 @@
decl << "inout ";
ty = ptr->StoreType();
}
- if (!EmitTypeAndName(decl, ty, type::AddressSpace::kUndefined,
+ if (!EmitTypeAndName(decl, ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, param_name)) {
return "";
}
diff --git a/src/tint/writer/hlsl/generator_impl.h b/src/tint/writer/hlsl/generator_impl.h
index 1e2faa1..da846f4 100644
--- a/src/tint/writer/hlsl/generator_impl.h
+++ b/src/tint/writer/hlsl/generator_impl.h
@@ -413,7 +413,7 @@
/// @returns true if the type is emitted
bool EmitType(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::Access access,
const std::string& name,
bool* name_printed = nullptr);
@@ -426,7 +426,7 @@
/// @returns true if the type is emitted
bool EmitTypeAndName(std::ostream& out,
const type::Type* type,
- type::AddressSpace address_space,
+ builtin::AddressSpace address_space,
builtin::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 71bf057..73eea96 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 @@
using HlslGeneratorImplTest_Expression = TestHelper;
TEST_F(HlslGeneratorImplTest_Expression, IndexAccessor) {
- GlobalVar("ary", ty.array<i32, 10>(), type::AddressSpace::kPrivate);
+ GlobalVar("ary", ty.array<i32, 10>(), builtin::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 eee3fed..c99ae54 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 @@
return;
}
- GlobalVar("left", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.f32(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -82,8 +82,8 @@
Enable(builtin::Extension::kF16);
- GlobalVar("left", ty.f16(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.f16(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.f16(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.f16(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -105,8 +105,8 @@
return;
}
- GlobalVar("left", ty.u32(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.u32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.u32(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -133,8 +133,8 @@
return;
}
- GlobalVar("left", ty.i32(), type::AddressSpace::kPrivate);
- GlobalVar("right", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("left", ty.i32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", ty.i32(), builtin::AddressSpace::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
@@ -237,7 +237,7 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = Expr(1_f);
@@ -254,7 +254,7 @@
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = Expr(1_h);
@@ -269,7 +269,7 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr(1_f);
auto* rhs = Expr("mat");
@@ -286,7 +286,7 @@
TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr(1_h);
auto* rhs = Expr("mat");
@@ -301,7 +301,7 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = vec3<f32>(1_f, 1_f, 1_f);
@@ -318,7 +318,7 @@
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = vec3<f16>(1_h, 1_h, 1_h);
@@ -333,7 +333,7 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f32) {
- GlobalVar("mat", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* lhs = vec3<f32>(1_f, 1_f, 1_f);
auto* rhs = Expr("mat");
@@ -350,7 +350,7 @@
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("mat", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("mat", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* lhs = vec3<f16>(1_h, 1_h, 1_h);
auto* rhs = Expr("mat");
@@ -365,8 +365,8 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f32) {
- GlobalVar("lhs", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -381,8 +381,8 @@
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix_f16) {
Enable(builtin::Extension::kF16);
- GlobalVar("lhs", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
@@ -395,8 +395,8 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -415,10 +415,10 @@
TEST_F(HlslGeneratorImplTest_Binary, Logical_Multi) {
// (a && b) || (c || d)
- 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);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
@@ -447,8 +447,8 @@
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_Or) {
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -474,9 +474,9 @@
// return 3i;
// }
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr =
If(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b")),
@@ -511,9 +511,9 @@
TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) {
// return (a && b) || c;
- GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr = Return(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
@@ -539,10 +539,10 @@
TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) {
// a = (b || c) && d;
- 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);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* expr =
Assign(Expr("a"),
@@ -570,12 +570,12 @@
TEST_F(HlslGeneratorImplTest_Binary, Decl_WithLogical) {
// var a : bool = (b && c) || d;
- GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("d", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* var =
- Var("a", ty.bool_(), type::AddressSpace::kUndefined,
+ Var("a", ty.bool_(), builtin::AddressSpace::kUndefined,
create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("b"), Expr("c")),
@@ -609,10 +609,10 @@
Param(Sym(), ty.bool_()),
},
ty.void_(), utils::Empty, utils::Empty);
- 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);
+ GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("d", ty.bool_(), builtin::AddressSpace::kPrivate);
utils::Vector params{
create<ast::BinaryExpression>(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 9811b79..c3b5b49 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 @@
if (param.type == CallParamType::kF16) {
Enable(builtin::Extension::kF16);
- GlobalVar("h2", ty.vec2<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("h3", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("hm2x2", ty.mat2x2<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("hm3x2", ty.mat3x2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("h2", ty.vec2<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("h3", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("hm2x2", ty.mat2x2<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("hm3x2", ty.mat3x2<f16>(), builtin::AddressSpace::kPrivate);
}
- GlobalVar("f2", ty.vec2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("f3", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("u2", ty.vec2<u32>(), type::AddressSpace::kPrivate);
- GlobalVar("i2", ty.vec2<i32>(), type::AddressSpace::kPrivate);
- GlobalVar("b2", ty.vec2<bool>(), type::AddressSpace::kPrivate);
- GlobalVar("m2x2", ty.mat2x2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("m3x2", ty.mat3x2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("f2", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("f3", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("u2", ty.vec2<u32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("i2", ty.vec2<i32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b2", ty.vec2<bool>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("m2x2", ty.mat2x2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("m3x2", ty.mat3x2<f32>(), builtin::AddressSpace::kPrivate);
auto* call = GenerateCall(param.builtin, param.type, this);
ASSERT_NE(nullptr, call) << "Unhandled builtin";
@@ -339,8 +339,8 @@
TEST_F(HlslGeneratorImplTest_Builtin, Builtin_Call) {
auto* call = Call("dot", "param1", "param2");
- GlobalVar("param1", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
@@ -353,8 +353,8 @@
}
TEST_F(HlslGeneratorImplTest_Builtin, Select_Scalar) {
- GlobalVar("a", Expr(1_f), type::AddressSpace::kPrivate);
- GlobalVar("b", Expr(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("a", Expr(1_f), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", Expr(2_f), builtin::AddressSpace::kPrivate);
auto* call = Call("select", "a", "b", true);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -366,8 +366,8 @@
}
TEST_F(HlslGeneratorImplTest_Builtin, Select_Vector) {
- GlobalVar("a", vec2<i32>(1_i, 2_i), type::AddressSpace::kPrivate);
- GlobalVar("b", vec2<i32>(3_i, 4_i), type::AddressSpace::kPrivate);
+ GlobalVar("a", vec2<i32>(1_i, 2_i), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", vec2<i32>(3_i, 4_i), builtin::AddressSpace::kPrivate);
auto* call = Call("select", "a", "b", vec2<bool>(true, false));
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1086,7 +1086,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Pack4x8Snorm) {
auto* call = Call("pack4x8snorm", "p1");
- GlobalVar("p1", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1108,7 +1108,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Pack4x8Unorm) {
auto* call = Call("pack4x8unorm", "p1");
- GlobalVar("p1", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1130,7 +1130,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Pack2x16Snorm) {
auto* call = Call("pack2x16snorm", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1152,7 +1152,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Pack2x16Unorm) {
auto* call = Call("pack2x16unorm", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1174,7 +1174,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Pack2x16Float) {
auto* call = Call("pack2x16float", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1196,7 +1196,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Unpack4x8Snorm) {
auto* call = Call("unpack4x8snorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1219,7 +1219,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Unpack4x8Unorm) {
auto* call = Call("unpack4x8unorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1242,7 +1242,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Unpack2x16Snorm) {
auto* call = Call("unpack2x16snorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1265,7 +1265,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Unpack2x16Unorm) {
auto* call = Call("unpack2x16unorm", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1288,7 +1288,7 @@
TEST_F(HlslGeneratorImplTest_Builtin, Unpack2x16Float) {
auto* call = Call("unpack2x16float", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::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 46b1406..9947a08 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 @@
Param(Sym(), ty.f32()),
},
ty.f32(), utils::Vector{Return(1.23_f)});
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::AddressSpace::kPrivate);
auto* call = Call("my_func", "param1", "param2");
WrapInFunction(call);
@@ -62,8 +62,8 @@
Param(Sym(), ty.f32()),
},
ty.void_(), utils::Empty, utils::Empty);
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::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 43e474a..fbef3f2 100644
--- a/src/tint/writer/hlsl/generator_impl_function_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_function_test.cc
@@ -101,8 +101,8 @@
// fn f(foo : ptr<function, f32>) -> f32 {
// return *foo;
// }
- Func("f", utils::Vector{Param("foo", ty.pointer<f32>(type::AddressSpace::kFunction))}, ty.f32(),
- utils::Vector{Return(Deref("foo"))});
+ Func("f", utils::Vector{Param("foo", ty.pointer<f32>(builtin::AddressSpace::kFunction))},
+ ty.f32(), utils::Vector{Return(Deref("foo"))});
GeneratorImpl& gen = SanitizeAndBuild();
@@ -360,7 +360,7 @@
TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_Uniform) {
auto* ubo_ty = Structure("UBO", utils::Vector{Member("coord", ty.vec4<f32>())});
auto* ubo =
- GlobalVar("ubo", ty.Of(ubo_ty), type::AddressSpace::kUniform, Binding(0_a), Group(1_a));
+ GlobalVar("ubo", ty.Of(ubo_ty), builtin::AddressSpace::kUniform, Binding(0_a), Group(1_a));
Func("sub_func",
utils::Vector{
@@ -403,7 +403,7 @@
TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_UniformStruct) {
auto* s = Structure("Uniforms", utils::Vector{Member("coord", ty.vec4<f32>())});
- GlobalVar("uniforms", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(1_a));
+ GlobalVar("uniforms", ty.Of(s), builtin::AddressSpace::kUniform, Binding(0_a), Group(1_a));
auto* var = Var("v", ty.f32(), MemberAccessor(MemberAccessor("uniforms", "coord"), "x"));
@@ -436,7 +436,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b"));
@@ -469,8 +469,8 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
- Group(1_a));
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Binding(0_a), Group(1_a));
auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b"));
@@ -502,7 +502,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
Func("frag_main", utils::Empty, ty.void_(),
@@ -533,7 +533,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
Func("frag_main", utils::Empty, ty.void_(),
@@ -560,7 +560,7 @@
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), type::AddressSpace::kUniform, Binding(0_a), Group(1_a));
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kUniform, Binding(0_a), Group(1_a));
Func("sub_func",
utils::Vector{
@@ -602,7 +602,7 @@
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), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(1_a));
Func("sub_func",
@@ -830,7 +830,7 @@
auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())});
- GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("data", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 c28e757..1e2b47b 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 @@
using HlslGeneratorImplTest_Identifier = TestHelper;
TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
- GlobalVar("foo", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("foo", ty.i32(), builtin::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 c599648..9feb41e 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 @@
using HlslGeneratorImplTest_If = TestHelper;
TEST_F(HlslGeneratorImplTest_If, Emit_If) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* cond = Expr("cond");
auto* body = Block(Return());
@@ -38,8 +38,8 @@
}
TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("else_cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* else_cond = Expr("else_cond");
auto* else_body = Block(Return());
@@ -65,7 +65,7 @@
}
TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* else_body = Block(Return());
@@ -88,8 +88,8 @@
}
TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("else_cond", ty.bool_(), builtin::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 de864c4..425c663 100644
--- a/src/tint/writer/hlsl/generator_impl_import_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_import_test.cc
@@ -252,7 +252,7 @@
testing::Values(HlslImportData{"clamp", "clamp"}));
TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) {
- GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("determinant", "var");
WrapInFunction(expr);
@@ -265,7 +265,7 @@
}
TEST_F(HlslGeneratorImplTest_Import, HlslImportData_QuantizeToF16_Scalar) {
- GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", Expr(2_f), builtin::AddressSpace::kPrivate);
auto* expr = Call("quantizeToF16", "v");
WrapInFunction(expr);
@@ -278,7 +278,7 @@
}
TEST_F(HlslGeneratorImplTest_Import, HlslImportData_QuantizeToF16_Vector) {
- GlobalVar("v", vec3<f32>(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec3<f32>(2_f), builtin::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 620543d..45bf04a 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_LoopNestedWithContinuing) {
Func("a_statement", {}, ty.void_(), {});
- GlobalVar("lhs", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.f32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Break());
auto* continuing = Block(CallStmt(Call("a_statement")));
@@ -142,7 +142,7 @@
// }
// }
- GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.f32(), builtin::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 2c11fc2..0a2112b 100644
--- a/src/tint/writer/hlsl/generator_impl_member_accessor_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_member_accessor_test.cc
@@ -93,16 +93,16 @@
ProgramBuilder& b = *this;
auto* s = b.Structure("Data", members);
- b.GlobalVar("data", b.ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
- b.Group(1_a), b.Binding(0_a));
+ b.GlobalVar("data", b.ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kReadWrite, b.Group(1_a), b.Binding(0_a));
}
void SetupUniformBuffer(utils::VectorRef<const ast::StructMember*> members) {
ProgramBuilder& b = *this;
auto* s = b.Structure("Data", members);
- b.GlobalVar("data", b.ty.Of(s), type::AddressSpace::kUniform, builtin::Access::kUndefined,
- b.Group(1_a), b.Binding(1_a));
+ b.GlobalVar("data", b.ty.Of(s), builtin::AddressSpace::kUniform,
+ builtin::Access::kUndefined, b.Group(1_a), b.Binding(1_a));
}
void SetupFunction(utils::VectorRef<const ast::Statement*> statements) {
@@ -122,7 +122,7 @@
TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())});
- GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("str", ty.Of(s), builtin::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 8013045..b7d1bb9 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 @@
TEST_F(HlslSanitizerTest, Call_ArrayLength) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -60,7 +60,7 @@
Member(0, "z", ty.f32()),
Member(4, "a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -92,7 +92,7 @@
TEST_F(HlslSanitizerTest, Call_ArrayLength_ViaLets) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* p = Let("p", AddressOf("b"));
@@ -129,9 +129,9 @@
TEST_F(HlslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniform) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
- GlobalVar("c", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(2_a),
+ GlobalVar("c", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(2_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -242,7 +242,7 @@
// let p : ptr<function, i32> = &v;
// let x : i32 = *p;
auto* v = Var("v", ty.i32());
- auto* p = Let("p", ty.pointer<i32>(type::AddressSpace::kFunction), AddressOf(v));
+ auto* p = Let("p", ty.pointer<i32>(builtin::AddressSpace::kFunction), AddressOf(v));
auto* x = Var("x", ty.i32(), Deref(p));
Func("main", utils::Empty, ty.void_(),
@@ -276,11 +276,12 @@
// let vp : ptr<function, vec4<f32>> = &(*mp)[2i];
// let v : vec4<f32> = *vp;
auto* a = Var("a", ty.array(ty.mat4x4<f32>(), 4_u));
- auto* ap = Let("ap", ty.pointer(ty.array(ty.mat4x4<f32>(), 4_u), type::AddressSpace::kFunction),
- AddressOf(a));
- auto* mp = Let("mp", ty.pointer(ty.mat4x4<f32>(), type::AddressSpace::kFunction),
+ auto* ap =
+ Let("ap", ty.pointer(ty.array(ty.mat4x4<f32>(), 4_u), builtin::AddressSpace::kFunction),
+ AddressOf(a));
+ auto* mp = Let("mp", ty.pointer(ty.mat4x4<f32>(), builtin::AddressSpace::kFunction),
AddressOf(IndexAccessor(Deref(ap), 3_i)));
- auto* vp = Let("vp", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction),
+ auto* vp = Let("vp", ty.pointer(ty.vec4<f32>(), builtin::AddressSpace::kFunction),
AddressOf(IndexAccessor(Deref(mp), 2_i)));
auto* v = Var("v", ty.vec4<f32>(), 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 6426b7c..810a99b 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 @@
using HlslGeneratorImplTest_Switch = TestHelper;
TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) {
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
auto* s = Switch( //
Expr("cond"), //
Case(CaseSelector(5_i), Block(Break())), //
@@ -46,7 +46,7 @@
}
TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch_MixedDefault) {
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
auto* s = Switch( //
Expr("cond"), //
Case(utils::Vector{CaseSelector(5_i), DefaultCaseSelector()}, Block(Break())));
@@ -76,8 +76,8 @@
// }
// }
// }
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
- GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* s = Switch( //
Expr("cond"), //
DefaultCase(Block(Assign(Expr("a"), Expr(42_i)))));
@@ -109,13 +109,13 @@
// }
// }
// }
- GlobalVar("global", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("global", ty.i32(), builtin::AddressSpace::kPrivate);
Func("bar", {}, ty.i32(),
utils::Vector{ //
Assign("global", Expr(84_i)), //
Return("global")});
- GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* s = Switch( //
Call("bar"), //
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 0aa019e..30ca010 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 @@
TEST_F(HlslGeneratorImplTest_Type, EmitType_Array) {
auto arr = ty.array<bool, 4>();
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "ary"))
<< gen.error();
EXPECT_EQ(out.str(), "bool ary[4]");
@@ -47,12 +47,12 @@
TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArray) {
auto arr = ty.array(ty.array<bool, 4>(), 5_u);
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "ary"))
<< gen.error();
EXPECT_EQ(out.str(), "bool ary[5][4]");
@@ -60,12 +60,12 @@
TEST_F(HlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) {
auto arr = ty.array(ty.array(ty.array<bool, 4>(), 5_u), 6_u);
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, "ary"))
<< gen.error();
EXPECT_EQ(out.str(), "bool ary[6][5][4]");
@@ -73,12 +73,12 @@
TEST_F(HlslGeneratorImplTest_Type, EmitType_Array_WithoutName) {
auto arr = ty.array<bool, 4>();
- ast::Type ty = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), type::AddressSpace::kUndefined,
+ ASSERT_TRUE(gen.EmitType(out, program->TypeOf(ty), builtin::AddressSpace::kUndefined,
builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "bool[4]");
@@ -90,8 +90,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, bool_, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, bool_, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "bool");
}
@@ -103,7 +103,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, f16, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, f16, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "float16_t");
}
@@ -115,7 +115,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, f32, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, f32, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "float");
}
@@ -127,7 +127,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, i32, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, i32, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "int");
}
@@ -140,8 +140,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, mat2x3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, mat2x3, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "matrix<float16_t, 2, 3>");
}
@@ -154,8 +154,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, mat2x3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, mat2x3, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "float2x3");
}
@@ -165,7 +165,7 @@
Member("a", ty.i32()),
Member("b", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -184,7 +184,7 @@
Member("a", ty.i32()),
Member("b", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(0_a));
GeneratorImpl& gen = Build();
@@ -198,14 +198,14 @@
Member("a", ty.i32()),
Member("b", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, sem_s, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, sem_s, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "S");
}
@@ -215,7 +215,7 @@
Member("double", ty.i32()),
Member("float", ty.f32()),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = SanitizeAndBuild();
@@ -232,7 +232,7 @@
Member("a", ty.i32(), utils::Vector{MemberOffset(0_a)}),
Member("b", ty.f32(), utils::Vector{MemberOffset(8_a)}),
});
- GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("g", ty.Of(s), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -253,7 +253,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, u32, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, u32, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "uint");
}
@@ -266,7 +266,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, vec3, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, vec3, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "float3");
}
@@ -277,8 +277,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, void_, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, void_, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "void");
}
@@ -289,8 +289,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, sampler, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, sampler, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "SamplerState");
}
@@ -301,8 +301,8 @@
GeneratorImpl& gen = Build();
std::stringstream out;
- ASSERT_TRUE(
- gen.EmitType(out, sampler, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ ASSERT_TRUE(gen.EmitType(out, sampler, builtin::AddressSpace::kUndefined,
+ builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "SamplerComparisonState");
}
@@ -513,7 +513,7 @@
std::stringstream out;
ASSERT_TRUE(
- gen.EmitType(out, s, type::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
+ gen.EmitType(out, s, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
<< gen.error();
EXPECT_EQ(out.str(), "Texture2DMS<float4>");
}
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 93a61dc..4bf4329 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 @@
using HlslUnaryOpTest = TestHelper;
TEST_F(HlslUnaryOpTest, AddressOf) {
- GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.f32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
WrapInFunction(op);
@@ -32,7 +32,7 @@
}
TEST_F(HlslUnaryOpTest, Complement) {
- GlobalVar("expr", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.u32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr("expr"));
WrapInFunction(op);
@@ -44,7 +44,7 @@
}
TEST_F(HlslUnaryOpTest, Indirection) {
- GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("G", ty.f32(), builtin::AddressSpace::kPrivate);
auto* p = Let("expr", create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
WrapInFunction(p, op);
@@ -57,7 +57,7 @@
}
TEST_F(HlslUnaryOpTest, Not) {
- GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
WrapInFunction(op);
@@ -69,7 +69,7 @@
}
TEST_F(HlslUnaryOpTest, Negation) {
- GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.i32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(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 fedf476..f8420ae 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_Private) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::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 ea30962..3895aba 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 @@
using HlslGeneratorImplTest_WorkgroupVar = TestHelper;
TEST_F(HlslGeneratorImplTest_WorkgroupVar, Basic) {
- GlobalVar("wg", ty.f32(), type::AddressSpace::kWorkgroup);
+ GlobalVar("wg", ty.f32(), builtin::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, Aliased) {
auto* alias = Alias("F32", ty.f32());
- GlobalVar("wg", ty.Of(alias), type::AddressSpace::kWorkgroup);
+ GlobalVar("wg", ty.Of(alias), builtin::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 5fc779a..5c77e47 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -204,7 +204,7 @@
// Use the SSBO binding numbers as the indices for the buffer size lookups.
for (auto* var : in->AST().GlobalVariables()) {
auto* global = in->Sem().Get<sem::GlobalVariable>(var);
- if (global && global->AddressSpace() == type::AddressSpace::kStorage) {
+ if (global && global->AddressSpace() == builtin::AddressSpace::kStorage) {
array_length_from_uniform_cfg.bindpoint_to_size_index.emplace(
global->BindingPoint(), global->BindingPoint().binding);
}
@@ -2048,15 +2048,15 @@
},
[&](const type::Pointer* ptr) {
switch (ptr->AddressSpace()) {
- case type::AddressSpace::kWorkgroup: {
+ case builtin::AddressSpace::kWorkgroup: {
auto& allocations = workgroup_allocations_[func_name];
out << " [[threadgroup(" << allocations.size() << ")]]";
allocations.push_back(ptr->StoreType()->Size());
return true;
}
- case type::AddressSpace::kStorage:
- case type::AddressSpace::kUniform: {
+ case builtin::AddressSpace::kStorage:
+ case builtin::AddressSpace::kUniform: {
uint32_t binding = get_binding_index(param);
if (binding == kInvalidBindingIndex) {
return false;
@@ -2760,20 +2760,20 @@
return true;
}
-bool GeneratorImpl::EmitAddressSpace(std::ostream& out, type::AddressSpace sc) {
+bool GeneratorImpl::EmitAddressSpace(std::ostream& out, builtin::AddressSpace sc) {
switch (sc) {
- case type::AddressSpace::kFunction:
- case type::AddressSpace::kPrivate:
- case type::AddressSpace::kHandle:
+ case builtin::AddressSpace::kFunction:
+ case builtin::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kHandle:
out << "thread";
return true;
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
out << "threadgroup";
return true;
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
out << "device";
return true;
- case type::AddressSpace::kUniform:
+ case builtin::AddressSpace::kUniform:
out << "constant";
return true;
default:
@@ -3025,13 +3025,13 @@
auto out = line();
switch (sem->AddressSpace()) {
- case type::AddressSpace::kFunction:
- case type::AddressSpace::kHandle:
+ case builtin::AddressSpace::kFunction:
+ case builtin::AddressSpace::kHandle:
break;
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kPrivate:
out << "thread ";
break;
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
out << "threadgroup ";
break;
default:
@@ -3053,9 +3053,9 @@
if (!EmitExpression(out, var->initializer)) {
return false;
}
- } else if (sem->AddressSpace() == type::AddressSpace::kPrivate ||
- sem->AddressSpace() == type::AddressSpace::kFunction ||
- sem->AddressSpace() == type::AddressSpace::kUndefined) {
+ } else if (sem->AddressSpace() == builtin::AddressSpace::kPrivate ||
+ sem->AddressSpace() == builtin::AddressSpace::kFunction ||
+ sem->AddressSpace() == builtin::AddressSpace::kUndefined) {
out << " = ";
if (!EmitZeroValue(out, type)) {
return false;
@@ -3073,14 +3073,14 @@
auto out = line();
switch (sem->AddressSpace()) {
- case type::AddressSpace::kFunction:
- case type::AddressSpace::kHandle:
- case type::AddressSpace::kUndefined:
+ case builtin::AddressSpace::kFunction:
+ case builtin::AddressSpace::kHandle:
+ case builtin::AddressSpace::kUndefined:
break;
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kPrivate:
out << "thread ";
break;
- case type::AddressSpace::kWorkgroup:
+ case builtin::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 750bed5..0e9b261 100644
--- a/src/tint/writer/msl/generator_impl.h
+++ b/src/tint/writer/msl/generator_impl.h
@@ -326,7 +326,7 @@
/// @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, type::AddressSpace sc);
+ bool EmitAddressSpace(std::ostream& out, builtin::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 @@
/// Name of atomicCompareExchangeWeak() helper for the given pointer storage
/// class and struct return type
using ACEWKeyType =
- utils::UnorderedKeyWrapper<std::tuple<type::AddressSpace, const sem::Struct*>>;
+ utils::UnorderedKeyWrapper<std::tuple<builtin::AddressSpace, const sem::Struct*>>;
std::unordered_map<ACEWKeyType, std::string> 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 eae2c17..47145d1 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_OfDref) {
- GlobalVar("ary", ty.array<i32, 10>(), type::AddressSpace::kPrivate);
+ GlobalVar("ary", ty.array<i32, 10>(), builtin::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 0eabc02..694ade7 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 @@
if (param.type == CallParamType::kF16) {
Enable(builtin::Extension::kF16);
- GlobalVar("h2", ty.vec2<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("h3", ty.vec3<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("hm2x2", ty.mat2x2<f16>(), type::AddressSpace::kPrivate);
- GlobalVar("hm3x2", ty.mat3x2<f16>(), type::AddressSpace::kPrivate);
+ GlobalVar("h2", ty.vec2<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("h3", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("hm2x2", ty.mat2x2<f16>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("hm3x2", ty.mat3x2<f16>(), builtin::AddressSpace::kPrivate);
}
- GlobalVar("f2", ty.vec2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("f3", ty.vec3<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("f4", ty.vec4<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("u1", ty.u32(), type::AddressSpace::kPrivate);
- GlobalVar("u2", ty.vec2<u32>(), type::AddressSpace::kPrivate);
- GlobalVar("i2", ty.vec2<i32>(), type::AddressSpace::kPrivate);
- GlobalVar("b2", ty.vec2<bool>(), type::AddressSpace::kPrivate);
- GlobalVar("m2x2", ty.mat2x2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("m3x2", ty.mat3x2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("f2", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("f3", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("f4", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("u1", ty.u32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("u2", ty.vec2<u32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("i2", ty.vec2<i32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b2", ty.vec2<bool>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("m2x2", ty.mat2x2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("m3x2", ty.mat3x2<f32>(), builtin::AddressSpace::kPrivate);
auto* call = GenerateCall(param.builtin, param.type, this);
ASSERT_NE(nullptr, call) << "Unhandled builtin";
@@ -370,8 +370,8 @@
"unpack_unorm2x16_to_float"}));
TEST_F(MslGeneratorImplTest, Builtin_Call) {
- GlobalVar("param1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
auto* call = Call("dot", "param1", "param2");
WrapInFunction(CallStmt(call));
@@ -1047,7 +1047,7 @@
TEST_F(MslGeneratorImplTest, Pack2x16Float) {
auto* call = Call("pack2x16float", "p1");
- GlobalVar("p1", ty.vec2<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.vec2<f32>(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1059,7 +1059,7 @@
TEST_F(MslGeneratorImplTest, Unpack2x16Float) {
auto* call = Call("unpack2x16float", "p1");
- GlobalVar("p1", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("p1", ty.u32(), builtin::AddressSpace::kPrivate);
WrapInFunction(CallStmt(call));
GeneratorImpl& gen = Build();
@@ -1070,7 +1070,7 @@
}
TEST_F(MslGeneratorImplTest, DotI32) {
- GlobalVar("v", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ GlobalVar("v", ty.vec3<i32>(), builtin::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 4449c2b..26da4e4 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 @@
utils::Vector{
Return(1.23_f),
});
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::AddressSpace::kPrivate);
auto* call = Call("my_func", "param1", "param2");
WrapInFunction(call);
@@ -65,8 +65,8 @@
Param(Sym(), ty.f32()),
},
ty.void_(), utils::Empty, utils::Empty);
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::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 05e8531..3eb809b 100644
--- a/src/tint/writer/msl/generator_impl_function_test.cc
+++ b/src/tint/writer/msl/generator_impl_function_test.cc
@@ -341,7 +341,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Group(0_a), Binding(0_a));
auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b"));
@@ -380,8 +380,8 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Group(0_a),
- Binding(0_a));
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Group(0_a), Binding(0_a));
auto* var = Var("v", ty.f32(), MemberAccessor("coord", "b"));
@@ -416,7 +416,7 @@
TEST_F(MslGeneratorImplTest, Emit_Attribute_Called_By_EntryPoint_With_Uniform) {
auto* ubo_ty = Structure("UBO", utils::Vector{Member("coord", ty.vec4<f32>())});
auto* ubo =
- GlobalVar("ubo", ty.Of(ubo_ty), type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
+ GlobalVar("ubo", ty.Of(ubo_ty), builtin::AddressSpace::kUniform, Group(0_a), Binding(0_a));
Func("sub_func",
utils::Vector{
@@ -466,7 +466,7 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Group(0_a), Binding(0_a));
Func("sub_func",
@@ -518,8 +518,8 @@
Member("b", ty.f32()),
});
- GlobalVar("coord", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Group(0_a),
- Binding(0_a));
+ GlobalVar("coord", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Group(0_a), Binding(0_a));
Func("sub_func",
utils::Vector{
@@ -656,7 +656,7 @@
auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())});
- GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("data", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 6fd95ae..d00acd5 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 @@
MslImportData{"clamp", "clamp"}));
TEST_F(MslGeneratorImplTest, MslImportData_Determinant) {
- GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("var", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("determinant", "var");
@@ -248,7 +248,7 @@
}
TEST_F(MslGeneratorImplTest, MslImportData_QuantizeToF16_Scalar) {
- GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", Expr(2_f), builtin::AddressSpace::kPrivate);
auto* expr = Call("quantizeToF16", "v");
WrapInFunction(expr);
@@ -261,7 +261,7 @@
}
TEST_F(MslGeneratorImplTest, MslImportData_QuantizeToF16_Vector) {
- GlobalVar("v", vec3<f32>(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec3<f32>(2_f), builtin::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 cac1306..6d2959c 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_LoopNestedWithContinuing) {
Func("a_statement", {}, ty.void_(), utils::Empty);
- GlobalVar("lhs", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("lhs", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.f32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Break());
auto* continuing = Block(CallStmt(Call("a_statement")));
@@ -139,7 +139,7 @@
// }
//
- GlobalVar("rhs", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("rhs", ty.f32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Decl(Var("lhs", ty.f32(), Expr(2.4_f))), //
Decl(Var("other", ty.f32())), //
@@ -216,7 +216,7 @@
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<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic<i32>(), builtin::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 @@
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<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic<i32>(), builtin::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 @@
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<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic<i32>(), builtin::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 0b54a52..1e1136e 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 @@
TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) {
GlobalVar("str", ty.Of(Structure("my_str", utils::Vector{Member("mem", ty.f32())})),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
auto* expr = MemberAccessor("str", "mem");
WrapInFunction(expr);
@@ -33,7 +33,7 @@
}
TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_xyz) {
- GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec4<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = MemberAccessor("my_vec", "xyz");
WrapInFunction(expr);
@@ -45,7 +45,7 @@
}
TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_gbr) {
- GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("my_vec", ty.vec4<f32>(), builtin::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 05708dd..f72e0e9 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 @@
TEST_F(MslSanitizerTest, Call_ArrayLength) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -82,7 +82,7 @@
Member(0, "z", ty.f32()),
Member(4, "a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -135,7 +135,7 @@
TEST_F(MslSanitizerTest, Call_ArrayLength_ViaLets) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* p = Let("p", AddressOf("b"));
@@ -192,9 +192,9 @@
TEST_F(MslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniform) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(0_a));
- GlobalVar("c", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(2_a),
+ GlobalVar("c", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(2_a),
Group(0_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -251,9 +251,9 @@
TEST_F(MslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniformMissingBinding) {
auto* s = Structure("my_struct", utils::Vector{Member(0, "a", ty.array<f32>())});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(0_a));
- GlobalVar("c", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(2_a),
+ GlobalVar("c", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 71d5858..52ae381 100644
--- a/src/tint/writer/msl/generator_impl_test.cc
+++ b/src/tint/writer/msl/generator_impl_test.cc
@@ -163,7 +163,7 @@
}
TEST_F(MslGeneratorImplTest, WorkgroupMatrix) {
- GlobalVar("m", ty.mat2x2<f32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("m", ty.mat2x2<f32>(), builtin::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 @@
}
TEST_F(MslGeneratorImplTest, WorkgroupMatrixInArray) {
- GlobalVar("m", ty.array(ty.mat2x2<f32>(), 4_i), type::AddressSpace::kWorkgroup);
+ GlobalVar("m", ty.array(ty.mat2x2<f32>(), 4_i), builtin::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 @@
Structure("S2", utils::Vector{
Member("s", ty("S1")),
});
- GlobalVar("s", ty("S2"), type::AddressSpace::kWorkgroup);
+ GlobalVar("s", ty("S2"), builtin::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 @@
}
TEST_F(MslGeneratorImplTest, WorkgroupMatrix_Multiples) {
- GlobalVar("m1", ty.mat2x2<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m2", ty.mat2x3<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m3", ty.mat2x4<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m4", ty.mat3x2<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m5", ty.mat3x3<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m6", ty.mat3x4<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m7", ty.mat4x2<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m8", ty.mat4x3<f32>(), type::AddressSpace::kWorkgroup);
- GlobalVar("m9", ty.mat4x4<f32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("m1", ty.mat2x2<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m2", ty.mat2x3<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m3", ty.mat2x4<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m4", ty.mat3x2<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m5", ty.mat3x3<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m6", ty.mat3x4<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m7", ty.mat4x2<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m8", ty.mat4x3<f32>(), builtin::AddressSpace::kWorkgroup);
+ GlobalVar("m9", ty.mat4x4<f32>(), builtin::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 1062fcd..8f056f4 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 @@
TEST_F(MslGeneratorImplTest, EmitType_Array) {
auto arr = ty.array<bool, 4>();
- ast::Type type = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type type = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
@@ -102,7 +102,7 @@
TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) {
auto a = ty.array<bool, 4>();
auto b = ty.array(a, 5_u);
- ast::Type type = GlobalVar("G", b, type::AddressSpace::kPrivate)->type;
+ ast::Type type = GlobalVar("G", b, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
@@ -115,7 +115,7 @@
auto a = ty.array<bool, 4>();
auto b = ty.array(a, 5_u);
auto c = ty.array(b, 6_u);
- ast::Type type = GlobalVar("G", c, type::AddressSpace::kPrivate)->type;
+ ast::Type type = GlobalVar("G", c, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
@@ -126,7 +126,7 @@
TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) {
auto arr = ty.array<bool, 4>();
- ast::Type type = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type type = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
@@ -137,7 +137,7 @@
TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray) {
auto arr = ty.array<bool, 1>();
- ast::Type type = GlobalVar("G", arr, type::AddressSpace::kPrivate)->type;
+ ast::Type type = GlobalVar("G", arr, builtin::AddressSpace::kPrivate)->type;
GeneratorImpl& gen = Build();
@@ -213,7 +213,7 @@
TEST_F(MslGeneratorImplTest, EmitType_Pointer) {
auto* f32 = create<type::F32>();
auto* p =
- create<type::Pointer>(f32, type::AddressSpace::kWorkgroup, builtin::Access::kReadWrite);
+ create<type::Pointer>(f32, builtin::AddressSpace::kWorkgroup, builtin::Access::kReadWrite);
GeneratorImpl& gen = Build();
@@ -284,8 +284,8 @@
Member("z", ty.f32()),
});
- ast::Type type = GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a))
+ ast::Type type = GlobalVar("G", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a))
->type;
GeneratorImpl& gen = Build();
@@ -393,8 +393,8 @@
Member("e", ty.f32()),
});
- ast::Type type = GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a))
+ ast::Type type = GlobalVar("G", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a))
->type;
GeneratorImpl& gen = Build();
@@ -485,8 +485,8 @@
Member("f", array_z),
});
- ast::Type type = GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a))
+ ast::Type type = GlobalVar("G", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a))
->type;
GeneratorImpl& gen = Build();
@@ -569,8 +569,8 @@
Member("c", ty.i32()),
});
- ast::Type type = GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a))
+ ast::Type type = GlobalVar("G", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a))
->type;
GeneratorImpl& gen = Build();
@@ -631,8 +631,8 @@
Member("tint_pad_21", ty.f32()),
});
- ast::Type type = GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a))
+ ast::Type type = GlobalVar("G", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a))
->type;
GeneratorImpl& gen = Build();
@@ -690,8 +690,8 @@
Member("b", ty.f32()),
});
- ast::Type type = GlobalVar("G", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
- Binding(0_a), Group(0_a))
+ ast::Type type = GlobalVar("G", ty.Of(s), builtin::AddressSpace::kStorage,
+ builtin::Access::kRead, Binding(0_a), Group(0_a))
->type;
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 ff4ac50..95801a8 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 @@
using MslUnaryOpTest = TestHelper;
TEST_F(MslUnaryOpTest, AddressOf) {
- GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.f32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
WrapInFunction(op);
@@ -32,7 +32,7 @@
}
TEST_F(MslUnaryOpTest, Complement) {
- GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.i32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr("expr"));
WrapInFunction(op);
@@ -44,7 +44,7 @@
}
TEST_F(MslUnaryOpTest, Indirection) {
- GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("G", ty.f32(), builtin::AddressSpace::kPrivate);
auto* p = Let("expr", create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
WrapInFunction(p, op);
@@ -57,7 +57,7 @@
}
TEST_F(MslUnaryOpTest, Not) {
- GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
WrapInFunction(op);
@@ -69,7 +69,7 @@
}
TEST_F(MslUnaryOpTest, Negation) {
- GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.i32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(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 1386abb..fa0c53f 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_Private) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
WrapInFunction(Expr("a"));
@@ -531,7 +531,7 @@
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Workgroup) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kWorkgroup);
WrapInFunction(Expr("a"));
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 33b7cbf..4683889 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -506,8 +506,8 @@
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() != type::AddressSpace::kIn &&
- var->AddressSpace() != type::AddressSpace::kOut) {
+ if (var->AddressSpace() != builtin::AddressSpace::kIn &&
+ var->AddressSpace() != builtin::AddressSpace::kOut) {
continue;
}
@@ -718,7 +718,7 @@
auto result = result_op();
auto var_id = std::get<uint32_t>(result);
- auto sc = type::AddressSpace::kFunction;
+ auto sc = builtin::AddressSpace::kFunction;
auto* type = sem->Type();
auto type_id = GenerateTypeIfNeeded(type);
if (type_id == 0) {
@@ -778,8 +778,9 @@
auto result = result_op();
auto var_id = std::get<uint32_t>(result);
- auto sc = sem->AddressSpace() == type::AddressSpace::kUndefined ? type::AddressSpace::kPrivate
- : sem->AddressSpace();
+ auto sc = sem->AddressSpace() == builtin::AddressSpace::kUndefined
+ ? builtin::AddressSpace::kPrivate
+ : sem->AddressSpace();
auto type_id = GenerateTypeIfNeeded(sem->Type());
if (type_id == 0) {
@@ -818,10 +819,10 @@
// 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() == type::AddressSpace::kPrivate ||
- sem->AddressSpace() == type::AddressSpace::kOut ||
+ if (sem->AddressSpace() == builtin::AddressSpace::kPrivate ||
+ sem->AddressSpace() == builtin::AddressSpace::kOut ||
(zero_initialize_workgroup_memory_ &&
- sem->AddressSpace() == type::AddressSpace::kWorkgroup)) {
+ sem->AddressSpace() == builtin::AddressSpace::kWorkgroup)) {
init_id = GenerateConstantNullIfNeeded(type);
if (init_id == 0) {
return 0;
@@ -1900,9 +1901,9 @@
// Create a new vector to splat scalar into
auto splat_vector = result_op();
auto* splat_vector_type = builder_.create<type::Pointer>(
- vec_type, type::AddressSpace::kFunction, builtin::Access::kReadWrite);
+ vec_type, builtin::AddressSpace::kFunction, builtin::Access::kReadWrite);
push_function_var({Operand(GenerateTypeIfNeeded(splat_vector_type)), splat_vector,
- U32Operand(ConvertAddressSpace(type::AddressSpace::kFunction)),
+ U32Operand(ConvertAddressSpace(builtin::AddressSpace::kFunction)),
Operand(GenerateConstantNullIfNeeded(vec_type))});
// Splat scalar into vector
@@ -3069,11 +3070,11 @@
uint32_t memory_id = 0;
switch (builtin->Parameters()[0]->Type()->As<type::Pointer>()->AddressSpace()) {
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
memory_id = GenerateConstantIfNeeded(
ScalarConstant::U32(static_cast<uint32_t>(spv::Scope::Workgroup)));
break;
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
memory_id = GenerateConstantIfNeeded(
ScalarConstant::U32(static_cast<uint32_t>(spv::Scope::Device)));
break;
@@ -3977,38 +3978,38 @@
return true;
}
-SpvStorageClass Builder::ConvertAddressSpace(type::AddressSpace klass) const {
+SpvStorageClass Builder::ConvertAddressSpace(builtin::AddressSpace klass) const {
switch (klass) {
- case type::AddressSpace::kIn:
+ case builtin::AddressSpace::kIn:
return SpvStorageClassInput;
- case type::AddressSpace::kOut:
+ case builtin::AddressSpace::kOut:
return SpvStorageClassOutput;
- case type::AddressSpace::kUniform:
+ case builtin::AddressSpace::kUniform:
return SpvStorageClassUniform;
- case type::AddressSpace::kWorkgroup:
+ case builtin::AddressSpace::kWorkgroup:
return SpvStorageClassWorkgroup;
- case type::AddressSpace::kPushConstant:
+ case builtin::AddressSpace::kPushConstant:
return SpvStorageClassPushConstant;
- case type::AddressSpace::kHandle:
+ case builtin::AddressSpace::kHandle:
return SpvStorageClassUniformConstant;
- case type::AddressSpace::kStorage:
+ case builtin::AddressSpace::kStorage:
return SpvStorageClassStorageBuffer;
- case type::AddressSpace::kPrivate:
+ case builtin::AddressSpace::kPrivate:
return SpvStorageClassPrivate;
- case type::AddressSpace::kFunction:
+ case builtin::AddressSpace::kFunction:
return SpvStorageClassFunction;
- case type::AddressSpace::kUndefined:
+ case builtin::AddressSpace::kUndefined:
break;
}
return SpvStorageClassMax;
}
-SpvBuiltIn Builder::ConvertBuiltin(builtin::BuiltinValue builtin, type::AddressSpace storage) {
+SpvBuiltIn Builder::ConvertBuiltin(builtin::BuiltinValue builtin, builtin::AddressSpace storage) {
switch (builtin) {
case builtin::BuiltinValue::kPosition:
- if (storage == type::AddressSpace::kIn) {
+ if (storage == builtin::AddressSpace::kIn) {
return SpvBuiltInFragCoord;
- } else if (TINT_LIKELY(storage == type::AddressSpace::kOut)) {
+ } else if (TINT_LIKELY(storage == builtin::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 c56085a..57df396 100644
--- a/src/tint/writer/spirv/builder.h
+++ b/src/tint/writer/spirv/builder.h
@@ -208,12 +208,12 @@
/// 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(type::AddressSpace klass) const;
+ SpvStorageClass ConvertAddressSpace(builtin::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(builtin::BuiltinValue builtin, type::AddressSpace storage);
+ SpvBuiltIn ConvertBuiltin(builtin::BuiltinValue builtin, builtin::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 a82d4b9..a6b8bc9 100644
--- a/src/tint/writer/spirv/builder_assign_test.cc
+++ b/src/tint/writer/spirv/builder_assign_test.cc
@@ -23,7 +23,7 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, Assign_Var) {
- auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.f32(), builtin::AddressSpace::kPrivate);
auto* assign = Assign("var", 1_f);
@@ -51,7 +51,7 @@
}
TEST_F(BuilderTest, Assign_Var_OutsideFunction_IsError) {
- auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.f32(), builtin::AddressSpace::kPrivate);
auto* assign = Assign("var", Expr(1_f));
@@ -70,7 +70,7 @@
}
TEST_F(BuilderTest, Assign_Var_ZeroInitializer) {
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* val = vec3<f32>();
auto* assign = Assign("var", val);
@@ -101,7 +101,7 @@
TEST_F(BuilderTest, Assign_Var_Complex_InitializerNestedVector) {
auto* init = vec3<f32>(vec2<f32>(1_f, 2_f), 3_f);
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* assign = Assign("var", init);
@@ -134,7 +134,7 @@
TEST_F(BuilderTest, Assign_Var_Complex_Initializer) {
auto* init = vec3<f32>(1_f, 2_f, 3_f);
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* assign = Assign("var", init);
@@ -209,7 +209,7 @@
}
TEST_F(BuilderTest, Assign_Vector) {
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* val = vec3<f32>(1_f, 1_f, 3_f);
auto* assign = Assign("var", val);
@@ -243,7 +243,7 @@
TEST_F(BuilderTest, Assign_Vector_MemberByName) {
// var.y = 1
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* assign = Assign(MemberAccessor("var", "y"), Expr(1_f));
@@ -278,7 +278,7 @@
TEST_F(BuilderTest, Assign_Vector_MemberByIndex) {
// var[1] = 1
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::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 b6dfb62..7251929 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 @@
}
TEST_F(BuilderTest, Binary_LogicalAnd_WithLoads) {
- 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* a_var = GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(true));
+ auto* b_var = GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(false));
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"), Expr("b"));
WrapInFunction(expr);
@@ -1207,8 +1207,8 @@
}
TEST_F(BuilderTest, Binary_LogicalOr_WithLoads) {
- 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* a_var = GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(true));
+ auto* b_var = GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(false));
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("a"), Expr("b"));
@@ -1251,19 +1251,19 @@
switch (type) {
case Type::f32:
builder->GlobalVar(name, builder->ty.vec3<f32>(), builder->vec3<f32>(1_f, 1_f, 1_f),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::f16:
builder->GlobalVar(name, builder->ty.vec3<f16>(), builder->vec3<f16>(1_h, 1_h, 1_h),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::i32:
builder->GlobalVar(name, builder->ty.vec3<i32>(), builder->vec3<i32>(1_i, 1_i, 1_i),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::u32:
builder->GlobalVar(name, builder->ty.vec3<u32>(), builder->vec3<u32>(1_u, 1_u, 1_u),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
}
return builder->Expr(name);
@@ -1273,19 +1273,19 @@
switch (type) {
case Type::f32:
builder->GlobalVar(name, builder->ty.f32(), builder->Expr(1_f),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::f16:
builder->GlobalVar(name, builder->ty.f16(), builder->Expr(1_h),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::i32:
builder->GlobalVar(name, builder->ty.i32(), builder->Expr(1_i),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::u32:
builder->GlobalVar(name, builder->ty.u32(), builder->Expr(1_u),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
}
return builder->Expr(name);
@@ -1580,11 +1580,11 @@
switch (type) {
case Type::f32:
builder->GlobalVar(name, builder->ty.mat3x4<f32>(), builder->mat3x4<f32>(),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::f16:
builder->GlobalVar(name, builder->ty.mat3x4<f16>(), builder->mat3x4<f16>(),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
}
return builder->Expr(name);
@@ -1594,11 +1594,11 @@
switch (type) {
case Type::f32:
builder->GlobalVar(name, builder->ty.mat4x3<f32>(), builder->mat4x3<f32>(),
- type::AddressSpace::kPrivate);
+ builtin::AddressSpace::kPrivate);
break;
case Type::f16:
builder->GlobalVar(name, builder->ty.mat4x3<f16>(), builder->mat4x3<f16>(),
- type::AddressSpace::kPrivate);
+ builtin::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 a895e5f..869a8c6 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_GLSLMethod_WithLoad_f32) {
- auto* var = GlobalVar("ident", ty.f32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("ident", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = Call("round", "ident");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -134,7 +134,7 @@
TEST_F(BuiltinBuilderTest, Call_GLSLMethod_WithLoad_f16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("ident", ty.f16(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("ident", ty.f16(), builtin::AddressSpace::kPrivate);
auto* expr = Call("round", "ident");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -173,7 +173,7 @@
using BuiltinBoolTest = BuiltinBuilderTestWithParam<BuiltinData>;
TEST_P(BuiltinBoolTest, Call_Bool_Scalar) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.bool_(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.bool_(), builtin::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_Vector) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.vec3<bool>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<bool>(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -232,9 +232,9 @@
testing::Values(BuiltinData{"any", "OpAny"}, BuiltinData{"all", "OpAll"}));
TEST_F(BuiltinBuilderTest, Call_Select) {
- auto* v3 = GlobalVar("v3", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* v3 = GlobalVar("v3", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
- auto* bool_v3 = GlobalVar("bool_v3", ty.vec3<bool>(), type::AddressSpace::kPrivate);
+ auto* bool_v3 = GlobalVar("bool_v3", ty.vec3<bool>(), builtin::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 @@
auto* s = Structure("my_struct", utils::Vector{
Member("a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* expr = Call("arrayLength", AddressOf(MemberAccessor("b", "a")));
@@ -322,7 +322,7 @@
Member("z", ty.f32()),
Member(4, "a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* expr = Call("arrayLength", AddressOf(MemberAccessor("b", "a")));
@@ -365,7 +365,7 @@
auto* s = Structure("my_struct", utils::Vector{
Member("a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* p = Let("p", AddressOf("b"));
@@ -424,7 +424,7 @@
auto* s = Structure("my_struct", utils::Vector{
Member("a", ty.array<f32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(1_a),
Group(2_a));
auto* p = Let("p", AddressOf(Deref(AddressOf("b"))));
@@ -2046,7 +2046,7 @@
}
TEST_F(BuiltinBuilderTest, Call_QuantizeToF16_Scalar) {
- GlobalVar("v", Expr(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", Expr(2_f), builtin::AddressSpace::kPrivate);
Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -2085,7 +2085,7 @@
}
TEST_F(BuiltinBuilderTest, Call_QuantizeToF16_Vector) {
- GlobalVar("v", vec3<f32>(2_f), type::AddressSpace::kPrivate);
+ GlobalVar("v", vec3<f32>(2_f), builtin::AddressSpace::kPrivate);
Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -2152,7 +2152,7 @@
using BuiltinIntTest = BuiltinBuilderTestWithParam<BuiltinData>;
TEST_P(BuiltinIntTest, Call_SInt_Scalar) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -2182,7 +2182,7 @@
TEST_P(BuiltinIntTest, Call_SInt_Vector) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -2213,7 +2213,7 @@
TEST_P(BuiltinIntTest, Call_UInt_Scalar) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.u32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.u32(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -2243,7 +2243,7 @@
TEST_P(BuiltinIntTest, Call_UInt_Vector) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.vec3<u32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<u32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3114,7 +3114,7 @@
namespace matrix_builtin_tests {
TEST_F(BuiltinBuilderTest, Call_Determinant_f32) {
- auto* var = GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("var", ty.mat3x3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("determinant", "var");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3151,7 +3151,7 @@
TEST_F(BuiltinBuilderTest, Call_Determinant_f16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("var", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("var", ty.mat3x3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("determinant", "var");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3186,7 +3186,7 @@
}
TEST_F(BuiltinBuilderTest, Call_Transpose_f32) {
- auto* var = GlobalVar("var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("var", ty.mat2x3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("transpose", "var");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3224,7 +3224,7 @@
TEST_F(BuiltinBuilderTest, Call_Transpose_f16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("var", ty.mat2x3<f16>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("var", ty.mat2x3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("transpose", "var");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3265,7 +3265,7 @@
namespace vector_builtin_tests {
TEST_F(BuiltinBuilderTest, Call_Dot_F32) {
- auto* var = GlobalVar("v", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "v", "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3296,7 +3296,7 @@
TEST_F(BuiltinBuilderTest, Call_Dot_F16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("v", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "v", "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3325,7 +3325,7 @@
}
TEST_F(BuiltinBuilderTest, Call_Dot_U32) {
- auto* var = GlobalVar("v", ty.vec3<u32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<u32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "v", "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3364,7 +3364,7 @@
}
TEST_F(BuiltinBuilderTest, Call_Dot_I32) {
- auto* var = GlobalVar("v", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call("dot", "v", "v");
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3410,7 +3410,7 @@
using BuiltinDeriveTest = BuiltinBuilderTestWithParam<BuiltinData>;
TEST_P(BuiltinDeriveTest, Call_Derivative_Scalar) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.f32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3443,7 +3443,7 @@
TEST_P(BuiltinDeriveTest, Call_Derivative_Vector) {
auto param = GetParam();
- auto* var = GlobalVar("v", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* expr = Call(param.name, "v");
auto* func = Func("func", utils::Empty, ty.void_(),
utils::Vector{
@@ -3513,7 +3513,7 @@
Member("u", ty.atomic<u32>()),
Member("i", ty.atomic<i32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(1_a), Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -3577,7 +3577,7 @@
Member("u", ty.atomic<u32>()),
Member("i", ty.atomic<i32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(1_a), Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -3649,7 +3649,7 @@
auto* s = Structure("S", utils::Vector{
Member("v", ty.atomic<i32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(1_a), Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -3722,7 +3722,7 @@
auto* s = Structure("S", utils::Vector{
Member("v", ty.atomic<u32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(1_a), Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -3797,7 +3797,7 @@
Member("u", ty.atomic<u32>()),
Member("i", ty.atomic<i32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(1_a), Group(2_a));
Func("a_func", utils::Empty, ty.void_(),
@@ -3873,7 +3873,7 @@
Member("u", ty.atomic<u32>()),
Member("i", ty.atomic<i32>()),
});
- GlobalVar("b", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("b", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 59e1848..085a6f2 100644
--- a/src/tint/writer/spirv/builder_entry_point_test.cc
+++ b/src/tint/writer/spirv/builder_entry_point_test.cc
@@ -20,9 +20,9 @@
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/stage_attribute.h"
#include "src/tint/ast/variable.h"
+#include "src/tint/builtin/address_space.h"
#include "src/tint/builtin/builtin_value.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 bdfc412..5cf97ea 100644
--- a/src/tint/writer/spirv/builder_function_test.cc
+++ b/src/tint/writer/spirv/builder_function_test.cc
@@ -61,7 +61,7 @@
}
TEST_F(BuilderTest, Function_Terminator_ReturnValue) {
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
Func("a_func", utils::Empty, ty.f32(), utils::Vector{Return("a")}, utils::Empty);
@@ -198,7 +198,7 @@
auto* s = Structure("Data", utils::Vector{Member("d", ty.f32())});
- GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("data", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 47f1ed2..72cf12b 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 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, FunctionVar_NoAddressSpace) {
- auto* v = Var("var", ty.f32(), type::AddressSpace::kFunction);
+ auto* v = Var("var", ty.f32(), builtin::AddressSpace::kFunction);
WrapInFunction(v);
spirv::Builder& b = Build();
@@ -45,7 +45,7 @@
TEST_F(BuilderTest, FunctionVar_WithConstantInitializer) {
auto* init = vec3<f32>(1_f, 1_f, 3_f);
- auto* v = Var("var", ty.vec3<f32>(), type::AddressSpace::kFunction, init);
+ auto* v = Var("var", ty.vec3<f32>(), builtin::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 d412db2..f9f9c4b 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 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, GlobalVar_WithAddressSpace) {
- auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.f32(), builtin::AddressSpace::kPrivate);
spirv::Builder& b = Build();
@@ -43,7 +43,7 @@
TEST_F(BuilderTest, GlobalVar_WithInitializer) {
auto* init = vec3<f32>(1_f, 1_f, 3_f);
- auto* v = GlobalVar("var", ty.vec3<f32>(), type::AddressSpace::kPrivate, init);
+ auto* v = GlobalVar("var", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, init);
spirv::Builder& b = Build();
@@ -67,7 +67,7 @@
// var v = c;
auto* c = GlobalConst("c", Expr(42_a));
- GlobalVar("v", type::AddressSpace::kPrivate, Expr(c));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Expr(c));
spirv::Builder& b = SanitizeAndBuild();
@@ -92,7 +92,7 @@
// var v = c;
auto* c = GlobalConst("c", vec3<f32>(1_f, 2_f, 3_f));
- GlobalVar("v", type::AddressSpace::kPrivate, Expr(c));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Expr(c));
spirv::Builder& b = SanitizeAndBuild();
@@ -122,7 +122,7 @@
Enable(builtin::Extension::kF16);
auto* c = GlobalConst("c", vec3<f16>(1_h, 2_h, 3_h));
- GlobalVar("v", type::AddressSpace::kPrivate, Expr(c));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Expr(c));
spirv::Builder& b = SanitizeAndBuild();
@@ -151,7 +151,7 @@
// var v = c;
auto* c = GlobalConst("c", Call(ty.vec3<Infer>(), 1_a, 2_a, 3_a));
- GlobalVar("v", type::AddressSpace::kPrivate, Expr(c));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Expr(c));
spirv::Builder& b = SanitizeAndBuild();
@@ -180,7 +180,7 @@
// var v = c;
auto* c = GlobalConst("c", Call(ty.vec3<Infer>(), 1._a, 2._a, 3._a));
- GlobalVar("v", type::AddressSpace::kPrivate, Expr(c));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Expr(c));
spirv::Builder& b = SanitizeAndBuild();
@@ -209,7 +209,7 @@
// var v = c;
auto* c = GlobalConst("c", vec3<f32>(vec2<f32>(1_f, 2_f), 3_f));
- GlobalVar("v", type::AddressSpace::kPrivate, Expr(c));
+ GlobalVar("v", builtin::AddressSpace::kPrivate, Expr(c));
spirv::Builder& b = SanitizeAndBuild();
@@ -252,7 +252,7 @@
struct BuiltinData {
builtin::BuiltinValue builtin;
- type::AddressSpace storage;
+ builtin::AddressSpace storage;
SpvBuiltIn result;
};
inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
@@ -270,38 +270,39 @@
INSTANTIATE_TEST_SUITE_P(
BuilderTest_Type,
BuiltinDataTest,
- testing::Values(
- BuiltinData{builtin::BuiltinValue::kUndefined, type::AddressSpace::kUndefined,
- SpvBuiltInMax},
- BuiltinData{builtin::BuiltinValue::kPosition, type::AddressSpace::kIn, SpvBuiltInFragCoord},
- BuiltinData{builtin::BuiltinValue::kPosition, type::AddressSpace::kOut, SpvBuiltInPosition},
- BuiltinData{
- builtin::BuiltinValue::kVertexIndex,
- type::AddressSpace::kIn,
- SpvBuiltInVertexIndex,
- },
- BuiltinData{builtin::BuiltinValue::kInstanceIndex, type::AddressSpace::kIn,
- SpvBuiltInInstanceIndex},
- BuiltinData{builtin::BuiltinValue::kFrontFacing, type::AddressSpace::kIn,
- SpvBuiltInFrontFacing},
- BuiltinData{builtin::BuiltinValue::kFragDepth, type::AddressSpace::kOut,
- SpvBuiltInFragDepth},
- BuiltinData{builtin::BuiltinValue::kLocalInvocationId, type::AddressSpace::kIn,
- SpvBuiltInLocalInvocationId},
- BuiltinData{builtin::BuiltinValue::kLocalInvocationIndex, type::AddressSpace::kIn,
- SpvBuiltInLocalInvocationIndex},
- BuiltinData{builtin::BuiltinValue::kGlobalInvocationId, type::AddressSpace::kIn,
- SpvBuiltInGlobalInvocationId},
- BuiltinData{builtin::BuiltinValue::kWorkgroupId, type::AddressSpace::kIn,
- SpvBuiltInWorkgroupId},
- BuiltinData{builtin::BuiltinValue::kNumWorkgroups, type::AddressSpace::kIn,
- SpvBuiltInNumWorkgroups},
- BuiltinData{builtin::BuiltinValue::kSampleIndex, type::AddressSpace::kIn,
- SpvBuiltInSampleId},
- BuiltinData{builtin::BuiltinValue::kSampleMask, type::AddressSpace::kIn,
- SpvBuiltInSampleMask},
- BuiltinData{builtin::BuiltinValue::kSampleMask, type::AddressSpace::kOut,
- SpvBuiltInSampleMask}));
+ testing::Values(BuiltinData{builtin::BuiltinValue::kUndefined,
+ builtin::AddressSpace::kUndefined, SpvBuiltInMax},
+ BuiltinData{builtin::BuiltinValue::kPosition, builtin::AddressSpace::kIn,
+ SpvBuiltInFragCoord},
+ BuiltinData{builtin::BuiltinValue::kPosition, builtin::AddressSpace::kOut,
+ SpvBuiltInPosition},
+ BuiltinData{
+ builtin::BuiltinValue::kVertexIndex,
+ builtin::AddressSpace::kIn,
+ SpvBuiltInVertexIndex,
+ },
+ BuiltinData{builtin::BuiltinValue::kInstanceIndex, builtin::AddressSpace::kIn,
+ SpvBuiltInInstanceIndex},
+ BuiltinData{builtin::BuiltinValue::kFrontFacing, builtin::AddressSpace::kIn,
+ SpvBuiltInFrontFacing},
+ BuiltinData{builtin::BuiltinValue::kFragDepth, builtin::AddressSpace::kOut,
+ SpvBuiltInFragDepth},
+ BuiltinData{builtin::BuiltinValue::kLocalInvocationId,
+ builtin::AddressSpace::kIn, SpvBuiltInLocalInvocationId},
+ BuiltinData{builtin::BuiltinValue::kLocalInvocationIndex,
+ builtin::AddressSpace::kIn, SpvBuiltInLocalInvocationIndex},
+ BuiltinData{builtin::BuiltinValue::kGlobalInvocationId,
+ builtin::AddressSpace::kIn, SpvBuiltInGlobalInvocationId},
+ BuiltinData{builtin::BuiltinValue::kWorkgroupId, builtin::AddressSpace::kIn,
+ SpvBuiltInWorkgroupId},
+ BuiltinData{builtin::BuiltinValue::kNumWorkgroups, builtin::AddressSpace::kIn,
+ SpvBuiltInNumWorkgroups},
+ BuiltinData{builtin::BuiltinValue::kSampleIndex, builtin::AddressSpace::kIn,
+ SpvBuiltInSampleId},
+ BuiltinData{builtin::BuiltinValue::kSampleMask, builtin::AddressSpace::kIn,
+ SpvBuiltInSampleMask},
+ BuiltinData{builtin::BuiltinValue::kSampleMask, builtin::AddressSpace::kOut,
+ SpvBuiltInSampleMask}));
TEST_F(BuilderTest, GlobalVar_DeclReadOnly) {
// struct A {
@@ -314,7 +315,7 @@
Member("b", ty.i32()),
});
- GlobalVar("b", ty.Of(A), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("b", ty.Of(A), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
spirv::Builder& b = SanitizeAndBuild();
@@ -356,7 +357,7 @@
auto* A = Structure("A", utils::Vector{Member("a", ty.i32())});
auto* B = Alias("B", ty.Of(A));
- GlobalVar("b", ty.Of(B), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("b", ty.Of(B), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
spirv::Builder& b = SanitizeAndBuild();
@@ -396,7 +397,7 @@
auto* A = Structure("A", utils::Vector{Member("a", ty.i32())});
auto* B = Alias("B", ty.Of(A));
- GlobalVar("b", ty.Of(B), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
+ GlobalVar("b", ty.Of(B), builtin::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
Group(0_a));
spirv::Builder& b = SanitizeAndBuild();
@@ -435,10 +436,10 @@
// var<storage, read_write> c : A
auto* A = Structure("A", utils::Vector{Member("a", ty.i32())});
- GlobalVar("b", ty.Of(A), type::AddressSpace::kStorage, builtin::Access::kRead, Group(0_a),
+ GlobalVar("b", ty.Of(A), builtin::AddressSpace::kStorage, builtin::Access::kRead, Group(0_a),
Binding(0_a));
- GlobalVar("c", ty.Of(A), type::AddressSpace::kStorage, builtin::Access::kReadWrite, Group(1_a),
- Binding(0_a));
+ GlobalVar("c", ty.Of(A), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ Group(1_a), Binding(0_a));
spirv::Builder& b = SanitizeAndBuild();
@@ -498,16 +499,16 @@
TEST_F(BuilderTest, GlobalVar_WorkgroupWithZeroInit) {
auto type_scalar = ty.i32();
- auto* var_scalar = GlobalVar("a", type_scalar, type::AddressSpace::kWorkgroup);
+ auto* var_scalar = GlobalVar("a", type_scalar, builtin::AddressSpace::kWorkgroup);
auto type_array = ty.array<f32, 16>();
- auto* var_array = GlobalVar("b", type_array, type::AddressSpace::kWorkgroup);
+ auto* var_array = GlobalVar("b", type_array, builtin::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), type::AddressSpace::kWorkgroup);
+ auto* var_struct = GlobalVar("c", ty.Of(type_struct), builtin::AddressSpace::kWorkgroup);
program = std::make_unique<Program>(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 4db5d42..7c56ba1 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_GlobalVar) {
- auto* v = GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("var", ty.f32(), builtin::AddressSpace::kPrivate);
auto* expr = Expr("var");
WrapInFunction(expr);
@@ -85,7 +85,7 @@
}
TEST_F(BuilderTest, IdentifierExpression_FunctionVar) {
- auto* v = Var("var", ty.f32(), type::AddressSpace::kFunction);
+ auto* v = Var("var", ty.f32(), builtin::AddressSpace::kFunction);
auto* expr = Expr("var");
WrapInFunction(v, expr);
@@ -109,7 +109,7 @@
}
TEST_F(BuilderTest, IdentifierExpression_Load) {
- auto* var = GlobalVar("var", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("var", ty.i32(), builtin::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 6462200..031ed68 100644
--- a/src/tint/writer/spirv/builder_if_test.cc
+++ b/src/tint/writer/spirv/builder_if_test.cc
@@ -68,7 +68,7 @@
// v = 2;
// }
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Assign("v", 2_i));
auto* expr = If(true, body);
WrapInFunction(expr);
@@ -104,7 +104,7 @@
// v = 3i;
// }
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Assign("v", 2_i));
auto* else_body = Block(Assign("v", 3_i));
@@ -146,7 +146,7 @@
// v = 3i;
// }
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Assign("v", 2_i));
auto* else_body = Block(Assign("v", 3_i));
@@ -197,7 +197,7 @@
// v = 5i;
// }
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::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 @@
// if (a) {
// }
- auto* var = GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("a", ty.bool_(), builtin::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 9fdc4fc..cf382e0 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 @@
TEST_F(SpvBuilderInitializerTest, Const) {
auto* c = Expr(42.2_f);
- auto* g = GlobalVar("g", ty.f32(), c, type::AddressSpace::kPrivate);
+ auto* g = GlobalVar("g", ty.f32(), c, builtin::AddressSpace::kPrivate);
spirv::Builder& b = Build();
@@ -1935,7 +1935,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_F32_With_F32) {
auto* ctor = Call<f32>(2_f);
- GlobalVar("g", ty.f32(), type::AddressSpace::kPrivate, ctor);
+ GlobalVar("g", ty.f32(), builtin::AddressSpace::kPrivate, ctor);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -1954,7 +1954,7 @@
Enable(builtin::Extension::kF16);
auto* ctor = Call<f16>(2_h);
- GlobalVar("g", ty.f16(), type::AddressSpace::kPrivate, ctor);
+ GlobalVar("g", ty.f16(), builtin::AddressSpace::kPrivate, ctor);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2015,7 +2015,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_U32_With_F32) {
auto* ctor = Call<u32>(1.5_f);
- GlobalVar("g", ty.u32(), type::AddressSpace::kPrivate, ctor);
+ GlobalVar("g", ty.u32(), builtin::AddressSpace::kPrivate, ctor);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2034,7 +2034,7 @@
Enable(builtin::Extension::kF16);
auto* ctor = Call<u32>(1.5_h);
- GlobalVar("g", ty.u32(), type::AddressSpace::kPrivate, ctor);
+ GlobalVar("g", ty.u32(), builtin::AddressSpace::kPrivate, ctor);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2099,7 +2099,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec2_With_F32) {
auto* cast = vec2<f32>(2_f);
- auto* g = GlobalVar("g", ty.vec2<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec2<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2117,7 +2117,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec2<f16>(2_h);
- auto* g = GlobalVar("g", ty.vec2<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec2<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2181,7 +2181,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec2_F32_With_Vec2) {
auto* cast = vec2<f32>(vec2<f32>(2_f, 2_f));
- GlobalVar("a", ty.vec2<f32>(), type::AddressSpace::kPrivate, cast);
+ GlobalVar("a", ty.vec2<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2203,7 +2203,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec2<f16>(vec2<f16>(2_h, 2_h));
- GlobalVar("a", ty.vec2<f16>(), type::AddressSpace::kPrivate, cast);
+ GlobalVar("a", ty.vec2<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2271,7 +2271,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_F32_With_Vec3) {
auto* cast = vec3<f32>(vec3<f32>(2_f, 2_f, 2_f));
- GlobalVar("a", ty.vec3<f32>(), type::AddressSpace::kPrivate, cast);
+ GlobalVar("a", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2293,7 +2293,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec3<f16>(vec3<f16>(2_h, 2_h, 2_h));
- GlobalVar("a", ty.vec3<f16>(), type::AddressSpace::kPrivate, cast);
+ GlobalVar("a", ty.vec3<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2361,7 +2361,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_F32_With_Vec4) {
auto* cast = vec4<f32>(vec4<f32>(2_f, 2_f, 2_f, 2_f));
- GlobalVar("a", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ GlobalVar("a", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2383,7 +2383,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(vec4<f16>(2_h, 2_h, 2_h, 2_h));
- GlobalVar("a", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ GlobalVar("a", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = SanitizeAndBuild();
ASSERT_TRUE(b.Build());
@@ -2451,7 +2451,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_F32) {
auto* cast = vec3<f32>(2_f);
- auto* g = GlobalVar("g", ty.vec3<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2469,7 +2469,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec3<f16>(2_h);
- auto* g = GlobalVar("g", ty.vec3<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec3<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2533,7 +2533,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_F32_Vec2) {
auto* cast = vec3<f32>(2_f, vec2<f32>(2_f, 2_f));
- auto* g = GlobalVar("g", ty.vec3<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2551,7 +2551,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec3<f16>(2_h, vec2<f16>(2_h, 2_h));
- auto* g = GlobalVar("g", ty.vec3<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec3<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2615,7 +2615,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec3_With_Vec2_F32) {
auto* cast = vec3<f32>(vec2<f32>(2_f, 2_f), 2_f);
- auto* g = GlobalVar("g", ty.vec3<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2633,7 +2633,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec3<f16>(vec2<f16>(2_h, 2_h), 2_h);
- auto* g = GlobalVar("g", ty.vec3<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec3<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2697,7 +2697,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32) {
auto* cast = vec4<f32>(2_f);
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2715,7 +2715,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(2_h);
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2779,7 +2779,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32_F32_Vec2) {
auto* cast = vec4<f32>(2_f, 2_f, vec2<f32>(2_f, 2_f));
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2797,7 +2797,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(2_h, 2_h, vec2<f16>(2_h, 2_h));
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2861,7 +2861,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32_Vec2_F32) {
auto* cast = vec4<f32>(2_f, vec2<f32>(2_f, 2_f), 2_f);
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2879,7 +2879,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(2_h, vec2<f16>(2_h, 2_h), 2_h);
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2943,7 +2943,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_Vec2_F32_F32) {
auto* cast = vec4<f32>(vec2<f32>(2_f, 2_f), 2_f, 2_f);
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -2961,7 +2961,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(vec2<f16>(2_h, 2_h), 2_h, 2_h);
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -3025,7 +3025,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_F32_With_Vec2_Vec2) {
auto* cast = vec4<f32>(vec2<f32>(2_f, 2_f), vec2<f32>(2_f, 2_f));
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -3043,7 +3043,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(vec2<f16>(2_h, 2_h), vec2<f16>(2_h, 2_h));
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -3082,7 +3082,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_F32_Vec3) {
auto* cast = vec4<f32>(2_f, vec3<f32>(2_f, 2_f, 2_f));
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -3100,7 +3100,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(2_h, vec3<f16>(2_h, 2_h, 2_h));
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -3164,7 +3164,7 @@
TEST_F(SpvBuilderInitializerTest, Type_GlobalVar_Vec4_With_Vec3_F32) {
auto* cast = vec4<f32>(vec3<f32>(2_f, 2_f, 2_f), 2_f);
- auto* g = GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -3182,7 +3182,7 @@
Enable(builtin::Extension::kF16);
auto* cast = vec4<f16>(vec3<f16>(2_h, 2_h, 2_h), 2_h);
- auto* g = GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kPrivate, cast);
+ auto* g = GlobalVar("g", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast);
spirv::Builder& b = Build();
@@ -4204,7 +4204,7 @@
}
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_I32) {
- auto* var = GlobalVar("i", ty.vec3<u32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<u32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<i32>("i");
WrapInFunction(cast);
@@ -4230,7 +4230,7 @@
}
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_I32) {
- auto* var = GlobalVar("i", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<i32>("i");
WrapInFunction(cast);
@@ -4258,7 +4258,7 @@
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_I32) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("i", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<i32>("i");
WrapInFunction(cast);
@@ -4284,7 +4284,7 @@
}
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_U32) {
- auto* var = GlobalVar("i", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<u32>("i");
WrapInFunction(cast);
@@ -4310,7 +4310,7 @@
}
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_U32) {
- auto* var = GlobalVar("i", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<u32>("i");
WrapInFunction(cast);
@@ -4338,7 +4338,7 @@
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_U32) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("i", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<u32>("i");
WrapInFunction(cast);
@@ -4364,7 +4364,7 @@
}
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_F32) {
- auto* var = GlobalVar("i", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<f32>("i");
WrapInFunction(cast);
@@ -4390,7 +4390,7 @@
}
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_F32) {
- auto* var = GlobalVar("i", ty.vec3<u32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<u32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<f32>("i");
WrapInFunction(cast);
@@ -4418,7 +4418,7 @@
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F16_to_F32) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("i", ty.vec3<f16>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<f16>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<f32>("i");
WrapInFunction(cast);
@@ -4446,7 +4446,7 @@
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_I32_to_F16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("i", ty.vec3<i32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<i32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<f16>("i");
WrapInFunction(cast);
@@ -4474,7 +4474,7 @@
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_U32_to_F16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("i", ty.vec3<u32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<u32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<f16>("i");
WrapInFunction(cast);
@@ -4502,7 +4502,7 @@
TEST_F(SpvBuilderInitializerTest, Type_Convert_Vectors_F32_to_F16) {
Enable(builtin::Extension::kF16);
- auto* var = GlobalVar("i", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("i", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* cast = vec3<f16>("i");
WrapInFunction(cast);
@@ -4590,9 +4590,9 @@
TEST_F(SpvBuilderInitializerTest, IsInitializerConst_Vector_WithIdent) {
// vec3<f32>(a, b, c) -> false
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("c", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("c", ty.f32(), builtin::AddressSpace::kPrivate);
auto* t = vec3<f32>("a", "b", "c");
WrapInFunction(t);
@@ -4662,8 +4662,8 @@
Member("b", ty.vec3<f32>()),
});
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("b", ty.vec3<f32>(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("b", ty.vec3<f32>(), builtin::AddressSpace::kPrivate);
auto* t = Call(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 ef8dfa8..5fc15b8 100644
--- a/src/tint/writer/spirv/builder_loop_test.cc
+++ b/src/tint/writer/spirv/builder_loop_test.cc
@@ -54,7 +54,7 @@
// break;
// }
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
auto* body = Block(Assign("v", 2_i), //
Break());
@@ -96,7 +96,7 @@
// }
// }
- auto* var = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
+ auto* var = GlobalVar("v", ty.i32(), builtin::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 a04a194..7e0bd18 100644
--- a/src/tint/writer/spirv/builder_switch_test.cc
+++ b/src/tint/writer/spirv/builder_switch_test.cc
@@ -56,8 +56,8 @@
// default: {}
// }
- auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
- auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -113,8 +113,8 @@
// default: {}
// }
- auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
- auto* a = GlobalVar("a", ty.u32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate);
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -170,8 +170,8 @@
// v = 1i;
// }
- auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
- auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -220,8 +220,8 @@
// v = 3i;
// }
- auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
- auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{
@@ -280,8 +280,8 @@
// v = 2i;
// }
- auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
- auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate);
auto* func = Func("a_func", utils::Empty, ty.void_(),
utils::Vector{Switch(Expr("a"), //
@@ -337,8 +337,8 @@
// default: {}
// }
- auto* v = GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
- auto* a = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("v", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* a = GlobalVar("a", ty.i32(), builtin::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 a6c7b2b..1b3e471 100644
--- a/src/tint/writer/spirv/builder_type_test.cc
+++ b/src/tint/writer/spirv/builder_type_test.cc
@@ -29,8 +29,8 @@
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), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
- Group(0_a));
+ GlobalVar("a", ty.Of(str), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Binding(0_a), Group(0_a));
ast::Type type = str->members[0]->type;
spirv::Builder& b = Build();
@@ -47,8 +47,8 @@
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), type::AddressSpace::kStorage, builtin::Access::kRead, Binding(0_a),
- Group(0_a));
+ GlobalVar("a", ty.Of(str), builtin::AddressSpace::kStorage, builtin::Access::kRead,
+ Binding(0_a), Group(0_a));
ast::Type type = str->members[0]->type;
spirv::Builder& b = Build();
@@ -64,7 +64,7 @@
TEST_F(BuilderTest_Type, GenerateArray) {
auto ary = ty.array<i32, 4>();
- ast::Type type = GlobalVar("a", ary, type::AddressSpace::kPrivate)->type;
+ ast::Type type = GlobalVar("a", ary, builtin::AddressSpace::kPrivate)->type;
spirv::Builder& b = Build();
@@ -81,7 +81,7 @@
TEST_F(BuilderTest_Type, GenerateArray_WithStride) {
auto ary = ty.array<i32, 4>(utils::Vector{Stride(16)});
- ast::Type ty = GlobalVar("a", ary, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("a", ary, builtin::AddressSpace::kPrivate)->type;
spirv::Builder& b = Build();
@@ -101,7 +101,7 @@
TEST_F(BuilderTest_Type, ReturnsGeneratedArray) {
auto ary = ty.array<i32, 4>();
- ast::Type ty = GlobalVar("a", ary, type::AddressSpace::kPrivate)->type;
+ ast::Type ty = GlobalVar("a", ary, builtin::AddressSpace::kPrivate)->type;
spirv::Builder& b = Build();
@@ -296,7 +296,8 @@
TEST_F(BuilderTest_Type, GeneratePtr) {
auto* i32 = create<type::I32>();
- auto* ptr = create<type::Pointer>(i32, type::AddressSpace::kOut, builtin::Access::kReadWrite);
+ auto* ptr =
+ create<type::Pointer>(i32, builtin::AddressSpace::kOut, builtin::Access::kReadWrite);
spirv::Builder& b = Build();
@@ -311,7 +312,8 @@
TEST_F(BuilderTest_Type, ReturnsGeneratedPtr) {
auto* i32 = create<type::I32>();
- auto* ptr = create<type::Pointer>(i32, type::AddressSpace::kOut, builtin::Access::kReadWrite);
+ auto* ptr =
+ create<type::Pointer>(i32, builtin::AddressSpace::kOut, builtin::Access::kReadWrite);
spirv::Builder& b = Build();
@@ -605,7 +607,7 @@
}
struct PtrData {
- type::AddressSpace ast_class;
+ builtin::AddressSpace ast_class;
SpvStorageClass result;
};
inline std::ostream& operator<<(std::ostream& out, PtrData data) {
@@ -623,15 +625,15 @@
INSTANTIATE_TEST_SUITE_P(
BuilderTest_Type,
PtrDataTest,
- testing::Values(PtrData{type::AddressSpace::kUndefined, 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}));
+ testing::Values(PtrData{builtin::AddressSpace::kUndefined, SpvStorageClassMax},
+ PtrData{builtin::AddressSpace::kIn, SpvStorageClassInput},
+ PtrData{builtin::AddressSpace::kOut, SpvStorageClassOutput},
+ PtrData{builtin::AddressSpace::kUniform, SpvStorageClassUniform},
+ PtrData{builtin::AddressSpace::kWorkgroup, SpvStorageClassWorkgroup},
+ PtrData{builtin::AddressSpace::kHandle, SpvStorageClassUniformConstant},
+ PtrData{builtin::AddressSpace::kStorage, SpvStorageClassStorageBuffer},
+ PtrData{builtin::AddressSpace::kPrivate, SpvStorageClassPrivate},
+ PtrData{builtin::AddressSpace::kFunction, SpvStorageClassFunction}));
TEST_F(BuilderTest_Type, DepthTexture_Generate_2d) {
auto* two_d = create<type::DepthTexture>(type::TextureDimension::k2d);
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 ed05a2d..31e7e6b 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 @@
using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, IndexAccessor) {
- GlobalVar("ary", ty.array<i32, 10>(), type::AddressSpace::kPrivate);
+ GlobalVar("ary", ty.array<i32, 10>(), builtin::AddressSpace::kPrivate);
auto* expr = IndexAccessor("ary", 5_i);
WrapInFunction(expr);
@@ -34,7 +34,7 @@
}
TEST_F(WgslGeneratorImplTest, IndexAccessor_OfDref) {
- GlobalVar("ary", ty.array<i32, 10>(), type::AddressSpace::kPrivate);
+ GlobalVar("ary", ty.array<i32, 10>(), builtin::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 3a6dd1a..c802cb1 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 @@
using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Assign) {
- auto* lhs = GlobalVar("lhs", ty.i32(), type::AddressSpace::kPrivate);
- auto* rhs = GlobalVar("rhs", ty.i32(), type::AddressSpace::kPrivate);
+ auto* lhs = GlobalVar("lhs", ty.i32(), builtin::AddressSpace::kPrivate);
+ auto* rhs = GlobalVar("rhs", ty.i32(), builtin::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 2770e5c..d86b1c4 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 @@
}
};
- GlobalVar("left", op_ty(), type::AddressSpace::kPrivate);
- GlobalVar("right", op_ty(), type::AddressSpace::kPrivate);
+ GlobalVar("left", op_ty(), builtin::AddressSpace::kPrivate);
+ GlobalVar("right", op_ty(), builtin::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 39a287c..4492628 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 @@
utils::Vector{
Return(1.23_f),
});
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::AddressSpace::kPrivate);
auto* call = Call("my_func", "param1", "param2");
WrapInFunction(call);
@@ -68,8 +68,8 @@
Param(Sym(), ty.f32()),
},
ty.void_(), utils::Empty, utils::Empty);
- GlobalVar("param1", ty.f32(), type::AddressSpace::kPrivate);
- GlobalVar("param2", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("param1", ty.f32(), builtin::AddressSpace::kPrivate);
+ GlobalVar("param2", ty.f32(), builtin::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 e29f0f4..53131cd 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 @@
Member("d", ty.f32()),
});
- GlobalVar("data", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ GlobalVar("data", ty.Of(s), builtin::AddressSpace::kStorage, builtin::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 5654ebe..cef2c74 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 @@
auto* func_var = Var("a", ty.f32());
WrapInFunction(func_var);
- GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -46,7 +46,7 @@
}
TEST_F(WgslGeneratorImplTest, Emit_GlobalsInterleaved) {
- GlobalVar("a0", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a0", ty.f32(), builtin::AddressSpace::kPrivate);
auto* s0 = Structure("S0", utils::Vector{
Member("a", ty.i32()),
@@ -58,7 +58,7 @@
},
utils::Empty);
- GlobalVar("a1", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("a1", ty.f32(), builtin::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 e0b167f..7b60b63 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 @@
using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) {
- GlobalVar("glsl", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("glsl", ty.f32(), builtin::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 0831f89..8b9d443 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 @@
using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_If) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* cond = Expr("cond");
auto* body = Block(Return());
@@ -39,8 +39,8 @@
}
TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("else_cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* else_cond = Expr("else_cond");
auto* else_body = Block(Return());
@@ -64,7 +64,7 @@
}
TEST_F(WgslGeneratorImplTest, Emit_IfWithElse) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* else_body = Block(Return());
@@ -87,8 +87,8 @@
}
TEST_F(WgslGeneratorImplTest, Emit_IfWithMultiple) {
- GlobalVar("cond", ty.bool_(), type::AddressSpace::kPrivate);
- GlobalVar("else_cond", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.bool_(), builtin::AddressSpace::kPrivate);
+ GlobalVar("else_cond", ty.bool_(), builtin::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 46dbbdb..62910fc 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 @@
// for({ignore(1i); ignore(2i);}; ; ) {
// return;
// }
- GlobalVar("a", ty.atomic<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic<i32>(), builtin::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 @@
// return;
// }
- GlobalVar("a", ty.atomic<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic<i32>(), builtin::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 @@
// for({ ignore(1i); ignore(2i); }; true; { ignore(3i); ignore(4i); }) {
// return;
// }
- GlobalVar("a", ty.atomic<i32>(), type::AddressSpace::kWorkgroup);
+ GlobalVar("a", ty.atomic<i32>(), builtin::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 5f7ebb5..208be35 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 @@
TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) {
auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())});
- GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("str", ty.Of(s), builtin::AddressSpace::kPrivate);
auto* expr = MemberAccessor("str", "mem");
WrapInFunction(expr);
@@ -35,7 +35,7 @@
TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor_OfDref) {
auto* s = Structure("Data", utils::Vector{Member("mem", ty.f32())});
- GlobalVar("str", ty.Of(s), type::AddressSpace::kPrivate);
+ GlobalVar("str", ty.Of(s), builtin::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 24dbae1..d16808a 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 @@
using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Switch) {
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
auto* def_body = Block(create<ast::BreakStatement>());
auto* def = Case(DefaultCaseSelector(), def_body);
@@ -56,7 +56,7 @@
}
TEST_F(WgslGeneratorImplTest, Emit_Switch_MixedDefault) {
- GlobalVar("cond", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("cond", ty.i32(), builtin::AddressSpace::kPrivate);
auto* def_body = Block(create<ast::BreakStatement>());
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 18fb678..455cbbc 100644
--- a/src/tint/writer/wgsl/generator_impl_type_test.cc
+++ b/src/tint/writer/wgsl/generator_impl_type_test.cc
@@ -132,7 +132,8 @@
}
TEST_F(WgslGeneratorImplTest, EmitType_Pointer) {
- auto type = Alias("make_type_reachable", ty.pointer<f32>(type::AddressSpace::kWorkgroup))->type;
+ auto type =
+ Alias("make_type_reachable", ty.pointer<f32>(builtin::AddressSpace::kWorkgroup))->type;
GeneratorImpl& gen = Build();
@@ -143,7 +144,7 @@
TEST_F(WgslGeneratorImplTest, EmitType_PointerAccessMode) {
auto type = Alias("make_type_reachable",
- ty.pointer<f32>(type::AddressSpace::kStorage, builtin::Access::kReadWrite))
+ ty.pointer<f32>(builtin::AddressSpace::kStorage, builtin::Access::kReadWrite))
->type;
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 544e1e3..a9cd10c 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 @@
using WgslUnaryOpTest = TestHelper;
TEST_F(WgslUnaryOpTest, AddressOf) {
- GlobalVar("expr", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.f32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
WrapInFunction(op);
@@ -32,7 +32,7 @@
}
TEST_F(WgslUnaryOpTest, Complement) {
- GlobalVar("expr", ty.u32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.u32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr("expr"));
WrapInFunction(op);
@@ -44,7 +44,7 @@
}
TEST_F(WgslUnaryOpTest, Indirection) {
- GlobalVar("G", ty.f32(), type::AddressSpace::kPrivate);
+ GlobalVar("G", ty.f32(), builtin::AddressSpace::kPrivate);
auto* p = Let("expr", create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
WrapInFunction(p, op);
@@ -57,7 +57,7 @@
}
TEST_F(WgslUnaryOpTest, Not) {
- GlobalVar("expr", ty.bool_(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.bool_(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
WrapInFunction(op);
@@ -69,7 +69,7 @@
}
TEST_F(WgslUnaryOpTest, Negation) {
- GlobalVar("expr", ty.i32(), type::AddressSpace::kPrivate);
+ GlobalVar("expr", ty.i32(), builtin::AddressSpace::kPrivate);
auto* op = create<ast::UnaryOpExpression>(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 33ead1d..5c9506f 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 @@
using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitVariable) {
- auto* v = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -32,7 +32,7 @@
}
TEST_F(WgslGeneratorImplTest, EmitVariable_AddressSpace) {
- auto* v = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
+ auto* v = GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate);
GeneratorImpl& gen = Build();
@@ -43,7 +43,7 @@
TEST_F(WgslGeneratorImplTest, EmitVariable_Access_Read) {
auto* s = Structure("S", utils::Vector{Member("a", ty.i32())});
- auto* v = GlobalVar("a", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kRead,
+ auto* v = GlobalVar("a", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kRead,
Binding(0_a), Group(0_a));
GeneratorImpl& gen = Build();
@@ -55,7 +55,7 @@
TEST_F(WgslGeneratorImplTest, EmitVariable_Access_ReadWrite) {
auto* s = Structure("S", utils::Vector{Member("a", ty.i32())});
- auto* v = GlobalVar("a", ty.Of(s), type::AddressSpace::kStorage, builtin::Access::kReadWrite,
+ auto* v = GlobalVar("a", ty.Of(s), builtin::AddressSpace::kStorage, builtin::Access::kReadWrite,
Binding(0_a), Group(0_a));
GeneratorImpl& gen = Build();
@@ -76,7 +76,7 @@
}
TEST_F(WgslGeneratorImplTest, EmitVariable_Initializer) {
- auto* v = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, Expr(1_f));
+ auto* v = GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, Expr(1_f));
GeneratorImpl& gen = Build();
