mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-06-05 06:03:34 +00:00
Move ast/address_space to type/
This CL moves the ast/address_space to type/address_space. This breaks the type dependency on ast for AddressSpace. Change-Id: Icb48e7423e18904865ec735024eb3b9864c947c2 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/117604 Kokoro: Kokoro <noreply+kokoro@google.com> Reviewed-by: Ben Clayton <bclayton@google.com> Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
parent
3cbf3fc4c5
commit
18b2158b4e
@ -183,8 +183,6 @@ libtint_source_set("libtint_core_all_src") {
|
||||
sources = [
|
||||
"ast/access.cc",
|
||||
"ast/access.h",
|
||||
"ast/address_space.cc",
|
||||
"ast/address_space.h",
|
||||
"ast/alias.cc",
|
||||
"ast/alias.h",
|
||||
"ast/array.cc",
|
||||
@ -563,6 +561,7 @@ libtint_source_set("libtint_core_all_src") {
|
||||
"type/abstract_float.h",
|
||||
"type/abstract_int.h",
|
||||
"type/abstract_numeric.h",
|
||||
"type/address_space.h",
|
||||
"type/array.h",
|
||||
"type/array_count.h",
|
||||
"type/atomic.h",
|
||||
@ -695,6 +694,8 @@ libtint_source_set("libtint_type_src") {
|
||||
"type/abstract_int.h",
|
||||
"type/abstract_numeric.cc",
|
||||
"type/abstract_numeric.h",
|
||||
"type/address_space.cc",
|
||||
"type/address_space.h",
|
||||
"type/array.cc",
|
||||
"type/array.h",
|
||||
"type/array_count.cc",
|
||||
@ -1124,7 +1125,6 @@ if (tint_build_unittests) {
|
||||
tint_unittests_source_set("tint_unittests_ast_src") {
|
||||
sources = [
|
||||
"ast/access_test.cc",
|
||||
"ast/address_space_test.cc",
|
||||
"ast/alias_test.cc",
|
||||
"ast/array_test.cc",
|
||||
"ast/assignment_statement_test.cc",
|
||||
@ -1303,6 +1303,7 @@ if (tint_build_unittests) {
|
||||
|
||||
tint_unittests_source_set("tint_unittests_type_src") {
|
||||
sources = [
|
||||
"type/address_space_test.cc",
|
||||
"type/array_test.cc",
|
||||
"type/atomic_test.cc",
|
||||
"type/bool_test.cc",
|
||||
|
@ -567,7 +567,6 @@ list(APPEND TINT_LIB_SRCS
|
||||
)
|
||||
|
||||
tint_generated(ast/access BENCH TEST)
|
||||
tint_generated(ast/address_space BENCH TEST)
|
||||
tint_generated(ast/builtin_value BENCH TEST)
|
||||
tint_generated(ast/extension BENCH TEST)
|
||||
tint_generated(ast/interpolate_attribute BENCH TEST)
|
||||
@ -575,6 +574,7 @@ tint_generated(ast/texel_format BENCH TEST)
|
||||
tint_generated(resolver/init_conv_intrinsic)
|
||||
tint_generated(sem/builtin_type)
|
||||
tint_generated(sem/parameter_usage)
|
||||
tint_generated(type/address_space BENCH TEST)
|
||||
tint_generated(type/short_name BENCH TEST)
|
||||
|
||||
if(UNIX)
|
||||
|
@ -72,7 +72,7 @@ TEST_F(ModuleTest, Assert_DifferentProgramID_GlobalVariable) {
|
||||
{
|
||||
ProgramBuilder b1;
|
||||
ProgramBuilder b2;
|
||||
b1.AST().AddGlobalVariable(b2.Var("var", b2.ty.i32(), ast::AddressSpace::kPrivate));
|
||||
b1.AST().AddGlobalVariable(b2.Var("var", b2.ty.i32(), type::AddressSpace::kPrivate));
|
||||
},
|
||||
"internal compiler error");
|
||||
}
|
||||
@ -92,7 +92,7 @@ TEST_F(ModuleTest, CloneOrder) {
|
||||
ProgramBuilder b;
|
||||
b.Func("F", {}, b.ty.void_(), {});
|
||||
b.Alias("A", b.ty.u32());
|
||||
b.GlobalVar("V", b.ty.i32(), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("V", b.ty.i32(), type::AddressSpace::kPrivate);
|
||||
return Program(std::move(b));
|
||||
}();
|
||||
|
||||
|
@ -24,14 +24,14 @@ Pointer::Pointer(ProgramID pid,
|
||||
NodeID nid,
|
||||
const Source& src,
|
||||
const Type* const subtype,
|
||||
ast::AddressSpace addr_space,
|
||||
type::AddressSpace addr_space,
|
||||
ast::Access ac)
|
||||
: Base(pid, nid, src), type(subtype), address_space(addr_space), access(ac) {}
|
||||
|
||||
std::string Pointer::FriendlyName(const SymbolTable& symbols) const {
|
||||
std::ostringstream out;
|
||||
out << "ptr<";
|
||||
if (address_space != ast::AddressSpace::kNone) {
|
||||
if (address_space != type::AddressSpace::kNone) {
|
||||
out << address_space << ", ";
|
||||
}
|
||||
out << type->FriendlyName(symbols);
|
||||
|
@ -18,8 +18,8 @@
|
||||
#include <string>
|
||||
|
||||
#include "src/tint/ast/access.h"
|
||||
#include "src/tint/ast/address_space.h"
|
||||
#include "src/tint/ast/type.h"
|
||||
#include "src/tint/type/address_space.h"
|
||||
|
||||
namespace tint::ast {
|
||||
|
||||
@ -37,7 +37,7 @@ class Pointer final : public Castable<Pointer, Type> {
|
||||
NodeID nid,
|
||||
const Source& src,
|
||||
const Type* const subtype,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access);
|
||||
/// Move constructor
|
||||
Pointer(Pointer&&);
|
||||
@ -57,7 +57,7 @@ class Pointer final : public Castable<Pointer, Type> {
|
||||
const Type* const type;
|
||||
|
||||
/// The address space of the pointer
|
||||
ast::AddressSpace const address_space;
|
||||
type::AddressSpace const address_space;
|
||||
|
||||
/// The access control of the pointer
|
||||
ast::Access const access;
|
||||
|
@ -24,21 +24,21 @@ using AstPointerTest = TestHelper;
|
||||
|
||||
TEST_F(AstPointerTest, Creation) {
|
||||
auto* i32 = create<I32>();
|
||||
auto* p = create<Pointer>(i32, ast::AddressSpace::kStorage, Access::kRead);
|
||||
auto* p = create<Pointer>(i32, type::AddressSpace::kStorage, Access::kRead);
|
||||
EXPECT_EQ(p->type, i32);
|
||||
EXPECT_EQ(p->address_space, ast::AddressSpace::kStorage);
|
||||
EXPECT_EQ(p->address_space, type::AddressSpace::kStorage);
|
||||
EXPECT_EQ(p->access, Access::kRead);
|
||||
}
|
||||
|
||||
TEST_F(AstPointerTest, FriendlyName) {
|
||||
auto* i32 = create<I32>();
|
||||
auto* p = create<Pointer>(i32, ast::AddressSpace::kWorkgroup, Access::kUndefined);
|
||||
auto* p = create<Pointer>(i32, type::AddressSpace::kWorkgroup, Access::kUndefined);
|
||||
EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<workgroup, i32>");
|
||||
}
|
||||
|
||||
TEST_F(AstPointerTest, FriendlyNameWithAccess) {
|
||||
auto* i32 = create<I32>();
|
||||
auto* p = create<Pointer>(i32, ast::AddressSpace::kStorage, Access::kReadWrite);
|
||||
auto* p = create<Pointer>(i32, type::AddressSpace::kStorage, Access::kReadWrite);
|
||||
EXPECT_EQ(p->FriendlyName(Symbols()), "ptr<storage, i32, read_write>");
|
||||
}
|
||||
|
||||
|
@ -25,7 +25,7 @@ Var::Var(ProgramID pid,
|
||||
const Source& src,
|
||||
const Symbol& sym,
|
||||
const ast::Type* ty,
|
||||
AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
Access access,
|
||||
const Expression* init,
|
||||
utils::VectorRef<const Attribute*> attrs)
|
||||
|
@ -56,7 +56,7 @@ class Var final : public Castable<Var, Variable> {
|
||||
const Source& source,
|
||||
const Symbol& sym,
|
||||
const ast::Type* type,
|
||||
AddressSpace declared_address_space,
|
||||
type::AddressSpace declared_address_space,
|
||||
Access declared_access,
|
||||
const Expression* initializer,
|
||||
utils::VectorRef<const Attribute*> attributes);
|
||||
@ -77,7 +77,7 @@ class Var final : public Castable<Var, Variable> {
|
||||
const Var* Clone(CloneContext* ctx) const override;
|
||||
|
||||
/// The declared address space
|
||||
const AddressSpace declared_address_space;
|
||||
const type::AddressSpace declared_address_space;
|
||||
|
||||
/// The declared access control
|
||||
const Access declared_access;
|
||||
|
@ -19,11 +19,11 @@
|
||||
#include <vector>
|
||||
|
||||
#include "src/tint/ast/access.h"
|
||||
#include "src/tint/ast/address_space.h"
|
||||
#include "src/tint/ast/attribute.h"
|
||||
#include "src/tint/ast/binding_attribute.h"
|
||||
#include "src/tint/ast/expression.h"
|
||||
#include "src/tint/ast/group_attribute.h"
|
||||
#include "src/tint/type/address_space.h"
|
||||
|
||||
// Forward declarations
|
||||
namespace tint::ast {
|
||||
|
@ -25,10 +25,10 @@ namespace {
|
||||
using VariableTest = TestHelper;
|
||||
|
||||
TEST_F(VariableTest, Creation) {
|
||||
auto* v = Var("my_var", ty.i32(), AddressSpace::kFunction);
|
||||
auto* v = Var("my_var", ty.i32(), type::AddressSpace::kFunction);
|
||||
|
||||
EXPECT_EQ(v->symbol, Symbol(1, ID()));
|
||||
EXPECT_EQ(v->declared_address_space, AddressSpace::kFunction);
|
||||
EXPECT_EQ(v->declared_address_space, type::AddressSpace::kFunction);
|
||||
EXPECT_TRUE(v->type->Is<ast::I32>());
|
||||
EXPECT_EQ(v->source.range.begin.line, 0u);
|
||||
EXPECT_EQ(v->source.range.begin.column, 0u);
|
||||
@ -38,10 +38,10 @@ TEST_F(VariableTest, Creation) {
|
||||
|
||||
TEST_F(VariableTest, CreationWithSource) {
|
||||
auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 5}}}, "i",
|
||||
ty.f32(), AddressSpace::kPrivate, utils::Empty);
|
||||
ty.f32(), type::AddressSpace::kPrivate, utils::Empty);
|
||||
|
||||
EXPECT_EQ(v->symbol, Symbol(1, ID()));
|
||||
EXPECT_EQ(v->declared_address_space, AddressSpace::kPrivate);
|
||||
EXPECT_EQ(v->declared_address_space, type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(v->type->Is<ast::F32>());
|
||||
EXPECT_EQ(v->source.range.begin.line, 27u);
|
||||
EXPECT_EQ(v->source.range.begin.column, 4u);
|
||||
@ -51,10 +51,10 @@ TEST_F(VariableTest, CreationWithSource) {
|
||||
|
||||
TEST_F(VariableTest, CreationEmpty) {
|
||||
auto* v = Var(Source{Source::Range{Source::Location{27, 4}, Source::Location{27, 7}}}, "a_var",
|
||||
ty.i32(), AddressSpace::kWorkgroup, utils::Empty);
|
||||
ty.i32(), type::AddressSpace::kWorkgroup, utils::Empty);
|
||||
|
||||
EXPECT_EQ(v->symbol, Symbol(1, ID()));
|
||||
EXPECT_EQ(v->declared_address_space, AddressSpace::kWorkgroup);
|
||||
EXPECT_EQ(v->declared_address_space, type::AddressSpace::kWorkgroup);
|
||||
EXPECT_TRUE(v->type->Is<ast::I32>());
|
||||
EXPECT_EQ(v->source.range.begin.line, 27u);
|
||||
EXPECT_EQ(v->source.range.begin.column, 4u);
|
||||
@ -92,7 +92,7 @@ TEST_F(VariableTest, Assert_DifferentProgramID_Initializer) {
|
||||
}
|
||||
|
||||
TEST_F(VariableTest, WithAttributes) {
|
||||
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Location(1_u),
|
||||
auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Location(1_u),
|
||||
Builtin(BuiltinValue::kPosition), Id(1200_u));
|
||||
|
||||
auto& attributes = var->attributes;
|
||||
@ -107,22 +107,22 @@ TEST_F(VariableTest, WithAttributes) {
|
||||
}
|
||||
|
||||
TEST_F(VariableTest, HasBindingPoint_BothProvided) {
|
||||
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Binding(2_a), Group(1_a));
|
||||
auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Binding(2_a), Group(1_a));
|
||||
EXPECT_TRUE(var->HasBindingPoint());
|
||||
}
|
||||
|
||||
TEST_F(VariableTest, HasBindingPoint_NeitherProvided) {
|
||||
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, utils::Empty);
|
||||
auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, utils::Empty);
|
||||
EXPECT_FALSE(var->HasBindingPoint());
|
||||
}
|
||||
|
||||
TEST_F(VariableTest, HasBindingPoint_MissingGroupAttribute) {
|
||||
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Binding(2_a));
|
||||
auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Binding(2_a));
|
||||
EXPECT_FALSE(var->HasBindingPoint());
|
||||
}
|
||||
|
||||
TEST_F(VariableTest, HasBindingPoint_MissingBindingAttribute) {
|
||||
auto* var = Var("my_var", ty.i32(), AddressSpace::kFunction, Group(1_a));
|
||||
auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Group(1_a));
|
||||
EXPECT_FALSE(var->HasBindingPoint());
|
||||
}
|
||||
|
||||
|
@ -586,7 +586,7 @@ uint32_t Inspector::GetWorkgroupStorageSize(const std::string& entry_point) {
|
||||
uint32_t total_size = 0;
|
||||
auto* func_sem = program_->Sem().Get(func);
|
||||
for (const sem::Variable* var : func_sem->TransitivelyReferencedGlobals()) {
|
||||
if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) {
|
||||
if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
|
||||
auto* ty = var->Type()->UnwrapRef();
|
||||
uint32_t align = ty->Align();
|
||||
uint32_t size = ty->Size();
|
||||
|
@ -743,7 +743,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly) {
|
||||
|
||||
TEST_F(InspectorGetEntryPointTest, OverrideReferencedIndirectly_ViaPrivateInitializer) {
|
||||
Override("foo", ty.f32());
|
||||
GlobalVar("bar", ast::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "foo"));
|
||||
GlobalVar("bar", type::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "foo"));
|
||||
MakePlainGlobalReferenceBodyFunction("ep_func", "bar", ty.f32(),
|
||||
utils::Vector{
|
||||
Stage(ast::PipelineStage::kCompute),
|
||||
@ -834,7 +834,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByAttributeIndirectly) {
|
||||
|
||||
TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) {
|
||||
Override("size", ty.u32());
|
||||
GlobalVar("v", ast::AddressSpace::kWorkgroup, ty.array(ty.f32(), "size"));
|
||||
GlobalVar("v", type::AddressSpace::kWorkgroup, ty.array(ty.f32(), "size"));
|
||||
Func("ep", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Assign(Phony(), IndexAccessor("v", 0_a)),
|
||||
@ -857,7 +857,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySize) {
|
||||
TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySizeIndirectly) {
|
||||
Override("foo", ty.u32());
|
||||
Override("bar", ty.u32(), Mul(2_a, "foo"));
|
||||
GlobalVar("v", ast::AddressSpace::kWorkgroup, ty.array(ty.f32(), Mul(2_a, Expr("bar"))));
|
||||
GlobalVar("v", type::AddressSpace::kWorkgroup, ty.array(ty.f32(), Mul(2_a, Expr("bar"))));
|
||||
Func("ep", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Assign(Phony(), IndexAccessor("v", 0_a)),
|
||||
@ -885,7 +885,7 @@ TEST_F(InspectorGetEntryPointTest, OverrideReferencedByArraySizeViaAlias) {
|
||||
Alias("MyArray", ty.array(ty.f32(), Mul(2_a, Expr("bar"))));
|
||||
Override("zoo", ty.u32());
|
||||
Alias("MyArrayUnused", ty.array(ty.f32(), Mul(2_a, Expr("zoo"))));
|
||||
GlobalVar("v", ast::AddressSpace::kWorkgroup, ty.type_name("MyArray"));
|
||||
GlobalVar("v", type::AddressSpace::kWorkgroup, ty.type_name("MyArray"));
|
||||
Func("ep", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Assign(Phony(), IndexAccessor("v", 0_a)),
|
||||
|
@ -126,11 +126,11 @@ void InspectorBuilder::AddUniformBuffer(const std::string& name,
|
||||
const ast::Type* type,
|
||||
uint32_t group,
|
||||
uint32_t binding) {
|
||||
GlobalVar(name, type, ast::AddressSpace::kUniform, Binding(AInt(binding)), Group(AInt(group)));
|
||||
GlobalVar(name, type, type::AddressSpace::kUniform, Binding(AInt(binding)), Group(AInt(group)));
|
||||
}
|
||||
|
||||
void InspectorBuilder::AddWorkgroupStorage(const std::string& name, const ast::Type* type) {
|
||||
GlobalVar(name, type, ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar(name, type, type::AddressSpace::kWorkgroup);
|
||||
}
|
||||
|
||||
void InspectorBuilder::AddStorageBuffer(const std::string& name,
|
||||
@ -138,7 +138,7 @@ void InspectorBuilder::AddStorageBuffer(const std::string& name,
|
||||
ast::Access access,
|
||||
uint32_t group,
|
||||
uint32_t binding) {
|
||||
GlobalVar(name, type, ast::AddressSpace::kStorage, access, Binding(AInt(binding)),
|
||||
GlobalVar(name, type, type::AddressSpace::kStorage, access, Binding(AInt(binding)),
|
||||
Group(AInt(group)));
|
||||
}
|
||||
|
||||
@ -188,7 +188,7 @@ void InspectorBuilder::AddResource(const std::string& name,
|
||||
}
|
||||
|
||||
void InspectorBuilder::AddGlobalVariable(const std::string& name, const ast::Type* type) {
|
||||
GlobalVar(name, type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar(name, type, type::AddressSpace::kPrivate);
|
||||
}
|
||||
|
||||
const ast::Function* InspectorBuilder::MakeSamplerReferenceBodyFunction(
|
||||
|
@ -1468,7 +1468,7 @@ FunctionEnd
|
||||
|
||||
TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) {
|
||||
auto* expr = Expr(true);
|
||||
GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate, expr);
|
||||
GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, expr);
|
||||
|
||||
auto& b = CreateBuilder();
|
||||
auto r = b.EmitLiteral(expr);
|
||||
@ -1482,7 +1482,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) {
|
||||
|
||||
TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) {
|
||||
auto* expr = Expr(false);
|
||||
GlobalVar("a", ty.bool_(), ast::AddressSpace::kPrivate, expr);
|
||||
GlobalVar("a", ty.bool_(), type::AddressSpace::kPrivate, expr);
|
||||
|
||||
auto& b = CreateBuilder();
|
||||
auto r = b.EmitLiteral(expr);
|
||||
@ -1496,7 +1496,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) {
|
||||
|
||||
TEST_F(IR_BuilderImplTest, EmitLiteral_F32) {
|
||||
auto* expr = Expr(1.2_f);
|
||||
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, expr);
|
||||
GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, expr);
|
||||
|
||||
auto& b = CreateBuilder();
|
||||
auto r = b.EmitLiteral(expr);
|
||||
@ -1511,7 +1511,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_F32) {
|
||||
TEST_F(IR_BuilderImplTest, EmitLiteral_F16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
auto* expr = Expr(1.2_h);
|
||||
GlobalVar("a", ty.f16(), ast::AddressSpace::kPrivate, expr);
|
||||
GlobalVar("a", ty.f16(), type::AddressSpace::kPrivate, expr);
|
||||
|
||||
auto& b = CreateBuilder();
|
||||
auto r = b.EmitLiteral(expr);
|
||||
@ -1525,7 +1525,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_F16) {
|
||||
|
||||
TEST_F(IR_BuilderImplTest, EmitLiteral_I32) {
|
||||
auto* expr = Expr(-2_i);
|
||||
GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate, expr);
|
||||
GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate, expr);
|
||||
|
||||
auto& b = CreateBuilder();
|
||||
auto r = b.EmitLiteral(expr);
|
||||
@ -1539,7 +1539,7 @@ TEST_F(IR_BuilderImplTest, EmitLiteral_I32) {
|
||||
|
||||
TEST_F(IR_BuilderImplTest, EmitLiteral_U32) {
|
||||
auto* expr = Expr(2_u);
|
||||
GlobalVar("a", ty.u32(), ast::AddressSpace::kPrivate, expr);
|
||||
GlobalVar("a", ty.u32(), type::AddressSpace::kPrivate, expr);
|
||||
|
||||
auto& b = CreateBuilder();
|
||||
auto r = b.EmitLiteral(expr);
|
||||
|
@ -181,14 +181,14 @@ class ProgramBuilder {
|
||||
~VarOptions();
|
||||
|
||||
const ast::Type* type = nullptr;
|
||||
ast::AddressSpace address_space = ast::AddressSpace::kNone;
|
||||
type::AddressSpace address_space = type::AddressSpace::kNone;
|
||||
ast::Access access = ast::Access::kUndefined;
|
||||
const ast::Expression* initializer = nullptr;
|
||||
utils::Vector<const ast::Attribute*, 4> attributes;
|
||||
|
||||
private:
|
||||
void Set(const ast::Type* t) { type = t; }
|
||||
void Set(ast::AddressSpace addr_space) { address_space = addr_space; }
|
||||
void Set(type::AddressSpace addr_space) { address_space = addr_space; }
|
||||
void Set(ast::Access ac) { access = ac; }
|
||||
void Set(const ast::Expression* c) { initializer = c; }
|
||||
void Set(utils::VectorRef<const ast::Attribute*> l) { attributes = std::move(l); }
|
||||
@ -940,9 +940,9 @@ class ProgramBuilder {
|
||||
/// @param type the type of the pointer
|
||||
/// @param address_space the address space of the pointer
|
||||
/// @param access the optional access control of the pointer
|
||||
/// @return the pointer to `type` with the given ast::AddressSpace
|
||||
/// @return the pointer to `type` with the given type::AddressSpace
|
||||
const ast::Pointer* pointer(const ast::Type* type,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access = ast::Access::kUndefined) const {
|
||||
return builder->create<ast::Pointer>(type, address_space, access);
|
||||
}
|
||||
@ -951,19 +951,19 @@ class ProgramBuilder {
|
||||
/// @param type the type of the pointer
|
||||
/// @param address_space the address space of the pointer
|
||||
/// @param access the optional access control of the pointer
|
||||
/// @return the pointer to `type` with the given ast::AddressSpace
|
||||
/// @return the pointer to `type` with the given type::AddressSpace
|
||||
const ast::Pointer* pointer(const Source& source,
|
||||
const ast::Type* type,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access = ast::Access::kUndefined) const {
|
||||
return builder->create<ast::Pointer>(source, type, address_space, access);
|
||||
}
|
||||
|
||||
/// @param address_space the address space of the pointer
|
||||
/// @param access the optional access control of the pointer
|
||||
/// @return the pointer to type `T` with the given ast::AddressSpace.
|
||||
/// @return the pointer to type `T` with the given type::AddressSpace.
|
||||
template <typename T>
|
||||
const ast::Pointer* pointer(ast::AddressSpace address_space,
|
||||
const ast::Pointer* pointer(type::AddressSpace address_space,
|
||||
ast::Access access = ast::Access::kUndefined) const {
|
||||
return pointer(Of<T>(), address_space, access);
|
||||
}
|
||||
@ -971,10 +971,10 @@ class ProgramBuilder {
|
||||
/// @param source the Source of the node
|
||||
/// @param address_space the address space of the pointer
|
||||
/// @param access the optional access control of the pointer
|
||||
/// @return the pointer to type `T` with the given ast::AddressSpace.
|
||||
/// @return the pointer to type `T` with the given type::AddressSpace.
|
||||
template <typename T>
|
||||
const ast::Pointer* pointer(const Source& source,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access = ast::Access::kUndefined) const {
|
||||
return pointer(source, Of<T>(), address_space, access);
|
||||
}
|
||||
@ -1697,7 +1697,7 @@ class ProgramBuilder {
|
||||
/// @param options the extra options passed to the ast::Var initializer
|
||||
/// Can be any of the following, in any order:
|
||||
/// * ast::Type* - specifies the variable type
|
||||
/// * ast::AddressSpace - specifies the variable address space
|
||||
/// * type::AddressSpace - specifies the variable address space
|
||||
/// * ast::Access - specifies the variable's access control
|
||||
/// * ast::Expression* - specifies the variable's initializer expression
|
||||
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
|
||||
@ -1716,7 +1716,7 @@ class ProgramBuilder {
|
||||
/// @param options the extra options passed to the ast::Var initializer
|
||||
/// Can be any of the following, in any order:
|
||||
/// * ast::Type* - specifies the variable type
|
||||
/// * ast::AddressSpace - specifies the variable address space
|
||||
/// * type::AddressSpace - specifies the variable address space
|
||||
/// * ast::Access - specifies the variable's access control
|
||||
/// * ast::Expression* - specifies the variable's initializer expression
|
||||
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
|
||||
@ -1820,7 +1820,7 @@ class ProgramBuilder {
|
||||
/// @param options the extra options passed to the ast::Var initializer
|
||||
/// Can be any of the following, in any order:
|
||||
/// * ast::Type* - specifies the variable type
|
||||
/// * ast::AddressSpace - specifies the variable address space
|
||||
/// * type::AddressSpace - specifies the variable address space
|
||||
/// * ast::Access - specifies the variable's access control
|
||||
/// * ast::Expression* - specifies the variable's initializer expression
|
||||
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
|
||||
@ -1839,7 +1839,7 @@ class ProgramBuilder {
|
||||
/// @param options the extra options passed to the ast::Var initializer
|
||||
/// Can be any of the following, in any order:
|
||||
/// * ast::Type* - specifies the variable type
|
||||
/// * ast::AddressSpace - specifies the variable address space
|
||||
/// * type::AddressSpace - specifies the variable address space
|
||||
/// * ast::Access - specifies the variable's access control
|
||||
/// * ast::Expression* - specifies the variable's initializer expression
|
||||
/// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector)
|
||||
|
@ -46,7 +46,7 @@ TEST_F(ProgramTest, IDsAreUnique) {
|
||||
}
|
||||
|
||||
TEST_F(ProgramTest, Assert_GlobalVariable) {
|
||||
GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
Program program(std::move(*this));
|
||||
EXPECT_TRUE(program.IsValid());
|
||||
|
@ -38,30 +38,30 @@ ast::PipelineStage EnumConverter::ToPipelineStage(spv::ExecutionModel model) {
|
||||
return ast::PipelineStage::kNone;
|
||||
}
|
||||
|
||||
ast::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) {
|
||||
type::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) {
|
||||
switch (sc) {
|
||||
case spv::StorageClass::Input:
|
||||
return ast::AddressSpace::kIn;
|
||||
return type::AddressSpace::kIn;
|
||||
case spv::StorageClass::Output:
|
||||
return ast::AddressSpace::kOut;
|
||||
return type::AddressSpace::kOut;
|
||||
case spv::StorageClass::Uniform:
|
||||
return ast::AddressSpace::kUniform;
|
||||
return type::AddressSpace::kUniform;
|
||||
case spv::StorageClass::Workgroup:
|
||||
return ast::AddressSpace::kWorkgroup;
|
||||
return type::AddressSpace::kWorkgroup;
|
||||
case spv::StorageClass::UniformConstant:
|
||||
return ast::AddressSpace::kNone;
|
||||
return type::AddressSpace::kNone;
|
||||
case spv::StorageClass::StorageBuffer:
|
||||
return ast::AddressSpace::kStorage;
|
||||
return type::AddressSpace::kStorage;
|
||||
case spv::StorageClass::Private:
|
||||
return ast::AddressSpace::kPrivate;
|
||||
return type::AddressSpace::kPrivate;
|
||||
case spv::StorageClass::Function:
|
||||
return ast::AddressSpace::kFunction;
|
||||
return type::AddressSpace::kFunction;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
Fail() << "unknown SPIR-V storage class: " << uint32_t(sc);
|
||||
return ast::AddressSpace::kUndefined;
|
||||
return type::AddressSpace::kUndefined;
|
||||
}
|
||||
|
||||
ast::BuiltinValue EnumConverter::ToBuiltin(spv::BuiltIn b) {
|
||||
|
@ -17,10 +17,10 @@
|
||||
|
||||
#include "spirv/unified1/spirv.h"
|
||||
#include "spirv/unified1/spirv.hpp11"
|
||||
#include "src/tint/ast/address_space.h"
|
||||
#include "src/tint/ast/builtin_value.h"
|
||||
#include "src/tint/ast/pipeline_stage.h"
|
||||
#include "src/tint/reader/spirv/fail_stream.h"
|
||||
#include "src/tint/type/address_space.h"
|
||||
#include "src/tint/type/storage_texture.h"
|
||||
#include "src/tint/type/texture_dimension.h"
|
||||
|
||||
@ -45,7 +45,7 @@ class EnumConverter {
|
||||
/// On failure, logs an error and returns kNone
|
||||
/// @param sc the SPIR-V storage class
|
||||
/// @returns a Tint AST address space
|
||||
ast::AddressSpace ToAddressSpace(const spv::StorageClass sc);
|
||||
type::AddressSpace ToAddressSpace(const spv::StorageClass sc);
|
||||
|
||||
/// Converts a SPIR-V Builtin value a Tint Builtin.
|
||||
/// On failure, logs an error and returns kNone
|
||||
|
@ -85,7 +85,7 @@ INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
|
||||
struct StorageClassCase {
|
||||
spv::StorageClass sc;
|
||||
bool expect_success;
|
||||
ast::AddressSpace expected;
|
||||
type::AddressSpace expected;
|
||||
};
|
||||
inline std::ostream& operator<<(std::ostream& out, StorageClassCase scc) {
|
||||
out << "StorageClassCase{ spv::StorageClass:::" << int(scc.sc)
|
||||
@ -126,19 +126,19 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
EnumConverterGood,
|
||||
SpvStorageClassTest,
|
||||
testing::Values(
|
||||
StorageClassCase{spv::StorageClass::Input, true, ast::AddressSpace::kIn},
|
||||
StorageClassCase{spv::StorageClass::Output, true, ast::AddressSpace::kOut},
|
||||
StorageClassCase{spv::StorageClass::Uniform, true, ast::AddressSpace::kUniform},
|
||||
StorageClassCase{spv::StorageClass::Workgroup, true, ast::AddressSpace::kWorkgroup},
|
||||
StorageClassCase{spv::StorageClass::UniformConstant, true, ast::AddressSpace::kNone},
|
||||
StorageClassCase{spv::StorageClass::StorageBuffer, true, ast::AddressSpace::kStorage},
|
||||
StorageClassCase{spv::StorageClass::Private, true, ast::AddressSpace::kPrivate},
|
||||
StorageClassCase{spv::StorageClass::Function, true, ast::AddressSpace::kFunction}));
|
||||
StorageClassCase{spv::StorageClass::Input, true, type::AddressSpace::kIn},
|
||||
StorageClassCase{spv::StorageClass::Output, true, type::AddressSpace::kOut},
|
||||
StorageClassCase{spv::StorageClass::Uniform, true, type::AddressSpace::kUniform},
|
||||
StorageClassCase{spv::StorageClass::Workgroup, true, type::AddressSpace::kWorkgroup},
|
||||
StorageClassCase{spv::StorageClass::UniformConstant, true, type::AddressSpace::kNone},
|
||||
StorageClassCase{spv::StorageClass::StorageBuffer, true, type::AddressSpace::kStorage},
|
||||
StorageClassCase{spv::StorageClass::Private, true, type::AddressSpace::kPrivate},
|
||||
StorageClassCase{spv::StorageClass::Function, true, type::AddressSpace::kFunction}));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
|
||||
SpvStorageClassTest,
|
||||
testing::Values(StorageClassCase{static_cast<spv::StorageClass>(9999),
|
||||
false, ast::AddressSpace::kUndefined}));
|
||||
false, type::AddressSpace::kUndefined}));
|
||||
|
||||
// Builtin
|
||||
|
||||
|
@ -2536,11 +2536,11 @@ bool FunctionEmitter::EmitFunctionVariables() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
auto* var = parser_impl_.MakeVar(inst.result_id(), ast::AddressSpace::kNone, var_store_type,
|
||||
initializer, AttributeList{});
|
||||
auto* var = parser_impl_.MakeVar(inst.result_id(), type::AddressSpace::kNone,
|
||||
var_store_type, initializer, AttributeList{});
|
||||
auto* var_decl_stmt = create<ast::VariableDeclStatement>(Source{}, var);
|
||||
AddStatement(var_decl_stmt);
|
||||
auto* var_type = ty_.Reference(var_store_type, ast::AddressSpace::kNone);
|
||||
auto* var_type = ty_.Reference(var_store_type, type::AddressSpace::kNone);
|
||||
identifier_types_.emplace(inst.result_id(), var_type);
|
||||
}
|
||||
return success();
|
||||
@ -3390,9 +3390,9 @@ bool FunctionEmitter::EmitStatementsInBasicBlock(const BlockInfo& block_info,
|
||||
// no need to remap pointer properties.
|
||||
auto* store_type = parser_impl_.ConvertType(def_inst->type_id());
|
||||
AddStatement(create<ast::VariableDeclStatement>(
|
||||
Source{}, parser_impl_.MakeVar(id, ast::AddressSpace::kNone, store_type, nullptr,
|
||||
Source{}, parser_impl_.MakeVar(id, type::AddressSpace::kNone, store_type, nullptr,
|
||||
AttributeList{})));
|
||||
auto* type = ty_.Reference(store_type, ast::AddressSpace::kNone);
|
||||
auto* type = ty_.Reference(store_type, type::AddressSpace::kNone);
|
||||
identifier_types_.emplace(id, type);
|
||||
}
|
||||
|
||||
@ -4882,7 +4882,7 @@ DefInfo::Pointer FunctionEmitter::GetPointerInfo(uint32_t id) {
|
||||
}
|
||||
// Local variables are always Function storage class, with default
|
||||
// access mode.
|
||||
return DefInfo::Pointer{ast::AddressSpace::kFunction, ast::Access::kUndefined};
|
||||
return DefInfo::Pointer{type::AddressSpace::kFunction, ast::Access::kUndefined};
|
||||
}
|
||||
case spv::Op::OpFunctionParameter: {
|
||||
const auto* type = As<Pointer>(parser_impl_.ConvertType(inst.type_id()));
|
||||
@ -5117,7 +5117,7 @@ void FunctionEmitter::FindValuesNeedingNamedOrHoistedDefinition() {
|
||||
// Avoid moving combinatorial values across constructs. This is a
|
||||
// simple heuristic to avoid changing the cost of an operation
|
||||
// by moving it into or out of a loop, for example.
|
||||
if ((def_info->pointer.address_space == ast::AddressSpace::kUndefined) &&
|
||||
if ((def_info->pointer.address_space == type::AddressSpace::kUndefined) &&
|
||||
local_def.used_in_another_construct) {
|
||||
should_hoist_to_let = true;
|
||||
}
|
||||
@ -6254,7 +6254,7 @@ bool FunctionEmitter::MakeVectorInsertDynamic(const spvtools::opt::Instruction&
|
||||
// API in parser_impl_.
|
||||
var_name = namer_.MakeDerivedName(original_value_name);
|
||||
|
||||
auto* temp_var = builder_.Var(var_name, type->Build(builder_), ast::AddressSpace::kNone,
|
||||
auto* temp_var = builder_.Var(var_name, type->Build(builder_), type::AddressSpace::kNone,
|
||||
src_vector.expr);
|
||||
|
||||
AddStatement(builder_.Decl({}, temp_var));
|
||||
@ -6324,7 +6324,7 @@ bool FunctionEmitter::MakeCompositeInsert(const spvtools::opt::Instruction& inst
|
||||
// It doesn't correspond to a SPIR-V ID, so we don't use the ordinary
|
||||
// API in parser_impl_.
|
||||
var_name = namer_.MakeDerivedName(original_value_name);
|
||||
auto* temp_var = builder_.Var(var_name, type->Build(builder_), ast::AddressSpace::kNone,
|
||||
auto* temp_var = builder_.Var(var_name, type->Build(builder_), type::AddressSpace::kNone,
|
||||
src_composite.expr);
|
||||
AddStatement(builder_.Decl({}, temp_var));
|
||||
}
|
||||
|
@ -331,7 +331,7 @@ struct DefInfo {
|
||||
/// buffer expressed in the old style (with Uniform address space)
|
||||
/// that needs to be remapped to StorageBuffer address space.
|
||||
/// This is kInvalid for non-pointers.
|
||||
ast::AddressSpace address_space = ast::AddressSpace::kUndefined;
|
||||
type::AddressSpace address_space = type::AddressSpace::kUndefined;
|
||||
|
||||
/// The declared access mode.
|
||||
ast::Access access = ast::Access::kUndefined;
|
||||
@ -368,7 +368,7 @@ inline std::ostream& operator<<(std::ostream& o, const DefInfo& di) {
|
||||
}
|
||||
o << " requires_named_let_def: " << (di.requires_named_let_def ? "true" : "false")
|
||||
<< " requires_hoisted_var_def: " << (di.requires_hoisted_var_def ? "true" : "false");
|
||||
if (di.pointer.address_space != ast::AddressSpace::kNone) {
|
||||
if (di.pointer.address_space != type::AddressSpace::kNone) {
|
||||
o << " sc:" << int(di.pointer.address_space);
|
||||
}
|
||||
switch (di.skip) {
|
||||
|
@ -1222,21 +1222,21 @@ const Type* ParserImpl::ConvertType(uint32_t type_id,
|
||||
}
|
||||
|
||||
auto ast_address_space = enum_converter_.ToAddressSpace(storage_class);
|
||||
if (ast_address_space == ast::AddressSpace::kUndefined) {
|
||||
if (ast_address_space == type::AddressSpace::kUndefined) {
|
||||
Fail() << "SPIR-V pointer type with ID " << type_id << " has invalid storage class "
|
||||
<< static_cast<uint32_t>(storage_class);
|
||||
return nullptr;
|
||||
}
|
||||
if (ast_address_space == ast::AddressSpace::kUniform &&
|
||||
if (ast_address_space == type::AddressSpace::kUniform &&
|
||||
remap_buffer_block_type_.count(pointee_type_id)) {
|
||||
ast_address_space = ast::AddressSpace::kStorage;
|
||||
ast_address_space = type::AddressSpace::kStorage;
|
||||
remap_buffer_block_type_.insert(type_id);
|
||||
}
|
||||
|
||||
// Pipeline input and output variables map to private variables.
|
||||
if (ast_address_space == ast::AddressSpace::kIn ||
|
||||
ast_address_space == ast::AddressSpace::kOut) {
|
||||
ast_address_space = ast::AddressSpace::kPrivate;
|
||||
if (ast_address_space == type::AddressSpace::kIn ||
|
||||
ast_address_space == type::AddressSpace::kOut) {
|
||||
ast_address_space = type::AddressSpace::kPrivate;
|
||||
}
|
||||
switch (ptr_as) {
|
||||
case PtrAs::Ref:
|
||||
@ -1460,14 +1460,14 @@ bool ParserImpl::EmitModuleScopeVariables() {
|
||||
continue;
|
||||
}
|
||||
switch (enum_converter_.ToAddressSpace(spirv_storage_class)) {
|
||||
case ast::AddressSpace::kNone:
|
||||
case ast::AddressSpace::kIn:
|
||||
case ast::AddressSpace::kOut:
|
||||
case ast::AddressSpace::kUniform:
|
||||
case ast::AddressSpace::kHandle:
|
||||
case ast::AddressSpace::kStorage:
|
||||
case ast::AddressSpace::kWorkgroup:
|
||||
case ast::AddressSpace::kPrivate:
|
||||
case type::AddressSpace::kNone:
|
||||
case type::AddressSpace::kIn:
|
||||
case type::AddressSpace::kOut:
|
||||
case type::AddressSpace::kUniform:
|
||||
case type::AddressSpace::kHandle:
|
||||
case type::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kWorkgroup:
|
||||
case type::AddressSpace::kPrivate:
|
||||
break;
|
||||
default:
|
||||
return Fail() << "invalid SPIR-V storage class " << int(spirv_storage_class)
|
||||
@ -1477,7 +1477,7 @@ bool ParserImpl::EmitModuleScopeVariables() {
|
||||
return false;
|
||||
}
|
||||
const Type* ast_store_type = nullptr;
|
||||
ast::AddressSpace ast_address_space = ast::AddressSpace::kNone;
|
||||
type::AddressSpace ast_address_space = type::AddressSpace::kNone;
|
||||
if (spirv_storage_class == spv::StorageClass::UniformConstant) {
|
||||
// These are opaque handles: samplers or textures
|
||||
ast_store_type = GetHandleTypeForSpirvHandle(var);
|
||||
@ -1578,7 +1578,7 @@ const spvtools::opt::analysis::IntConstant* ParserImpl::GetArraySize(uint32_t va
|
||||
}
|
||||
|
||||
ast::Var* ParserImpl::MakeVar(uint32_t id,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
const Type* storage_type,
|
||||
const ast::Expression* initializer,
|
||||
AttributeList decorations) {
|
||||
@ -1588,7 +1588,7 @@ ast::Var* ParserImpl::MakeVar(uint32_t id,
|
||||
}
|
||||
|
||||
ast::Access access = ast::Access::kUndefined;
|
||||
if (address_space == ast::AddressSpace::kStorage) {
|
||||
if (address_space == type::AddressSpace::kStorage) {
|
||||
bool read_only = false;
|
||||
if (auto* tn = storage_type->As<Named>()) {
|
||||
read_only = read_only_struct_types_.count(tn->name) > 0;
|
||||
@ -1600,12 +1600,12 @@ ast::Var* ParserImpl::MakeVar(uint32_t id,
|
||||
|
||||
// Handle variables (textures and samplers) are always in the handle
|
||||
// address space, so we don't mention the address space.
|
||||
if (address_space == ast::AddressSpace::kHandle) {
|
||||
address_space = ast::AddressSpace::kNone;
|
||||
if (address_space == type::AddressSpace::kHandle) {
|
||||
address_space = type::AddressSpace::kNone;
|
||||
}
|
||||
|
||||
if (!ConvertDecorationsForVariable(id, &storage_type, &decorations,
|
||||
address_space != ast::AddressSpace::kPrivate)) {
|
||||
address_space != type::AddressSpace::kPrivate)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
@ -423,14 +423,14 @@ class ParserImpl : Reader {
|
||||
/// Creates an AST 'var' node for a SPIR-V ID, including any attached decorations, unless it's
|
||||
/// an ignorable builtin variable.
|
||||
/// @param id the SPIR-V result ID
|
||||
/// @param address_space the address space, which cannot be ast::AddressSpace::kNone
|
||||
/// @param address_space the address space, which cannot be type::AddressSpace::kNone
|
||||
/// @param storage_type the storage type of the variable
|
||||
/// @param initializer the variable initializer
|
||||
/// @param decorations the variable decorations
|
||||
/// @returns a new Variable node, or null in the ignorable variable case and
|
||||
/// in the error case
|
||||
ast::Var* MakeVar(uint32_t id,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
const Type* storage_type,
|
||||
const ast::Expression* initializer,
|
||||
AttributeList decorations);
|
||||
|
@ -731,7 +731,7 @@ TEST_F(SpvParserTest, ConvertType_PointerInput) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -747,7 +747,7 @@ TEST_F(SpvParserTest, ConvertType_PointerOutput) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -763,7 +763,7 @@ TEST_F(SpvParserTest, ConvertType_PointerUniform) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kUniform);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kUniform);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -779,7 +779,7 @@ TEST_F(SpvParserTest, ConvertType_PointerWorkgroup) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kWorkgroup);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kWorkgroup);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -795,7 +795,7 @@ TEST_F(SpvParserTest, ConvertType_PointerUniformConstant) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kNone);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kNone);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -811,7 +811,7 @@ TEST_F(SpvParserTest, ConvertType_PointerStorageBuffer) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kStorage);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kStorage);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -827,7 +827,7 @@ TEST_F(SpvParserTest, ConvertType_PointerPrivate) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -843,7 +843,7 @@ TEST_F(SpvParserTest, ConvertType_PointerFunction) {
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<F32>());
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kFunction);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kFunction);
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
}
|
||||
|
||||
@ -862,12 +862,12 @@ TEST_F(SpvParserTest, ConvertType_PointerToPointer) {
|
||||
|
||||
auto* ptr_ty = type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ty, nullptr);
|
||||
EXPECT_EQ(ptr_ty->address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(ptr_ty->address_space, type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(ptr_ty->type->Is<Pointer>());
|
||||
|
||||
auto* ptr_ptr_ty = ptr_ty->type->As<Pointer>();
|
||||
EXPECT_NE(ptr_ptr_ty, nullptr);
|
||||
EXPECT_EQ(ptr_ptr_ty->address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(ptr_ptr_ty->address_space, type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(ptr_ptr_ty->type->Is<F32>());
|
||||
|
||||
EXPECT_TRUE(p->error().empty());
|
||||
|
@ -175,7 +175,7 @@ Type::~Type() = default;
|
||||
|
||||
Texture::~Texture() = default;
|
||||
|
||||
Pointer::Pointer(const Type* t, ast::AddressSpace s, ast::Access a)
|
||||
Pointer::Pointer(const Type* t, type::AddressSpace s, ast::Access a)
|
||||
: type(t), address_space(s), access(a) {}
|
||||
Pointer::Pointer(const Pointer&) = default;
|
||||
|
||||
@ -183,7 +183,7 @@ const ast::Type* Pointer::Build(ProgramBuilder& b) const {
|
||||
return b.ty.pointer(type->Build(b), address_space, access);
|
||||
}
|
||||
|
||||
Reference::Reference(const Type* t, ast::AddressSpace s, ast::Access a)
|
||||
Reference::Reference(const Type* t, type::AddressSpace s, ast::Access a)
|
||||
: type(t), address_space(s), access(a) {}
|
||||
Reference::Reference(const Reference&) = default;
|
||||
|
||||
@ -460,13 +460,13 @@ const Type* TypeManager::AsUnsigned(const Type* ty) {
|
||||
}
|
||||
|
||||
const spirv::Pointer* TypeManager::Pointer(const Type* el,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access) {
|
||||
return state->pointers_.Get(el, address_space, access);
|
||||
}
|
||||
|
||||
const spirv::Reference* TypeManager::Reference(const Type* el,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access) {
|
||||
return state->references_.Get(el, address_space, access);
|
||||
}
|
||||
|
@ -20,10 +20,10 @@
|
||||
#include <vector>
|
||||
|
||||
#include "src/tint/ast/access.h"
|
||||
#include "src/tint/ast/address_space.h"
|
||||
#include "src/tint/ast/sampler.h"
|
||||
#include "src/tint/ast/storage_texture.h"
|
||||
#include "src/tint/castable.h"
|
||||
#include "src/tint/type/address_space.h"
|
||||
#include "src/tint/type/texture_dimension.h"
|
||||
#include "src/tint/utils/block_allocator.h"
|
||||
|
||||
@ -163,7 +163,7 @@ struct Pointer final : public Castable<Pointer, Type> {
|
||||
/// @param ty the store type
|
||||
/// @param sc the pointer address space
|
||||
/// @param access the declared access mode
|
||||
Pointer(const Type* ty, ast::AddressSpace sc, ast::Access access);
|
||||
Pointer(const Type* ty, type::AddressSpace sc, ast::Access access);
|
||||
|
||||
/// Copy constructor
|
||||
/// @param other the other type to copy
|
||||
@ -181,7 +181,7 @@ struct Pointer final : public Castable<Pointer, Type> {
|
||||
/// the store type
|
||||
Type const* const type;
|
||||
/// the pointer address space
|
||||
ast::AddressSpace const address_space;
|
||||
type::AddressSpace const address_space;
|
||||
/// the pointer declared access mode
|
||||
ast::Access const access;
|
||||
};
|
||||
@ -194,7 +194,7 @@ struct Reference final : public Castable<Reference, Type> {
|
||||
/// @param ty the referenced type
|
||||
/// @param sc the reference address space
|
||||
/// @param access the reference declared access mode
|
||||
Reference(const Type* ty, ast::AddressSpace sc, ast::Access access);
|
||||
Reference(const Type* ty, type::AddressSpace sc, ast::Access access);
|
||||
|
||||
/// Copy constructor
|
||||
/// @param other the other type to copy
|
||||
@ -212,7 +212,7 @@ struct Reference final : public Castable<Reference, Type> {
|
||||
/// the store type
|
||||
Type const* const type;
|
||||
/// the pointer address space
|
||||
ast::AddressSpace const address_space;
|
||||
type::AddressSpace const address_space;
|
||||
/// the pointer declared access mode
|
||||
ast::Access const access;
|
||||
};
|
||||
@ -550,7 +550,7 @@ class TypeManager {
|
||||
/// @return a Pointer type. Repeated calls with the same arguments will return
|
||||
/// the same pointer.
|
||||
const spirv::Pointer* Pointer(const Type* ty,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access = ast::Access::kUndefined);
|
||||
/// @param ty the referenced type
|
||||
/// @param address_space the reference address space
|
||||
@ -558,7 +558,7 @@ class TypeManager {
|
||||
/// @return a Reference type. Repeated calls with the same arguments will
|
||||
/// return the same pointer.
|
||||
const spirv::Reference* Reference(const Type* ty,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access = ast::Access::kUndefined);
|
||||
/// @param ty the element type
|
||||
/// @param sz the number of elements in the vector
|
||||
|
@ -29,8 +29,8 @@ TEST(SpvParserTypeTest, SameArgumentsGivesSamePointer) {
|
||||
EXPECT_EQ(ty.U32(), ty.U32());
|
||||
EXPECT_EQ(ty.F32(), ty.F32());
|
||||
EXPECT_EQ(ty.I32(), ty.I32());
|
||||
EXPECT_EQ(ty.Pointer(ty.I32(), ast::AddressSpace::kNone),
|
||||
ty.Pointer(ty.I32(), ast::AddressSpace::kNone));
|
||||
EXPECT_EQ(ty.Pointer(ty.I32(), type::AddressSpace::kNone),
|
||||
ty.Pointer(ty.I32(), type::AddressSpace::kNone));
|
||||
EXPECT_EQ(ty.Vector(ty.I32(), 3), ty.Vector(ty.I32(), 3));
|
||||
EXPECT_EQ(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.I32(), 3, 2));
|
||||
EXPECT_EQ(ty.Array(ty.I32(), 3, 2), ty.Array(ty.I32(), 3, 2));
|
||||
@ -54,10 +54,10 @@ TEST(SpvParserTypeTest, DifferentArgumentsGivesDifferentPointer) {
|
||||
Symbol sym_b(Symbol(2, {}));
|
||||
|
||||
TypeManager ty;
|
||||
EXPECT_NE(ty.Pointer(ty.I32(), ast::AddressSpace::kNone),
|
||||
ty.Pointer(ty.U32(), ast::AddressSpace::kNone));
|
||||
EXPECT_NE(ty.Pointer(ty.I32(), ast::AddressSpace::kNone),
|
||||
ty.Pointer(ty.I32(), ast::AddressSpace::kIn));
|
||||
EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kNone),
|
||||
ty.Pointer(ty.U32(), type::AddressSpace::kNone));
|
||||
EXPECT_NE(ty.Pointer(ty.I32(), type::AddressSpace::kNone),
|
||||
ty.Pointer(ty.I32(), type::AddressSpace::kIn));
|
||||
EXPECT_NE(ty.Vector(ty.I32(), 3), ty.Vector(ty.U32(), 3));
|
||||
EXPECT_NE(ty.Vector(ty.I32(), 3), ty.Vector(ty.I32(), 2));
|
||||
EXPECT_NE(ty.Matrix(ty.I32(), 3, 2), ty.Matrix(ty.U32(), 3, 2));
|
||||
|
@ -213,7 +213,7 @@ ParserImpl::VarDeclInfo::VarDeclInfo(const VarDeclInfo&) = default;
|
||||
|
||||
ParserImpl::VarDeclInfo::VarDeclInfo(Source source_in,
|
||||
std::string name_in,
|
||||
ast::AddressSpace address_space_in,
|
||||
type::AddressSpace address_space_in,
|
||||
ast::Access access_in,
|
||||
const ast::Type* type_in)
|
||||
: source(std::move(source_in)),
|
||||
@ -1251,7 +1251,7 @@ Expect<const ast::Type*> ParserImpl::expect_type(std::string_view use) {
|
||||
Expect<const ast::Type*> ParserImpl::expect_type_specifier_pointer(const Source& s) {
|
||||
const char* use = "ptr declaration";
|
||||
|
||||
auto address_space = ast::AddressSpace::kNone;
|
||||
auto address_space = type::AddressSpace::kNone;
|
||||
auto access = ast::Access::kUndefined;
|
||||
|
||||
auto subtype = expect_lt_gt_block(use, [&]() -> Expect<const ast::Type*> {
|
||||
@ -1372,8 +1372,8 @@ Expect<const ast::Type*> ParserImpl::expect_type_specifier_matrix(const Source&
|
||||
// | 'storage'
|
||||
//
|
||||
// Note, we also parse `push_constant` from the experimental extension
|
||||
Expect<ast::AddressSpace> ParserImpl::expect_address_space(std::string_view use) {
|
||||
return expect_enum("address space", ast::ParseAddressSpace, ast::kAddressSpaceStrings, use);
|
||||
Expect<type::AddressSpace> ParserImpl::expect_address_space(std::string_view use) {
|
||||
return expect_enum("address space", type::ParseAddressSpace, type::kAddressSpaceStrings, use);
|
||||
}
|
||||
|
||||
// struct_decl
|
||||
|
@ -284,7 +284,7 @@ class ParserImpl {
|
||||
/// @param type_in variable type
|
||||
VarDeclInfo(Source source_in,
|
||||
std::string name_in,
|
||||
ast::AddressSpace address_space_in,
|
||||
type::AddressSpace address_space_in,
|
||||
ast::Access access_in,
|
||||
const ast::Type* type_in);
|
||||
/// Destructor
|
||||
@ -295,7 +295,7 @@ class ParserImpl {
|
||||
/// Variable name
|
||||
std::string name;
|
||||
/// Variable address space
|
||||
ast::AddressSpace address_space = ast::AddressSpace::kNone;
|
||||
type::AddressSpace address_space = type::AddressSpace::kNone;
|
||||
/// Variable access control
|
||||
ast::Access access = ast::Access::kUndefined;
|
||||
/// Variable type
|
||||
@ -305,7 +305,7 @@ class ParserImpl {
|
||||
/// VariableQualifier contains the parsed information for a variable qualifier
|
||||
struct VariableQualifier {
|
||||
/// The variable's address space
|
||||
ast::AddressSpace address_space = ast::AddressSpace::kNone;
|
||||
type::AddressSpace address_space = type::AddressSpace::kNone;
|
||||
/// The variable's access control
|
||||
ast::Access access = ast::Access::kUndefined;
|
||||
};
|
||||
@ -461,8 +461,8 @@ class ParserImpl {
|
||||
Maybe<const ast::Type*> type_specifier();
|
||||
/// Parses an `address_space` grammar element, erroring on parse failure.
|
||||
/// @param use a description of what was being parsed if an error was raised.
|
||||
/// @returns the address space or ast::AddressSpace::kNone if none matched
|
||||
Expect<ast::AddressSpace> expect_address_space(std::string_view use);
|
||||
/// @returns the address space or type::AddressSpace::kNone if none matched
|
||||
Expect<type::AddressSpace> expect_address_space(std::string_view use);
|
||||
/// Parses a `struct_decl` grammar element.
|
||||
/// @returns the struct type or nullptr on error
|
||||
Maybe<const ast::Struct*> struct_decl();
|
||||
|
@ -19,7 +19,7 @@ namespace {
|
||||
|
||||
struct AddressSpaceData {
|
||||
const char* input;
|
||||
ast::AddressSpace result;
|
||||
type::AddressSpace result;
|
||||
};
|
||||
inline std::ostream& operator<<(std::ostream& out, AddressSpaceData data) {
|
||||
out << std::string(data.input);
|
||||
@ -43,11 +43,11 @@ TEST_P(ParserAddressSpaceTest, Parses) {
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
ParserImplTest,
|
||||
ParserAddressSpaceTest,
|
||||
testing::Values(AddressSpaceData{"uniform", ast::AddressSpace::kUniform},
|
||||
AddressSpaceData{"workgroup", ast::AddressSpace::kWorkgroup},
|
||||
AddressSpaceData{"storage", ast::AddressSpace::kStorage},
|
||||
AddressSpaceData{"private", ast::AddressSpace::kPrivate},
|
||||
AddressSpaceData{"function", ast::AddressSpace::kFunction}));
|
||||
testing::Values(AddressSpaceData{"uniform", type::AddressSpace::kUniform},
|
||||
AddressSpaceData{"workgroup", type::AddressSpace::kWorkgroup},
|
||||
AddressSpaceData{"storage", type::AddressSpace::kStorage},
|
||||
AddressSpaceData{"private", type::AddressSpace::kPrivate},
|
||||
AddressSpaceData{"function", type::AddressSpace::kFunction}));
|
||||
|
||||
TEST_F(ParserImplTest, AddressSpace_NoMatch) {
|
||||
auto p = parser("not-a-address-space");
|
||||
|
@ -31,7 +31,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithoutInitializer) {
|
||||
|
||||
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
|
||||
EXPECT_TRUE(var->type->Is<ast::F32>());
|
||||
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(var->declared_address_space, type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_EQ(var->source.range.begin.line, 1u);
|
||||
EXPECT_EQ(var->source.range.begin.column, 14u);
|
||||
@ -55,7 +55,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithInitializer) {
|
||||
|
||||
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
|
||||
EXPECT_TRUE(var->type->Is<ast::F32>());
|
||||
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(var->declared_address_space, type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_EQ(var->source.range.begin.line, 1u);
|
||||
EXPECT_EQ(var->source.range.begin.column, 14u);
|
||||
@ -81,7 +81,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithAttribute) {
|
||||
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
|
||||
ASSERT_NE(var->type, nullptr);
|
||||
EXPECT_TRUE(var->type->Is<ast::F32>());
|
||||
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kUniform);
|
||||
EXPECT_EQ(var->declared_address_space, type::AddressSpace::kUniform);
|
||||
|
||||
EXPECT_EQ(var->source.range.begin.line, 1u);
|
||||
EXPECT_EQ(var->source.range.begin.column, 36u);
|
||||
@ -112,7 +112,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_WithAttribute_MulitpleGroups) {
|
||||
EXPECT_EQ(var->symbol, p->builder().Symbols().Get("a"));
|
||||
ASSERT_NE(var->type, nullptr);
|
||||
EXPECT_TRUE(var->type->Is<ast::F32>());
|
||||
EXPECT_EQ(var->declared_address_space, ast::AddressSpace::kUniform);
|
||||
EXPECT_EQ(var->declared_address_space, type::AddressSpace::kUniform);
|
||||
|
||||
EXPECT_EQ(var->source.range.begin.line, 1u);
|
||||
EXPECT_EQ(var->source.range.begin.column, 36u);
|
||||
|
@ -176,7 +176,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr) {
|
||||
|
||||
auto* ptr = t.value->As<ast::Pointer>();
|
||||
ASSERT_TRUE(ptr->type->Is<ast::F32>());
|
||||
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
|
||||
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 19u}}));
|
||||
}
|
||||
|
||||
@ -191,7 +191,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_WithAccess) {
|
||||
|
||||
auto* ptr = t.value->As<ast::Pointer>();
|
||||
ASSERT_TRUE(ptr->type->Is<ast::F32>());
|
||||
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->access, ast::Access::kRead);
|
||||
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 25u}}));
|
||||
}
|
||||
@ -207,7 +207,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_ToVec) {
|
||||
|
||||
auto* ptr = t.value->As<ast::Pointer>();
|
||||
ASSERT_TRUE(ptr->type->Is<ast::Vector>());
|
||||
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
|
||||
|
||||
auto* vec = ptr->type->As<ast::Vector>();
|
||||
ASSERT_EQ(vec->width, 2u);
|
||||
|
@ -167,7 +167,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr) {
|
||||
|
||||
auto* ptr = t.value->As<ast::Pointer>();
|
||||
ASSERT_TRUE(ptr->type->Is<ast::F32>());
|
||||
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
|
||||
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 19u}}));
|
||||
}
|
||||
|
||||
@ -182,7 +182,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_WithAccess) {
|
||||
|
||||
auto* ptr = t.value->As<ast::Pointer>();
|
||||
ASSERT_TRUE(ptr->type->Is<ast::F32>());
|
||||
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->access, ast::Access::kRead);
|
||||
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 25u}}));
|
||||
}
|
||||
@ -198,7 +198,7 @@ TEST_F(ParserImplTest, TypeDeclWithoutIdent_Ptr_ToVec) {
|
||||
|
||||
auto* ptr = t.value->As<ast::Pointer>();
|
||||
ASSERT_TRUE(ptr->type->Is<ast::Vector>());
|
||||
ASSERT_EQ(ptr->address_space, ast::AddressSpace::kFunction);
|
||||
ASSERT_EQ(ptr->address_space, type::AddressSpace::kFunction);
|
||||
|
||||
auto* vec = ptr->type->As<ast::Vector>();
|
||||
ASSERT_EQ(vec->width, 2u);
|
||||
|
@ -80,7 +80,7 @@ TEST_F(ParserImplTest, VariableDecl_WithAddressSpace) {
|
||||
EXPECT_FALSE(p->has_error());
|
||||
EXPECT_EQ(v->name, "my_var");
|
||||
EXPECT_TRUE(v->type->Is<ast::F32>());
|
||||
EXPECT_EQ(v->address_space, ast::AddressSpace::kPrivate);
|
||||
EXPECT_EQ(v->address_space, type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_EQ(v->source.range.begin.line, 1u);
|
||||
EXPECT_EQ(v->source.range.begin.column, 14u);
|
||||
@ -96,7 +96,7 @@ TEST_F(ParserImplTest, VariableDecl_WithPushConstant) {
|
||||
EXPECT_FALSE(p->has_error());
|
||||
EXPECT_EQ(v->name, "my_var");
|
||||
EXPECT_TRUE(v->type->Is<ast::F32>());
|
||||
EXPECT_EQ(v->address_space, ast::AddressSpace::kPushConstant);
|
||||
EXPECT_EQ(v->address_space, type::AddressSpace::kPushConstant);
|
||||
}
|
||||
|
||||
TEST_F(ParserImplTest, VariableDecl_InvalidAddressSpace) {
|
||||
|
@ -19,7 +19,7 @@ namespace {
|
||||
|
||||
struct VariableStorageData {
|
||||
const char* input;
|
||||
ast::AddressSpace address_space;
|
||||
type::AddressSpace address_space;
|
||||
ast::Access access;
|
||||
};
|
||||
inline std::ostream& operator<<(std::ostream& out, VariableStorageData data) {
|
||||
@ -47,14 +47,14 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
ParserImplTest,
|
||||
VariableQualifierTest,
|
||||
testing::Values(
|
||||
VariableStorageData{"uniform", ast::AddressSpace::kUniform, ast::Access::kUndefined},
|
||||
VariableStorageData{"workgroup", ast::AddressSpace::kWorkgroup, ast::Access::kUndefined},
|
||||
VariableStorageData{"storage", ast::AddressSpace::kStorage, ast::Access::kUndefined},
|
||||
VariableStorageData{"private", ast::AddressSpace::kPrivate, ast::Access::kUndefined},
|
||||
VariableStorageData{"function", ast::AddressSpace::kFunction, ast::Access::kUndefined},
|
||||
VariableStorageData{"storage, read", ast::AddressSpace::kStorage, ast::Access::kRead},
|
||||
VariableStorageData{"storage, write", ast::AddressSpace::kStorage, ast::Access::kWrite},
|
||||
VariableStorageData{"storage, read_write", ast::AddressSpace::kStorage,
|
||||
VariableStorageData{"uniform", type::AddressSpace::kUniform, ast::Access::kUndefined},
|
||||
VariableStorageData{"workgroup", type::AddressSpace::kWorkgroup, ast::Access::kUndefined},
|
||||
VariableStorageData{"storage", type::AddressSpace::kStorage, ast::Access::kUndefined},
|
||||
VariableStorageData{"private", type::AddressSpace::kPrivate, ast::Access::kUndefined},
|
||||
VariableStorageData{"function", type::AddressSpace::kFunction, ast::Access::kUndefined},
|
||||
VariableStorageData{"storage, read", type::AddressSpace::kStorage, ast::Access::kRead},
|
||||
VariableStorageData{"storage, write", type::AddressSpace::kStorage, ast::Access::kWrite},
|
||||
VariableStorageData{"storage, read_write", type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite}));
|
||||
|
||||
TEST_F(ParserImplTest, VariableQualifier_NoMatch) {
|
||||
|
@ -39,7 +39,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, StorageBuffer_UnalignedMember)
|
||||
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)}),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::AddressSpace::kStorage, Group(0_a),
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), type::AddressSpace::kStorage, Group(0_a),
|
||||
Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -69,7 +69,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, StorageBuffer_UnalignedMember_S
|
||||
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(4_i)}),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::AddressSpace::kStorage, Group(0_a),
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), type::AddressSpace::kStorage, Group(0_a),
|
||||
Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -100,8 +100,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_S
|
||||
Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -145,8 +145,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest,
|
||||
utils::Vector{MemberAlign(16_i)}),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -170,8 +170,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_A
|
||||
Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -204,8 +204,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_UnalignedMember_A
|
||||
utils::Vector{MemberAlign(16_i)}),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -236,8 +236,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_MembersOffsetNotM
|
||||
Member(Source{{78, 90}}, "scalar", ty.i32()),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -288,8 +288,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest,
|
||||
Member(Source{{78, 90}}, "scalar", ty.i32()),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{22, 24}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -336,8 +336,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest,
|
||||
Member(Source{{78, 90}}, "scalar", ty.i32(), utils::Vector{MemberAlign(16_i)}),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{22, 34}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{22, 34}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -358,7 +358,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_Vec3MemberOffset_
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"),
|
||||
ast::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -381,7 +381,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_Vec3F16MemberOffs
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"),
|
||||
ast::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -406,8 +406,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
|
||||
Member("scalar", ty.i32()),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -440,8 +440,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
|
||||
Member("scalar", ty.i32()),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -483,8 +483,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
|
||||
Member("scalar", ty.i32()),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -502,7 +502,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
|
||||
// @group(0) @binding(0)
|
||||
// var<uniform> a : array<f32, 4u>;
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.array(Source{{34, 56}}, ty.f32(), 4_u),
|
||||
ast::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -523,8 +523,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
|
||||
Member("inner", ty.array(Source{{34, 56}}, ty.array(ty.f32(), 4_u), 4_u)),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -556,8 +556,8 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, UniformBuffer_InvalidArrayStrid
|
||||
Member("scalar", ty.i32()),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::AddressSpace::kUniform, Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), type::AddressSpace::kUniform,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -575,7 +575,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, PushConstant_UnalignedMember) {
|
||||
Source{{12, 34}}, "S",
|
||||
utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}),
|
||||
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_i)})});
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -600,7 +600,7 @@ TEST_F(ResolverAddressSpaceLayoutValidationTest, PushConstant_Aligned) {
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5_a)}),
|
||||
Member("b", ty.f32(), utils::Vector{MemberAlign(4_i)})});
|
||||
GlobalVar("a", ty.type_name("S"), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("a", ty.type_name("S"), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
@ -38,7 +38,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NoAddressSpace_Fail) {
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NoAddressSpace_Fail) {
|
||||
// type g = ptr<f32>;
|
||||
Alias("g", ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kUndefined));
|
||||
Alias("g", ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kUndefined));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: ptr missing address space");
|
||||
@ -46,7 +46,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NoAddressSpace_Fail) {
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_Fail) {
|
||||
// var<private> g : f32;
|
||||
GlobalVar(Source{{12, 34}}, "g", ty.f32(), ast::AddressSpace::kFunction);
|
||||
GlobalVar(Source{{12, 34}}, "g", ty.f32(), type::AddressSpace::kFunction);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -56,7 +56,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_FunctionAddressSpace_F
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray) {
|
||||
// var<private> v : array<i32>;
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -67,7 +67,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArray)
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArray) {
|
||||
// type t : ptr<private, array<i32>>;
|
||||
Alias("t", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()),
|
||||
ast::AddressSpace::kPrivate));
|
||||
type::AddressSpace::kPrivate));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -79,7 +79,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Private_RuntimeArrayIn
|
||||
// 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.type_name("S"), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.type_name("S"), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -92,7 +92,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Private_RuntimeArrayInSt
|
||||
// struct S { m : array<i32> };
|
||||
// type t = ptr<private, S>;
|
||||
Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.array(ty.i32()))});
|
||||
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kPrivate));
|
||||
Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kPrivate));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -104,7 +104,7 @@ note: while instantiating ptr<private, S, read_write>)");
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray) {
|
||||
// var<workgroup> v : array<i32>;
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.array(Source{{12, 34}}, ty.i32()),
|
||||
ast::AddressSpace::kWorkgroup);
|
||||
type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -114,7 +114,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArray) {
|
||||
// type t = ptr<workgroup, array<i32>>;
|
||||
Alias("t", ty.pointer(ty.array(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kWorkgroup));
|
||||
Alias("t", ty.pointer(ty.array(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -126,7 +126,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Workgroup_RuntimeArray
|
||||
// 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.type_name("S"), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.type_name("S"), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -139,7 +139,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Workgroup_RuntimeArrayIn
|
||||
// struct S { m : array<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.type_name("S"), ast::AddressSpace::kWorkgroup));
|
||||
Alias(Source{{56, 78}}, "t", ty.pointer(ty.type_name("S"), type::AddressSpace::kWorkgroup));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -150,7 +150,7 @@ note: while instantiating ptr<workgroup, S, read_write>)");
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) {
|
||||
// var<storage> g : bool;
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), ast::AddressSpace::kStorage,
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kStorage,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -164,7 +164,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Bool) {
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Bool) {
|
||||
// type t = ptr<storage, bool>;
|
||||
Alias(Source{{56, 78}}, "t",
|
||||
ty.pointer(ty.bool_(Source{{12, 34}}), ast::AddressSpace::kStorage));
|
||||
ty.pointer(ty.bool_(Source{{12, 34}}), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -179,7 +179,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_BoolAlias) {
|
||||
// @binding(0) @group(0) var<storage, read> g : a;
|
||||
Alias("a", ty.bool_());
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.type_name(Source{{12, 34}}, "a"),
|
||||
ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -194,7 +194,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_BoolAlias) {
|
||||
// type t = ptr<storage, a>;
|
||||
Alias("a", ty.bool_());
|
||||
Alias(Source{{56, 78}}, "t",
|
||||
ty.pointer(ty.type_name(Source{{12, 34}}, "a"), ast::AddressSpace::kStorage));
|
||||
ty.pointer(ty.type_name(Source{{12, 34}}, "a"), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -207,8 +207,8 @@ note: while instantiating ptr<storage, bool, read>)");
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) {
|
||||
// var<storage> g : ptr<private, f32>;
|
||||
GlobalVar(Source{{56, 78}}, "g",
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate),
|
||||
ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
|
||||
type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -221,8 +221,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_Pointer) {
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) {
|
||||
// type t = ptr<storage, ptr<private, f32>>;
|
||||
Alias("t", ty.pointer(Source{{56, 78}},
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate),
|
||||
ast::AddressSpace::kStorage));
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
|
||||
type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -234,14 +234,14 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_Pointer) {
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_IntScalar) {
|
||||
// var<storage> g : i32;
|
||||
GlobalVar("g", ty.i32(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.i32(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_IntScalar) {
|
||||
// type t = ptr<storage, i32;
|
||||
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kStorage));
|
||||
Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -251,7 +251,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_F16) {
|
||||
// var<storage> g : f16;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("g", ty.f16(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.f16(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -261,7 +261,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_F16) {
|
||||
// type t = ptr<storage, f16>;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Alias("t", ty.pointer(ty.f16(), ast::AddressSpace::kStorage));
|
||||
Alias("t", ty.pointer(ty.f16(), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -273,7 +273,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_F16Alias) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Alias("a", ty.f16());
|
||||
GlobalVar("g", ty.type_name("a"), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.type_name("a"), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -285,21 +285,21 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_F16Alias) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Alias("a", ty.f16());
|
||||
Alias("t", ty.pointer(ty.type_name("a"), ast::AddressSpace::kStorage));
|
||||
Alias("t", ty.pointer(ty.type_name("a"), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF32) {
|
||||
// var<storage> g : vec4<f32>;
|
||||
GlobalVar("g", ty.vec4<f32>(), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) {
|
||||
// type t = ptr<storage, vec4<f32>>;
|
||||
Alias("t", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kStorage));
|
||||
Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -307,7 +307,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF32) {
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) {
|
||||
// var<storage> g : vec4<f16>;
|
||||
Enable(ast::Extension::kF16);
|
||||
GlobalVar("g", ty.vec(ty.f16(), 4u), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.vec(ty.f16(), 4u), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -315,7 +315,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_VectorF16) {
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_VectorF16) {
|
||||
// type t = ptr<storage, vec4<f16>>;
|
||||
Enable(ast::Extension::kF16);
|
||||
Alias("t", ty.pointer(ty.vec(ty.f16(), 4u), ast::AddressSpace::kStorage));
|
||||
Alias("t", ty.pointer(ty.vec(ty.f16(), 4u), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -324,7 +324,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ArrayF32) {
|
||||
// struct S{ a : f32 };
|
||||
// var<storage, read> g : array<S, 3u>;
|
||||
Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage,
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage,
|
||||
ast::Access::kRead, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -334,7 +334,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ArrayF32) {
|
||||
// struct S{ a : f32 };
|
||||
// type t = ptr<storage, array<S, 3u>>;
|
||||
Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage));
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -346,7 +346,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ArrayF16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("a", ty.f16())});
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage,
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage,
|
||||
ast::Access::kRead, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -359,7 +359,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ArrayF16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("a", ty.f16())});
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kStorage,
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kStorage,
|
||||
ast::Access::kRead));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -369,8 +369,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructI32) {
|
||||
// struct S { x : i32 };
|
||||
// var<storage, read> g : S;
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a),
|
||||
Group(0_a));
|
||||
GlobalVar("g", ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -379,7 +379,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructI32) {
|
||||
// struct S { x : i32 };
|
||||
// type t = ptr<storage, read, S>;
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead));
|
||||
Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -391,7 +391,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructI32Alias
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
Alias("a2", ty.type_name("a1"));
|
||||
GlobalVar("g", ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar("g", ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -404,7 +404,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructI32Aliases
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
Alias("a2", ty.type_name("a1"));
|
||||
Alias("t", ty.pointer(ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead));
|
||||
Alias("t", ty.pointer(ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -415,8 +415,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructF16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a),
|
||||
Group(0_a));
|
||||
GlobalVar("g", ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -427,7 +427,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructF16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kStorage, ast::Access::kRead));
|
||||
Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kStorage, ast::Access::kRead));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -441,7 +441,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_StructF16Alias
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
Alias("a2", ty.type_name("a1"));
|
||||
GlobalVar("g", ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar("g", ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -456,14 +456,14 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_StructF16Aliases
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
Alias("a2", ty.type_name("a1"));
|
||||
Alias("g", ty.pointer(ty.type_name("a2"), ast::AddressSpace::kStorage, ast::Access::kRead));
|
||||
Alias("g", ty.pointer(ty.type_name("a2"), type::AddressSpace::kStorage, ast::Access::kRead));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode) {
|
||||
// var<private, read> g : a;
|
||||
GlobalVar(Source{{12, 34}}, "g", ty.i32(), ast::AddressSpace::kPrivate, ast::Access::kRead);
|
||||
GlobalVar(Source{{12, 34}}, "g", ty.i32(), type::AddressSpace::kPrivate, ast::Access::kRead);
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -475,7 +475,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_NotStorage_AccessMode)
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) {
|
||||
// type t = ptr<private, read, a>;
|
||||
Alias("t",
|
||||
ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kPrivate, ast::Access::kRead));
|
||||
ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kPrivate, ast::Access::kRead));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -486,7 +486,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_NotStorage_AccessMode) {
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode) {
|
||||
// @group(0) @binding(0) var<storage, read> a : i32;
|
||||
GlobalVar("a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead, Group(0_a),
|
||||
GlobalVar("a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead, Group(0_a),
|
||||
Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -494,14 +494,14 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadAccessMode
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadAccessMode) {
|
||||
// type t = ptr<storage, read, i32>;
|
||||
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead));
|
||||
Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAccessMode) {
|
||||
// @group(0) @binding(0) var<storage, read_write> a : i32;
|
||||
GlobalVar("a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a),
|
||||
GlobalVar("a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a),
|
||||
Binding(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -509,14 +509,14 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_ReadWriteAcces
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_ReadWriteAccessMode) {
|
||||
// type t = ptr<storage, read_write, i32>;
|
||||
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kStorage, ast::Access::kReadWrite));
|
||||
Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kStorage, ast::Access::kReadWrite));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMode) {
|
||||
// @group(0) @binding(0) var<storage, read_write> a : i32;
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kWrite,
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kWrite,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -527,8 +527,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_Storage_WriteAccessMod
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_Storage_WriteAccessMode) {
|
||||
// type t = ptr<storage, read_write, i32>;
|
||||
Alias("t",
|
||||
ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kStorage, ast::Access::kWrite));
|
||||
Alias("t", ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kStorage,
|
||||
ast::Access::kWrite));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -543,7 +543,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBuffer_Struct_R
|
||||
Structure("S",
|
||||
utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))});
|
||||
|
||||
GlobalVar(Source{{90, 12}}, "svar", ty.type_name("S"), ast::AddressSpace::kUniform,
|
||||
GlobalVar(Source{{90, 12}}, "svar", ty.type_name("S"), type::AddressSpace::kUniform,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -560,7 +560,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBuffer_Struct_Run
|
||||
Structure("S",
|
||||
utils::Vector{Member(Source{{56, 78}}, "m", ty.array(Source{{12, 34}}, ty.i32()))});
|
||||
|
||||
Alias("t", ty.pointer(Source{{90, 12}}, ty.type_name("S"), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(Source{{90, 12}}, ty.type_name("S"), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -575,7 +575,7 @@ note: see layout of struct:
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) {
|
||||
// var<uniform> g : bool;
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), ast::AddressSpace::kUniform,
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kUniform,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -589,7 +589,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBool) {
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBool) {
|
||||
// type t = ptr<uniform, bool>;
|
||||
Alias("t",
|
||||
ty.pointer(Source{{56, 78}}, ty.bool_(Source{{12, 34}}), ast::AddressSpace::kUniform));
|
||||
ty.pointer(Source{{56, 78}}, ty.bool_(Source{{12, 34}}), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -604,7 +604,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferBoolAlias
|
||||
// var<uniform> g : a;
|
||||
Alias("a", ty.bool_());
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.type_name(Source{{12, 34}}, "a"),
|
||||
ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -619,7 +619,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBoolAlias)
|
||||
// type t = ptr<uniform, a>;
|
||||
Alias("a", ty.bool_());
|
||||
Alias("t", ty.pointer(Source{{56, 78}}, ty.type_name(Source{{12, 34}}, "a"),
|
||||
ast::AddressSpace::kUniform));
|
||||
type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -632,8 +632,8 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferBoolAlias)
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) {
|
||||
// var<uniform> g : ptr<private, f32>;
|
||||
GlobalVar(Source{{56, 78}}, "g",
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate),
|
||||
ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
|
||||
type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -646,8 +646,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformPointer) {
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) {
|
||||
// type t = ptr<uniform, ptr<private, f32>>;
|
||||
Alias("t", ty.pointer(Source{{56, 78}},
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate),
|
||||
ast::AddressSpace::kUniform));
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
|
||||
type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -659,7 +659,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformPointer) {
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar) {
|
||||
// var<uniform> g : i32;
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.i32(), ast::AddressSpace::kUniform, Binding(0_a),
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.i32(), type::AddressSpace::kUniform, Binding(0_a),
|
||||
Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -667,7 +667,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferIntScalar
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferIntScalar) {
|
||||
// type t = ptr<uniform, i32>;
|
||||
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -677,7 +677,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferF16) {
|
||||
// var<uniform> g : f16;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("g", ty.f16(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.f16(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -687,21 +687,21 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferF16) {
|
||||
// type t = ptr<uniform, f16>;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Alias("t", ty.pointer(ty.f16(), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.f16(), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF32) {
|
||||
// var<uniform> g : vec4<f32>;
|
||||
GlobalVar("g", ty.vec4<f32>(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF32) {
|
||||
// type t = ptr<uniform, vec4<f32>>;
|
||||
Alias("t", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -711,7 +711,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferVectorF16
|
||||
// var<uniform> g : vec4<f16>;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("g", ty.vec4<f16>(), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.vec4<f16>(), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -721,7 +721,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferVectorF16)
|
||||
// type t = ptr<uniform, vec4<f16>>;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Alias("t", ty.pointer(ty.vec4<f16>(), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.vec4<f16>(), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -732,7 +732,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferArrayF32)
|
||||
// }
|
||||
// var<uniform> g : array<S, 3u>;
|
||||
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})});
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform, Binding(0_a),
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform, Binding(0_a),
|
||||
Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -744,7 +744,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferArrayF32) {
|
||||
// }
|
||||
// type t = ptr<uniform, array<S, 3u>>;
|
||||
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(16_a)})});
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -758,7 +758,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferArrayF16)
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})});
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform, Binding(0_a),
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform, Binding(0_a),
|
||||
Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -773,7 +773,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferArrayF16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("a", ty.f16(), utils::Vector{MemberSize(16_a)})});
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -782,7 +782,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructI32
|
||||
// struct S { x : i32 };
|
||||
// var<uniform> g : S;
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.type_name("S"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -791,7 +791,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructI32)
|
||||
// struct S { x : i32 };
|
||||
// type t = ptr<uniform, S>;
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -802,7 +802,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructI32
|
||||
// var<uniform> g : a1;
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
GlobalVar("g", ty.type_name("a1"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.type_name("a1"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -813,7 +813,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructI32Al
|
||||
// type t = ptr<uniform, a1>;
|
||||
Structure("S", utils::Vector{Member("x", ty.i32())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
Alias("t", ty.pointer(ty.type_name("a1"), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.type_name("a1"), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -825,7 +825,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructF16
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
GlobalVar("g", ty.type_name("S"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.type_name("S"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -837,7 +837,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructF16)
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
Alias("t", ty.pointer(ty.type_name("S"), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.type_name("S"), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -851,7 +851,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_UniformBufferStructF16
|
||||
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
GlobalVar("g", ty.type_name("a1"), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("g", ty.type_name("a1"), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -865,7 +865,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_UniformBufferStructF16Al
|
||||
|
||||
Structure("S", utils::Vector{Member("x", ty.f16())});
|
||||
Alias("a1", ty.type_name("S"));
|
||||
Alias("t", ty.pointer(ty.type_name("a1"), ast::AddressSpace::kUniform));
|
||||
Alias("t", ty.pointer(ty.type_name("a1"), type::AddressSpace::kUniform));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -874,7 +874,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantBool) {
|
||||
// enable chromium_experimental_push_constant;
|
||||
// var<push_constant> g : bool;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.bool_(Source{{12, 34}}), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -888,7 +888,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantBool) {
|
||||
// type t = ptr<push_constant, bool>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Alias(Source{{56, 78}}, "t",
|
||||
ty.pointer(ty.bool_(Source{{12, 34}}), ast::AddressSpace::kPushConstant));
|
||||
ty.pointer(ty.bool_(Source{{12, 34}}), type::AddressSpace::kPushConstant));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -903,7 +903,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantF16) {
|
||||
// var<push_constant> g : f16;
|
||||
Enable(ast::Extension::kF16);
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar("g", ty.f16(Source{{56, 78}}), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("g", ty.f16(Source{{56, 78}}), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -916,7 +916,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantF16) {
|
||||
// type t = ptr<push_constant, f16>;
|
||||
Enable(ast::Extension::kF16);
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Alias("t", ty.pointer(ty.f16(Source{{56, 78}}), ast::AddressSpace::kPushConstant));
|
||||
Alias("t", ty.pointer(ty.f16(Source{{56, 78}}), type::AddressSpace::kPushConstant));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -928,8 +928,8 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantPointer) {
|
||||
// var<push_constant> g : ptr<private, f32>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar(Source{{56, 78}}, "g",
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate),
|
||||
ast::AddressSpace::kPushConstant);
|
||||
ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
|
||||
type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -943,8 +943,8 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantPointer) {
|
||||
// type t = ptr<push_constant, ptr<private, f32>>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Alias(Source{{56, 78}}, "t",
|
||||
ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), ast::AddressSpace::kPrivate),
|
||||
ast::AddressSpace::kPushConstant));
|
||||
ty.pointer(ty.pointer(Source{{12, 34}}, ty.f32(), type::AddressSpace::kPrivate),
|
||||
type::AddressSpace::kPushConstant));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
@ -957,7 +957,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantIntScalar)
|
||||
// enable chromium_experimental_push_constant;
|
||||
// var<push_constant> g : i32;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar("g", ty.i32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("g", ty.i32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -966,7 +966,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantIntScalar) {
|
||||
// enable chromium_experimental_push_constant;
|
||||
// type t = ptr<push_constant, i32>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Alias("t", ty.pointer(ty.i32(), ast::AddressSpace::kPushConstant));
|
||||
Alias("t", ty.pointer(ty.i32(), type::AddressSpace::kPushConstant));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -975,7 +975,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantVectorF32)
|
||||
// enable chromium_experimental_push_constant;
|
||||
// var<push_constant> g : vec4<f32>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar("g", ty.vec4<f32>(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("g", ty.vec4<f32>(), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -984,7 +984,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantVectorF32) {
|
||||
// enable chromium_experimental_push_constant;
|
||||
// var<push_constant> g : vec4<f32>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Alias("t", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kPushConstant));
|
||||
Alias("t", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kPushConstant));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -995,7 +995,7 @@ TEST_F(ResolverAddressSpaceValidationTest, GlobalVariable_PushConstantArrayF32)
|
||||
// var<push_constant> g : array<S, 3u>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("g", ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kPushConstant);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -1006,7 +1006,7 @@ TEST_F(ResolverAddressSpaceValidationTest, PointerAlias_PushConstantArrayF32) {
|
||||
// type t = ptr<push_constant, array<S, 3u>>;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), ast::AddressSpace::kPushConstant));
|
||||
Alias("t", ty.pointer(ty.array(ty.type_name("S"), 3_u), type::AddressSpace::kPushConstant));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
@ -35,19 +35,19 @@ struct ResolverAliasAnalysisTest : public resolver::TestHelper, public testing::
|
||||
// target(&v1, aliased ? &v1 : &v2);
|
||||
// }
|
||||
struct TwoPointerConfig {
|
||||
ast::AddressSpace address_space; // The address space for the pointers.
|
||||
type::AddressSpace address_space; // The address space for the pointers.
|
||||
bool aliased; // Whether the pointers alias or not.
|
||||
};
|
||||
class TwoPointers : public ResolverTestWithParam<TwoPointerConfig> {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
utils::Vector<const ast::Statement*, 4> body;
|
||||
if (GetParam().address_space == ast::AddressSpace::kFunction) {
|
||||
if (GetParam().address_space == type::AddressSpace::kFunction) {
|
||||
body.Push(Decl(Var("v1", ty.i32())));
|
||||
body.Push(Decl(Var("v2", ty.i32())));
|
||||
} else {
|
||||
GlobalVar("v1", ast::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("v2", ast::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("v1", type::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("v2", type::AddressSpace::kPrivate, ty.i32());
|
||||
}
|
||||
body.Push(CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"),
|
||||
AddressOf(Source{{56, 78}}, GetParam().aliased ? "v1" : "v2"))));
|
||||
@ -190,10 +190,10 @@ TEST_P(TwoPointers, ReadWriteAcrossDifferentFunctions) {
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest,
|
||||
TwoPointers,
|
||||
::testing::Values(TwoPointerConfig{ast::AddressSpace::kFunction, false},
|
||||
TwoPointerConfig{ast::AddressSpace::kFunction, true},
|
||||
TwoPointerConfig{ast::AddressSpace::kPrivate, false},
|
||||
TwoPointerConfig{ast::AddressSpace::kPrivate, true}),
|
||||
::testing::Values(TwoPointerConfig{type::AddressSpace::kFunction, false},
|
||||
TwoPointerConfig{type::AddressSpace::kFunction, true},
|
||||
TwoPointerConfig{type::AddressSpace::kPrivate, false},
|
||||
TwoPointerConfig{type::AddressSpace::kPrivate, true}),
|
||||
[](const ::testing::TestParamInfo<TwoPointers::ParamType>& p) {
|
||||
std::stringstream ss;
|
||||
ss << (p.param.aliased ? "Aliased" : "Unaliased") << "_"
|
||||
@ -214,8 +214,8 @@ INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest,
|
||||
class OnePointerOneModuleScope : public ResolverTestWithParam<bool> {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
GlobalVar("global_1", ast::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("global_2", ast::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("global_1", type::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("global_2", type::AddressSpace::kPrivate, ty.i32());
|
||||
Func("caller", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
CallStmt(Call("target",
|
||||
@ -226,7 +226,7 @@ class OnePointerOneModuleScope : public ResolverTestWithParam<bool> {
|
||||
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>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(), std::move(body));
|
||||
if (GetParam() && err) {
|
||||
@ -295,7 +295,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) {
|
||||
// f1(p1);
|
||||
Func("f2",
|
||||
utils::Vector<const ast::Parameter*, 4>{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -303,7 +303,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) {
|
||||
});
|
||||
Func("f1",
|
||||
utils::Vector<const ast::Parameter*, 4>{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -330,7 +330,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) {
|
||||
// f1(p1);
|
||||
Func("f2",
|
||||
utils::Vector<const ast::Parameter*, 4>{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -339,7 +339,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) {
|
||||
});
|
||||
Func("f1",
|
||||
utils::Vector<const ast::Parameter*, 4>{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -365,7 +365,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) {
|
||||
// f1(p1);
|
||||
Func("f2",
|
||||
utils::Vector<const ast::Parameter*, 4>{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -373,7 +373,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) {
|
||||
});
|
||||
Func("f1",
|
||||
utils::Vector<const ast::Parameter*, 4>{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -400,7 +400,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) {
|
||||
// f1(p1);
|
||||
Func("f2",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -409,7 +409,7 @@ TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) {
|
||||
});
|
||||
Func("f1",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -435,7 +435,7 @@ TEST_P(OnePointerOneModuleScope, ReadWriteAcrossDifferentFunctions) {
|
||||
// f2();
|
||||
Func("f1",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -487,8 +487,8 @@ class Use : public ResolverTestWithParam<bool> {
|
||||
void Run(const ast::Statement* stmt, const char* err = nullptr) {
|
||||
Func("target",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p1", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -531,7 +531,7 @@ TEST_P(Use, Write_CompoundAssignment_LHS) {
|
||||
TEST_P(Use, Read_CompoundAssignment_RHS) {
|
||||
// var<private> global : i32;
|
||||
// global += *p2;
|
||||
GlobalVar("global", ast::AddressSpace::kPrivate, ty.i32());
|
||||
GlobalVar("global", type::AddressSpace::kPrivate, ty.i32());
|
||||
Run(CompoundAssign("global", Deref("p2"), ast::BinaryOp::kAdd),
|
||||
R"(56:78 warning: invalid aliased pointer argument
|
||||
12:34 note: aliases with another argument passed here)");
|
||||
@ -578,7 +578,7 @@ TEST_P(Use, Read_Convert) {
|
||||
TEST_P(Use, Read_IndexAccessor) {
|
||||
// var<private> data : array<f32, 4>;
|
||||
// _ = data[*p2];
|
||||
GlobalVar("data", ast::AddressSpace::kPrivate, ty.array<f32, 4>());
|
||||
GlobalVar("data", type::AddressSpace::kPrivate, ty.array<f32, 4>());
|
||||
Run(Assign(Phony(), IndexAccessor("data", Deref("p2"))),
|
||||
R"(56:78 warning: invalid aliased pointer argument
|
||||
12:34 note: aliases with another argument passed here)");
|
||||
@ -592,7 +592,7 @@ TEST_P(Use, Read_LetInitializer) {
|
||||
|
||||
TEST_P(Use, Read_VarInitializer) {
|
||||
// var x = *p2;
|
||||
Run(Decl(Var("x", ast::AddressSpace::kFunction, Deref("p2"))),
|
||||
Run(Decl(Var("x", type::AddressSpace::kFunction, Deref("p2"))),
|
||||
R"(56:78 warning: invalid aliased pointer argument
|
||||
12:34 note: aliases with another argument passed here)");
|
||||
}
|
||||
@ -602,7 +602,7 @@ TEST_P(Use, Read_ReturnValue) {
|
||||
// foo(p2);
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.i32(),
|
||||
utils::Vector{
|
||||
@ -659,8 +659,8 @@ class UseBool : public ResolverTestWithParam<bool> {
|
||||
void Run(const ast::Statement* stmt, const char* err = nullptr) {
|
||||
Func("target",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer<bool>(ast::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer<bool>(ast::AddressSpace::kFunction)),
|
||||
Param("p1", ty.pointer<bool>(type::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer<bool>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -724,8 +724,8 @@ TEST_F(ResolverAliasAnalysisTest, NoAccess_MemberAccessor) {
|
||||
Structure("S", utils::Vector{Member("a", ty.i32())});
|
||||
Func("f2",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)),
|
||||
Param("p1", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -753,8 +753,8 @@ TEST_F(ResolverAliasAnalysisTest, Read_MemberAccessor) {
|
||||
Structure("S", utils::Vector{Member("a", ty.i32())});
|
||||
Func("f2",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)),
|
||||
Param("p1", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -785,8 +785,8 @@ TEST_F(ResolverAliasAnalysisTest, Write_MemberAccessor) {
|
||||
Structure("S", utils::Vector{Member("a", ty.i32())});
|
||||
Func("f2",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.type_name("S"), ast::AddressSpace::kFunction)),
|
||||
Param("p1", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.type_name("S"), type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -816,8 +816,8 @@ TEST_F(ResolverAliasAnalysisTest, Read_MultiComponentSwizzle) {
|
||||
Structure("S", utils::Vector{Member("a", ty.i32())});
|
||||
Func("f2",
|
||||
utils::Vector{
|
||||
Param("p1", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction)),
|
||||
Param("p1", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction)),
|
||||
Param("p2", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -848,7 +848,7 @@ TEST_F(ResolverAliasAnalysisTest, SinglePointerReadWrite) {
|
||||
// }
|
||||
Func("f1",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -901,7 +901,7 @@ TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) {
|
||||
// }
|
||||
Func("f2",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -909,7 +909,7 @@ TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) {
|
||||
});
|
||||
Func("f3",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
|
@ -27,7 +27,7 @@ namespace {
|
||||
using ResolverIndexAccessorTest = ResolverTest;
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) {
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1_f));
|
||||
WrapInFunction(acc);
|
||||
|
||||
@ -36,7 +36,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) {
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
|
||||
auto* acc = IndexAccessor("my_var", idx);
|
||||
WrapInFunction(Decl(idx), acc);
|
||||
@ -50,7 +50,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) {
|
||||
GlobalVar("my_var", ty.mat4x4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.mat4x4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* idx = Var("idx", ty.u32(), Expr(3_u));
|
||||
auto* idy = Var("idy", ty.u32(), Expr(2_u));
|
||||
auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy);
|
||||
@ -100,7 +100,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_BothDimension_Dynamic) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Matrix) {
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* acc = IndexAccessor("my_var", 1_i);
|
||||
WrapInFunction(acc);
|
||||
@ -118,7 +118,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* acc = IndexAccessor(IndexAccessor("my_var", 0_i), 1_i);
|
||||
WrapInFunction(acc);
|
||||
@ -135,7 +135,7 @@ TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Vector_F32) {
|
||||
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2_f));
|
||||
WrapInFunction(acc);
|
||||
|
||||
@ -144,7 +144,7 @@ TEST_F(ResolverIndexAccessorTest, Vector_F32) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) {
|
||||
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* idx = Var("idx", ty.i32(), Expr(2_i));
|
||||
auto* acc = IndexAccessor("my_var", idx);
|
||||
WrapInFunction(Decl(idx), acc);
|
||||
@ -167,7 +167,7 @@ TEST_F(ResolverIndexAccessorTest, Vector_Dynamic) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Vector) {
|
||||
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* acc = IndexAccessor("my_var", 2_i);
|
||||
WrapInFunction(acc);
|
||||
@ -184,7 +184,7 @@ TEST_F(ResolverIndexAccessorTest, Vector) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) {
|
||||
GlobalVar("my_var", ty.array<f32, 3>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
|
||||
auto* acc = IndexAccessor("my_var", 2_i);
|
||||
WrapInFunction(acc);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -197,7 +197,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_i32) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) {
|
||||
GlobalVar("my_var", ty.array<f32, 3>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
|
||||
auto* acc = IndexAccessor("my_var", 2_u);
|
||||
WrapInFunction(acc);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -210,7 +210,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_u32) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) {
|
||||
GlobalVar("my_var", ty.array<f32, 3>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.array<f32, 3>(), type::AddressSpace::kPrivate);
|
||||
auto* acc = IndexAccessor("my_var", 2_a);
|
||||
WrapInFunction(acc);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -225,7 +225,7 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_AInt) {
|
||||
TEST_F(ResolverIndexAccessorTest, Alias_Array) {
|
||||
auto* aary = Alias("myarrty", ty.array<f32, 3>());
|
||||
|
||||
GlobalVar("my_var", ty.Of(aary), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.Of(aary), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* acc = IndexAccessor("my_var", 2_i);
|
||||
WrapInFunction(acc);
|
||||
@ -316,7 +316,7 @@ TEST_F(ResolverIndexAccessorTest, Expr_Deref_FuncGoodParent) {
|
||||
// let x: f32 = (*p)[idx];
|
||||
// return x;
|
||||
// }
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction));
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
|
||||
auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
|
||||
auto* star_p = Deref(p);
|
||||
auto* acc = IndexAccessor(Source{{12, 34}}, star_p, idx);
|
||||
@ -337,7 +337,7 @@ TEST_F(ResolverIndexAccessorTest, Expr_Deref_FuncBadParent) {
|
||||
// let x: f32 = *p[idx];
|
||||
// return x;
|
||||
// }
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction));
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
|
||||
auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
|
||||
auto* accessor_expr = IndexAccessor(Source{{12, 34}}, p, idx);
|
||||
auto* star_p = Deref(accessor_expr);
|
||||
|
@ -33,7 +33,7 @@ TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("m", ty.i32()),
|
||||
});
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i));
|
||||
@ -193,7 +193,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
|
||||
// var a : i32;
|
||||
// let b : ptr<function,i32> = &a;
|
||||
// *b = 2i;
|
||||
const auto func = ast::AddressSpace::kFunction;
|
||||
const auto func = type::AddressSpace::kFunction;
|
||||
WrapInFunction(Var("a", ty.i32(), func, Expr(2_i)), //
|
||||
Let("b", ty.pointer<i32>(func), AddressOf(Expr("a"))), //
|
||||
Assign(Deref("b"), 2_i));
|
||||
@ -205,7 +205,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignMaterializedThroughPointer_Pass)
|
||||
// var a : i32;
|
||||
// let b : ptr<function,i32> = &a;
|
||||
// *b = 2;
|
||||
const auto func = ast::AddressSpace::kFunction;
|
||||
const auto func = type::AddressSpace::kFunction;
|
||||
auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
|
||||
auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
|
||||
WrapInFunction(var_a, var_b, Assign(Deref("b"), 2_a));
|
||||
@ -252,8 +252,8 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Atomic) {
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("a", ty.atomic(ty.i32())),
|
||||
});
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
Binding(0_a), Group(0_a));
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(0_a), Group(0_a));
|
||||
|
||||
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));
|
||||
|
||||
@ -269,8 +269,8 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_RuntimeArray) {
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("a", ty.array(ty.f32())),
|
||||
});
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
Binding(0_a), Group(0_a));
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.Of(s), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(0_a), Group(0_a));
|
||||
|
||||
WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));
|
||||
|
||||
@ -289,7 +289,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_NonConstructibleStruct_Fa
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("arr", ty.array<i32>()),
|
||||
});
|
||||
GlobalVar("s", ty.Of(s), ast::AddressSpace::kStorage, Group(0_a), Binding(0_a));
|
||||
GlobalVar("s", ty.Of(s), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
|
||||
|
||||
WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s")));
|
||||
|
||||
@ -311,7 +311,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("arr", ty.array<i32>()),
|
||||
});
|
||||
GlobalVar("s", ty.Of(s), ast::AddressSpace::kStorage, Group(0_a), Binding(0_a));
|
||||
GlobalVar("s", ty.Of(s), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
|
||||
|
||||
WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr")));
|
||||
|
||||
@ -364,9 +364,9 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) {
|
||||
GlobalVar("tex", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
|
||||
Binding(0_a));
|
||||
GlobalVar("smp", ty.sampler(ast::SamplerKind::kSampler), Group(0_a), Binding(1_a));
|
||||
GlobalVar("u", ty.Of(U), ast::AddressSpace::kUniform, Group(0_a), Binding(2_a));
|
||||
GlobalVar("s", ty.Of(S), ast::AddressSpace::kStorage, Group(0_a), Binding(3_a));
|
||||
GlobalVar("wg", ty.array<f32, 10>(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("u", ty.Of(U), type::AddressSpace::kUniform, Group(0_a), Binding(2_a));
|
||||
GlobalVar("s", ty.Of(S), type::AddressSpace::kStorage, Group(0_a), Binding(3_a));
|
||||
GlobalVar("wg", ty.array<f32, 10>(), type::AddressSpace::kWorkgroup);
|
||||
|
||||
WrapInFunction(Assign(Phony(), 1_i), //
|
||||
Assign(Phony(), 2_u), //
|
||||
|
@ -27,7 +27,7 @@ using namespace tint::number_suffixes; // NOLINT
|
||||
struct ResolverAtomicTest : public resolver::TestHelper, public testing::Test {};
|
||||
|
||||
TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) {
|
||||
auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kWorkgroup);
|
||||
auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
|
||||
@ -37,7 +37,7 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupI32) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
|
||||
auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), ast::AddressSpace::kWorkgroup);
|
||||
auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
|
||||
@ -48,7 +48,7 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
|
||||
|
||||
TEST_F(ResolverAtomicTest, GlobalStorageStruct) {
|
||||
auto* s = Structure("s", utils::Vector{Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))});
|
||||
auto* g = GlobalVar("g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
auto* g = GlobalVar("g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
@ -27,13 +27,13 @@ namespace {
|
||||
struct ResolverAtomicValidationTest : public resolver::TestHelper, public testing::Test {};
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, AddressSpace_WorkGroup) {
|
||||
GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve());
|
||||
}
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) {
|
||||
GlobalVar("g", ty.atomic(Source{{12, 34}}, ty.i32()), ast::AddressSpace::kStorage,
|
||||
GlobalVar("g", ty.atomic(Source{{12, 34}}, ty.i32()), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Group(0_a), Binding(0_a));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -41,21 +41,21 @@ TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage) {
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, AddressSpace_Storage_Struct) {
|
||||
auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))});
|
||||
GlobalVar("g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a),
|
||||
GlobalVar("g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kReadWrite, Group(0_a),
|
||||
Binding(0_a));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, InvalidType) {
|
||||
GlobalVar("a", ty.atomic(ty.f32(Source{{12, 34}})), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("a", ty.atomic(ty.f32(Source{{12, 34}})), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: atomic only supports i32 or u32 types");
|
||||
}
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Simple) {
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -63,7 +63,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Simple) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) {
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -72,7 +72,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Array) {
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Struct) {
|
||||
auto* s = Structure("s", utils::Vector{Member("a", ty.atomic(ty.i32()))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -88,7 +88,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_StructOfStruct) {
|
||||
auto* Inner =
|
||||
Structure("Inner", utils::Vector{Member("m", ty.atomic(Source{{12, 34}}, ty.i32()))});
|
||||
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -104,7 +104,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_StructOfStructOfArray)
|
||||
auto* Inner =
|
||||
Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
|
||||
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -118,7 +118,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfArray) {
|
||||
|
||||
auto* atomic_array =
|
||||
Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32()));
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.Of(atomic_array), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.Of(atomic_array), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -132,7 +132,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfStruct) {
|
||||
// var<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), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -149,7 +149,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_ArrayOfStructOfArray) {
|
||||
|
||||
auto* atomic_array = Alias("AtomicArray", ty.atomic(ty.i32()));
|
||||
auto* s = Structure("S", utils::Vector{Member(Source{{12, 34}}, "m", ty.Of(atomic_array))});
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -188,7 +188,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Complex) {
|
||||
auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))});
|
||||
auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))});
|
||||
auto* s0 = Structure("S0", utils::Vector{Member("x", ty.Of(s1))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s0), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s0), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -198,7 +198,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAddressSpace_Complex) {
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) {
|
||||
auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -210,7 +210,7 @@ TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) {
|
||||
|
||||
TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Struct) {
|
||||
auto* s = Structure("s", utils::Vector{Member(Source{{12, 34}}, "a", ty.atomic(ty.i32()))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -228,7 +228,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStruct) {
|
||||
auto* Inner =
|
||||
Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
|
||||
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -246,7 +246,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStructOfArray) {
|
||||
auto* Inner =
|
||||
Structure("Inner", utils::Vector{Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
|
||||
auto* Outer = Structure("Outer", utils::Vector{Member("m", ty.Of(Inner))});
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.Of(Outer), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -287,7 +287,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Complex) {
|
||||
auto* s2 = Structure("S2", utils::Vector{Member("x", ty.Of(s3))});
|
||||
auto* s1 = Structure("S1", utils::Vector{Member("x", ty.Of(s2))});
|
||||
auto* s0 = Structure("S0", utils::Vector{Member("x", ty.Of(s1))});
|
||||
GlobalVar(Source{{12, 34}}, "g", ty.Of(s0), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{12, 34}}, "g", ty.Of(s0), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
|
@ -722,8 +722,8 @@ TEST_F(StructMemberAttributeTest, Align_Attribute_ConstAFloat) {
|
||||
}
|
||||
|
||||
TEST_F(StructMemberAttributeTest, Align_Attribute_Var) {
|
||||
GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined,
|
||||
Expr(1.23_f));
|
||||
GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate,
|
||||
ast::Access::kUndefined, Expr(1.23_f));
|
||||
|
||||
Structure(Source{{6, 4}}, "mystruct",
|
||||
utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(),
|
||||
@ -796,8 +796,8 @@ TEST_F(StructMemberAttributeTest, Size_Attribute_ConstAFloat) {
|
||||
}
|
||||
|
||||
TEST_F(StructMemberAttributeTest, Size_Attribute_Var) {
|
||||
GlobalVar(Source{{1, 2}}, "val", ty.f32(), ast::AddressSpace::kPrivate, ast::Access::kUndefined,
|
||||
Expr(1.23_f));
|
||||
GlobalVar(Source{{1, 2}}, "val", ty.f32(), type::AddressSpace::kPrivate,
|
||||
ast::Access::kUndefined, Expr(1.23_f));
|
||||
|
||||
Structure(Source{{6, 4}}, "mystruct",
|
||||
utils::Vector{Member(Source{{12, 5}}, "a", ty.f32(),
|
||||
@ -875,7 +875,7 @@ TEST_P(VariableAttributeTest, IsValid) {
|
||||
if (IsBindingAttribute(params.kind)) {
|
||||
GlobalVar("a", ty.sampler(ast::SamplerKind::kSampler), attrs);
|
||||
} else {
|
||||
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, attrs);
|
||||
GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, attrs);
|
||||
}
|
||||
|
||||
if (params.should_pass) {
|
||||
@ -1046,7 +1046,7 @@ TEST_P(ArrayStrideTest, All) {
|
||||
create<ast::StrideAttribute>(Source{{12, 34}}, params.stride),
|
||||
});
|
||||
|
||||
GlobalVar("myarray", arr, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("myarray", arr, type::AddressSpace::kPrivate);
|
||||
|
||||
if (params.should_pass) {
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -1129,7 +1129,7 @@ TEST_F(ArrayStrideTest, DuplicateAttribute) {
|
||||
create<ast::StrideAttribute>(Source{{56, 78}}, 4u),
|
||||
});
|
||||
|
||||
GlobalVar("myarray", arr, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("myarray", arr, type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -1148,7 +1148,7 @@ TEST_F(ResourceAttributeTest, UniformBufferMissingBinding) {
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("x", ty.i32()),
|
||||
});
|
||||
GlobalVar(Source{{12, 34}}, "G", ty.Of(s), ast::AddressSpace::kUniform);
|
||||
GlobalVar(Source{{12, 34}}, "G", ty.Of(s), type::AddressSpace::kUniform);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -1159,7 +1159,7 @@ TEST_F(ResourceAttributeTest, StorageBufferMissingBinding) {
|
||||
auto* s = Structure("S", utils::Vector{
|
||||
Member("x", ty.i32()),
|
||||
});
|
||||
GlobalVar(Source{{12, 34}}, "G", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead);
|
||||
GlobalVar(Source{{12, 34}}, "G", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -1245,7 +1245,7 @@ TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByDifferentEntryPoints) {
|
||||
}
|
||||
|
||||
TEST_F(ResourceAttributeTest, BindingPointOnNonResource) {
|
||||
GlobalVar(Source{{12, 34}}, "G", ty.f32(), ast::AddressSpace::kPrivate, Binding(1_a),
|
||||
GlobalVar(Source{{12, 34}}, "G", ty.f32(), type::AddressSpace::kPrivate, Binding(1_a),
|
||||
Group(2_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
|
@ -80,7 +80,7 @@ using ResolverBuiltinTest_BoolMethod = ResolverTestWithParam<std::string>;
|
||||
TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) {
|
||||
auto name = GetParam();
|
||||
|
||||
GlobalVar("my_var", ty.bool_(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.bool_(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call(name, "my_var");
|
||||
WrapInFunction(expr);
|
||||
@ -93,7 +93,7 @@ TEST_P(ResolverBuiltinTest_BoolMethod, Scalar) {
|
||||
TEST_P(ResolverBuiltinTest_BoolMethod, Vector) {
|
||||
auto name = GetParam();
|
||||
|
||||
GlobalVar("my_var", ty.vec3<bool>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec3<bool>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call(name, "my_var");
|
||||
WrapInFunction(expr);
|
||||
@ -108,9 +108,9 @@ INSTANTIATE_TEST_SUITE_P(ResolverTest,
|
||||
testing::Values("any", "all"));
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Select) {
|
||||
GlobalVar("my_var", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
GlobalVar("bool_var", ty.vec3<bool>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("bool_var", ty.vec3<bool>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call("select", "my_var", "my_var", "bool_var");
|
||||
WrapInFunction(expr);
|
||||
@ -214,7 +214,7 @@ using ResolverBuiltinArrayTest = ResolverTest;
|
||||
TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) {
|
||||
auto* ary = ty.array<i32>();
|
||||
auto* str = Structure("S", utils::Vector{Member("x", ary)});
|
||||
GlobalVar("a", ty.Of(str), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a),
|
||||
GlobalVar("a", ty.Of(str), type::AddressSpace::kStorage, ast::Access::kRead, Binding(0_a),
|
||||
Group(0_a));
|
||||
|
||||
auto* call = Call("arrayLength", AddressOf(MemberAccessor("a", "x")));
|
||||
@ -227,7 +227,7 @@ TEST_F(ResolverBuiltinArrayTest, ArrayLength_Vector) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinArrayTest, ArrayLength_Error_ArraySized) {
|
||||
GlobalVar("arr", ty.array<i32, 4>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("arr", ty.array<i32, 4>(), type::AddressSpace::kPrivate);
|
||||
auto* call = Call("arrayLength", AddressOf("arr"));
|
||||
WrapInFunction(call);
|
||||
|
||||
@ -1070,7 +1070,7 @@ TEST_F(ResolverBuiltinFloatTest, FrexpVector_sig) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinFloatTest, Frexp_Error_FirstParamInt) {
|
||||
GlobalVar("v", ty.i32(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("v", ty.i32(), type::AddressSpace::kWorkgroup);
|
||||
auto* call = Call("frexp", 1_i, AddressOf("v"));
|
||||
WrapInFunction(call);
|
||||
|
||||
@ -1319,7 +1319,7 @@ TEST_F(ResolverBuiltinFloatTest, ModfVector_f16) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) {
|
||||
GlobalVar("whole", ty.f32(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("whole", ty.f32(), type::AddressSpace::kWorkgroup);
|
||||
auto* call = Call("modf", 1_i, AddressOf("whole"));
|
||||
WrapInFunction(call);
|
||||
|
||||
@ -1335,7 +1335,7 @@ TEST_F(ResolverBuiltinFloatTest, Modf_Error_FirstParamInt) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamIntPtr) {
|
||||
GlobalVar("whole", ty.i32(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("whole", ty.i32(), type::AddressSpace::kWorkgroup);
|
||||
auto* call = Call("modf", 1_f, AddressOf("whole"));
|
||||
WrapInFunction(call);
|
||||
|
||||
@ -1365,7 +1365,7 @@ TEST_F(ResolverBuiltinFloatTest, Modf_Error_SecondParamNotAPointer) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinFloatTest, Modf_Error_VectorSizesDontMatch) {
|
||||
GlobalVar("whole", ty.vec4<f32>(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("whole", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
|
||||
auto* call = Call("modf", vec2<f32>(1_f, 2_f), AddressOf("whole"));
|
||||
WrapInFunction(call);
|
||||
|
||||
@ -1845,7 +1845,7 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
namespace matrix_builtin_tests {
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) {
|
||||
GlobalVar("var", ty.mat2x2<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat2x2<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1859,7 +1859,7 @@ TEST_F(ResolverBuiltinTest, Determinant_2x2_f32) {
|
||||
TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("var", ty.mat2x2<f16>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat2x2<f16>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1871,7 +1871,7 @@ TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) {
|
||||
GlobalVar("var", ty.mat3x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat3x3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1885,7 +1885,7 @@ TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) {
|
||||
TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("var", ty.mat3x3<f16>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat3x3<f16>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1897,7 +1897,7 @@ TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) {
|
||||
GlobalVar("var", ty.mat4x4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat4x4<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1911,7 +1911,7 @@ TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) {
|
||||
TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("var", ty.mat4x4<f16>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat4x4<f16>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1923,7 +1923,7 @@ TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Determinant_NotSquare) {
|
||||
GlobalVar("var", ty.mat2x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.mat2x3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1938,7 +1938,7 @@ TEST_F(ResolverBuiltinTest, Determinant_NotSquare) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) {
|
||||
GlobalVar("var", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("var", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* call = Call("determinant", "var");
|
||||
WrapInFunction(call);
|
||||
@ -1958,7 +1958,7 @@ TEST_F(ResolverBuiltinTest, Determinant_NotMatrix) {
|
||||
namespace vector_builtin_tests {
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) {
|
||||
GlobalVar("my_var", ty.vec2<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec2<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call("dot", "my_var", "my_var");
|
||||
WrapInFunction(expr);
|
||||
@ -1972,7 +1972,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec2_f32) {
|
||||
TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("my_var", ty.vec2<f16>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec2<f16>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call("dot", "my_var", "my_var");
|
||||
WrapInFunction(expr);
|
||||
@ -1984,7 +1984,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) {
|
||||
GlobalVar("my_var", ty.vec3<i32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec3<i32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call("dot", "my_var", "my_var");
|
||||
WrapInFunction(expr);
|
||||
@ -1996,7 +1996,7 @@ TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinTest, Dot_Vec4_u32) {
|
||||
GlobalVar("my_var", ty.vec4<u32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_var", ty.vec4<u32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call("dot", "my_var", "my_var");
|
||||
WrapInFunction(expr);
|
||||
@ -2031,7 +2031,7 @@ using ResolverBuiltinDerivativeTest = ResolverTestWithParam<std::string>;
|
||||
TEST_P(ResolverBuiltinDerivativeTest, Scalar) {
|
||||
auto name = GetParam();
|
||||
|
||||
GlobalVar("ident", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call(name, "ident");
|
||||
Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
|
||||
@ -2045,7 +2045,7 @@ TEST_P(ResolverBuiltinDerivativeTest, Scalar) {
|
||||
|
||||
TEST_P(ResolverBuiltinDerivativeTest, Vector) {
|
||||
auto name = GetParam();
|
||||
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Call(name, "ident");
|
||||
Func("func", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
|
||||
@ -2141,7 +2141,7 @@ class ResolverBuiltinTest_TextureOperation : public ResolverTestWithParam<Textur
|
||||
GlobalVar(name, type, Binding(0_a), Group(0_a));
|
||||
|
||||
} else {
|
||||
GlobalVar(name, type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar(name, type, type::AddressSpace::kPrivate);
|
||||
}
|
||||
|
||||
call_params->Push(Expr(name));
|
||||
|
@ -166,7 +166,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalConstUsedAsType)
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsFunction) {
|
||||
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
|
||||
WrapInFunction(Call(Expr(Source{{56, 78}}, "mix"), 1_f, 2_f, 3_f));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -176,7 +176,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsFunction
|
||||
|
||||
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable) {
|
||||
auto* mix =
|
||||
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
|
||||
auto* use = Expr("mix");
|
||||
WrapInFunction(Decl(Var("v", use)));
|
||||
|
||||
@ -187,7 +187,7 @@ TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsVariable
|
||||
}
|
||||
|
||||
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVarUsedAsType) {
|
||||
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), type::AddressSpace::kPrivate);
|
||||
WrapInFunction(Construct(ty.type_name(Source{{56, 78}}, "mix")));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -481,7 +481,7 @@ TEST_P(BuiltinTextureConstExprArgValidationTest, GlobalVar) {
|
||||
overload.BuildSamplerVariable(this);
|
||||
|
||||
// Build the module-scope var 'G' with the offset value
|
||||
GlobalVar("G", expr({}, *this), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("G", expr({}, *this), type::AddressSpace::kPrivate);
|
||||
|
||||
auto args = overload.args(this);
|
||||
auto*& arg_to_replace = (param.position == Position::kFirst) ? args.Front() : args.Back();
|
||||
@ -652,7 +652,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_WrongAddressSpace) {
|
||||
// fn foo() {
|
||||
// workgroupUniformLoad(&v);
|
||||
// }
|
||||
GlobalVar("v", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
GlobalVar("v", ty.i32(), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
utils::Vector{Group(0_a), Binding(0_a)});
|
||||
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
|
||||
|
||||
@ -670,7 +670,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_Atomic) {
|
||||
// fn foo() {
|
||||
// workgroupUniformLoad(&v);
|
||||
// }
|
||||
GlobalVar("v", ty.atomic<i32>(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("v", ty.atomic<i32>(), type::AddressSpace::kWorkgroup);
|
||||
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -684,7 +684,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_AtomicInArray) {
|
||||
// fn foo() {
|
||||
// workgroupUniformLoad(&v);
|
||||
// }
|
||||
GlobalVar("v", ty.array(ty.atomic<i32>(), 4_a), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("v", ty.array(ty.atomic<i32>(), 4_a), type::AddressSpace::kWorkgroup);
|
||||
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf(Source{{12, 34}}, "v"))));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -703,7 +703,7 @@ TEST_F(ResolverBuiltinValidationTest, WorkgroupUniformLoad_AtomicInStruct) {
|
||||
Structure("Inner", utils::Vector{Member("a", ty.array(ty.atomic<i32>(), 4_a))});
|
||||
Structure("S", utils::Vector{Member("i", ty.type_name("Inner"))});
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.array(ty.type_name("S"), 4_a),
|
||||
ast::AddressSpace::kWorkgroup);
|
||||
type::AddressSpace::kWorkgroup);
|
||||
WrapInFunction(CallStmt(Call("workgroupUniformLoad", AddressOf("v"))));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
|
@ -100,7 +100,7 @@ using ResolverBuiltinsStageTest = ResolverTestWithParam<Params>;
|
||||
TEST_P(ResolverBuiltinsStageTest, All_input) {
|
||||
const Params& params = GetParam();
|
||||
|
||||
auto* p = GlobalVar("p", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
auto* p = GlobalVar("p", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* input = Param("input", params.type(*this),
|
||||
utils::Vector{Builtin(Source{{12, 34}}, params.builtin)});
|
||||
switch (params.stage) {
|
||||
|
@ -103,7 +103,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_VariableIdentExpr) {
|
||||
// var z: i32 = 1i;
|
||||
// foo(&z);
|
||||
// }
|
||||
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
|
||||
auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
|
||||
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -120,7 +120,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_LetIdentExpr) {
|
||||
// let z: i32 = 1i;
|
||||
// foo(&z);
|
||||
// }
|
||||
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
|
||||
auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
|
||||
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -142,7 +142,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfFunctionMember) {
|
||||
auto* S = Structure("S", utils::Vector{
|
||||
Member("m", ty.i32()),
|
||||
});
|
||||
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
|
||||
auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
|
||||
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -169,7 +169,7 @@ TEST_F(ResolverCallValidationTest,
|
||||
auto* S = Structure("S", utils::Vector{
|
||||
Member("m", ty.i32()),
|
||||
});
|
||||
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
|
||||
auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
|
||||
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -189,7 +189,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfLetMember) {
|
||||
auto* S = Structure("S", utils::Vector{
|
||||
Member("m", ty.i32()),
|
||||
});
|
||||
auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
|
||||
auto* param = Param("p", ty.pointer<i32>(type::AddressSpace::kFunction));
|
||||
Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -208,12 +208,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParam) {
|
||||
// }
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
Func("bar",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -235,12 +235,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParamWithMain) {
|
||||
// }
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
Func("bar",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(),
|
||||
utils::Vector{
|
||||
@ -268,13 +268,13 @@ TEST_F(ResolverCallValidationTest, LetPointer) {
|
||||
// }
|
||||
Func("x",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Decl(Var("v", ty.i32())),
|
||||
Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), AddressOf("v"))),
|
||||
Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction), AddressOf("v"))),
|
||||
CallStmt(Call("x", "p")),
|
||||
},
|
||||
utils::Vector{
|
||||
@ -293,13 +293,13 @@ TEST_F(ResolverCallValidationTest, LetPointerPrivate) {
|
||||
// }
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kPrivate), AddressOf("v"))),
|
||||
Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kPrivate), AddressOf("v"))),
|
||||
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
|
||||
},
|
||||
utils::Vector{
|
||||
@ -318,13 +318,13 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar) {
|
||||
// }
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::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(), ast::AddressSpace::kFunction),
|
||||
Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction),
|
||||
AddressOf(IndexAccessor("v", 0_a)))),
|
||||
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
|
||||
},
|
||||
@ -349,13 +349,13 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar_WithFullPtrParametersE
|
||||
Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::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(), ast::AddressSpace::kFunction),
|
||||
Decl(Let("p", ty.pointer(ty.i32(), type::AddressSpace::kFunction),
|
||||
AddressOf(IndexAccessor("v", 0_a)))),
|
||||
CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
|
||||
},
|
||||
@ -377,7 +377,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain) {
|
||||
// }
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer(ty.array<i32, 4>(), ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer(ty.array<i32, 4>(), type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
@ -406,7 +406,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar) {
|
||||
// }
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
@ -440,7 +440,7 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar_WithFullPtrPa
|
||||
Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
|
||||
Func("foo",
|
||||
utils::Vector{
|
||||
Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
|
||||
Param("p", ty.pointer<i32>(type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.void_(), utils::Empty);
|
||||
Func("main", utils::Empty, ty.void_(),
|
||||
@ -462,7 +462,7 @@ TEST_F(ResolverCallValidationTest, CallVariable) {
|
||||
// fn f() {
|
||||
// v();
|
||||
// }
|
||||
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate);
|
||||
Func("f", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
CallStmt(Call(Source{{12, 34}}, "v")),
|
||||
|
@ -51,7 +51,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, CompatibleTypesAssignThroughPoi
|
||||
// var a : i32;
|
||||
// let b : ptr<function,i32> = &a;
|
||||
// *b += 2;
|
||||
const auto func = ast::AddressSpace::kFunction;
|
||||
const auto func = type::AddressSpace::kFunction;
|
||||
auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
|
||||
auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
|
||||
WrapInFunction(var_a, var_b,
|
||||
@ -233,7 +233,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, ReadOnlyBuffer) {
|
||||
// {
|
||||
// a += 1i;
|
||||
// }
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1_i, ast::BinaryOp::kAdd));
|
||||
|
||||
@ -264,7 +264,7 @@ TEST_F(ResolverCompoundAssignmentValidationTest, LhsLiteral) {
|
||||
TEST_F(ResolverCompoundAssignmentValidationTest, LhsAtomic) {
|
||||
// var<workgroup> a : atomic<i32>;
|
||||
// a += a;
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
|
||||
WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", "a", ast::BinaryOp::kAdd));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
|
@ -279,7 +279,7 @@ TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index_OOB_Low) {
|
||||
|
||||
TEST_F(ResolverConstEvalTest, RuntimeArray_vec3_f32_Index_OOB_Low) {
|
||||
auto* sb = GlobalVar("sb", ty.array(ty.vec3<f32>()), Group(0_a), Binding(0_a),
|
||||
ast::AddressSpace::kStorage);
|
||||
type::AddressSpace::kStorage);
|
||||
auto* expr = IndexAccessor(sb, Expr(Source{{12, 34}}, -2_i));
|
||||
WrapInFunction(expr);
|
||||
|
||||
|
@ -426,7 +426,7 @@ const ast::Node* SymbolTestHelper::Add(SymbolDeclKind kind, Symbol symbol, Sourc
|
||||
auto& b = *builder;
|
||||
switch (kind) {
|
||||
case SymbolDeclKind::GlobalVar:
|
||||
return b.GlobalVar(source, symbol, b.ty.i32(), ast::AddressSpace::kPrivate);
|
||||
return b.GlobalVar(source, symbol, b.ty.i32(), type::AddressSpace::kPrivate);
|
||||
case SymbolDeclKind::GlobalConst:
|
||||
return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1_i));
|
||||
case SymbolDeclKind::Alias:
|
||||
@ -469,27 +469,27 @@ const ast::Node* SymbolTestHelper::Add(SymbolUseKind kind, Symbol symbol, Source
|
||||
switch (kind) {
|
||||
case SymbolUseKind::GlobalVarType: {
|
||||
auto* node = b.ty.type_name(source, symbol);
|
||||
b.GlobalVar(b.Sym(), node, ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar(b.Sym(), node, type::AddressSpace::kPrivate);
|
||||
return node;
|
||||
}
|
||||
case SymbolUseKind::GlobalVarArrayElemType: {
|
||||
auto* node = b.ty.type_name(source, symbol);
|
||||
b.GlobalVar(b.Sym(), b.ty.array(node, 4_i), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar(b.Sym(), b.ty.array(node, 4_i), type::AddressSpace::kPrivate);
|
||||
return node;
|
||||
}
|
||||
case SymbolUseKind::GlobalVarArraySizeValue: {
|
||||
auto* node = b.Expr(source, symbol);
|
||||
b.GlobalVar(b.Sym(), b.ty.array(b.ty.i32(), node), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar(b.Sym(), b.ty.array(b.ty.i32(), node), type::AddressSpace::kPrivate);
|
||||
return node;
|
||||
}
|
||||
case SymbolUseKind::GlobalVarVectorElemType: {
|
||||
auto* node = b.ty.type_name(source, symbol);
|
||||
b.GlobalVar(b.Sym(), b.ty.vec3(node), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar(b.Sym(), b.ty.vec3(node), type::AddressSpace::kPrivate);
|
||||
return node;
|
||||
}
|
||||
case SymbolUseKind::GlobalVarMatrixElemType: {
|
||||
auto* node = b.ty.type_name(source, symbol);
|
||||
b.GlobalVar(b.Sym(), b.ty.mat3x4(node), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar(b.Sym(), b.ty.mat3x4(node), type::AddressSpace::kPrivate);
|
||||
return node;
|
||||
}
|
||||
case SymbolUseKind::GlobalVarSampledTexElemType: {
|
||||
@ -504,7 +504,7 @@ const ast::Node* SymbolTestHelper::Add(SymbolUseKind kind, Symbol symbol, Source
|
||||
}
|
||||
case SymbolUseKind::GlobalVarValue: {
|
||||
auto* node = b.Expr(source, symbol);
|
||||
b.GlobalVar(b.Sym(), b.ty.i32(), ast::AddressSpace::kPrivate, node);
|
||||
b.GlobalVar(b.Sym(), b.ty.i32(), type::AddressSpace::kPrivate, node);
|
||||
return node;
|
||||
}
|
||||
case SymbolUseKind::GlobalConstType: {
|
||||
@ -725,7 +725,7 @@ TEST_F(ResolverDependencyGraphUsedBeforeDeclTest, VarUsed) {
|
||||
Block(Assign(Expr(Source{{12, 34}}, "G"), 3.14_f)),
|
||||
});
|
||||
|
||||
GlobalVar(Source{{56, 78}}, "G", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
GlobalVar(Source{{56, 78}}, "G", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
|
||||
Build();
|
||||
}
|
||||
@ -1212,7 +1212,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) {
|
||||
const auto type_sym = Sym("TYPE");
|
||||
const auto func_sym = Sym("FUNC");
|
||||
|
||||
const auto* value_decl = GlobalVar(value_sym, ty.i32(), ast::AddressSpace::kPrivate);
|
||||
const auto* value_decl = GlobalVar(value_sym, ty.i32(), type::AddressSpace::kPrivate);
|
||||
const auto* type_decl = Alias(type_sym, ty.i32());
|
||||
const auto* func_decl = Func(func_sym, utils::Empty, ty.void_(), utils::Empty);
|
||||
|
||||
@ -1290,7 +1290,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) {
|
||||
GlobalVar(Sym(), ty.array(T, V, 4));
|
||||
GlobalVar(Sym(), ty.vec3(T));
|
||||
GlobalVar(Sym(), ty.mat3x2(T));
|
||||
GlobalVar(Sym(), ty.pointer(T, ast::AddressSpace::kPrivate));
|
||||
GlobalVar(Sym(), ty.pointer(T, type::AddressSpace::kPrivate));
|
||||
GlobalVar(Sym(), ty.sampled_texture(type::TextureDimension::k2d, T));
|
||||
GlobalVar(Sym(), ty.depth_texture(type::TextureDimension::k2d));
|
||||
GlobalVar(Sym(), ty.depth_multisampled_texture(type::TextureDimension::k2d));
|
||||
|
@ -453,14 +453,14 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithEnable) {
|
||||
// enable chromium_experimental_push_constant;
|
||||
// var<push_constant> a : u32;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve());
|
||||
}
|
||||
|
||||
TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) {
|
||||
// var<push_constant> a : u32;
|
||||
GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -470,7 +470,7 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantDisallowedWithoutEnable) {
|
||||
|
||||
TEST_F(ResolverEntryPointValidationTest, PushConstantAllowedWithIgnoreAddressSpaceAttribute) {
|
||||
// var<push_constant> a : u32; // With ast::DisabledValidation::kIgnoreAddressSpace
|
||||
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant,
|
||||
GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant,
|
||||
utils::Vector{Disable(ast::DisabledValidation::kIgnoreAddressSpace)});
|
||||
|
||||
EXPECT_TRUE(r()->Resolve());
|
||||
@ -483,7 +483,7 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantOneVariableUsedInEntryPoint
|
||||
// _ = a;
|
||||
// }
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
Func("main", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")},
|
||||
utils::Vector{Stage(ast::PipelineStage::kCompute),
|
||||
@ -501,8 +501,8 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantTwoVariablesUsedInEntryPoin
|
||||
// _ = b;
|
||||
// }
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{3, 4}}, "b", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
Func(Source{{5, 6}}, "main", {}, ty.void_(),
|
||||
utils::Vector{Assign(Phony(), "a"), Assign(Phony(), "b")},
|
||||
@ -532,8 +532,8 @@ TEST_F(ResolverEntryPointValidationTest,
|
||||
// uses_b();
|
||||
// }
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar(Source{{1, 2}}, "a", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{3, 4}}, "b", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{1, 2}}, "a", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
GlobalVar(Source{{3, 4}}, "b", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
Func(Source{{5, 6}}, "uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")});
|
||||
Func(Source{{7, 8}}, "uses_b", {}, ty.void_(), utils::Vector{Assign(Phony(), "b")});
|
||||
@ -565,8 +565,8 @@ TEST_F(ResolverEntryPointValidationTest, PushConstantTwoVariablesUsedInDifferent
|
||||
// _ = a;
|
||||
// }
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar("a", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("b", ty.u32(), ast::AddressSpace::kPushConstant);
|
||||
GlobalVar("a", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
GlobalVar("b", ty.u32(), type::AddressSpace::kPushConstant);
|
||||
|
||||
Func("uses_a", {}, ty.void_(), utils::Vector{Assign(Phony(), "a")},
|
||||
utils::Vector{Stage(ast::PipelineStage::kCompute),
|
||||
|
@ -29,14 +29,14 @@ TEST_F(ResolverF16ExtensionTest, TypeUsedWithExtension) {
|
||||
// var<private> v : f16;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("v", ty.f16(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.f16(), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverF16ExtensionTest, TypeUsedWithoutExtension) {
|
||||
// var<private> v : f16;
|
||||
GlobalVar("v", ty.f16(Source{{12, 34}}), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.f16(Source{{12, 34}}), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
|
||||
@ -47,14 +47,14 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithExtension) {
|
||||
// var<private> v : vec2<f16>;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("v", ty.vec2<f16>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.vec2<f16>(), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverF16ExtensionTest, Vec2TypeUsedWithoutExtension) {
|
||||
// var<private> v : vec2<f16>;
|
||||
GlobalVar("v", ty.vec2(ty.f16(Source{{12, 34}})), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.vec2(ty.f16(Source{{12, 34}})), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
|
||||
@ -65,14 +65,14 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithExtension) {
|
||||
// var<private> v = vec2<f16>();
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("v", Construct(ty.vec2<f16>()), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", Construct(ty.vec2<f16>()), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverF16ExtensionTest, Vec2TypeInitUsedWithoutExtension) {
|
||||
// var<private> v = vec2<f16>();
|
||||
GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}}))), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}}))), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
|
||||
@ -84,7 +84,7 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithExtension) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("v", Construct(ty.vec2<f16>(), Construct(ty.vec2<f32>())),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -92,7 +92,7 @@ TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithExtension) {
|
||||
TEST_F(ResolverF16ExtensionTest, Vec2TypeConvUsedWithoutExtension) {
|
||||
// var<private> v = vec2<f16>(vec2<f32>());
|
||||
GlobalVar("v", Construct(ty.vec2(ty.f16(Source{{12, 34}})), Construct(ty.vec2<f32>())),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
|
||||
@ -103,14 +103,14 @@ TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithExtension) {
|
||||
// var<private> v = 16h;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("v", Expr(16_h), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", Expr(16_h), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverF16ExtensionTest, F16LiteralUsedWithoutExtension) {
|
||||
// var<private> v = 16h;
|
||||
GlobalVar("v", Expr(Source{{12, 34}}, 16_h), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", Expr(Source{{12, 34}}, 16_h), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
|
||||
@ -123,14 +123,14 @@ TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithExtension) {
|
||||
// var<private> v : vec2h;
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_P(ResolverF16ExtensionShortNameTest, Vec2hTypeUsedWithoutExtension) {
|
||||
// var<private> v : vec2h;
|
||||
GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.type_name(Source{{12, 34}}, GetParam()), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: f16 type used without 'f16' extension enabled");
|
||||
|
@ -39,7 +39,7 @@ TEST_F(ResolverFunctionValidationTest, DuplicateParameterName) {
|
||||
TEST_F(ResolverFunctionValidationTest, ParameterMayShadowGlobal) {
|
||||
// var<private> common_name : f32;
|
||||
// fn func(common_name : f32) { }
|
||||
GlobalVar("common_name", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("common_name", ty.f32(), type::AddressSpace::kPrivate);
|
||||
Func("func", utils::Vector{Param("common_name", ty.f32())}, ty.void_(), utils::Empty);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -420,7 +420,7 @@ TEST_F(ResolverFunctionValidationTest, CannotCallFunctionAtModuleScope) {
|
||||
utils::Vector{
|
||||
Return(1_i),
|
||||
});
|
||||
GlobalVar("x", Call(Source{{12, 34}}, "F"), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("x", Call(Source{{12, 34}}, "F"), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), R"(12:34 error: functions cannot be called at module-scope)");
|
||||
@ -874,7 +874,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) {
|
||||
// var<private> x = 64i;
|
||||
// @compute @workgroup_size(x)
|
||||
// fn main() {}
|
||||
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(64_i));
|
||||
GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(64_i));
|
||||
Func("main", utils::Empty, ty.void_(), utils::Empty,
|
||||
utils::Vector{
|
||||
Stage(ast::PipelineStage::kCompute),
|
||||
@ -890,7 +890,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) {
|
||||
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) {
|
||||
// @compute @workgroup_size(1 << 2 + 4)
|
||||
// fn main() {}
|
||||
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(0_i));
|
||||
GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
|
||||
Func("main", utils::Empty, ty.void_(), utils::Empty,
|
||||
utils::Vector{
|
||||
Stage(ast::PipelineStage::kCompute),
|
||||
@ -906,7 +906,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_x) {
|
||||
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) {
|
||||
// @compute @workgroup_size(1, 1 << 2 + 4)
|
||||
// fn main() {}
|
||||
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(0_i));
|
||||
GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
|
||||
Func("main", utils::Empty, ty.void_(), utils::Empty,
|
||||
utils::Vector{
|
||||
Stage(ast::PipelineStage::kCompute),
|
||||
@ -922,7 +922,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_y) {
|
||||
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) {
|
||||
// @compute @workgroup_size(1, 1, 1 << 2 + 4)
|
||||
// fn main() {}
|
||||
GlobalVar("x", ty.i32(), ast::AddressSpace::kPrivate, Expr(0_i));
|
||||
GlobalVar("x", ty.i32(), type::AddressSpace::kPrivate, Expr(0_i));
|
||||
Func("main", utils::Empty, ty.void_(), utils::Empty,
|
||||
utils::Vector{
|
||||
Stage(ast::PipelineStage::kCompute),
|
||||
@ -936,7 +936,7 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_InvalidExpr_z) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_NonPlain) {
|
||||
auto* ret_type = ty.pointer(Source{{12, 34}}, ty.i32(), ast::AddressSpace::kFunction);
|
||||
auto* ret_type = ty.pointer(Source{{12, 34}}, ty.i32(), type::AddressSpace::kFunction);
|
||||
Func("f", utils::Empty, ret_type, utils::Empty);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -1050,7 +1050,7 @@ enum class Expectation {
|
||||
kAlwaysFail,
|
||||
};
|
||||
struct TestParams {
|
||||
ast::AddressSpace address_space;
|
||||
type::AddressSpace address_space;
|
||||
Expectation expectation;
|
||||
};
|
||||
|
||||
@ -1094,15 +1094,15 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
ResolverTest,
|
||||
ResolverFunctionParameterValidationTest,
|
||||
testing::Values(
|
||||
TestParams{ast::AddressSpace::kNone, Expectation::kAlwaysFail},
|
||||
TestParams{ast::AddressSpace::kIn, Expectation::kAlwaysFail},
|
||||
TestParams{ast::AddressSpace::kOut, Expectation::kAlwaysFail},
|
||||
TestParams{ast::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension},
|
||||
TestParams{ast::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension},
|
||||
TestParams{ast::AddressSpace::kHandle, Expectation::kAlwaysFail},
|
||||
TestParams{ast::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension},
|
||||
TestParams{ast::AddressSpace::kPrivate, Expectation::kAlwaysPass},
|
||||
TestParams{ast::AddressSpace::kFunction, Expectation::kAlwaysPass}));
|
||||
TestParams{type::AddressSpace::kNone, Expectation::kAlwaysFail},
|
||||
TestParams{type::AddressSpace::kIn, Expectation::kAlwaysFail},
|
||||
TestParams{type::AddressSpace::kOut, Expectation::kAlwaysFail},
|
||||
TestParams{type::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension},
|
||||
TestParams{type::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension},
|
||||
TestParams{type::AddressSpace::kHandle, Expectation::kAlwaysFail},
|
||||
TestParams{type::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension},
|
||||
TestParams{type::AddressSpace::kPrivate, Expectation::kAlwaysPass},
|
||||
TestParams{type::AddressSpace::kFunction, Expectation::kAlwaysPass}));
|
||||
|
||||
} // namespace
|
||||
} // namespace tint::resolver
|
||||
|
@ -29,7 +29,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolMember) {
|
||||
auto* s =
|
||||
Structure("S", utils::Vector{Member(Source{{56, 78}}, "x", ty.bool_(Source{{12, 34}}))});
|
||||
|
||||
GlobalVar(Source{{90, 12}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{90, 12}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -45,7 +45,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolVectorMember) {
|
||||
auto* s = Structure(
|
||||
"S", utils::Vector{Member(Source{{56, 78}}, "x", ty.vec3<bool>(Source{{12, 34}}))});
|
||||
|
||||
GlobalVar(Source{{90, 12}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{90, 12}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -62,7 +62,7 @@ TEST_F(ResolverHostShareableValidationTest, Aliases) {
|
||||
auto* s = Structure(
|
||||
"S", utils::Vector{Member(Source{{56, 78}}, "x", ty.type_name(Source{{12, 34}}, "a1"))});
|
||||
auto* a2 = Alias("a2", ty.Of(s));
|
||||
GlobalVar(Source{{90, 12}}, "g", ty.Of(a2), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{90, 12}}, "g", ty.Of(a2), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -81,7 +81,7 @@ TEST_F(ResolverHostShareableValidationTest, NestedStructures) {
|
||||
|
||||
auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))});
|
||||
|
||||
GlobalVar(Source{{9, 10}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{9, 10}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
@ -120,7 +120,7 @@ TEST_F(ResolverHostShareableValidationTest, NoError) {
|
||||
|
||||
auto* s = Structure("S", utils::Vector{Member(Source{{7, 8}}, "m", ty.Of(i3))});
|
||||
|
||||
GlobalVar(Source{{9, 10}}, "g", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{9, 10}}, "g", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
@ -64,8 +64,8 @@ TEST_F(ResolverIncrementDecrementValidationTest, ThroughPointer) {
|
||||
// var a : i32;
|
||||
// let b : ptr<function,i32> = &a;
|
||||
// *b++;
|
||||
auto* var_a = Var("a", ty.i32(), ast::AddressSpace::kFunction);
|
||||
auto* var_b = Let("b", ty.pointer<i32>(ast::AddressSpace::kFunction), AddressOf(Expr("a")));
|
||||
auto* var_a = Var("a", ty.i32(), type::AddressSpace::kFunction);
|
||||
auto* var_b = Let("b", ty.pointer<i32>(type::AddressSpace::kFunction), AddressOf(Expr("a")));
|
||||
WrapInFunction(var_a, var_b, Increment(Source{{12, 34}}, Deref("b")));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -127,7 +127,7 @@ TEST_F(ResolverIncrementDecrementValidationTest, Vector) {
|
||||
TEST_F(ResolverIncrementDecrementValidationTest, Atomic) {
|
||||
// var<workgroup> a : atomic<i32>;
|
||||
// a++;
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
|
||||
WrapInFunction(Increment(Expr(Source{{56, 78}}, "a")));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -193,7 +193,7 @@ TEST_F(ResolverIncrementDecrementValidationTest, ReadOnlyBuffer) {
|
||||
// {
|
||||
// a++;
|
||||
// }
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kStorage, ast::Access::kRead,
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kStorage, ast::Access::kRead,
|
||||
Group(0_a), Binding(0_a));
|
||||
WrapInFunction(Increment(Source{{56, 78}}, "a"));
|
||||
|
||||
|
@ -97,7 +97,7 @@ TEST_P(ResolverInferredTypeParamTest, GlobalVar_Pass) {
|
||||
|
||||
// var a = <type initializer>;
|
||||
auto* ctor_expr = params.create_value(*this, 0);
|
||||
auto* var = GlobalVar("a", ast::AddressSpace::kPrivate, ctor_expr);
|
||||
auto* var = GlobalVar("a", type::AddressSpace::kPrivate, ctor_expr);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
EXPECT_EQ(TypeOf(var)->UnwrapRef(), expected_type);
|
||||
@ -124,7 +124,7 @@ TEST_P(ResolverInferredTypeParamTest, LocalVar_Pass) {
|
||||
|
||||
// var a = <type initializer>;
|
||||
auto* ctor_expr = params.create_value(*this, 0);
|
||||
auto* var = Var("a", ast::AddressSpace::kFunction, ctor_expr);
|
||||
auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
|
||||
WrapInFunction(var);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -139,7 +139,7 @@ TEST_F(ResolverInferredTypeTest, InferArray_Pass) {
|
||||
create<type::U32>(), create<type::ConstantArrayCount>(10u), 4u, 4u * 10u, 4u, 4u);
|
||||
|
||||
auto* ctor_expr = Construct(type);
|
||||
auto* var = Var("a", ast::AddressSpace::kFunction, ctor_expr);
|
||||
auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
|
||||
WrapInFunction(var);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -158,7 +158,7 @@ TEST_F(ResolverInferredTypeTest, InferStruct_Pass) {
|
||||
|
||||
auto* ctor_expr = Construct(ty.Of(str));
|
||||
|
||||
auto* var = Var("a", ast::AddressSpace::kFunction, ctor_expr);
|
||||
auto* var = Var("a", type::AddressSpace::kFunction, ctor_expr);
|
||||
WrapInFunction(var);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
@ -330,7 +330,7 @@ class TemplateNumberMatcher : public NumberMatcher {
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
using TexelFormat = ast::TexelFormat;
|
||||
using Access = ast::Access;
|
||||
using AddressSpace = ast::AddressSpace;
|
||||
using AddressSpace = type::AddressSpace;
|
||||
using ParameterUsage = sem::ParameterUsage;
|
||||
using PipelineStage = ast::PipelineStage;
|
||||
|
||||
@ -560,7 +560,7 @@ bool match_ptr(MatchState&, const type::Type* ty, Number& S, const type::Type*&
|
||||
}
|
||||
|
||||
const type::Pointer* build_ptr(MatchState& state, Number S, const type::Type* T, Number& A) {
|
||||
return state.builder.create<type::Pointer>(T, static_cast<ast::AddressSpace>(S.Value()),
|
||||
return state.builder.create<type::Pointer>(T, static_cast<type::AddressSpace>(S.Value()),
|
||||
static_cast<ast::Access>(A.Value()));
|
||||
}
|
||||
|
||||
@ -1275,7 +1275,7 @@ Impl::Builtin Impl::Lookup(sem::BuiltinType builtin_type,
|
||||
params.Reserve(match.parameters.Length());
|
||||
for (auto& p : match.parameters) {
|
||||
params.Push(builder.create<sem::Parameter>(
|
||||
nullptr, static_cast<uint32_t>(params.Length()), p.type, ast::AddressSpace::kNone,
|
||||
nullptr, static_cast<uint32_t>(params.Length()), p.type, type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined, p.usage));
|
||||
}
|
||||
sem::PipelineStageSet supported_stages;
|
||||
@ -1476,7 +1476,7 @@ IntrinsicTable::InitOrConv Impl::Lookup(InitConvIntrinsic type,
|
||||
params.Reserve(match.parameters.Length());
|
||||
for (auto& p : match.parameters) {
|
||||
params.Push(builder.create<sem::Parameter>(
|
||||
nullptr, static_cast<uint32_t>(params.Length()), p.type, ast::AddressSpace::kNone,
|
||||
nullptr, static_cast<uint32_t>(params.Length()), p.type, type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined, p.usage));
|
||||
}
|
||||
auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
|
||||
@ -1491,7 +1491,7 @@ IntrinsicTable::InitOrConv Impl::Lookup(InitConvIntrinsic type,
|
||||
// Conversion.
|
||||
auto* target = converters.GetOrCreate(match, [&]() {
|
||||
auto param = builder.create<sem::Parameter>(
|
||||
nullptr, 0u, match.parameters[0].type, ast::AddressSpace::kNone,
|
||||
nullptr, 0u, match.parameters[0].type, type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined, match.parameters[0].usage);
|
||||
auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
|
||||
: sem::EvaluationStage::kRuntime;
|
||||
|
@ -232,7 +232,7 @@ TEST_F(IntrinsicTableTest, MatchPointer) {
|
||||
auto* i32 = create<type::I32>();
|
||||
auto* atomicI32 = create<type::Atomic>(i32);
|
||||
auto* ptr =
|
||||
create<type::Pointer>(atomicI32, ast::AddressSpace::kWorkgroup, ast::Access::kReadWrite);
|
||||
create<type::Pointer>(atomicI32, type::AddressSpace::kWorkgroup, ast::Access::kReadWrite);
|
||||
auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr},
|
||||
sem::EvaluationStage::kConstant, Source{});
|
||||
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
|
||||
@ -256,7 +256,7 @@ TEST_F(IntrinsicTableTest, MatchArray) {
|
||||
auto* arr =
|
||||
create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
|
||||
auto* arr_ptr =
|
||||
create<type::Pointer>(arr, ast::AddressSpace::kStorage, ast::Access::kReadWrite);
|
||||
create<type::Pointer>(arr, type::AddressSpace::kStorage, ast::Access::kReadWrite);
|
||||
auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{arr_ptr},
|
||||
sem::EvaluationStage::kConstant, Source{});
|
||||
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
|
||||
@ -448,7 +448,7 @@ TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) {
|
||||
auto result = table->Lookup(
|
||||
BuiltinType::kCos,
|
||||
utils::Vector{
|
||||
create<type::Reference>(f32, ast::AddressSpace::kFunction, ast::Access::kReadWrite),
|
||||
create<type::Reference>(f32, type::AddressSpace::kFunction, ast::Access::kReadWrite),
|
||||
},
|
||||
sem::EvaluationStage::kConstant, Source{});
|
||||
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
|
||||
@ -548,7 +548,7 @@ TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) {
|
||||
|
||||
TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_RuntimeEval) {
|
||||
auto* af = create<type::AbstractFloat>();
|
||||
auto* bool_ref = create<type::Reference>(create<type::Bool>(), ast::AddressSpace::kFunction,
|
||||
auto* bool_ref = create<type::Reference>(create<type::Bool>(), type::AddressSpace::kFunction,
|
||||
ast::Access::kReadWrite);
|
||||
auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_ref},
|
||||
sem::EvaluationStage::kRuntime, Source{});
|
||||
|
@ -95,7 +95,7 @@ TEST_F(ResolverIsHostShareable, Matrix) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIsHostShareable, Pointer) {
|
||||
auto* ptr = create<type::Pointer>(create<type::I32>(), ast::AddressSpace::kPrivate,
|
||||
auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
|
||||
ast::Access::kReadWrite);
|
||||
EXPECT_FALSE(r()->IsHostShareable(ptr));
|
||||
}
|
||||
|
@ -78,7 +78,7 @@ TEST_F(ResolverIsStorableTest, Matrix) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverIsStorableTest, Pointer) {
|
||||
auto* ptr = create<type::Pointer>(create<type::I32>(), ast::AddressSpace::kPrivate,
|
||||
auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
|
||||
ast::Access::kReadWrite);
|
||||
EXPECT_FALSE(r()->IsStorable(ptr));
|
||||
}
|
||||
@ -112,7 +112,7 @@ TEST_F(ResolverIsStorableTest, Struct_AllMembersStorable) {
|
||||
TEST_F(ResolverIsStorableTest, Struct_SomeMembersNonStorable) {
|
||||
Structure("S", utils::Vector{
|
||||
Member("a", ty.i32()),
|
||||
Member("b", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Member("b", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
});
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -138,7 +138,7 @@ TEST_F(ResolverIsStorableTest, Struct_NestedNonStorable) {
|
||||
auto* non_storable =
|
||||
Structure("nonstorable", utils::Vector{
|
||||
Member("a", ty.i32()),
|
||||
Member("b", ty.pointer<i32>(ast::AddressSpace::kPrivate)),
|
||||
Member("b", ty.pointer<i32>(type::AddressSpace::kPrivate)),
|
||||
});
|
||||
Structure("S", utils::Vector{
|
||||
Member("a", ty.i32()),
|
||||
|
@ -929,7 +929,7 @@ TEST_P(MaterializeAbstractNumericToDefaultType, Test) {
|
||||
break;
|
||||
}
|
||||
case Method::kIndex: {
|
||||
GlobalVar("arr", ty.array<i32, 4>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("arr", ty.array<i32, 4>(), type::AddressSpace::kPrivate);
|
||||
WrapInFunction(IndexAccessor("arr", abstract_expr()));
|
||||
break;
|
||||
}
|
||||
|
@ -159,7 +159,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaOverrideInit) {
|
||||
|
||||
TEST_F(ResolverOverrideTest, TransitiveReferences_ViaPrivateInit) {
|
||||
auto* a = Override("a", ty.f32());
|
||||
auto* b = GlobalVar("b", ast::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "a"));
|
||||
auto* b = GlobalVar("b", type::AddressSpace::kPrivate, ty.f32(), Mul(2_a, "a"));
|
||||
Override("unused", ty.f32(), Expr(1_f));
|
||||
auto* func = Func("foo", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -209,7 +209,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize) {
|
||||
auto* a = Override("a", ty.i32());
|
||||
auto* b = Override("b", ty.i32(), Mul(2_a, "a"));
|
||||
auto* arr_ty = ty.array(ty.i32(), Mul(2_a, "b"));
|
||||
auto* arr = GlobalVar("arr", ast::AddressSpace::kWorkgroup, arr_ty);
|
||||
auto* arr = GlobalVar("arr", type::AddressSpace::kWorkgroup, arr_ty);
|
||||
Override("unused", ty.i32(), Expr(1_a));
|
||||
auto* func = Func("foo", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -249,7 +249,7 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_ViaArraySize_Alias) {
|
||||
auto* a = Override("a", ty.i32());
|
||||
auto* b = Override("b", ty.i32(), Mul(2_a, "a"));
|
||||
auto* arr_ty = Alias("arr_ty", ty.array(ty.i32(), Mul(2_a, "b")));
|
||||
auto* arr = GlobalVar("arr", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty"));
|
||||
auto* arr = GlobalVar("arr", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty"));
|
||||
Override("unused", ty.i32(), Expr(1_a));
|
||||
auto* func = Func("foo", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -294,8 +294,8 @@ TEST_F(ResolverOverrideTest, TransitiveReferences_MultipleEntryPoints) {
|
||||
auto* d = Override("d", ty.i32());
|
||||
Alias("arr_ty1", ty.array(ty.i32(), Mul("b1", "c1")));
|
||||
Alias("arr_ty2", ty.array(ty.i32(), Mul("b2", "c2")));
|
||||
auto* arr1 = GlobalVar("arr1", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty1"));
|
||||
auto* arr2 = GlobalVar("arr2", ast::AddressSpace::kWorkgroup, ty.type_name("arr_ty2"));
|
||||
auto* arr1 = GlobalVar("arr1", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty1"));
|
||||
auto* arr2 = GlobalVar("arr2", type::AddressSpace::kWorkgroup, ty.type_name("arr_ty2"));
|
||||
Override("unused", ty.i32(), Expr(1_a));
|
||||
auto* func1 = Func("foo1", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
|
@ -39,7 +39,7 @@ TEST_F(ResolverPtrRefTest, AddressOf) {
|
||||
|
||||
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(), ast::AddressSpace::kFunction);
|
||||
EXPECT_EQ(TypeOf(expr)->As<type::Pointer>()->AddressSpace(), type::AddressSpace::kFunction);
|
||||
}
|
||||
|
||||
TEST_F(ResolverPtrRefTest, AddressOfThenDeref) {
|
||||
@ -68,23 +68,23 @@ TEST_F(ResolverPtrRefTest, DefaultPtrAddressSpace) {
|
||||
|
||||
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
|
||||
auto* function = Var("f", ty.i32());
|
||||
auto* private_ = GlobalVar("p", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* workgroup = GlobalVar("w", ty.i32(), ast::AddressSpace::kWorkgroup);
|
||||
auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup);
|
||||
auto* uniform =
|
||||
GlobalVar("ub", ty.Of(buf), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("ub", ty.Of(buf), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
auto* storage =
|
||||
GlobalVar("sb", ty.Of(buf), ast::AddressSpace::kStorage, Binding(1_a), Group(0_a));
|
||||
GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage, Binding(1_a), Group(0_a));
|
||||
|
||||
auto* function_ptr =
|
||||
Let("f_ptr", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), AddressOf(function));
|
||||
Let("f_ptr", ty.pointer(ty.i32(), type::AddressSpace::kFunction), AddressOf(function));
|
||||
auto* private_ptr =
|
||||
Let("p_ptr", ty.pointer(ty.i32(), ast::AddressSpace::kPrivate), AddressOf(private_));
|
||||
Let("p_ptr", ty.pointer(ty.i32(), type::AddressSpace::kPrivate), AddressOf(private_));
|
||||
auto* workgroup_ptr =
|
||||
Let("w_ptr", ty.pointer(ty.i32(), ast::AddressSpace::kWorkgroup), AddressOf(workgroup));
|
||||
Let("w_ptr", ty.pointer(ty.i32(), type::AddressSpace::kWorkgroup), AddressOf(workgroup));
|
||||
auto* uniform_ptr =
|
||||
Let("ub_ptr", ty.pointer(ty.Of(buf), ast::AddressSpace::kUniform), AddressOf(uniform));
|
||||
Let("ub_ptr", ty.pointer(ty.Of(buf), type::AddressSpace::kUniform), AddressOf(uniform));
|
||||
auto* storage_ptr =
|
||||
Let("sb_ptr", ty.pointer(ty.Of(buf), ast::AddressSpace::kStorage), AddressOf(storage));
|
||||
Let("sb_ptr", ty.pointer(ty.Of(buf), type::AddressSpace::kStorage), AddressOf(storage));
|
||||
|
||||
WrapInFunction(function, function_ptr, private_ptr, workgroup_ptr, uniform_ptr, storage_ptr);
|
||||
|
||||
|
@ -143,12 +143,12 @@ TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) {
|
||||
// }
|
||||
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), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
Binding(0_a), Group(0_a));
|
||||
auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(0_a), Group(0_a));
|
||||
|
||||
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i);
|
||||
auto* ptr =
|
||||
Let(Source{{12, 34}}, "p", ty.pointer<i32>(ast::AddressSpace::kStorage), AddressOf(expr));
|
||||
Let(Source{{12, 34}}, "p", ty.pointer<i32>(type::AddressSpace::kStorage), AddressOf(expr));
|
||||
|
||||
WrapInFunction(ptr);
|
||||
|
||||
|
@ -391,11 +391,11 @@ sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) {
|
||||
ty = rhs->Type()->UnwrapRef(); // Implicit load of RHS
|
||||
}
|
||||
|
||||
if (rhs && !validator_.VariableInitializer(v, ast::AddressSpace::kNone, ty, rhs)) {
|
||||
if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kNone, ty, rhs)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast<type::Type*>(ty),
|
||||
if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast<type::Type*>(ty),
|
||||
v->source)) {
|
||||
AddNote("while instantiating 'let' " + builder_->Symbols().NameFor(v->symbol), v->source);
|
||||
return nullptr;
|
||||
@ -404,12 +404,12 @@ sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) {
|
||||
sem::Variable* sem = nullptr;
|
||||
if (is_global) {
|
||||
sem = builder_->create<sem::GlobalVariable>(
|
||||
v, ty, sem::EvaluationStage::kRuntime, ast::AddressSpace::kNone,
|
||||
v, ty, sem::EvaluationStage::kRuntime, type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined,
|
||||
/* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
|
||||
} else {
|
||||
sem = builder_->create<sem::LocalVariable>(v, ty, sem::EvaluationStage::kRuntime,
|
||||
ast::AddressSpace::kNone,
|
||||
type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined, current_statement_,
|
||||
/* constant_value */ nullptr);
|
||||
}
|
||||
@ -453,11 +453,11 @@ sem::Variable* Resolver::Override(const ast::Override* v) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (rhs && !validator_.VariableInitializer(v, ast::AddressSpace::kNone, ty, rhs)) {
|
||||
if (rhs && !validator_.VariableInitializer(v, type::AddressSpace::kNone, ty, rhs)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast<type::Type*>(ty),
|
||||
if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast<type::Type*>(ty),
|
||||
v->source)) {
|
||||
AddNote("while instantiating 'override' " + builder_->Symbols().NameFor(v->symbol),
|
||||
v->source);
|
||||
@ -465,7 +465,7 @@ sem::Variable* Resolver::Override(const ast::Override* v) {
|
||||
}
|
||||
|
||||
auto* sem = builder_->create<sem::GlobalVariable>(
|
||||
v, ty, sem::EvaluationStage::kOverride, ast::AddressSpace::kNone, ast::Access::kUndefined,
|
||||
v, ty, sem::EvaluationStage::kOverride, type::AddressSpace::kNone, ast::Access::kUndefined,
|
||||
/* constant_value */ nullptr, sem::BindingPoint{}, std::nullopt);
|
||||
sem->SetInitializer(rhs);
|
||||
|
||||
@ -546,11 +546,11 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) {
|
||||
ty = rhs->Type();
|
||||
}
|
||||
|
||||
if (!validator_.VariableInitializer(c, ast::AddressSpace::kNone, ty, rhs)) {
|
||||
if (!validator_.VariableInitializer(c, type::AddressSpace::kNone, ty, rhs)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, const_cast<type::Type*>(ty),
|
||||
if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, const_cast<type::Type*>(ty),
|
||||
c->source)) {
|
||||
AddNote("while instantiating 'const' " + builder_->Symbols().NameFor(c->symbol), c->source);
|
||||
return nullptr;
|
||||
@ -558,10 +558,10 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) {
|
||||
|
||||
const auto value = rhs->ConstantValue();
|
||||
auto* sem = is_global ? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>(
|
||||
c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone,
|
||||
c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined, value, sem::BindingPoint{}, std::nullopt))
|
||||
: static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>(
|
||||
c, ty, sem::EvaluationStage::kConstant, ast::AddressSpace::kNone,
|
||||
c, ty, sem::EvaluationStage::kConstant, type::AddressSpace::kNone,
|
||||
ast::Access::kUndefined, current_statement_, value));
|
||||
|
||||
sem->SetInitializer(rhs);
|
||||
@ -606,20 +606,20 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) {
|
||||
}
|
||||
|
||||
auto address_space = var->declared_address_space;
|
||||
if (address_space == ast::AddressSpace::kNone) {
|
||||
if (address_space == type::AddressSpace::kNone) {
|
||||
// No declared address space. Infer from usage / type.
|
||||
if (!is_global) {
|
||||
address_space = ast::AddressSpace::kFunction;
|
||||
address_space = type::AddressSpace::kFunction;
|
||||
} else if (storage_ty->UnwrapRef()->is_handle()) {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
|
||||
// If the store type is a texture type or a sampler type, then the
|
||||
// variable declaration must not have a address space attribute. The
|
||||
// address space will always be handle.
|
||||
address_space = ast::AddressSpace::kHandle;
|
||||
address_space = type::AddressSpace::kHandle;
|
||||
}
|
||||
}
|
||||
|
||||
if (!is_global && address_space != ast::AddressSpace::kFunction &&
|
||||
if (!is_global && address_space != type::AddressSpace::kFunction &&
|
||||
validator_.IsValidationEnabled(var->attributes,
|
||||
ast::DisabledValidation::kIgnoreAddressSpace)) {
|
||||
AddError("function-scope 'var' declaration must use 'function' address space", var->source);
|
||||
@ -740,7 +740,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, uint32_t index)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, ty, param->type->source)) {
|
||||
if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, ty, param->type->source)) {
|
||||
add_note();
|
||||
return nullptr;
|
||||
}
|
||||
@ -791,7 +791,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, uint32_t index)
|
||||
}
|
||||
|
||||
auto* sem = builder_->create<sem::Parameter>(
|
||||
param, index, ty, ast::AddressSpace::kNone, ast::Access::kUndefined,
|
||||
param, index, ty, type::AddressSpace::kNone, ast::Access::kUndefined,
|
||||
sem::ParameterUsage::kNone, binding_point, location);
|
||||
builder_->Sem().Add(param, sem);
|
||||
return sem;
|
||||
@ -821,12 +821,12 @@ utils::Result<uint32_t> Resolver::LocationAttribute(const ast::LocationAttribute
|
||||
return static_cast<uint32_t>(value);
|
||||
}
|
||||
|
||||
ast::Access Resolver::DefaultAccessForAddressSpace(ast::AddressSpace address_space) {
|
||||
ast::Access Resolver::DefaultAccessForAddressSpace(type::AddressSpace address_space) {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class
|
||||
switch (address_space) {
|
||||
case ast::AddressSpace::kStorage:
|
||||
case ast::AddressSpace::kUniform:
|
||||
case ast::AddressSpace::kHandle:
|
||||
case type::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kUniform:
|
||||
case type::AddressSpace::kHandle:
|
||||
return ast::Access::kRead;
|
||||
default:
|
||||
break;
|
||||
@ -1036,7 +1036,7 @@ sem::Function* Resolver::Function(const ast::Function* decl) {
|
||||
}
|
||||
|
||||
if (auto* str = return_type->As<sem::Struct>()) {
|
||||
if (!ApplyAddressSpaceUsageToType(ast::AddressSpace::kNone, str, decl->source)) {
|
||||
if (!ApplyAddressSpaceUsageToType(type::AddressSpace::kNone, str, decl->source)) {
|
||||
AddNote(
|
||||
"while instantiating return type for " + builder_->Symbols().NameFor(decl->symbol),
|
||||
decl->source);
|
||||
@ -2099,10 +2099,10 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
|
||||
[&]() -> sem::TypeInitializer* {
|
||||
auto params = utils::Transform(args, [&](auto, size_t i) {
|
||||
return builder_->create<sem::Parameter>(
|
||||
nullptr, // declaration
|
||||
static_cast<uint32_t>(i), // index
|
||||
arr->ElemType(), // type
|
||||
ast::AddressSpace::kNone, // address_space
|
||||
nullptr, // declaration
|
||||
static_cast<uint32_t>(i), // index
|
||||
arr->ElemType(), // type
|
||||
type::AddressSpace::kNone, // address_space
|
||||
ast::Access::kUndefined);
|
||||
});
|
||||
return builder_->create<sem::TypeInitializer>(arr, std::move(params),
|
||||
@ -2131,7 +2131,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
|
||||
nullptr, // declaration
|
||||
static_cast<uint32_t>(i), // index
|
||||
str->Members()[i]->Type(), // type
|
||||
ast::AddressSpace::kNone, // address_space
|
||||
type::AddressSpace::kNone, // address_space
|
||||
ast::Access::kUndefined); // access
|
||||
}
|
||||
return builder_->create<sem::TypeInitializer>(str, std::move(params),
|
||||
@ -3759,7 +3759,7 @@ sem::Statement* Resolver::IncrementDecrementStatement(
|
||||
});
|
||||
}
|
||||
|
||||
bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space,
|
||||
bool Resolver::ApplyAddressSpaceUsageToType(type::AddressSpace address_space,
|
||||
type::Type* ty,
|
||||
const Source& usage) {
|
||||
ty = const_cast<type::Type*>(ty->UnwrapRef());
|
||||
@ -3787,7 +3787,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space,
|
||||
}
|
||||
|
||||
if (auto* arr = ty->As<type::Array>()) {
|
||||
if (address_space != ast::AddressSpace::kStorage) {
|
||||
if (address_space != type::AddressSpace::kStorage) {
|
||||
if (arr->Count()->Is<type::RuntimeArrayCount>()) {
|
||||
AddError("runtime-sized arrays can only be used in the <storage> address space",
|
||||
usage);
|
||||
@ -3806,7 +3806,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(ast::AddressSpace address_space,
|
||||
usage);
|
||||
}
|
||||
|
||||
if (ast::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) {
|
||||
if (type::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) {
|
||||
std::stringstream err;
|
||||
err << "Type '" << sem_.TypeNameOf(ty) << "' cannot be used in address space '"
|
||||
<< address_space << "' as it is non-host-shareable";
|
||||
|
@ -378,11 +378,11 @@ class Resolver {
|
||||
/// given type and address space. Used for generating sensible error
|
||||
/// messages.
|
||||
/// @returns true on success, false on error
|
||||
bool ApplyAddressSpaceUsageToType(ast::AddressSpace sc, type::Type* ty, const Source& usage);
|
||||
bool ApplyAddressSpaceUsageToType(type::AddressSpace sc, type::Type* ty, const Source& usage);
|
||||
|
||||
/// @param address_space the address space
|
||||
/// @returns the default access control for the given address space
|
||||
ast::Access DefaultAccessForAddressSpace(ast::AddressSpace address_space);
|
||||
ast::Access DefaultAccessForAddressSpace(type::AddressSpace address_space);
|
||||
|
||||
/// Allocate constant IDs for pipeline-overridable constants.
|
||||
/// @returns true on success, false on error
|
||||
|
@ -325,7 +325,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_Alias) {
|
||||
|
||||
TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) {
|
||||
auto* init = Expr(2_i);
|
||||
GlobalVar("my_var", ty.i32(), ast::AddressSpace::kPrivate, init);
|
||||
GlobalVar("my_var", ty.i32(), type::AddressSpace::kPrivate, init);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -405,7 +405,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) {
|
||||
Func("func_i32", utils::Empty, ty.void_(), utils::Vector{fn_i32_decl});
|
||||
|
||||
// Declare f32 "foo" at module scope
|
||||
auto* mod_f32 = Var("foo", ty.f32(), ast::AddressSpace::kPrivate, Expr(2_f));
|
||||
auto* mod_f32 = Var("foo", ty.f32(), type::AddressSpace::kPrivate, Expr(2_f));
|
||||
auto* mod_init = mod_f32->initializer;
|
||||
AST().AddGlobalVariable(mod_f32);
|
||||
|
||||
@ -433,7 +433,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) {
|
||||
|
||||
TEST_F(ResolverTest, ArraySize_UnsignedLiteral) {
|
||||
// var<private> a : array<f32, 10u>;
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_u)), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_u)), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -446,7 +446,7 @@ TEST_F(ResolverTest, ArraySize_UnsignedLiteral) {
|
||||
|
||||
TEST_F(ResolverTest, ArraySize_SignedLiteral) {
|
||||
// var<private> a : array<f32, 10i>;
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_i)), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr(10_i)), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -461,7 +461,7 @@ TEST_F(ResolverTest, ArraySize_UnsignedConst) {
|
||||
// const size = 10u;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(10_u));
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -476,7 +476,7 @@ TEST_F(ResolverTest, ArraySize_SignedConst) {
|
||||
// const size = 0;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(10_i));
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -491,7 +491,7 @@ TEST_F(ResolverTest, ArraySize_NamedOverride) {
|
||||
// override size = 10i;
|
||||
// var<workgroup> a : array<f32, size>;
|
||||
auto* override = Override("size", Expr(10_i));
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kWorkgroup);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -509,8 +509,8 @@ TEST_F(ResolverTest, ArraySize_NamedOverride_Equivalence) {
|
||||
// var<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")), ast::AddressSpace::kWorkgroup);
|
||||
auto* b = GlobalVar("b", ty.array(ty.f32(), Expr("size")), ast::AddressSpace::kWorkgroup);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
|
||||
auto* b = GlobalVar("b", ty.array(ty.f32(), Expr("size")), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -536,7 +536,7 @@ TEST_F(ResolverTest, ArraySize_UnnamedOverride) {
|
||||
// var<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), ast::AddressSpace::kWorkgroup);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), cnt), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -556,8 +556,8 @@ TEST_F(ResolverTest, ArraySize_UnamedOverride_Equivalence) {
|
||||
auto* override = Override("size", Expr(10_i));
|
||||
auto* a_cnt = Mul("size", 2_a);
|
||||
auto* b_cnt = Mul("size", 2_a);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), a_cnt), ast::AddressSpace::kWorkgroup);
|
||||
auto* b = GlobalVar("b", ty.array(ty.f32(), b_cnt), ast::AddressSpace::kWorkgroup);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), a_cnt), type::AddressSpace::kWorkgroup);
|
||||
auto* b = GlobalVar("b", ty.array(ty.f32(), b_cnt), type::AddressSpace::kWorkgroup);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -579,7 +579,7 @@ TEST_F(ResolverTest, ArraySize_UnamedOverride_Equivalence) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Expr_Bitcast) {
|
||||
GlobalVar("name", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* bitcast = create<ast::BitcastExpression>(ty.f32(), Expr("name"));
|
||||
WrapInFunction(bitcast);
|
||||
@ -642,7 +642,7 @@ TEST_F(ResolverTest, Expr_Call_Builtin) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Expr_Cast) {
|
||||
GlobalVar("name", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("name", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* cast = Construct(ty.f32(), "name");
|
||||
WrapInFunction(cast);
|
||||
@ -700,7 +700,7 @@ TEST_F(ResolverTest, Expr_Initializer_Type_Vec4) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Expr_Identifier_GlobalVariable) {
|
||||
auto* my_var = GlobalVar("my_var", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
auto* my_var = GlobalVar("my_var", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* ident = Expr("my_var");
|
||||
WrapInFunction(ident);
|
||||
@ -801,7 +801,7 @@ TEST_F(ResolverTest, Expr_Identifier_Function_Ptr) {
|
||||
auto* v = Expr("v");
|
||||
auto* p = Expr("p");
|
||||
auto* v_decl = Decl(Var("v", ty.f32()));
|
||||
auto* p_decl = Decl(Let("p", ty.pointer<f32>(ast::AddressSpace::kFunction), AddressOf(v)));
|
||||
auto* p_decl = Decl(Let("p", ty.pointer<f32>(type::AddressSpace::kFunction), AddressOf(v)));
|
||||
auto* assign = Assign(Deref(p), 1.23_f);
|
||||
Func("my_func", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -876,7 +876,7 @@ TEST_F(ResolverTest, Function_Parameters_Locations) {
|
||||
auto* param_b = Param("b", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kVertexIndex)});
|
||||
auto* param_c = Param("c", ty.u32(), utils::Vector{Location(1_a)});
|
||||
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* func = Func("my_func",
|
||||
utils::Vector{
|
||||
param_a,
|
||||
@ -906,7 +906,7 @@ TEST_F(ResolverTest, Function_Parameters_Locations) {
|
||||
|
||||
TEST_F(ResolverTest, Function_GlobalVariable_Location) {
|
||||
auto* var = GlobalVar(
|
||||
"my_vec", ty.vec4<f32>(), ast::AddressSpace::kIn,
|
||||
"my_vec", ty.vec4<f32>(), type::AddressSpace::kIn,
|
||||
utils::Vector{Location(3_a), Disable(ast::DisabledValidation::kIgnoreAddressSpace)});
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -919,10 +919,10 @@ TEST_F(ResolverTest, Function_GlobalVariable_Location) {
|
||||
TEST_F(ResolverTest, Function_RegisterInputOutputVariables) {
|
||||
auto* s = Structure("S", utils::Vector{Member("m", ty.u32())});
|
||||
|
||||
auto* sb_var = GlobalVar("sb_var", ty.Of(s), ast::AddressSpace::kStorage,
|
||||
auto* sb_var = GlobalVar("sb_var", ty.Of(s), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(0_a), Group(0_a));
|
||||
auto* wg_var = GlobalVar("wg_var", ty.f32(), ast::AddressSpace::kWorkgroup);
|
||||
auto* priv_var = GlobalVar("priv_var", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup);
|
||||
auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* func = Func("my_func", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -965,7 +965,7 @@ TEST_F(ResolverTest, Function_ReturnType_Location) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Function_ReturnType_NoLocation) {
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* func = Func("my_func", utils::Empty, ty.vec4<f32>(),
|
||||
utils::Vector{
|
||||
Return("my_vec"),
|
||||
@ -987,10 +987,10 @@ TEST_F(ResolverTest, Function_ReturnType_NoLocation) {
|
||||
TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) {
|
||||
auto* s = Structure("S", utils::Vector{Member("m", ty.u32())});
|
||||
|
||||
auto* sb_var = GlobalVar("sb_var", ty.Of(s), ast::AddressSpace::kStorage,
|
||||
auto* sb_var = GlobalVar("sb_var", ty.Of(s), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(0_a), Group(0_a));
|
||||
auto* wg_var = GlobalVar("wg_var", ty.f32(), ast::AddressSpace::kWorkgroup);
|
||||
auto* priv_var = GlobalVar("priv_var", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
auto* wg_var = GlobalVar("wg_var", ty.f32(), type::AddressSpace::kWorkgroup);
|
||||
auto* priv_var = GlobalVar("priv_var", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
Func("my_func", utils::Empty, ty.f32(),
|
||||
utils::Vector{Assign("wg_var", "wg_var"), Assign("sb_var", "sb_var"),
|
||||
@ -1241,7 +1241,7 @@ TEST_F(ResolverTest, Function_WorkgroupSize_Mixed) {
|
||||
TEST_F(ResolverTest, Expr_MemberAccessor_Struct) {
|
||||
auto* st = Structure(
|
||||
"S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())});
|
||||
GlobalVar("my_struct", ty.Of(st), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_struct", ty.Of(st), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* mem = MemberAccessor("my_struct", "second_member");
|
||||
WrapInFunction(mem);
|
||||
@ -1262,7 +1262,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) {
|
||||
auto* st = Structure(
|
||||
"S", utils::Vector{Member("first_member", ty.i32()), Member("second_member", ty.f32())});
|
||||
auto* alias = Alias("alias", ty.Of(st));
|
||||
GlobalVar("my_struct", ty.Of(alias), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_struct", ty.Of(alias), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* mem = MemberAccessor("my_struct", "second_member");
|
||||
WrapInFunction(mem);
|
||||
@ -1279,7 +1279,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* mem = MemberAccessor("my_vec", "xzyw");
|
||||
WrapInFunction(mem);
|
||||
@ -1297,7 +1297,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle_SingleElement) {
|
||||
GlobalVar("my_vec", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* mem = MemberAccessor("my_vec", "b");
|
||||
WrapInFunction(mem);
|
||||
@ -1330,7 +1330,7 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
|
||||
|
||||
auto* stB = Structure("B", utils::Vector{Member("foo", ty.vec4<f32>())});
|
||||
auto* stA = Structure("A", utils::Vector{Member("mem", ty.array(ty.Of(stB), 3_i))});
|
||||
GlobalVar("c", ty.Of(stA), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("c", ty.Of(stA), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* mem =
|
||||
MemberAccessor(MemberAccessor(IndexAccessor(MemberAccessor("c", "mem"), 0_i), "foo"), "yx");
|
||||
@ -1348,7 +1348,7 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
|
||||
TEST_F(ResolverTest, Expr_MemberAccessor_InBinaryOp) {
|
||||
auto* st = Structure(
|
||||
"S", utils::Vector{Member("first_member", ty.f32()), Member("second_member", ty.f32())});
|
||||
GlobalVar("my_struct", ty.Of(st), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_struct", ty.Of(st), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Add(MemberAccessor("my_struct", "first_member"),
|
||||
MemberAccessor("my_struct", "second_member"));
|
||||
@ -1651,8 +1651,8 @@ TEST_P(Expr_Binary_Test_Valid, All) {
|
||||
ss << FriendlyName(lhs_type) << " " << params.op << " " << FriendlyName(rhs_type);
|
||||
SCOPED_TRACE(ss.str());
|
||||
|
||||
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs"));
|
||||
WrapInFunction(expr);
|
||||
@ -1686,8 +1686,8 @@ TEST_P(Expr_Binary_Test_WithAlias_Valid, All) {
|
||||
<< FriendlyName(rhs_type);
|
||||
SCOPED_TRACE(ss.str());
|
||||
|
||||
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = create<ast::BinaryExpression>(params.op, Expr("lhs"), Expr("rhs"));
|
||||
WrapInFunction(expr);
|
||||
@ -1732,8 +1732,8 @@ TEST_P(Expr_Binary_Test_Invalid, All) {
|
||||
ss << FriendlyName(lhs_type) << " " << op << " " << FriendlyName(rhs_type);
|
||||
SCOPED_TRACE(ss.str());
|
||||
|
||||
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = create<ast::BinaryExpression>(Source{{12, 34}}, op, Expr("lhs"), Expr("rhs"));
|
||||
WrapInFunction(expr);
|
||||
@ -1772,8 +1772,8 @@ TEST_P(Expr_Binary_Test_Invalid_VectorMatrixMultiply, All) {
|
||||
is_valid_expr = vec_size == mat_cols;
|
||||
}
|
||||
|
||||
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs"));
|
||||
WrapInFunction(expr);
|
||||
@ -1809,8 +1809,8 @@ TEST_P(Expr_Binary_Test_Invalid_MatrixMatrixMultiply, All) {
|
||||
auto* col = create<type::Vector>(f32, lhs_mat_rows);
|
||||
auto* result_type = create<type::Matrix>(col, rhs_mat_cols);
|
||||
|
||||
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("lhs", lhs_type, type::AddressSpace::kPrivate);
|
||||
GlobalVar("rhs", rhs_type, type::AddressSpace::kPrivate);
|
||||
|
||||
auto* expr = Mul(Source{{12, 34}}, Expr("lhs"), Expr("rhs"));
|
||||
WrapInFunction(expr);
|
||||
@ -1838,11 +1838,11 @@ TEST_P(UnaryOpExpressionTest, Expr_UnaryOp) {
|
||||
auto op = GetParam();
|
||||
|
||||
if (op == ast::UnaryOp::kNot) {
|
||||
GlobalVar("ident", ty.vec4<bool>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.vec4<bool>(), type::AddressSpace::kPrivate);
|
||||
} else if (op == ast::UnaryOp::kNegation || op == ast::UnaryOp::kComplement) {
|
||||
GlobalVar("ident", ty.vec4<i32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.vec4<i32>(), type::AddressSpace::kPrivate);
|
||||
} else {
|
||||
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
}
|
||||
auto* der = create<ast::UnaryOpExpression>(op, Expr("ident"));
|
||||
WrapInFunction(der);
|
||||
@ -1874,7 +1874,7 @@ TEST_F(ResolverTest, AddressSpace_SetsIfMissing) {
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kFunction);
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kFunction);
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, AddressSpace_SetForSampler) {
|
||||
@ -1883,7 +1883,7 @@ TEST_F(ResolverTest, AddressSpace_SetForSampler) {
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kHandle);
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kHandle);
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, AddressSpace_SetForTexture) {
|
||||
@ -1892,7 +1892,7 @@ TEST_F(ResolverTest, AddressSpace_SetForTexture) {
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kHandle);
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kHandle);
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) {
|
||||
@ -1902,14 +1902,14 @@ TEST_F(ResolverTest, AddressSpace_DoesNotSetOnConst) {
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), ast::AddressSpace::kNone);
|
||||
EXPECT_EQ(Sem().Get(var)->AddressSpace(), type::AddressSpace::kNone);
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, Access_SetForStorageBuffer) {
|
||||
// struct S { x : i32 };
|
||||
// var<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), ast::AddressSpace::kStorage,
|
||||
auto* var = GlobalVar(Source{{56, 78}}, "g", ty.Of(s), type::AddressSpace::kStorage,
|
||||
Binding(0_a), Group(0_a));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -1942,11 +1942,11 @@ TEST_F(ResolverTest, Function_EntryPoints_StageAttribute) {
|
||||
// ep_1 -> {}
|
||||
// ep_2 -> {}
|
||||
|
||||
GlobalVar("first", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("second", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("call_a", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("call_b", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("call_c", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("first", ty.f32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("second", ty.f32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("call_a", ty.f32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("call_b", ty.f32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("call_c", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* func_b = Func("b", utils::Empty, ty.f32(),
|
||||
utils::Vector{
|
||||
@ -2086,8 +2086,8 @@ TEST_F(ResolverTest, ASTNodeReachedTwice) {
|
||||
{
|
||||
ProgramBuilder b;
|
||||
auto* expr = b.Expr(1_i);
|
||||
b.GlobalVar("a", b.ty.i32(), ast::AddressSpace::kPrivate, expr);
|
||||
b.GlobalVar("b", b.ty.i32(), ast::AddressSpace::kPrivate, expr);
|
||||
b.GlobalVar("a", b.ty.i32(), type::AddressSpace::kPrivate, expr);
|
||||
b.GlobalVar("b", b.ty.i32(), type::AddressSpace::kPrivate, expr);
|
||||
Resolver(&b).Resolve();
|
||||
},
|
||||
"internal compiler error: AST node 'tint::ast::IntLiteralExpression' was encountered twice "
|
||||
@ -2095,7 +2095,7 @@ TEST_F(ResolverTest, ASTNodeReachedTwice) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, UnaryOp_Not) {
|
||||
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* der = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr(Source{{12, 34}}, "ident"));
|
||||
WrapInFunction(der);
|
||||
|
||||
@ -2104,7 +2104,7 @@ TEST_F(ResolverTest, UnaryOp_Not) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, UnaryOp_Complement) {
|
||||
GlobalVar("ident", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* der =
|
||||
create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr(Source{{12, 34}}, "ident"));
|
||||
WrapInFunction(der);
|
||||
@ -2114,7 +2114,7 @@ TEST_F(ResolverTest, UnaryOp_Complement) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, UnaryOp_Negation) {
|
||||
GlobalVar("ident", ty.u32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("ident", ty.u32(), type::AddressSpace::kPrivate);
|
||||
auto* der =
|
||||
create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr(Source{{12, 34}}, "ident"));
|
||||
WrapInFunction(der);
|
||||
@ -2273,7 +2273,7 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715
|
||||
GlobalVar("s", ty.sampler(ast::SamplerKind::kSampler), Group(0_a), Binding(0_a));
|
||||
GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
|
||||
Binding(1_a));
|
||||
GlobalVar("c", ty.vec2<f32>(), ast::AddressSpace::kUniform, Group(0_a), Binding(2_a));
|
||||
GlobalVar("c", ty.vec2<f32>(), type::AddressSpace::kUniform, Group(0_a), Binding(2_a));
|
||||
|
||||
Func("main", utils::Empty, ty.vec4<f32>(),
|
||||
utils::Vector{
|
||||
@ -2289,9 +2289,9 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715
|
||||
Func("helper",
|
||||
utils::Vector{
|
||||
Param("sl", ty.pointer(ty.sampler(ast::SamplerKind::kSampler),
|
||||
ast::AddressSpace::kFunction)),
|
||||
type::AddressSpace::kFunction)),
|
||||
Param("tl", ty.pointer(ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
|
||||
ast::AddressSpace::kFunction)),
|
||||
type::AddressSpace::kFunction)),
|
||||
},
|
||||
ty.vec4<f32>(),
|
||||
utils::Vector{
|
||||
@ -2304,15 +2304,15 @@ TEST_F(ResolverTest, TextureSampler_Bug1715) { // crbug.com/tint/1715
|
||||
|
||||
TEST_F(ResolverTest, ModuleDependencyOrderedDeclarations) {
|
||||
auto* f0 = Func("f0", utils::Empty, ty.void_(), utils::Empty);
|
||||
auto* v0 = GlobalVar("v0", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* v0 = GlobalVar("v0", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* a0 = Alias("a0", ty.i32());
|
||||
auto* s0 = Structure("s0", utils::Vector{Member("m", ty.i32())});
|
||||
auto* f1 = Func("f1", utils::Empty, ty.void_(), utils::Empty);
|
||||
auto* v1 = GlobalVar("v1", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* v1 = GlobalVar("v1", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* a1 = Alias("a1", ty.i32());
|
||||
auto* s1 = Structure("s1", utils::Vector{Member("m", ty.i32())});
|
||||
auto* f2 = Func("f2", utils::Empty, ty.void_(), utils::Empty);
|
||||
auto* v2 = GlobalVar("v2", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* v2 = GlobalVar("v2", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* a2 = Alias("a2", ty.i32());
|
||||
auto* s2 = Structure("s2", utils::Vector{Member("m", ty.i32())});
|
||||
|
||||
|
@ -616,13 +616,13 @@ struct DataType<ptr<T>> {
|
||||
/// @param b the ProgramBuilder
|
||||
/// @return a new AST alias type
|
||||
static inline const ast::Type* AST(ProgramBuilder& b) {
|
||||
return b.create<ast::Pointer>(DataType<T>::AST(b), ast::AddressSpace::kPrivate,
|
||||
return b.create<ast::Pointer>(DataType<T>::AST(b), type::AddressSpace::kPrivate,
|
||||
ast::Access::kUndefined);
|
||||
}
|
||||
/// @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), ast::AddressSpace::kPrivate,
|
||||
return b.create<type::Pointer>(DataType<T>::Sem(b), type::AddressSpace::kPrivate,
|
||||
ast::Access::kReadWrite);
|
||||
}
|
||||
|
||||
@ -631,7 +631,7 @@ struct DataType<ptr<T>> {
|
||||
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), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar(sym, DataType<T>::AST(b), type::AddressSpace::kPrivate);
|
||||
return b.AddressOf(sym);
|
||||
}
|
||||
|
||||
|
@ -27,7 +27,7 @@ namespace {
|
||||
class ResolverRootIdentifierTest : public ResolverTest {};
|
||||
|
||||
TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) {
|
||||
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
|
||||
auto* expr = Expr(a);
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -38,7 +38,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalPrivateVar) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) {
|
||||
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kWorkgroup);
|
||||
auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kWorkgroup);
|
||||
auto* expr = Expr(a);
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -49,7 +49,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalWorkgroupVar) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) {
|
||||
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kStorage, Group(0_a), Binding(0_a));
|
||||
auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kStorage, Group(0_a), Binding(0_a));
|
||||
auto* expr = Expr(a);
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -60,7 +60,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalStorageVar) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) {
|
||||
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kUniform, Group(0_a), Binding(0_a));
|
||||
auto* expr = Expr(a);
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -72,7 +72,7 @@ TEST_F(ResolverRootIdentifierTest, GlobalUniformVar) {
|
||||
|
||||
TEST_F(ResolverRootIdentifierTest, GlobalTextureVar) {
|
||||
auto* a = GlobalVar("a", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
|
||||
ast::AddressSpace::kNone, Group(0_a), Binding(0_a));
|
||||
type::AddressSpace::kNone, Group(0_a), Binding(0_a));
|
||||
auto* expr = Expr(a);
|
||||
WrapInFunction(Call("textureDimensions", expr));
|
||||
|
||||
@ -142,7 +142,7 @@ TEST_F(ResolverRootIdentifierTest, PointerParameter) {
|
||||
// {
|
||||
// let b = a;
|
||||
// }
|
||||
auto* param = Param("a", ty.pointer(ty.f32(), ast::AddressSpace::kFunction));
|
||||
auto* param = Param("a", ty.pointer(ty.f32(), type::AddressSpace::kFunction));
|
||||
auto* expr_param = Expr(param);
|
||||
auto* let = Let("b", expr_param);
|
||||
auto* expr_let = Expr("b");
|
||||
@ -199,7 +199,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughIndexAccessor) {
|
||||
// {
|
||||
// a[2i]
|
||||
// }
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), 4_u), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.array(ty.f32(), 4_u), type::AddressSpace::kPrivate);
|
||||
auto* expr = IndexAccessor(a, 2_i);
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -216,7 +216,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughMemberAccessor) {
|
||||
// a.f
|
||||
// }
|
||||
auto* S = Structure("S", utils::Vector{Member("f", ty.f32())});
|
||||
auto* a = GlobalVar("a", ty.Of(S), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.Of(S), type::AddressSpace::kPrivate);
|
||||
auto* expr = MemberAccessor(a, "f");
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -232,7 +232,7 @@ TEST_F(ResolverRootIdentifierTest, ThroughPointers) {
|
||||
// let a_ptr1 = &*&a;
|
||||
// let a_ptr2 = &*a_ptr1;
|
||||
// }
|
||||
auto* a = GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
auto* a = GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
|
||||
auto* address_of_1 = AddressOf(a);
|
||||
auto* deref_1 = Deref(address_of_1);
|
||||
auto* address_of_2 = AddressOf(deref_1);
|
||||
|
@ -31,7 +31,7 @@ struct SideEffectsTest : ResolverTest {
|
||||
template <typename T>
|
||||
void MakeSideEffectFunc(const char* name) {
|
||||
auto global = Sym();
|
||||
GlobalVar(global, ty.Of<T>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(global, ty.Of<T>(), type::AddressSpace::kPrivate);
|
||||
auto local = Sym();
|
||||
Func(name, utils::Empty, ty.Of<T>(),
|
||||
utils::Vector{
|
||||
@ -44,7 +44,7 @@ struct SideEffectsTest : ResolverTest {
|
||||
template <typename MAKE_TYPE_FUNC>
|
||||
void MakeSideEffectFunc(const char* name, MAKE_TYPE_FUNC make_type) {
|
||||
auto global = Sym();
|
||||
GlobalVar(global, make_type(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(global, make_type(), type::AddressSpace::kPrivate);
|
||||
auto local = Sym();
|
||||
Func(name, utils::Empty, make_type(),
|
||||
utils::Vector{
|
||||
@ -89,7 +89,7 @@ TEST_F(SideEffectsTest, VariableUser) {
|
||||
}
|
||||
|
||||
TEST_F(SideEffectsTest, Call_Builtin_NoSE) {
|
||||
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate);
|
||||
auto* expr = Call("dpdx", "a");
|
||||
Func("f", utils::Empty, ty.void_(), utils::Vector{Ignore(expr)},
|
||||
utils::Vector{create<ast::StageAttribute>(ast::PipelineStage::kFragment)});
|
||||
@ -115,7 +115,7 @@ TEST_F(SideEffectsTest, Call_Builtin_NoSE_WithSEArg) {
|
||||
}
|
||||
|
||||
TEST_F(SideEffectsTest, Call_Builtin_SE) {
|
||||
GlobalVar("a", ty.atomic(ty.i32()), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kWorkgroup);
|
||||
auto* expr = Call("atomicAdd", AddressOf("a"), 1_i);
|
||||
WrapInFunction(expr);
|
||||
|
||||
@ -164,21 +164,21 @@ TEST_P(SideEffectsBuiltinTest, Test) {
|
||||
auto& c = GetParam();
|
||||
|
||||
uint32_t next_binding = 0;
|
||||
GlobalVar("f", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("i", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("u", ty.u32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("b", ty.bool_(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("vf", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("vf2", ty.vec2<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("vi2", ty.vec2<i32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("vf4", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("vb", ty.vec3<bool>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("m", ty.mat3x3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("arr", ty.array<f32, 10>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("storage_arr", ty.array<f32>(), ast::AddressSpace::kStorage, Group(0_a),
|
||||
GlobalVar("f", ty.f32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("i", ty.i32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("u", ty.u32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("b", ty.bool_(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("vf", ty.vec3<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),
|
||||
Binding(AInt(next_binding++)));
|
||||
GlobalVar("workgroup_arr", ty.array<f32, 4>(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("a", ty.atomic(ty.i32()), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
GlobalVar("workgroup_arr", ty.array<f32, 4>(), type::AddressSpace::kWorkgroup);
|
||||
GlobalVar("a", ty.atomic(ty.i32()), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
Group(0_a), Binding(AInt(next_binding++)));
|
||||
if (c.pipeline_stage != ast::PipelineStage::kCompute) {
|
||||
GlobalVar("t2d", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
|
||||
|
@ -84,7 +84,7 @@ TEST_F(ResolverStaticAssertTest, Local_Const_Fail) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverStaticAssertTest, Local_NonConst) {
|
||||
GlobalVar("V", ty.bool_(), Expr(true), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("V", ty.bool_(), Expr(true), type::AddressSpace::kPrivate);
|
||||
WrapInFunction(StaticAssert(Expr(Source{{12, 34}}, "V")));
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
|
@ -46,7 +46,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromParameter) {
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kNone));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kNone));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) {
|
||||
@ -58,55 +58,55 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromReturnType) {
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kNone));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kNone));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromGlobal) {
|
||||
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
|
||||
GlobalVar("g", ty.Of(s), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("g", ty.Of(s), type::AddressSpace::kPrivate);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalAlias) {
|
||||
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
auto* a = Alias("A", ty.Of(s));
|
||||
GlobalVar("g", ty.Of(a), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("g", ty.Of(a), type::AddressSpace::kPrivate);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalStruct) {
|
||||
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
auto* o = Structure("O", utils::Vector{Member("a", ty.Of(s))});
|
||||
GlobalVar("g", ty.Of(o), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("g", ty.Of(o), type::AddressSpace::kPrivate);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaGlobalArray) {
|
||||
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
auto* a = ty.array(ty.Of(s), 3_u);
|
||||
GlobalVar("g", a, ast::AddressSpace::kPrivate);
|
||||
GlobalVar("g", a, type::AddressSpace::kPrivate);
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kPrivate));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kPrivate));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) {
|
||||
@ -118,7 +118,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableFromLocal) {
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) {
|
||||
@ -130,7 +130,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalAlias) {
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) {
|
||||
@ -142,7 +142,7 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalStruct) {
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) {
|
||||
@ -154,13 +154,13 @@ TEST_F(ResolverAddressSpaceUseTest, StructReachableViaLocalArray) {
|
||||
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(ast::AddressSpace::kFunction));
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(type::AddressSpace::kFunction));
|
||||
}
|
||||
|
||||
TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) {
|
||||
auto* s = Structure("S", utils::Vector{Member("a", ty.f32())});
|
||||
GlobalVar("x", ty.Of(s), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("y", ty.Of(s), ast::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a),
|
||||
GlobalVar("x", ty.Of(s), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("y", ty.Of(s), type::AddressSpace::kStorage, ast::Access::kRead, Binding(1_a),
|
||||
Group(0_a));
|
||||
WrapInFunction(Var("g", ty.Of(s)));
|
||||
|
||||
@ -169,8 +169,8 @@ TEST_F(ResolverAddressSpaceUseTest, StructMultipleAddressSpaceUses) {
|
||||
auto* sem = TypeOf(s)->As<sem::Struct>();
|
||||
ASSERT_NE(sem, nullptr);
|
||||
EXPECT_THAT(sem->AddressSpaceUsage(),
|
||||
UnorderedElementsAre(ast::AddressSpace::kUniform, ast::AddressSpace::kStorage,
|
||||
ast::AddressSpace::kFunction));
|
||||
UnorderedElementsAre(type::AddressSpace::kUniform, type::AddressSpace::kStorage,
|
||||
type::AddressSpace::kFunction));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
@ -69,10 +69,12 @@ TEST_F(ResolverTypeInitializerValidationTest, InferTypeTest_Simple) {
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
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(), ast::AddressSpace::kFunction);
|
||||
EXPECT_EQ(TypeOf(a_ident)->As<type::Reference>()->AddressSpace(),
|
||||
type::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(), ast::AddressSpace::kFunction);
|
||||
EXPECT_EQ(TypeOf(b_ident)->As<type::Reference>()->AddressSpace(),
|
||||
type::AddressSpace::kFunction);
|
||||
}
|
||||
|
||||
using InferTypeTest_FromInitializerExpression = ResolverTestWithParam<Params>;
|
||||
@ -95,8 +97,8 @@ TEST_P(InferTypeTest_FromInitializerExpression, All) {
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
auto* got = TypeOf(a_ident);
|
||||
auto* expected = create<type::Reference>(params.create_rhs_sem_type(*this),
|
||||
ast::AddressSpace::kFunction, ast::Access::kReadWrite);
|
||||
auto* expected = create<type::Reference>(
|
||||
params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite);
|
||||
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
|
||||
<< "expected: " << FriendlyName(expected) << "\n";
|
||||
}
|
||||
@ -149,8 +151,8 @@ TEST_P(InferTypeTest_FromArithmeticExpression, All) {
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
auto* got = TypeOf(a_ident);
|
||||
auto* expected = create<type::Reference>(params.create_rhs_sem_type(*this),
|
||||
ast::AddressSpace::kFunction, ast::Access::kReadWrite);
|
||||
auto* expected = create<type::Reference>(
|
||||
params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite);
|
||||
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
|
||||
<< "expected: " << FriendlyName(expected) << "\n";
|
||||
}
|
||||
@ -197,8 +199,8 @@ TEST_P(InferTypeTest_FromCallExpression, All) {
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
auto* got = TypeOf(a_ident);
|
||||
auto* expected = create<type::Reference>(params.create_rhs_sem_type(*this),
|
||||
ast::AddressSpace::kFunction, ast::Access::kReadWrite);
|
||||
auto* expected = create<type::Reference>(
|
||||
params.create_rhs_sem_type(*this), type::AddressSpace::kFunction, ast::Access::kReadWrite);
|
||||
ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n"
|
||||
<< "expected: " << FriendlyName(expected) << "\n";
|
||||
}
|
||||
@ -1968,7 +1970,7 @@ TEST_F(ResolverTypeInitializerValidationTest, NestedVectorInitializers_Success)
|
||||
|
||||
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) {
|
||||
auto* alias = Alias("UnsignedInt", ty.u32());
|
||||
GlobalVar("uint_var", ty.Of(alias), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("uint_var", ty.Of(alias), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* tc = vec2<f32>(Source{{12, 34}}, "uint_var");
|
||||
WrapInFunction(tc);
|
||||
@ -1980,8 +1982,8 @@ TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) {
|
||||
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Success) {
|
||||
auto* f32_alias = Alias("Float32", ty.f32());
|
||||
auto* vec2_alias = Alias("VectorFloat2", ty.vec2<f32>());
|
||||
GlobalVar("my_f32", ty.Of(f32_alias), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec2", ty.Of(vec2_alias), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_f32", ty.Of(f32_alias), type::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec2", ty.Of(vec2_alias), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* tc = vec3<f32>("my_vec2", "my_f32");
|
||||
WrapInFunction(tc);
|
||||
|
@ -95,7 +95,7 @@ TEST_F(ResolverTypeValidationTest, GlobalOverrideNoInitializer_Pass) {
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, GlobalVariableWithAddressSpace_Pass) {
|
||||
// var<private> global_var: f32;
|
||||
GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -111,9 +111,9 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableUnique_Pass) {
|
||||
// var global_var0 : f32 = 0.1;
|
||||
// var global_var1 : i32 = 0;
|
||||
|
||||
GlobalVar("global_var0", ty.f32(), ast::AddressSpace::kPrivate, Expr(0.1_f));
|
||||
GlobalVar("global_var0", ty.f32(), type::AddressSpace::kPrivate, Expr(0.1_f));
|
||||
|
||||
GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), ast::AddressSpace::kPrivate, Expr(1_f));
|
||||
GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), type::AddressSpace::kPrivate, Expr(1_f));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -129,7 +129,7 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Pass)
|
||||
Decl(Var("a", ty.f32(), Expr(2_f))),
|
||||
});
|
||||
|
||||
GlobalVar("a", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
GlobalVar("a", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -193,19 +193,19 @@ TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierDifferentFunctions_Pass)
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Pass) {
|
||||
// var<private> a : array<f32, 4>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)), type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) {
|
||||
// var<private> a : array<f32, 4u>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) {
|
||||
// var<private> a : array<f32, 4i>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
@ -213,7 +213,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Pass) {
|
||||
// const size = 4u;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(4_u));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
@ -221,34 +222,35 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Pass) {
|
||||
// const size = 4i;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(4_i));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Zero) {
|
||||
// var<private> a : array<f32, 0>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_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)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Zero) {
|
||||
// var<private> a : array<f32, 0i>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_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)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10_i)), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0");
|
||||
}
|
||||
@ -257,7 +259,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Zero) {
|
||||
// const size = 0u;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(0_u));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
|
||||
}
|
||||
@ -266,7 +269,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Zero) {
|
||||
// const size = 0i;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(0_i));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0");
|
||||
}
|
||||
@ -275,14 +279,15 @@ TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Negative) {
|
||||
// const size = -10i;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(-10_i));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0");
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) {
|
||||
// var<private> a : array<f32, 10.0>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
r()->error(),
|
||||
@ -293,7 +298,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) {
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) {
|
||||
// var<private> a : array<f32, vec2<i32>(10, 10)>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.vec2<i32>(), 10_i, 10_i)),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
r()->error(),
|
||||
@ -305,7 +310,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_FloatConst) {
|
||||
// const size = 10.0;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Expr(10_f));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
r()->error(),
|
||||
@ -317,7 +323,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) {
|
||||
// const size = vec2<i32>(100, 100);
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalConst("size", Construct(ty.vec2<i32>(), 100_i, 100_i));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(
|
||||
r()->error(),
|
||||
@ -328,14 +335,14 @@ TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) {
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_UnderElementCountLimit) {
|
||||
// var<private> a : array<f32, 65535>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a)),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) {
|
||||
// var<private> a : array<f32, 65536>;
|
||||
GlobalVar(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.f32(), Expr(65536_a)),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), R"(12:34 error: array count (65536) must be less than 65536
|
||||
56:78 note: while instantiating 'var' a)");
|
||||
@ -343,8 +350,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) {
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_StorageBufferLargeArray) {
|
||||
// var<storage> a : array<f32, 65536>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)), ast::AddressSpace::kStorage,
|
||||
utils::Vector{Binding(0_u), Group(0_u)});
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)),
|
||||
type::AddressSpace::kStorage, utils::Vector{Binding(0_u), Group(0_u)});
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
@ -355,7 +362,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NestedStorageBufferLargeArray) {
|
||||
// var<storage> a : S;
|
||||
Structure("S", utils::Vector{Member(Source{{12, 34}}, "a",
|
||||
ty.array(Source{{12, 20}}, ty.f32(), 65536_a))});
|
||||
GlobalVar("a", ty.type_name(Source{{12, 30}}, "S"), ast::AddressSpace::kStorage,
|
||||
GlobalVar("a", ty.type_name(Source{{12, 30}}, "S"), type::AddressSpace::kStorage,
|
||||
utils::Vector{Binding(0_u), Group(0_u)});
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
@ -368,7 +375,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ImplicitStride) {
|
||||
Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", ty.f32(),
|
||||
utils::Vector{MemberOffset(800000_a)})});
|
||||
GlobalVar("a", ty.array(ty.type_name(Source{{12, 30}}, "S"), Expr(Source{{12, 34}}, 65535_a)),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
"12:34 error: array byte size (0xc34f7cafc) must not exceed 0xffffffff bytes");
|
||||
@ -377,7 +384,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ImplicitStride) {
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ExplicitStride) {
|
||||
// var<private> a : @stride(8000000) array<f32, 65535>;
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a), 8000000),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
"12:34 error: array byte size (0x7a1185ee00) must not exceed 0xffffffff bytes");
|
||||
@ -387,7 +394,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_PrivateVar) {
|
||||
// override size = 10i;
|
||||
// var<private> a : array<f32, size>;
|
||||
Override("size", Expr(10_i));
|
||||
GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
"12:34 error: array with an 'override' element count can only be used as the store "
|
||||
@ -399,7 +406,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_InArray) {
|
||||
// var<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),
|
||||
ast::AddressSpace::kWorkgroup);
|
||||
type::AddressSpace::kWorkgroup);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
"12:34 error: array with an 'override' element count can only be used as the store "
|
||||
@ -458,7 +465,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionVar_Implicit)
|
||||
// var a = w;
|
||||
// }
|
||||
Override("size", Expr(10_i));
|
||||
GlobalVar("w", ty.array(ty.f32(), "size"), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("w", ty.array(ty.f32(), "size"), type::AddressSpace::kWorkgroup);
|
||||
Func("f", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Decl(Var("a", Expr(Source{{12, 34}}, "w"))),
|
||||
@ -476,7 +483,7 @@ TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionLet_Implicit)
|
||||
// let a = w;
|
||||
// }
|
||||
Override("size", Expr(10_i));
|
||||
GlobalVar("w", ty.array(ty.f32(), "size"), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("w", ty.array(ty.f32(), "size"), type::AddressSpace::kWorkgroup);
|
||||
Func("f", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
Decl(Let("a", Expr(Source{{12, 34}}, "w"))),
|
||||
@ -495,8 +502,8 @@ TEST_F(ResolverTypeValidationTest, ArraySize_UnnamedOverride_Equivalence) {
|
||||
// a = b;
|
||||
// }
|
||||
Override("size", Expr(10_i));
|
||||
GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("b", ty.array(ty.f32(), Add("size", 1_i)), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), type::AddressSpace::kWorkgroup);
|
||||
GlobalVar("b", ty.array(ty.f32(), Add("size", 1_i)), type::AddressSpace::kWorkgroup);
|
||||
WrapInFunction(Assign(Source{{12, 34}}, "a", "b"));
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -530,15 +537,16 @@ TEST_F(ResolverTypeValidationTest, ArraySize_Workgroup_Overridable) {
|
||||
// var<workgroup> a : array<f32, size>;
|
||||
Override("size", Expr(10_i));
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
ast::AddressSpace::kWorkgroup);
|
||||
type::AddressSpace::kWorkgroup);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) {
|
||||
// var<private> size : i32 = 10i;
|
||||
// var<private> a : array<f32, size>;
|
||||
GlobalVar("size", ty.i32(), Expr(10_i), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("size", ty.i32(), Expr(10_i), type::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")),
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
R"(12:34 error: var 'size' cannot be referenced at module-scope
|
||||
@ -698,7 +706,7 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayInStructInArray) {
|
||||
|
||||
Structure("Foo", utils::Vector{Member("rt", ty.array<f32>())});
|
||||
GlobalVar("v", ty.array(ty.type_name(Source{{12, 34}}, "Foo"), 4_u),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve()) << r()->error();
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -744,7 +752,7 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayIsNotLast_Fail) {
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, RuntimeArrayAsGlobalVariable) {
|
||||
GlobalVar(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32()),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
||||
@ -793,7 +801,7 @@ TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsPointerParameter_Fail) {
|
||||
// fn func(a : ptr<workgroup, array<u32>>) {}
|
||||
|
||||
auto* param = Param("a", ty.pointer(Source{{56, 78}}, ty.array(Source{{12, 34}}, ty.i32()),
|
||||
ast::AddressSpace::kWorkgroup));
|
||||
type::AddressSpace::kWorkgroup));
|
||||
|
||||
Func("func", utils::Vector{param}, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -858,7 +866,7 @@ TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsLast_Pass) {
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) {
|
||||
auto* tex_ty = ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, ty.f32());
|
||||
GlobalVar("arr", ty.array(tex_ty, 4_i), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("arr", ty.array(tex_ty, 4_i), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -866,8 +874,8 @@ TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) {
|
||||
auto* ptr_ty = ty.pointer<u32>(Source{{12, 34}}, ast::AddressSpace::kUniform);
|
||||
GlobalVar("arr", ty.array(ptr_ty, 4_i, 16), ast::AddressSpace::kPrivate);
|
||||
auto* ptr_ty = ty.pointer<u32>(Source{{12, 34}}, type::AddressSpace::kUniform);
|
||||
GlobalVar("arr", ty.array(ptr_ty, 4_i, 16), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -877,8 +885,8 @@ TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) {
|
||||
TEST_F(ResolverTypeValidationTest, VariableAsType) {
|
||||
// var<private> a : i32;
|
||||
// var<private> b : a;
|
||||
GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("b", ty.type_name("a"), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("b", ty.type_name("a"), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -890,7 +898,7 @@ TEST_F(ResolverTypeValidationTest, FunctionAsType) {
|
||||
// fn f() {}
|
||||
// var<private> v : f;
|
||||
Func("f", utils::Empty, ty.void_(), {});
|
||||
GlobalVar("v", ty.type_name("f"), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.type_name("f"), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -900,7 +908,7 @@ note: 'f' declared here)");
|
||||
|
||||
TEST_F(ResolverTypeValidationTest, BuiltinAsType) {
|
||||
// var<private> v : max;
|
||||
GlobalVar("v", ty.type_name("max"), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("v", ty.type_name("max"), type::AddressSpace::kPrivate);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "error: cannot use builtin 'max' as type");
|
||||
@ -1264,7 +1272,7 @@ TEST_P(ValidMatrixTypes, Okay) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("a", ty.mat(params.elem_ty(*this), params.columns, params.rows),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
|
||||
@ -1303,7 +1311,7 @@ TEST_P(InvalidMatrixElementTypes, InvalidElementType) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("a", ty.mat(Source{{12, 34}}, params.elem_ty(*this), params.columns, params.rows),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:34 error: matrix element type must be 'f32' or 'f16'");
|
||||
}
|
||||
@ -1345,7 +1353,7 @@ TEST_P(ValidVectorTypes, Okay) {
|
||||
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(r()->Resolve()) << r()->error();
|
||||
}
|
||||
INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
|
||||
@ -1380,7 +1388,7 @@ TEST_P(InvalidVectorElementTypes, InvalidElementType) {
|
||||
Enable(ast::Extension::kF16);
|
||||
|
||||
GlobalVar("a", ty.vec(Source{{12, 34}}, params.elem_ty(*this), params.width),
|
||||
ast::AddressSpace::kPrivate);
|
||||
type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
"12:34 error: vector element type must be 'bool', 'f32', 'f16', 'i32' "
|
||||
|
@ -1688,11 +1688,11 @@ class UniformityGraph {
|
||||
|
||||
auto var_type = [&](const sem::Variable* var) {
|
||||
switch (var->AddressSpace()) {
|
||||
case ast::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kStorage:
|
||||
return "read_write storage buffer ";
|
||||
case ast::AddressSpace::kWorkgroup:
|
||||
case type::AddressSpace::kWorkgroup:
|
||||
return "workgroup storage variable ";
|
||||
case ast::AddressSpace::kPrivate:
|
||||
case type::AddressSpace::kPrivate:
|
||||
return "module-scope private variable ";
|
||||
default:
|
||||
return "";
|
||||
|
@ -5305,7 +5305,7 @@ TEST_F(UniformityAnalysisTest, MaximumNumberOfPointerParameters) {
|
||||
foo_body.Push(b.Decl(b.Let("rhs", rhs_init)));
|
||||
for (int i = 0; i < 255; i++) {
|
||||
params.Push(
|
||||
b.Param("p" + std::to_string(i), ty.pointer(ty.i32(), ast::AddressSpace::kFunction)));
|
||||
b.Param("p" + std::to_string(i), ty.pointer(ty.i32(), type::AddressSpace::kFunction)));
|
||||
if (i > 0) {
|
||||
foo_body.Push(b.Assign(b.Deref("p" + std::to_string(i)), "rhs"));
|
||||
}
|
||||
@ -5324,7 +5324,7 @@ TEST_F(UniformityAnalysisTest, MaximumNumberOfPointerParameters) {
|
||||
// workgroupBarrier();
|
||||
// }
|
||||
// }
|
||||
b.GlobalVar("non_uniform_global", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("non_uniform_global", ty.i32(), type::AddressSpace::kPrivate);
|
||||
utils::Vector<const ast::Statement*, 8> main_body;
|
||||
utils::Vector<const ast::Expression*, 8> args;
|
||||
for (int i = 0; i < 255; i++) {
|
||||
@ -7850,7 +7850,7 @@ TEST_F(UniformityAnalysisTest, StressGraphTraversalDepth) {
|
||||
// workgroupBarrier();
|
||||
// }
|
||||
// }
|
||||
b.GlobalVar("v0", ty.i32(), ast::AddressSpace::kPrivate, b.Expr(0_i));
|
||||
b.GlobalVar("v0", ty.i32(), type::AddressSpace::kPrivate, b.Expr(0_i));
|
||||
utils::Vector<const ast::Statement*, 8> foo_body;
|
||||
std::string v_last = "v0";
|
||||
for (int i = 1; i < 100000; i++) {
|
||||
|
@ -62,8 +62,8 @@ class FakeExpr final : public Castable<FakeExpr, ast::Expression> {
|
||||
};
|
||||
|
||||
TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) {
|
||||
GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("dst", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
|
||||
GlobalVar("dst", ty.vec4<f32>(), type::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 @@ TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInFragmentStage) {
|
||||
// f1();
|
||||
//}
|
||||
|
||||
GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), ast::AddressSpace::kWorkgroup);
|
||||
GlobalVar("dst", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar(Source{{1, 2}}, "wg", ty.vec4<f32>(), type::AddressSpace::kWorkgroup);
|
||||
GlobalVar("dst", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg"));
|
||||
|
||||
Func(Source{{5, 6}}, "f2", utils::Empty, ty.void_(), utils::Vector{stmt});
|
||||
@ -234,7 +234,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariable_Pass) {
|
||||
// return;
|
||||
// }
|
||||
|
||||
GlobalVar("global_var", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
GlobalVar("global_var", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
|
||||
Func("my_func", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -308,7 +308,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableDifferentScope_Fail) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) {
|
||||
auto* var = Var("var", ty.i32(), ast::AddressSpace::kWorkgroup);
|
||||
auto* var = Var("var", ty.i32(), type::AddressSpace::kWorkgroup);
|
||||
|
||||
Func("func", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -322,7 +322,7 @@ TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableWorkgroupClass) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) {
|
||||
auto* var = Var("s", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* var = Var("s", ty.i32(), type::AddressSpace::kPrivate);
|
||||
|
||||
Func("func", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -337,7 +337,7 @@ TEST_F(ResolverValidationTest, AddressSpace_FunctionVariableI32) {
|
||||
|
||||
TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) {
|
||||
auto* t = ty.sampler(ast::SamplerKind::kSampler);
|
||||
GlobalVar(Source{{12, 34}}, "var", t, ast::AddressSpace::kHandle, Binding(0_a), Group(0_a));
|
||||
GlobalVar(Source{{12, 34}}, "var", t, type::AddressSpace::kHandle, Binding(0_a), Group(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
|
||||
@ -347,7 +347,7 @@ TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) {
|
||||
|
||||
TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) {
|
||||
auto* t = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
|
||||
GlobalVar(Source{{12, 34}}, "var", t, ast::AddressSpace::kHandle, Binding(0_a), Group(0_a));
|
||||
GlobalVar(Source{{12, 34}}, "var", t, type::AddressSpace::kHandle, Binding(0_a), Group(0_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve()) << r()->error();
|
||||
|
||||
@ -356,7 +356,7 @@ TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) {
|
||||
GlobalVar("my_vec", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* ident = Expr(Source{{{3, 3}, {3, 7}}}, "xyqz");
|
||||
|
||||
@ -368,7 +368,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadChar) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_MixedChars) {
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* ident = Expr(Source{{{3, 3}, {3, 7}}}, "rgyw");
|
||||
|
||||
@ -381,7 +381,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_MixedChars) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) {
|
||||
GlobalVar("my_vec", ty.vec3<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec3<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* ident = Expr(Source{{{3, 3}, {3, 8}}}, "zzzzz");
|
||||
auto* mem = MemberAccessor("my_vec", ident);
|
||||
@ -392,7 +392,7 @@ TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadLength) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverValidationTest, Expr_MemberAccessor_VectorSwizzle_BadIndex) {
|
||||
GlobalVar("my_vec", ty.vec2<f32>(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("my_vec", ty.vec2<f32>(), type::AddressSpace::kPrivate);
|
||||
|
||||
auto* ident = Expr(Source{{3, 3}}, "z");
|
||||
auto* mem = MemberAccessor("my_vec", ident);
|
||||
@ -425,7 +425,7 @@ TEST_F(ResolverValidationTest, EXpr_MemberAccessor_FuncGoodParent) {
|
||||
// let x: f32 = (*p).z;
|
||||
// return x;
|
||||
// }
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction));
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
|
||||
auto* star_p = Deref(p);
|
||||
auto* z = Expr("z");
|
||||
auto* accessor_expr = MemberAccessor(star_p, z);
|
||||
@ -443,7 +443,7 @@ TEST_F(ResolverValidationTest, EXpr_MemberAccessor_FuncBadParent) {
|
||||
// let x: f32 = *p.z;
|
||||
// return x;
|
||||
// }
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::AddressSpace::kFunction));
|
||||
auto* p = Param("p", ty.pointer(ty.vec4<f32>(), type::AddressSpace::kFunction));
|
||||
auto* z = Expr(Source{{12, 34}}, "z");
|
||||
auto* accessor_expr = MemberAccessor(p, z);
|
||||
auto* star_p = Deref(accessor_expr);
|
||||
@ -1277,8 +1277,8 @@ TEST_F(ResolverValidationTest, OffsetAndAlignAndSizeAttribute) {
|
||||
TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) {
|
||||
auto* vf = Var("vf", ty.f32());
|
||||
auto* c =
|
||||
Construct(Source{{12, 34}}, ty.pointer<i32>(ast::AddressSpace::kFunction), ExprList(vf));
|
||||
auto* ip = Let("ip", ty.pointer<i32>(ast::AddressSpace::kFunction), c);
|
||||
Construct(Source{{12, 34}}, ty.pointer<i32>(type::AddressSpace::kFunction), ExprList(vf));
|
||||
auto* ip = Let("ip", ty.pointer<i32>(type::AddressSpace::kFunction), c);
|
||||
WrapInFunction(Decl(vf), Decl(ip));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -1286,21 +1286,21 @@ TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) {
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, I32_Overflow) {
|
||||
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a));
|
||||
GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:24 error: value 2147483648 cannot be represented as 'i32'");
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, I32_Underflow) {
|
||||
GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, -2147483649_a));
|
||||
GlobalVar("v", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, -2147483649_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:24 error: value -2147483649 cannot be represented as 'i32'");
|
||||
}
|
||||
|
||||
TEST_F(ResolverTest, U32_Overflow) {
|
||||
GlobalVar("v", ty.u32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a));
|
||||
GlobalVar("v", ty.u32(), type::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), "12:24 error: value 4294967296 cannot be represented as 'u32'");
|
||||
|
@ -273,7 +273,7 @@ bool Validator::Atomic(const ast::Atomic* a, const type::Atomic* s) const {
|
||||
}
|
||||
|
||||
bool Validator::Pointer(const ast::Pointer* a, const type::Pointer* s) const {
|
||||
if (s->AddressSpace() == ast::AddressSpace::kUndefined) {
|
||||
if (s->AddressSpace() == type::AddressSpace::kUndefined) {
|
||||
AddError("ptr missing address space", a->source);
|
||||
return false;
|
||||
}
|
||||
@ -283,7 +283,7 @@ bool Validator::Pointer(const ast::Pointer* a, const type::Pointer* s) const {
|
||||
// When writing a variable declaration or a pointer type in WGSL source:
|
||||
// * For the storage address space, the access mode is optional, and defaults to read.
|
||||
// * For other address spaces, the access mode must not be written.
|
||||
if (a->address_space != ast::AddressSpace::kStorage) {
|
||||
if (a->address_space != type::AddressSpace::kStorage) {
|
||||
AddError("only pointers in <storage> address space may declare an access mode",
|
||||
a->source);
|
||||
return false;
|
||||
@ -358,7 +358,7 @@ bool Validator::Materialize(const type::Type* to,
|
||||
}
|
||||
|
||||
bool Validator::VariableInitializer(const ast::Variable* v,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
const type::Type* storage_ty,
|
||||
const sem::Expression* initializer) const {
|
||||
auto* initializer_ty = initializer->Type();
|
||||
@ -375,8 +375,8 @@ bool Validator::VariableInitializer(const ast::Variable* v,
|
||||
|
||||
if (v->Is<ast::Var>()) {
|
||||
switch (address_space) {
|
||||
case ast::AddressSpace::kPrivate:
|
||||
case ast::AddressSpace::kFunction:
|
||||
case type::AddressSpace::kPrivate:
|
||||
case type::AddressSpace::kFunction:
|
||||
break; // Allowed an initializer
|
||||
default:
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#var-and-let
|
||||
@ -394,17 +394,17 @@ bool Validator::VariableInitializer(const ast::Variable* v,
|
||||
}
|
||||
|
||||
bool Validator::AddressSpaceLayout(const type::Type* store_ty,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
Source source) const {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class-layout-constraints
|
||||
|
||||
auto is_uniform_struct_or_array = [address_space](const type::Type* ty) {
|
||||
return address_space == ast::AddressSpace::kUniform &&
|
||||
return address_space == type::AddressSpace::kUniform &&
|
||||
ty->IsAnyOf<type::Array, sem::Struct>();
|
||||
};
|
||||
|
||||
auto is_uniform_struct = [address_space](const type::Type* ty) {
|
||||
return address_space == ast::AddressSpace::kUniform && ty->Is<sem::Struct>();
|
||||
return address_space == type::AddressSpace::kUniform && ty->Is<sem::Struct>();
|
||||
};
|
||||
|
||||
auto required_alignment_of = [&](const type::Type* ty) {
|
||||
@ -425,7 +425,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!ast::IsHostShareable(address_space)) {
|
||||
if (!type::IsHostShareable(address_space)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -438,7 +438,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
|
||||
// Among three host-shareable address spaces, f16 is supported in "uniform" and
|
||||
// "storage" address space, but not "push_constant" address space yet.
|
||||
if (Is<type::F16>(type::Type::DeepestElementOf(store_ty)) &&
|
||||
address_space == ast::AddressSpace::kPushConstant) {
|
||||
address_space == type::AddressSpace::kPushConstant) {
|
||||
AddError("using f16 types in 'push_constant' address space is not implemented yet", source);
|
||||
return false;
|
||||
}
|
||||
@ -515,7 +515,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
|
||||
return false;
|
||||
}
|
||||
|
||||
if (address_space == ast::AddressSpace::kUniform) {
|
||||
if (address_space == type::AddressSpace::kUniform) {
|
||||
// We already validated that this array member is itself aligned to 16 bytes above, so
|
||||
// we only need to validate that stride is a multiple of 16 bytes.
|
||||
if (arr->Stride() % 16 != 0) {
|
||||
@ -581,7 +581,7 @@ bool Validator::GlobalVariable(
|
||||
const sem::GlobalVariable* global,
|
||||
const utils::Hashmap<OverrideId, const sem::Variable*, 8>& override_ids) const {
|
||||
auto* decl = global->Declaration();
|
||||
if (global->AddressSpace() != ast::AddressSpace::kWorkgroup &&
|
||||
if (global->AddressSpace() != type::AddressSpace::kWorkgroup &&
|
||||
IsArrayWithOverrideCount(global->Type())) {
|
||||
RaiseArrayWithOverrideCountError(decl->type ? decl->type->source
|
||||
: decl->initializer->source);
|
||||
@ -597,7 +597,7 @@ bool Validator::GlobalVariable(
|
||||
return false;
|
||||
}
|
||||
|
||||
if (global->AddressSpace() == ast::AddressSpace::kNone) {
|
||||
if (global->AddressSpace() == type::AddressSpace::kNone) {
|
||||
AddError("module-scope 'var' declaration must have a address space", decl->source);
|
||||
return false;
|
||||
}
|
||||
@ -606,8 +606,8 @@ bool Validator::GlobalVariable(
|
||||
bool is_shader_io_attribute =
|
||||
attr->IsAnyOf<ast::BuiltinAttribute, ast::InterpolateAttribute,
|
||||
ast::InvariantAttribute, ast::LocationAttribute>();
|
||||
bool has_io_address_space = global->AddressSpace() == ast::AddressSpace::kIn ||
|
||||
global->AddressSpace() == ast::AddressSpace::kOut;
|
||||
bool has_io_address_space = global->AddressSpace() == type::AddressSpace::kIn ||
|
||||
global->AddressSpace() == type::AddressSpace::kOut;
|
||||
if (!attr->IsAnyOf<ast::BindingAttribute, ast::GroupAttribute,
|
||||
ast::InternalAttribute>() &&
|
||||
(!is_shader_io_attribute || !has_io_address_space)) {
|
||||
@ -639,15 +639,15 @@ bool Validator::GlobalVariable(
|
||||
return false;
|
||||
}
|
||||
|
||||
if (global->AddressSpace() == ast::AddressSpace::kFunction) {
|
||||
if (global->AddressSpace() == type::AddressSpace::kFunction) {
|
||||
AddError("module-scope 'var' must not use address space 'function'", decl->source);
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (global->AddressSpace()) {
|
||||
case ast::AddressSpace::kUniform:
|
||||
case ast::AddressSpace::kStorage:
|
||||
case ast::AddressSpace::kHandle: {
|
||||
case type::AddressSpace::kUniform:
|
||||
case type::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kHandle: {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#resource-interface
|
||||
// Each resource variable must be declared with both group and binding attributes.
|
||||
if (!decl->HasBindingPoint()) {
|
||||
@ -682,7 +682,7 @@ bool Validator::Var(const sem::Variable* v) const {
|
||||
}
|
||||
|
||||
if (store_ty->is_handle()) {
|
||||
if (var->declared_address_space != ast::AddressSpace::kNone) {
|
||||
if (var->declared_address_space != type::AddressSpace::kNone) {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
|
||||
// If the store type is a texture type or a sampler type, then the variable declaration
|
||||
// must not have a address space attribute. The address space will always be handle.
|
||||
@ -698,7 +698,7 @@ bool Validator::Var(const sem::Variable* v) const {
|
||||
// When writing a variable declaration or a pointer type in WGSL source:
|
||||
// * For the storage address space, the access mode is optional, and defaults to read.
|
||||
// * For other address spaces, the access mode must not be written.
|
||||
if (var->declared_address_space != ast::AddressSpace::kStorage) {
|
||||
if (var->declared_address_space != type::AddressSpace::kStorage) {
|
||||
AddError("only variables in <storage> address space may declare an access mode",
|
||||
var->source);
|
||||
return false;
|
||||
@ -711,8 +711,8 @@ bool Validator::Var(const sem::Variable* v) const {
|
||||
}
|
||||
|
||||
if (IsValidationEnabled(var->attributes, ast::DisabledValidation::kIgnoreAddressSpace) &&
|
||||
(var->declared_address_space == ast::AddressSpace::kIn ||
|
||||
var->declared_address_space == ast::AddressSpace::kOut)) {
|
||||
(var->declared_address_space == type::AddressSpace::kIn ||
|
||||
var->declared_address_space == type::AddressSpace::kOut)) {
|
||||
AddError("invalid use of input/output address space", var->source);
|
||||
return false;
|
||||
}
|
||||
@ -806,13 +806,13 @@ bool Validator::Parameter(const ast::Function* func, const sem::Variable* var) c
|
||||
|
||||
auto sc = ref->AddressSpace();
|
||||
switch (sc) {
|
||||
case ast::AddressSpace::kFunction:
|
||||
case ast::AddressSpace::kPrivate:
|
||||
case type::AddressSpace::kFunction:
|
||||
case type::AddressSpace::kPrivate:
|
||||
ok = true;
|
||||
break;
|
||||
case ast::AddressSpace::kStorage:
|
||||
case ast::AddressSpace::kUniform:
|
||||
case ast::AddressSpace::kWorkgroup:
|
||||
case type::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kUniform:
|
||||
case type::AddressSpace::kWorkgroup:
|
||||
ok = enabled_extensions_.Contains(
|
||||
ast::Extension::kChromiumExperimentalFullPtrParameters);
|
||||
break;
|
||||
@ -1863,7 +1863,7 @@ bool Validator::PipelineStages(utils::VectorRef<sem::Function*> entry_points) co
|
||||
auto stage = entry_point->Declaration()->PipelineStage();
|
||||
if (stage != ast::PipelineStage::kCompute) {
|
||||
for (auto* var : func->DirectlyReferencedGlobals()) {
|
||||
if (var->AddressSpace() == ast::AddressSpace::kWorkgroup) {
|
||||
if (var->AddressSpace() == type::AddressSpace::kWorkgroup) {
|
||||
std::stringstream stage_name;
|
||||
stage_name << stage;
|
||||
for (auto* user : var->Users()) {
|
||||
@ -1949,7 +1949,7 @@ bool Validator::PushConstants(utils::VectorRef<sem::Function*> entry_points) con
|
||||
|
||||
auto check_push_constant = [&](const sem::Function* func, const sem::Function* ep) {
|
||||
for (auto* var : func->DirectlyReferencedGlobals()) {
|
||||
if (var->AddressSpace() != ast::AddressSpace::kPushConstant ||
|
||||
if (var->AddressSpace() != type::AddressSpace::kPushConstant ||
|
||||
var == push_constant_var) {
|
||||
continue;
|
||||
}
|
||||
@ -2455,14 +2455,14 @@ std::string Validator::VectorPretty(uint32_t size, const type::Type* element_typ
|
||||
bool Validator::CheckTypeAccessAddressSpace(
|
||||
const type::Type* store_ty,
|
||||
ast::Access access,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
utils::VectorRef<const tint::ast::Attribute*> attributes,
|
||||
const Source& source) const {
|
||||
if (!AddressSpaceLayout(store_ty, address_space, source)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (address_space == ast::AddressSpace::kPushConstant &&
|
||||
if (address_space == type::AddressSpace::kPushConstant &&
|
||||
!enabled_extensions_.Contains(ast::Extension::kChromiumExperimentalPushConstant) &&
|
||||
IsValidationEnabled(attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
|
||||
AddError(
|
||||
@ -2472,7 +2472,7 @@ bool Validator::CheckTypeAccessAddressSpace(
|
||||
return false;
|
||||
}
|
||||
|
||||
if (address_space == ast::AddressSpace::kStorage && access == ast::Access::kWrite) {
|
||||
if (address_space == type::AddressSpace::kStorage && access == ast::Access::kWrite) {
|
||||
// The access mode for the storage address space can only be 'read' or
|
||||
// 'read_write'.
|
||||
AddError("access mode 'write' is not valid for the 'storage' address space", source);
|
||||
@ -2480,11 +2480,11 @@ bool Validator::CheckTypeAccessAddressSpace(
|
||||
}
|
||||
|
||||
auto atomic_error = [&]() -> const char* {
|
||||
if (address_space != ast::AddressSpace::kStorage &&
|
||||
address_space != ast::AddressSpace::kWorkgroup) {
|
||||
if (address_space != type::AddressSpace::kStorage &&
|
||||
address_space != type::AddressSpace::kWorkgroup) {
|
||||
return "atomic variables must have <storage> or <workgroup> address space";
|
||||
}
|
||||
if (address_space == ast::AddressSpace::kStorage && access != ast::Access::kReadWrite) {
|
||||
if (address_space == type::AddressSpace::kStorage && access != ast::Access::kReadWrite) {
|
||||
return "atomic variables in <storage> address space must have read_write access "
|
||||
"mode";
|
||||
}
|
||||
|
@ -74,7 +74,7 @@ struct TypeAndAddressSpace {
|
||||
/// The type
|
||||
const type::Type* type;
|
||||
/// The address space
|
||||
ast::AddressSpace address_space;
|
||||
type::AddressSpace address_space;
|
||||
|
||||
/// Equality operator
|
||||
/// @param other the other TypeAndAddressSpace to compare this TypeAndAddressSpace to
|
||||
@ -418,7 +418,7 @@ class Validator {
|
||||
/// @param initializer the RHS initializer expression
|
||||
/// @returns true on succes, false otherwise
|
||||
bool VariableInitializer(const ast::Variable* v,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
const type::Type* storage_type,
|
||||
const sem::Expression* initializer) const;
|
||||
|
||||
@ -464,7 +464,7 @@ class Validator {
|
||||
/// @param sc the address space
|
||||
/// @param source the source of the type
|
||||
/// @returns true on success, false otherwise
|
||||
bool AddressSpaceLayout(const type::Type* type, ast::AddressSpace sc, Source source) const;
|
||||
bool AddressSpaceLayout(const type::Type* type, type::AddressSpace sc, Source source) const;
|
||||
|
||||
/// @returns true if the attribute list contains a
|
||||
/// ast::DisableValidationAttribute with the validation mode equal to
|
||||
@ -519,7 +519,7 @@ class Validator {
|
||||
/// @returns true on success, false if an error was raised.
|
||||
bool CheckTypeAccessAddressSpace(const type::Type* store_ty,
|
||||
ast::Access access,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
utils::VectorRef<const tint::ast::Attribute*> attributes,
|
||||
const Source& source) const;
|
||||
SymbolTable& symbols_;
|
||||
|
@ -78,7 +78,7 @@ TEST_F(ValidatorIsStorableTest, Matrix) {
|
||||
}
|
||||
|
||||
TEST_F(ValidatorIsStorableTest, Pointer) {
|
||||
auto* ptr = create<type::Pointer>(create<type::I32>(), ast::AddressSpace::kPrivate,
|
||||
auto* ptr = create<type::Pointer>(create<type::I32>(), type::AddressSpace::kPrivate,
|
||||
ast::Access::kReadWrite);
|
||||
EXPECT_FALSE(v()->IsStorable(ptr));
|
||||
}
|
||||
|
@ -238,7 +238,7 @@ TEST_F(ResolverVariableTest, LocalVar_ShadowsGlobalVar) {
|
||||
// var a = a;
|
||||
// }
|
||||
|
||||
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* v = Var("a", Expr("a"));
|
||||
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(v)});
|
||||
|
||||
@ -421,7 +421,7 @@ TEST_F(ResolverVariableTest, LocalLet) {
|
||||
auto* b = Let("b", ty.bool_(), b_c);
|
||||
auto* s = Let("s", ty.Of(S), s_c);
|
||||
auto* a = Let("a", ty.Of(A), a_c);
|
||||
auto* p = Let("p", ty.pointer<i32>(ast::AddressSpace::kFunction), p_c);
|
||||
auto* p = Let("p", ty.pointer<i32>(type::AddressSpace::kFunction), p_c);
|
||||
|
||||
Func("F", utils::Empty, ty.void_(),
|
||||
utils::Vector{
|
||||
@ -472,8 +472,8 @@ TEST_F(ResolverVariableTest, LocalLet_InheritsAccessFromOriginatingVariable) {
|
||||
// }
|
||||
auto* inner = Structure("Inner", utils::Vector{Member("arr", ty.array<i32, 4>())});
|
||||
auto* buf = Structure("S", utils::Vector{Member("inner", ty.Of(inner))});
|
||||
auto* storage = GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
Binding(0_a), Group(0_a));
|
||||
auto* storage = GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(0_a), Group(0_a));
|
||||
|
||||
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 3_i);
|
||||
auto* ptr = Let("p", AddressOf(expr));
|
||||
@ -554,7 +554,7 @@ TEST_F(ResolverVariableTest, LocalLet_ShadowsGlobalVar) {
|
||||
// let a = a;
|
||||
// }
|
||||
|
||||
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* l = Let("a", Expr("a"));
|
||||
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(l)});
|
||||
|
||||
@ -766,7 +766,7 @@ TEST_F(ResolverVariableTest, LocalConst_ShadowsGlobalVar) {
|
||||
// const a = 1i;
|
||||
// }
|
||||
|
||||
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* c = Const("a", Expr(1_i));
|
||||
Func("F", utils::Empty, ty.void_(), utils::Vector{Decl(c)});
|
||||
|
||||
@ -1037,12 +1037,12 @@ TEST_F(ResolverVariableTest, GlobalVar_AddressSpace) {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class
|
||||
|
||||
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
|
||||
auto* private_ = GlobalVar("p", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* workgroup = GlobalVar("w", ty.i32(), ast::AddressSpace::kWorkgroup);
|
||||
auto* private_ = GlobalVar("p", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* workgroup = GlobalVar("w", ty.i32(), type::AddressSpace::kWorkgroup);
|
||||
auto* uniform =
|
||||
GlobalVar("ub", ty.Of(buf), ast::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
GlobalVar("ub", ty.Of(buf), type::AddressSpace::kUniform, Binding(0_a), Group(0_a));
|
||||
auto* storage =
|
||||
GlobalVar("sb", ty.Of(buf), ast::AddressSpace::kStorage, Binding(1_a), Group(0_a));
|
||||
GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage, Binding(1_a), Group(0_a));
|
||||
auto* handle =
|
||||
GlobalVar("h", ty.depth_texture(type::TextureDimension::k2d), Binding(2_a), Group(0_a));
|
||||
|
||||
@ -1065,7 +1065,7 @@ TEST_F(ResolverVariableTest, GlobalVar_ExplicitAddressSpace) {
|
||||
// https://gpuweb.github.io/gpuweb/wgsl/#storage-class
|
||||
|
||||
auto* buf = Structure("S", utils::Vector{Member("m", ty.i32())});
|
||||
auto* storage = GlobalVar("sb", ty.Of(buf), ast::AddressSpace::kStorage,
|
||||
auto* storage = GlobalVar("sb", ty.Of(buf), type::AddressSpace::kStorage,
|
||||
ast::Access::kReadWrite, Binding(1_a), Group(0_a));
|
||||
|
||||
ASSERT_TRUE(r()->Resolve()) << r()->error();
|
||||
@ -1222,7 +1222,7 @@ TEST_F(ResolverVariableTest, Param_ShadowsGlobalVar) {
|
||||
// fn F(a : bool) {
|
||||
// }
|
||||
|
||||
auto* g = GlobalVar("a", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
auto* g = GlobalVar("a", ty.i32(), type::AddressSpace::kPrivate);
|
||||
auto* p = Param("a", ty.bool_());
|
||||
Func("F", utils::Vector{p}, ty.void_(), utils::Empty);
|
||||
|
||||
|
@ -61,8 +61,8 @@ TEST_F(ResolverVariableValidationTest, GlobalVarInitializerNoReturnValueBuiltin)
|
||||
TEST_F(ResolverVariableValidationTest, GlobalVarUsedAtModuleScope) {
|
||||
// var<private> a : i32;
|
||||
// var<private> b : i32 = a;
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), ast::AddressSpace::kPrivate);
|
||||
GlobalVar("b", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a"));
|
||||
GlobalVar(Source{{12, 34}}, "a", ty.i32(), type::AddressSpace::kPrivate);
|
||||
GlobalVar("b", ty.i32(), type::AddressSpace::kPrivate, Expr(Source{{56, 78}}, "a"));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(), R"(56:78 error: var 'a' cannot be referenced at module-scope
|
||||
@ -112,8 +112,8 @@ TEST_F(ResolverVariableValidationTest, VarTypeNotConstructible) {
|
||||
// var i : i32;
|
||||
// var p : pointer<function, i32> = &v;
|
||||
auto* i = Var("i", ty.i32());
|
||||
auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, ast::AddressSpace::kFunction),
|
||||
ast::AddressSpace::kNone, AddressOf(Source{{12, 34}}, "i"));
|
||||
auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, type::AddressSpace::kFunction),
|
||||
type::AddressSpace::kNone, AddressOf(Source{{12, 34}}, "i"));
|
||||
WrapInFunction(i, p);
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
@ -205,7 +205,7 @@ TEST_F(ResolverVariableValidationTest, VarInitializerWrongTypeViaAlias) {
|
||||
TEST_F(ResolverVariableValidationTest, LetOfPtrConstructedWithRef) {
|
||||
// var a : f32;
|
||||
// let b : ptr<function,f32> = a;
|
||||
const auto priv = ast::AddressSpace::kFunction;
|
||||
const auto priv = type::AddressSpace::kFunction;
|
||||
auto* var_a = Var("a", ty.f32(), priv);
|
||||
auto* var_b = Let(Source{{12, 34}}, "b", ty.pointer<f32>(priv), Expr("a"));
|
||||
WrapInFunction(var_a, var_b);
|
||||
@ -236,7 +236,7 @@ TEST_F(ResolverVariableValidationTest, GlobalVarRedeclaredAsLocal) {
|
||||
// return 0;
|
||||
// }
|
||||
|
||||
GlobalVar("v", ty.f32(), ast::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
GlobalVar("v", ty.f32(), type::AddressSpace::kPrivate, Expr(2.1_f));
|
||||
|
||||
WrapInFunction(Var(Source{{12, 34}}, "v", ty.f32(), Expr(2_f)));
|
||||
|
||||
@ -295,12 +295,12 @@ TEST_F(ResolverVariableValidationTest, InferredPtrStorageAccessMismatch) {
|
||||
Member("inner", ty.Of(inner)),
|
||||
});
|
||||
auto* storage =
|
||||
GlobalVar("s", ty.Of(buf), ast::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
GlobalVar("s", ty.Of(buf), type::AddressSpace::kStorage, Binding(0_a), Group(0_a));
|
||||
|
||||
auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i);
|
||||
auto* ptr =
|
||||
Let(Source{{12, 34}}, "p",
|
||||
ty.pointer<i32>(ast::AddressSpace::kStorage, ast::Access::kReadWrite), AddressOf(expr));
|
||||
auto* ptr = Let(Source{{12, 34}}, "p",
|
||||
ty.pointer<i32>(type::AddressSpace::kStorage, ast::Access::kReadWrite),
|
||||
AddressOf(expr));
|
||||
|
||||
WrapInFunction(ptr);
|
||||
|
||||
@ -359,7 +359,7 @@ TEST_F(ResolverVariableValidationTest, NonConstructibleType_InferredType) {
|
||||
|
||||
TEST_F(ResolverVariableValidationTest, InvalidAddressSpaceForInitializer) {
|
||||
// var<workgroup> v : f32 = 1.23;
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.f32(), ast::AddressSpace::kWorkgroup, Expr(1.23_f));
|
||||
GlobalVar(Source{{12, 34}}, "v", ty.f32(), type::AddressSpace::kWorkgroup, Expr(1.23_f));
|
||||
|
||||
EXPECT_FALSE(r()->Resolve());
|
||||
EXPECT_EQ(r()->error(),
|
||||
@ -490,7 +490,7 @@ TEST_F(ResolverVariableValidationTest, GlobalVariable_PushConstantWithInitialize
|
||||
// enable chromium_experimental_push_constant;
|
||||
// var<push_constant> a : u32 = 0u;
|
||||
Enable(ast::Extension::kChromiumExperimentalPushConstant);
|
||||
GlobalVar(Source{{1u, 2u}}, "a", ty.u32(), ast::AddressSpace::kPushConstant,
|
||||
GlobalVar(Source{{1u, 2u}}, "a", ty.u32(), type::AddressSpace::kPushConstant,
|
||||
Expr(Source{{3u, 4u}}, u32(0)));
|
||||
|
||||
ASSERT_FALSE(r()->Resolve());
|
||||
|
@ -68,7 +68,7 @@ Function::VariableBindings Function::TransitivelyReferencedUniformVariables() co
|
||||
VariableBindings ret;
|
||||
|
||||
for (auto* global : TransitivelyReferencedGlobals()) {
|
||||
if (global->AddressSpace() != ast::AddressSpace::kUniform) {
|
||||
if (global->AddressSpace() != type::AddressSpace::kUniform) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -83,7 +83,7 @@ Function::VariableBindings Function::TransitivelyReferencedStorageBufferVariable
|
||||
VariableBindings ret;
|
||||
|
||||
for (auto* global : TransitivelyReferencedGlobals()) {
|
||||
if (global->AddressSpace() != ast::AddressSpace::kStorage) {
|
||||
if (global->AddressSpace() != type::AddressSpace::kStorage) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -17,9 +17,9 @@
|
||||
|
||||
#include <optional>
|
||||
|
||||
#include "src/tint/ast/address_space.h"
|
||||
#include "src/tint/ast/struct.h"
|
||||
#include "src/tint/symbol.h"
|
||||
#include "src/tint/type/address_space.h"
|
||||
#include "src/tint/type/struct.h"
|
||||
#include "src/tint/type/type.h"
|
||||
#include "src/tint/utils/vector.h"
|
||||
|
@ -31,7 +31,7 @@ namespace tint::sem {
|
||||
Variable::Variable(const ast::Variable* declaration,
|
||||
const type::Type* type,
|
||||
EvaluationStage stage,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const constant::Value* constant_value)
|
||||
: declaration_(declaration),
|
||||
@ -46,7 +46,7 @@ Variable::~Variable() = default;
|
||||
LocalVariable::LocalVariable(const ast::Variable* declaration,
|
||||
const type::Type* type,
|
||||
EvaluationStage stage,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const sem::Statement* statement,
|
||||
const constant::Value* constant_value)
|
||||
@ -58,7 +58,7 @@ LocalVariable::~LocalVariable() = default;
|
||||
GlobalVariable::GlobalVariable(const ast::Variable* declaration,
|
||||
const type::Type* type,
|
||||
EvaluationStage stage,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const constant::Value* constant_value,
|
||||
sem::BindingPoint binding_point,
|
||||
@ -72,7 +72,7 @@ GlobalVariable::~GlobalVariable() = default;
|
||||
Parameter::Parameter(const ast::Parameter* declaration,
|
||||
uint32_t index,
|
||||
const type::Type* type,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const ParameterUsage usage /* = ParameterUsage::kNone */,
|
||||
sem::BindingPoint binding_point /* = {} */,
|
||||
|
@ -22,11 +22,11 @@
|
||||
#include "tint/override_id.h"
|
||||
|
||||
#include "src/tint/ast/access.h"
|
||||
#include "src/tint/ast/address_space.h"
|
||||
#include "src/tint/ast/parameter.h"
|
||||
#include "src/tint/sem/binding_point.h"
|
||||
#include "src/tint/sem/expression.h"
|
||||
#include "src/tint/sem/parameter_usage.h"
|
||||
#include "src/tint/type/address_space.h"
|
||||
#include "src/tint/type/type.h"
|
||||
#include "src/tint/utils/unique_vector.h"
|
||||
|
||||
@ -57,7 +57,7 @@ class Variable : public Castable<Variable, Node> {
|
||||
Variable(const ast::Variable* declaration,
|
||||
const type::Type* type,
|
||||
EvaluationStage stage,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const constant::Value* constant_value);
|
||||
|
||||
@ -74,7 +74,7 @@ class Variable : public Castable<Variable, Node> {
|
||||
EvaluationStage Stage() const { return stage_; }
|
||||
|
||||
/// @returns the address space for the variable
|
||||
ast::AddressSpace AddressSpace() const { return address_space_; }
|
||||
type::AddressSpace AddressSpace() const { return address_space_; }
|
||||
|
||||
/// @returns the access control for the variable
|
||||
ast::Access Access() const { return access_; }
|
||||
@ -100,7 +100,7 @@ class Variable : public Castable<Variable, Node> {
|
||||
const ast::Variable* const declaration_;
|
||||
const type::Type* const type_;
|
||||
const EvaluationStage stage_;
|
||||
const ast::AddressSpace address_space_;
|
||||
const type::AddressSpace address_space_;
|
||||
const ast::Access access_;
|
||||
const constant::Value* constant_value_;
|
||||
const Expression* initializer_ = nullptr;
|
||||
@ -121,7 +121,7 @@ class LocalVariable final : public Castable<LocalVariable, Variable> {
|
||||
LocalVariable(const ast::Variable* declaration,
|
||||
const type::Type* type,
|
||||
EvaluationStage stage,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const sem::Statement* statement,
|
||||
const constant::Value* constant_value);
|
||||
@ -162,7 +162,7 @@ class GlobalVariable final : public Castable<GlobalVariable, Variable> {
|
||||
GlobalVariable(const ast::Variable* declaration,
|
||||
const type::Type* type,
|
||||
EvaluationStage stage,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const constant::Value* constant_value,
|
||||
sem::BindingPoint binding_point = {},
|
||||
@ -205,7 +205,7 @@ class Parameter final : public Castable<Parameter, Variable> {
|
||||
Parameter(const ast::Parameter* declaration,
|
||||
uint32_t index,
|
||||
const type::Type* type,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
ast::Access access,
|
||||
const ParameterUsage usage = ParameterUsage::kNone,
|
||||
sem::BindingPoint binding_point = {},
|
||||
|
@ -47,7 +47,7 @@ Transform::ApplyResult AddBlockAttribute::Apply(const Program* src,
|
||||
bool made_changes = false;
|
||||
for (auto* global : src->AST().GlobalVariables()) {
|
||||
auto* var = sem.Get(global);
|
||||
if (!ast::IsHostShareable(var->AddressSpace())) {
|
||||
if (!type::IsHostShareable(var->AddressSpace())) {
|
||||
// Not declared in a host-sharable address space
|
||||
continue;
|
||||
}
|
||||
|
@ -107,7 +107,7 @@ struct ArrayLengthFromUniform::State {
|
||||
u32((max_buffer_size_index / 4) + 1))),
|
||||
});
|
||||
buffer_size_ubo =
|
||||
b.GlobalVar(b.Sym(), b.ty.Of(buffer_size_struct), ast::AddressSpace::kUniform,
|
||||
b.GlobalVar(b.Sym(), b.ty.Of(buffer_size_struct), type::AddressSpace::kUniform,
|
||||
b.Group(AInt(cfg->ubo_binding.group)),
|
||||
b.Binding(AInt(cfg->ubo_binding.binding)));
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ Transform::ApplyResult BindingRemapper::Apply(const Program* src,
|
||||
return Program(std::move(b));
|
||||
}
|
||||
auto* sem = src->Sem().Get(var);
|
||||
if (sem->AddressSpace() != ast::AddressSpace::kStorage) {
|
||||
if (sem->AddressSpace() != type::AddressSpace::kStorage) {
|
||||
b.Diagnostics().add_error(
|
||||
diag::System::Transform,
|
||||
"cannot apply access control to variable with address space " +
|
||||
|
@ -679,7 +679,7 @@ struct BuiltinPolyfill::State {
|
||||
auto name = b.Symbols().New("tint_workgroupUniformLoad");
|
||||
b.Func(name,
|
||||
utils::Vector{
|
||||
b.Param("p", b.ty.pointer(T(type), ast::AddressSpace::kWorkgroup)),
|
||||
b.Param("p", b.ty.pointer(T(type), type::AddressSpace::kWorkgroup)),
|
||||
},
|
||||
T(type),
|
||||
utils::Vector{
|
||||
|
@ -112,7 +112,7 @@ Transform::ApplyResult CalculateArrayLength::Apply(const Program* src,
|
||||
b.Param("buffer",
|
||||
b.ty.pointer(type, buffer_type->AddressSpace(), buffer_type->Access()),
|
||||
utils::Vector{disable_validation}),
|
||||
b.Param("result", b.ty.pointer(b.ty.u32(), ast::AddressSpace::kFunction)),
|
||||
b.Param("result", b.ty.pointer(b.ty.u32(), type::AddressSpace::kFunction)),
|
||||
},
|
||||
b.ty.void_(), nullptr,
|
||||
utils::Vector{
|
||||
|
@ -234,7 +234,7 @@ struct CanonicalizeEntryPointIO::State {
|
||||
auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attributes);
|
||||
if (cfg.shader_style == ShaderStyle::kGlsl && builtin) {
|
||||
name = GLSLBuiltinToString(builtin->builtin, func_ast->PipelineStage(),
|
||||
ast::AddressSpace::kIn);
|
||||
type::AddressSpace::kIn);
|
||||
}
|
||||
auto symbol = ctx.dst->Symbols().New(name);
|
||||
|
||||
@ -251,7 +251,7 @@ struct CanonicalizeEntryPointIO::State {
|
||||
value = ctx.dst->IndexAccessor(value, 0_i);
|
||||
}
|
||||
}
|
||||
ctx.dst->GlobalVar(symbol, ast_type, ast::AddressSpace::kIn, std::move(attributes));
|
||||
ctx.dst->GlobalVar(symbol, ast_type, type::AddressSpace::kIn, std::move(attributes));
|
||||
return value;
|
||||
} else if (cfg.shader_style == ShaderStyle::kMsl &&
|
||||
ast::HasAttribute<ast::BuiltinAttribute>(attributes)) {
|
||||
@ -300,7 +300,7 @@ struct CanonicalizeEntryPointIO::State {
|
||||
if (cfg.shader_style == ShaderStyle::kGlsl) {
|
||||
if (auto* b = ast::GetAttribute<ast::BuiltinAttribute>(attributes)) {
|
||||
name = GLSLBuiltinToString(b->builtin, func_ast->PipelineStage(),
|
||||
ast::AddressSpace::kOut);
|
||||
type::AddressSpace::kOut);
|
||||
value = ToGLSLBuiltin(b->builtin, value, type);
|
||||
}
|
||||
}
|
||||
@ -530,7 +530,7 @@ struct CanonicalizeEntryPointIO::State {
|
||||
type = ctx.dst->ty.array(type, 1_u);
|
||||
lhs = ctx.dst->IndexAccessor(lhs, 0_i);
|
||||
}
|
||||
ctx.dst->GlobalVar(name, type, ast::AddressSpace::kOut, std::move(attributes));
|
||||
ctx.dst->GlobalVar(name, type, type::AddressSpace::kOut, std::move(attributes));
|
||||
wrapper_body.Push(ctx.dst->Assign(lhs, outval.value));
|
||||
}
|
||||
}
|
||||
@ -674,7 +674,7 @@ struct CanonicalizeEntryPointIO::State {
|
||||
/// @returns the gl_ string corresponding to that builtin
|
||||
const char* GLSLBuiltinToString(ast::BuiltinValue builtin,
|
||||
ast::PipelineStage stage,
|
||||
ast::AddressSpace address_space) {
|
||||
type::AddressSpace address_space) {
|
||||
switch (builtin) {
|
||||
case ast::BuiltinValue::kPosition:
|
||||
switch (stage) {
|
||||
@ -706,7 +706,7 @@ struct CanonicalizeEntryPointIO::State {
|
||||
case ast::BuiltinValue::kSampleIndex:
|
||||
return "gl_SampleID";
|
||||
case ast::BuiltinValue::kSampleMask:
|
||||
if (address_space == ast::AddressSpace::kIn) {
|
||||
if (address_space == type::AddressSpace::kIn) {
|
||||
return "gl_SampleMaskIn";
|
||||
} else {
|
||||
return "gl_SampleMask";
|
||||
|
@ -89,7 +89,7 @@ Transform::ApplyResult ClampFragDepth::Apply(const Program* src, const DataMap&,
|
||||
// Abort on any use of push constants in the module.
|
||||
for (auto* global : src->AST().GlobalVariables()) {
|
||||
if (auto* var = global->As<ast::Var>()) {
|
||||
if (TINT_UNLIKELY(var->declared_address_space == ast::AddressSpace::kPushConstant)) {
|
||||
if (TINT_UNLIKELY(var->declared_address_space == type::AddressSpace::kPushConstant)) {
|
||||
TINT_ICE(Transform, b.Diagnostics())
|
||||
<< "ClampFragDepth doesn't know how to handle module that already use push "
|
||||
"constants.";
|
||||
@ -124,7 +124,7 @@ Transform::ApplyResult ClampFragDepth::Apply(const Program* src, const DataMap&,
|
||||
utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())});
|
||||
|
||||
auto args_sym = b.Symbols().New("frag_depth_clamp_args");
|
||||
b.GlobalVar(args_sym, b.ty.type_name("FragDepthClampArgs"), ast::AddressSpace::kPushConstant);
|
||||
b.GlobalVar(args_sym, b.ty.type_name("FragDepthClampArgs"), type::AddressSpace::kPushConstant);
|
||||
|
||||
auto base_fn_sym = b.Symbols().New("clamp_frag_depth");
|
||||
b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(),
|
||||
|
@ -50,8 +50,8 @@ namespace {
|
||||
bool ShouldRun(const Program* program) {
|
||||
for (auto* decl : program->AST().GlobalDeclarations()) {
|
||||
if (auto* var = program->Sem().Get<sem::Variable>(decl)) {
|
||||
if (var->AddressSpace() == ast::AddressSpace::kStorage ||
|
||||
var->AddressSpace() == ast::AddressSpace::kUniform) {
|
||||
if (var->AddressSpace() == type::AddressSpace::kStorage ||
|
||||
var->AddressSpace() == type::AddressSpace::kUniform) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -109,7 +109,7 @@ struct OffsetBinOp : Offset {
|
||||
|
||||
/// LoadStoreKey is the unordered map key to a load or store intrinsic.
|
||||
struct LoadStoreKey {
|
||||
ast::AddressSpace const address_space; // buffer address space
|
||||
type::AddressSpace const address_space; // buffer address space
|
||||
ast::Access const access; // buffer access
|
||||
type::Type const* buf_ty = nullptr; // buffer type
|
||||
type::Type const* el_ty = nullptr; // element type
|
||||
@ -223,7 +223,7 @@ bool IntrinsicDataTypeFor(const type::Type* ty, DecomposeMemoryAccess::Intrinsic
|
||||
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied
|
||||
/// to a stub function to load the type `ty`.
|
||||
DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
const type::Type* ty) {
|
||||
DecomposeMemoryAccess::Intrinsic::DataType type;
|
||||
if (!IntrinsicDataTypeFor(ty, type)) {
|
||||
@ -237,7 +237,7 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder,
|
||||
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied
|
||||
/// to a stub function to store the type `ty`.
|
||||
DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder,
|
||||
ast::AddressSpace address_space,
|
||||
type::AddressSpace address_space,
|
||||
const type::Type* ty) {
|
||||
DecomposeMemoryAccess::Intrinsic::DataType type;
|
||||
if (!IntrinsicDataTypeFor(ty, type)) {
|
||||
@ -300,7 +300,7 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder,
|
||||
return nullptr;
|
||||
}
|
||||
return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
|
||||
builder->ID(), builder->AllocateNodeID(), op, ast::AddressSpace::kStorage, type);
|
||||
builder->ID(), builder->AllocateNodeID(), op, type::AddressSpace::kStorage, type);
|
||||
}
|
||||
|
||||
/// BufferAccess describes a single storage or uniform buffer access
|
||||
@ -466,7 +466,7 @@ struct DecomposeMemoryAccess::State {
|
||||
const sem::VariableUser* var_user) {
|
||||
auto address_space = var_user->Variable()->AddressSpace();
|
||||
auto access = var_user->Variable()->Access();
|
||||
if (address_space != ast::AddressSpace::kStorage) {
|
||||
if (address_space != type::AddressSpace::kStorage) {
|
||||
access = ast::Access::kUndefined;
|
||||
}
|
||||
return utils::GetOrCreate(
|
||||
@ -565,7 +565,7 @@ struct DecomposeMemoryAccess::State {
|
||||
const sem::VariableUser* var_user) {
|
||||
auto address_space = var_user->Variable()->AddressSpace();
|
||||
auto access = var_user->Variable()->Access();
|
||||
if (address_space != ast::AddressSpace::kStorage) {
|
||||
if (address_space != type::AddressSpace::kStorage) {
|
||||
access = ast::Access::kUndefined;
|
||||
}
|
||||
return utils::GetOrCreate(
|
||||
@ -678,7 +678,7 @@ struct DecomposeMemoryAccess::State {
|
||||
auto op = intrinsic->Type();
|
||||
auto address_space = var_user->Variable()->AddressSpace();
|
||||
auto access = var_user->Variable()->Access();
|
||||
if (address_space != ast::AddressSpace::kStorage) {
|
||||
if (address_space != type::AddressSpace::kStorage) {
|
||||
access = ast::Access::kUndefined;
|
||||
}
|
||||
return utils::GetOrCreate(atomic_funcs, AtomicKey{access, buf_ty, el_ty, op}, [&] {
|
||||
@ -686,7 +686,7 @@ struct DecomposeMemoryAccess::State {
|
||||
// atomic. This is replaced with two parameters: the buffer and offset.
|
||||
utils::Vector params{
|
||||
b.Param("buffer",
|
||||
b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), ast::AddressSpace::kStorage,
|
||||
b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), type::AddressSpace::kStorage,
|
||||
access),
|
||||
utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}),
|
||||
b.Param("offset", b.ty.u32()),
|
||||
@ -744,7 +744,7 @@ struct DecomposeMemoryAccess::State {
|
||||
DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid,
|
||||
ast::NodeID nid,
|
||||
Op o,
|
||||
ast::AddressSpace sc,
|
||||
type::AddressSpace sc,
|
||||
DataType ty)
|
||||
: Base(pid, nid), op(o), address_space(sc), type(ty) {}
|
||||
DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default;
|
||||
@ -883,8 +883,8 @@ Transform::ApplyResult DecomposeMemoryAccess::Apply(const Program* src,
|
||||
// X
|
||||
if (auto* sem_ident = sem.Get(ident)) {
|
||||
if (auto* var = sem_ident->UnwrapLoad()->As<sem::VariableUser>()) {
|
||||
if (var->Variable()->AddressSpace() == ast::AddressSpace::kStorage ||
|
||||
var->Variable()->AddressSpace() == ast::AddressSpace::kUniform) {
|
||||
if (var->Variable()->AddressSpace() == type::AddressSpace::kStorage ||
|
||||
var->Variable()->AddressSpace() == type::AddressSpace::kUniform) {
|
||||
// Variable to a storage or uniform buffer
|
||||
state.AddAccess(ident, {
|
||||
var,
|
||||
|
@ -81,7 +81,7 @@ class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Trans
|
||||
/// @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, ast::AddressSpace sc, DataType ty);
|
||||
Intrinsic(ProgramID pid, ast::NodeID nid, Op o, type::AddressSpace sc, DataType ty);
|
||||
/// Destructor
|
||||
~Intrinsic() override;
|
||||
|
||||
@ -101,7 +101,7 @@ class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Trans
|
||||
const Op op;
|
||||
|
||||
/// The address space of the buffer this intrinsic operates on
|
||||
ast::AddressSpace const address_space;
|
||||
type::AddressSpace const address_space;
|
||||
|
||||
/// The type of the intrinsic
|
||||
const DataType type;
|
||||
|
@ -39,7 +39,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunNonStridedArray) {
|
||||
// var<private> arr : array<f32, 4u>
|
||||
|
||||
ProgramBuilder b;
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(), type::AddressSpace::kPrivate);
|
||||
EXPECT_FALSE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
|
||||
}
|
||||
|
||||
@ -47,7 +47,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunDefaultStridedArray) {
|
||||
// var<private> arr : @stride(4) array<f32, 4u>
|
||||
|
||||
ProgramBuilder b;
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(4), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(4), type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
|
||||
}
|
||||
|
||||
@ -55,7 +55,7 @@ TEST_F(DecomposeStridedArrayTest, ShouldRunExplicitStridedArray) {
|
||||
// var<private> arr : @stride(16) array<f32, 4u>
|
||||
|
||||
ProgramBuilder b;
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(16), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(16), type::AddressSpace::kPrivate);
|
||||
EXPECT_TRUE(ShouldRun<DecomposeStridedArray>(Program(std::move(b))));
|
||||
}
|
||||
|
||||
@ -78,7 +78,7 @@ TEST_F(DecomposeStridedArrayTest, PrivateDefaultStridedArray) {
|
||||
// }
|
||||
|
||||
ProgramBuilder b;
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(4), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(4), type::AddressSpace::kPrivate);
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.array<f32, 4u>(4), b.Expr("arr"))),
|
||||
@ -114,7 +114,7 @@ TEST_F(DecomposeStridedArrayTest, PrivateStridedArray) {
|
||||
// }
|
||||
|
||||
ProgramBuilder b;
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(32), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("arr", b.ty.array<f32, 4u>(32), type::AddressSpace::kPrivate);
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.Expr("arr"))),
|
||||
@ -158,7 +158,7 @@ TEST_F(DecomposeStridedArrayTest, ReadUniformStridedArray) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.MemberAccessor("s", "a"))),
|
||||
@ -206,7 +206,7 @@ TEST_F(DecomposeStridedArrayTest, ReadUniformDefaultStridedArray) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array(b.ty.vec4<f32>(), 4_u, 16))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func(
|
||||
"f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
@ -252,7 +252,7 @@ TEST_F(DecomposeStridedArrayTest, ReadStorageStridedArray) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.array<f32, 4u>(32), b.MemberAccessor("s", "a"))),
|
||||
@ -300,7 +300,7 @@ TEST_F(DecomposeStridedArrayTest, ReadStorageDefaultStridedArray) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(4))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.array<f32, 4u>(4), b.MemberAccessor("s", "a"))),
|
||||
@ -344,8 +344,8 @@ TEST_F(DecomposeStridedArrayTest, WriteStorageStridedArray) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array<f32, 4u>(32))),
|
||||
@ -398,8 +398,8 @@ TEST_F(DecomposeStridedArrayTest, WriteStorageDefaultStridedArray) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(4))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Assign(b.MemberAccessor("s", "a"), b.Construct(b.ty.array<f32, 4u>(4))),
|
||||
@ -450,8 +450,8 @@ TEST_F(DecomposeStridedArrayTest, ReadWriteViaPointerLets) {
|
||||
// }
|
||||
ProgramBuilder b;
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.array<f32, 4u>(32))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "a")))),
|
||||
@ -511,8 +511,8 @@ TEST_F(DecomposeStridedArrayTest, PrivateAliasedStridedArray) {
|
||||
ProgramBuilder b;
|
||||
b.Alias("ARR", b.ty.array<f32, 4u>(32));
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.type_name("ARR"))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.type_name("ARR"), b.MemberAccessor("s", "a"))),
|
||||
@ -581,8 +581,8 @@ TEST_F(DecomposeStridedArrayTest, PrivateNestedStridedArray) {
|
||||
b.ty.array(b.ty.type_name("ARR_A"), 3_u, 16), //
|
||||
4_u, 128));
|
||||
auto* S = b.Structure("S", utils::Vector{b.Member("a", b.ty.type_name("ARR_B"))});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.ty.type_name("ARR_B"), b.MemberAccessor("s", "a"))),
|
||||
|
@ -72,8 +72,8 @@ Transform::ApplyResult DecomposeStridedMatrix::Apply(const Program* src,
|
||||
for (auto* node : src->ASTNodes().Objects()) {
|
||||
if (auto* str = node->As<ast::Struct>()) {
|
||||
auto* str_ty = src->Sem().Get(str);
|
||||
if (!str_ty->UsedAs(ast::AddressSpace::kUniform) &&
|
||||
!str_ty->UsedAs(ast::AddressSpace::kStorage)) {
|
||||
if (!str_ty->UsedAs(type::AddressSpace::kUniform) &&
|
||||
!str_ty->UsedAs(type::AddressSpace::kStorage)) {
|
||||
continue;
|
||||
}
|
||||
for (auto* member : str_ty->Members()) {
|
||||
|
@ -76,7 +76,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformMatrix) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
|
||||
@ -133,7 +133,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformColumn) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func(
|
||||
"f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
@ -187,7 +187,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadUniformMatrix_DefaultStride) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kUniform, b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
|
||||
@ -241,8 +241,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadStorageMatrix) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
|
||||
@ -299,8 +299,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadStorageColumn) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func(
|
||||
"f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
@ -354,8 +354,8 @@ TEST_F(DecomposeStridedMatrixTest, WriteStorageMatrix) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Assign(b.MemberAccessor("s", "m"),
|
||||
@ -413,8 +413,8 @@ TEST_F(DecomposeStridedMatrixTest, WriteStorageColumn) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Assign(b.IndexAccessor(b.MemberAccessor("s", "m"), 1_i), b.vec2<f32>(1_f, 2_f)),
|
||||
@ -473,8 +473,8 @@ TEST_F(DecomposeStridedMatrixTest, ReadWriteViaPointerLets) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kStorage, ast::Access::kReadWrite, b.Group(0_a),
|
||||
b.Binding(0_a));
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kStorage, ast::Access::kReadWrite,
|
||||
b.Group(0_a), b.Binding(0_a));
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("a", b.AddressOf(b.MemberAccessor("s", "m")))),
|
||||
@ -545,7 +545,7 @@ TEST_F(DecomposeStridedMatrixTest, ReadPrivateMatrix) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kPrivate);
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Decl(b.Let("x", b.ty.mat2x2<f32>(), b.MemberAccessor("s", "m"))),
|
||||
@ -599,7 +599,7 @@ TEST_F(DecomposeStridedMatrixTest, WritePrivateMatrix) {
|
||||
b.Disable(ast::DisabledValidation::kIgnoreStrideAttribute),
|
||||
}),
|
||||
});
|
||||
b.GlobalVar("s", b.ty.Of(S), ast::AddressSpace::kPrivate);
|
||||
b.GlobalVar("s", b.ty.Of(S), type::AddressSpace::kPrivate);
|
||||
b.Func("f", utils::Empty, b.ty.void_(),
|
||||
utils::Vector{
|
||||
b.Assign(b.MemberAccessor("s", "m"),
|
||||
|
@ -81,7 +81,7 @@ Transform::ApplyResult DemoteToHelper::Apply(const Program* src, const DataMap&,
|
||||
|
||||
// Create a module-scope flag that indicates whether the current invocation has been discarded.
|
||||
auto flag = b.Symbols().New("tint_discarded");
|
||||
b.GlobalVar(flag, ast::AddressSpace::kPrivate, b.Expr(false));
|
||||
b.GlobalVar(flag, type::AddressSpace::kPrivate, b.Expr(false));
|
||||
|
||||
// Replace all discard statements with a statement that marks the invocation as discarded.
|
||||
ctx.ReplaceAll([&](const ast::DiscardStatement*) -> const ast::Statement* {
|
||||
@ -125,12 +125,12 @@ Transform::ApplyResult DemoteToHelper::Apply(const Program* src, const DataMap&,
|
||||
// Skip writes to invocation-private address spaces.
|
||||
auto* ref = sem.Get(assign->lhs)->Type()->As<type::Reference>();
|
||||
switch (ref->AddressSpace()) {
|
||||
case ast::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kStorage:
|
||||
// Need to mask these.
|
||||
break;
|
||||
case ast::AddressSpace::kFunction:
|
||||
case ast::AddressSpace::kPrivate:
|
||||
case ast::AddressSpace::kOut:
|
||||
case type::AddressSpace::kFunction:
|
||||
case type::AddressSpace::kPrivate:
|
||||
case type::AddressSpace::kOut:
|
||||
// Skip these.
|
||||
return;
|
||||
default:
|
||||
|
@ -50,7 +50,7 @@ struct AccessRoot {
|
||||
/// function-scope variable ('function'), or pointer parameter in the source program.
|
||||
tint::sem::Variable const* variable = nullptr;
|
||||
/// The address space of the variable or pointer type.
|
||||
tint::ast::AddressSpace address_space = tint::ast::AddressSpace::kUndefined;
|
||||
tint::type::AddressSpace address_space = tint::type::AddressSpace::kUndefined;
|
||||
};
|
||||
|
||||
/// Inequality operator for AccessRoot
|
||||
@ -450,7 +450,7 @@ struct DirectVariableAccess::State {
|
||||
Switch(
|
||||
variable->Declaration(),
|
||||
[&](const ast::Var*) {
|
||||
if (variable->AddressSpace() != ast::AddressSpace::kHandle) {
|
||||
if (variable->AddressSpace() != type::AddressSpace::kHandle) {
|
||||
// Start a new access chain for the non-handle 'var' access
|
||||
create_new_chain();
|
||||
}
|
||||
@ -749,15 +749,15 @@ struct DirectVariableAccess::State {
|
||||
|
||||
/// @returns true if the address space @p address_space requires transforming given the
|
||||
/// transform's options.
|
||||
bool AddressSpaceRequiresTransform(ast::AddressSpace address_space) const {
|
||||
bool AddressSpaceRequiresTransform(type::AddressSpace address_space) const {
|
||||
switch (address_space) {
|
||||
case ast::AddressSpace::kUniform:
|
||||
case ast::AddressSpace::kStorage:
|
||||
case ast::AddressSpace::kWorkgroup:
|
||||
case type::AddressSpace::kUniform:
|
||||
case type::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kWorkgroup:
|
||||
return true;
|
||||
case ast::AddressSpace::kPrivate:
|
||||
case type::AddressSpace::kPrivate:
|
||||
return opts.transform_private;
|
||||
case ast::AddressSpace::kFunction:
|
||||
case type::AddressSpace::kFunction:
|
||||
return opts.transform_function;
|
||||
default:
|
||||
return false;
|
||||
@ -1180,9 +1180,9 @@ struct DirectVariableAccess::State {
|
||||
for (auto* param : fn->Parameters()) {
|
||||
if (auto* ptr = param->Type()->As<type::Pointer>()) {
|
||||
switch (ptr->AddressSpace()) {
|
||||
case ast::AddressSpace::kUniform:
|
||||
case ast::AddressSpace::kStorage:
|
||||
case ast::AddressSpace::kWorkgroup:
|
||||
case type::AddressSpace::kUniform:
|
||||
case type::AddressSpace::kStorage:
|
||||
case type::AddressSpace::kWorkgroup:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
@ -1193,8 +1193,8 @@ struct DirectVariableAccess::State {
|
||||
}
|
||||
|
||||
/// @returns true if the given address space is 'private' or 'function'.
|
||||
static bool IsPrivateOrFunction(const ast::AddressSpace sc) {
|
||||
return sc == ast::AddressSpace::kPrivate || sc == ast::AddressSpace::kFunction;
|
||||
static bool IsPrivateOrFunction(const type::AddressSpace sc) {
|
||||
return sc == type::AddressSpace::kPrivate || sc == type::AddressSpace::kFunction;
|
||||
}
|
||||
};
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user