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

Resolver: Add ast -> sem type resolving

Browse Source 
Not currently called (nothing currently attaches ast::Type nodes to the AST), but implements some of the boilerplate that'll be shortly required.

This change also removes a bunch of duplicated enumerators from the sem namespace for their counterpart in the ast namespace.

Bug: tint:724
Change-Id: I0372a9f4eca2f9357ff161e7ec1b67eae1c4c8f6
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/48603
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Ben Clayton
2021-04-21 13:47:12 +00:00
committed by Commit Bot service account
parent a922e65d72
commit fec63b7aa6
62 changed files with 1405 additions and 1591 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/resolver/assignment_validation_test.cc
View File

@@ -256,8 +256,8 @@ TEST_F(ResolverAssignmentValidationTest, AssignFromPointer_Fail) {
// a = b;
auto* tex_type = create<sem::StorageTexture>(
sem::TextureDimension::k1d, sem::ImageFormat::kRgba8Unorm,
sem::StorageTexture::SubtypeFor(sem::ImageFormat::kRgba8Unorm, Types()));
ast::TextureDimension::k1d, ast::ImageFormat::kRgba8Unorm,
sem::StorageTexture::SubtypeFor(ast::ImageFormat::kRgba8Unorm, Types()));
auto* tex_ac =
create<sem::AccessControl>(ast::AccessControl::kReadOnly, tex_type);

90
src/resolver/intrinsic_test.cc
View File

@@ -206,9 +206,9 @@ inline std::ostream& operator<<(std::ostream& out, Texture data) {
}
struct TextureTestParams {
sem::TextureDimension dim;
ast::TextureDimension dim;
Texture type = Texture::kF32;
sem::ImageFormat format = sem::ImageFormat::kR16Float;
ast::ImageFormat format = ast::ImageFormat::kR16Float;
};
inline std::ostream& operator<<(std::ostream& out, TextureTestParams data) {
out << data.dim << "_" << data.type;
@@ -223,16 +223,16 @@ class ResolverIntrinsicTest_TextureOperation
/// @param dim dimensionality of the texture being sampled
/// @param scalar the scalar type
/// @returns a pointer to a type appropriate for the coord param
sem::Type* GetCoordsType(sem::TextureDimension dim, sem::Type* scalar) {
sem::Type* GetCoordsType(ast::TextureDimension dim, sem::Type* scalar) {
switch (dim) {
case sem::TextureDimension::k1d:
case ast::TextureDimension::k1d:
return scalar;
case sem::TextureDimension::k2d:
case sem::TextureDimension::k2dArray:
case ast::TextureDimension::k2d:
case ast::TextureDimension::k2dArray:
return create<sem::Vector>(scalar, 2);
case sem::TextureDimension::k3d:
case sem::TextureDimension::kCube:
case sem::TextureDimension::kCubeArray:
case ast::TextureDimension::k3d:
case ast::TextureDimension::kCube:
case ast::TextureDimension::kCubeArray:
return create<sem::Vector>(scalar, 3);
default:
[=]() { FAIL() << "Unsupported texture dimension: " << dim; }();
@@ -276,7 +276,7 @@ TEST_P(ResolverIntrinsicTest_StorageTextureOperation, TextureLoadRo) {
add_call_param("texture", ro_texture_type, &call_params);
add_call_param("coords", coords_type, &call_params);
if (sem::IsTextureArray(dim)) {
if (ast::IsTextureArray(dim)) {
add_call_param("array_index", ty.i32(), &call_params);
}
@@ -301,30 +301,30 @@ INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverIntrinsicTest_StorageTextureOperation,
testing::Values(
TextureTestParams{sem::TextureDimension::k1d, Texture::kF32,
sem::ImageFormat::kR32Float},
TextureTestParams{sem::TextureDimension::k1d, Texture::kI32,
sem::ImageFormat::kR32Sint},
TextureTestParams{sem::TextureDimension::k1d, Texture::kF32,
sem::ImageFormat::kRgba8Unorm},
TextureTestParams{sem::TextureDimension::k2d, Texture::kF32,
sem::ImageFormat::kR32Float},
TextureTestParams{sem::TextureDimension::k2d, Texture::kI32,
sem::ImageFormat::kR32Sint},
TextureTestParams{sem::TextureDimension::k2d, Texture::kF32,
sem::ImageFormat::kRgba8Unorm},
TextureTestParams{sem::TextureDimension::k2dArray, Texture::kF32,
sem::ImageFormat::kR32Float},
TextureTestParams{sem::TextureDimension::k2dArray, Texture::kI32,
sem::ImageFormat::kR32Sint},
TextureTestParams{sem::TextureDimension::k2dArray, Texture::kF32,
sem::ImageFormat::kRgba8Unorm},
TextureTestParams{sem::TextureDimension::k3d, Texture::kF32,
sem::ImageFormat::kR32Float},
TextureTestParams{sem::TextureDimension::k3d, Texture::kI32,
sem::ImageFormat::kR32Sint},
TextureTestParams{sem::TextureDimension::k3d, Texture::kF32,
sem::ImageFormat::kRgba8Unorm}));
TextureTestParams{ast::TextureDimension::k1d, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k1d, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k1d, Texture::kF32,
ast::ImageFormat::kRgba8Unorm},
TextureTestParams{ast::TextureDimension::k2d, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k2d, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k2d, Texture::kF32,
ast::ImageFormat::kRgba8Unorm},
TextureTestParams{ast::TextureDimension::k2dArray, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k2dArray, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k2dArray, Texture::kF32,
ast::ImageFormat::kRgba8Unorm},
TextureTestParams{ast::TextureDimension::k3d, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k3d, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k3d, Texture::kF32,
ast::ImageFormat::kRgba8Unorm}));
using ResolverIntrinsicTest_SampledTextureOperation =
ResolverIntrinsicTest_TextureOperation;
@@ -340,7 +340,7 @@ TEST_P(ResolverIntrinsicTest_SampledTextureOperation, TextureLoadSampled) {
add_call_param("texture", texture_type, &call_params);
add_call_param("coords", coords_type, &call_params);
if (dim == sem::TextureDimension::k2dArray) {
if (dim == ast::TextureDimension::k2dArray) {
add_call_param("array_index", ty.i32(), &call_params);
}
add_call_param("level", ty.i32(), &call_params);
@@ -365,10 +365,10 @@ TEST_P(ResolverIntrinsicTest_SampledTextureOperation, TextureLoadSampled) {
INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverIntrinsicTest_SampledTextureOperation,
testing::Values(TextureTestParams{sem::TextureDimension::k1d},
TextureTestParams{sem::TextureDimension::k2d},
TextureTestParams{sem::TextureDimension::k2dArray},
TextureTestParams{sem::TextureDimension::k3d}));
testing::Values(TextureTestParams{ast::TextureDimension::k1d},
TextureTestParams{ast::TextureDimension::k2d},
TextureTestParams{ast::TextureDimension::k2dArray},
TextureTestParams{ast::TextureDimension::k3d}));
TEST_F(ResolverIntrinsicTest, Dot_Vec2) {
Global("my_var", ty.vec2<f32>(), ast::StorageClass::kInput);
@@ -1924,16 +1924,16 @@ TEST_P(ResolverIntrinsicTest_Texture, Call) {
switch (param.texture_dimension) {
default:
FAIL() << "invalid texture dimensions: " << param.texture_dimension;
case sem::TextureDimension::k1d:
case ast::TextureDimension::k1d:
EXPECT_EQ(TypeOf(call)->type_name(), ty.i32()->type_name());
break;
case sem::TextureDimension::k2d:
case sem::TextureDimension::k2dArray:
case ast::TextureDimension::k2d:
case ast::TextureDimension::k2dArray:
EXPECT_EQ(TypeOf(call)->type_name(), ty.vec2<i32>()->type_name());
break;
case sem::TextureDimension::k3d:
case sem::TextureDimension::kCube:
case sem::TextureDimension::kCubeArray:
case ast::TextureDimension::k3d:
case ast::TextureDimension::kCube:
case ast::TextureDimension::kCubeArray:
EXPECT_EQ(TypeOf(call)->type_name(), ty.vec3<i32>()->type_name());
break;
}

114
src/resolver/resolver.cc
View File

@@ -18,29 +18,42 @@
#include <utility>
#include "src/ast/access_decoration.h"
#include "src/ast/alias.h"
#include "src/ast/array.h"
#include "src/ast/assignment_statement.h"
#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
#include "src/ast/call_statement.h"
#include "src/ast/constant_id_decoration.h"
#include "src/ast/continue_statement.h"
#include "src/ast/depth_texture.h"
#include "src/ast/discard_statement.h"
#include "src/ast/fallthrough_statement.h"
#include "src/ast/if_statement.h"
#include "src/ast/internal_decoration.h"
#include "src/ast/loop_statement.h"
#include "src/ast/matrix.h"
#include "src/ast/pointer.h"
#include "src/ast/return_statement.h"
#include "src/ast/sampled_texture.h"
#include "src/ast/sampler.h"
#include "src/ast/storage_texture.h"
#include "src/ast/struct_block_decoration.h"
#include "src/ast/switch_statement.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/ast/vector.h"
#include "src/ast/workgroup_decoration.h"
#include "src/sem/access_control_type.h"
#include "src/sem/array.h"
#include "src/sem/call.h"
#include "src/sem/depth_texture_type.h"
#include "src/sem/function.h"
#include "src/sem/member_accessor_expression.h"
#include "src/sem/multisampled_texture_type.h"
#include "src/sem/pointer_type.h"
#include "src/sem/sampled_texture_type.h"
#include "src/sem/sampler_type.h"
#include "src/sem/statement.h"
#include "src/sem/storage_texture_type.h"
#include "src/sem/struct.h"
@@ -78,36 +91,36 @@ Source CombineSourceRange(const Source& start, const Source& end) {
start.file_path, start.file_content);
}
bool IsValidStorageTextureDimension(sem::TextureDimension dim) {
bool IsValidStorageTextureDimension(ast::TextureDimension dim) {
switch (dim) {
case sem::TextureDimension::k1d:
case sem::TextureDimension::k2d:
case sem::TextureDimension::k2dArray:
case sem::TextureDimension::k3d:
case ast::TextureDimension::k1d:
case ast::TextureDimension::k2d:
case ast::TextureDimension::k2dArray:
case ast::TextureDimension::k3d:
return true;
default:
return false;
}
}
bool IsValidStorageTextureImageFormat(sem::ImageFormat format) {
bool IsValidStorageTextureImageFormat(ast::ImageFormat format) {
switch (format) {
case sem::ImageFormat::kR32Uint:
case sem::ImageFormat::kR32Sint:
case sem::ImageFormat::kR32Float:
case sem::ImageFormat::kRg32Uint:
case sem::ImageFormat::kRg32Sint:
case sem::ImageFormat::kRg32Float:
case sem::ImageFormat::kRgba8Unorm:
case sem::ImageFormat::kRgba8Snorm:
case sem::ImageFormat::kRgba8Uint:
case sem::ImageFormat::kRgba8Sint:
case sem::ImageFormat::kRgba16Uint:
case sem::ImageFormat::kRgba16Sint:
case sem::ImageFormat::kRgba16Float:
case sem::ImageFormat::kRgba32Uint:
case sem::ImageFormat::kRgba32Sint:
case sem::ImageFormat::kRgba32Float:
case ast::ImageFormat::kR32Uint:
case ast::ImageFormat::kR32Sint:
case ast::ImageFormat::kR32Float:
case ast::ImageFormat::kRg32Uint:
case ast::ImageFormat::kRg32Sint:
case ast::ImageFormat::kRg32Float:
case ast::ImageFormat::kRgba8Unorm:
case ast::ImageFormat::kRgba8Snorm:
case ast::ImageFormat::kRgba8Uint:
case ast::ImageFormat::kRgba8Sint:
case ast::ImageFormat::kRgba16Uint:
case ast::ImageFormat::kRgba16Sint:
case ast::ImageFormat::kRgba16Float:
case ast::ImageFormat::kRgba32Uint:
case ast::ImageFormat::kRgba32Sint:
case ast::ImageFormat::kRgba32Float:
return true;
default:
return false;
@@ -266,6 +279,61 @@ bool Resolver::ResolveInternal() {
return true;
}
sem::Type* Resolver::Type(ast::Type* ty) {
Mark(ty);
sem::Type* s = nullptr;
if (ty->Is<ast::Void>()) {
s = builder_->create<sem::Void>();
} else if (ty->Is<ast::Bool>()) {
s = builder_->create<sem::Bool>();
} else if (ty->Is<ast::I32>()) {
s = builder_->create<sem::I32>();
} else if (ty->Is<ast::U32>()) {
s = builder_->create<sem::U32>();
} else if (ty->Is<ast::F32>()) {
s = builder_->create<sem::F32>();
} else if (auto* alias = ty->As<ast::Alias>()) {
auto* el = Type(alias->type());
s = builder_->create<sem::Alias>(alias->symbol(), el);
} else if (auto* access = ty->As<ast::AccessControl>()) {
auto* el = Type(access->type());
s = builder_->create<sem::AccessControl>(access->access_control(), el);
} else if (auto* vec = ty->As<ast::Vector>()) {
auto* el = Type(vec->type());
s = builder_->create<sem::Vector>(el, vec->size());
} else if (auto* mat = ty->As<ast::Matrix>()) {
auto* el = Type(mat->type());
s = builder_->create<sem::Matrix>(el, mat->rows(), mat->columns());
} else if (auto* arr = ty->As<ast::Array>()) {
auto* el = Type(arr->type());
s = builder_->create<sem::ArrayType>(el, arr->size(), arr->decorations());
} else if (auto* ptr = ty->As<ast::Pointer>()) {
auto* el = Type(ptr->type());
s = builder_->create<sem::Pointer>(el, ptr->storage_class());
} else if (auto* str = ty->As<ast::Struct>()) {
s = builder_->create<sem::StructType>(str);
} else if (auto* sampler = ty->As<ast::Sampler>()) {
s = builder_->create<sem::Sampler>(sampler->kind());
} else if (auto* sampled_tex = ty->As<ast::SampledTexture>()) {
auto* el = Type(sampled_tex->type());
s = builder_->create<sem::SampledTexture>(sampled_tex->dim(), el);
} else if (auto* depth_tex = ty->As<ast::DepthTexture>()) {
s = builder_->create<sem::DepthTexture>(depth_tex->dim());
} else if (auto* storage_tex = ty->As<ast::StorageTexture>()) {
auto* el = Type(storage_tex->type());
s = builder_->create<sem::StorageTexture>(storage_tex->dim(),
storage_tex->image_format(), el);
}
if (s == nullptr) {
return nullptr;
}
if (!Type(s)) {
return nullptr;
}
return s;
}
// TODO(crbug.com/tint/724): This method should be replaced by Type(ast::Type*)
bool Resolver::Type(sem::Type* ty) {
ty = ty->UnwrapAliasIfNeeded();
if (auto* str = ty->As<sem::StructType>()) {
@@ -413,7 +481,7 @@ bool Resolver::ValidateVariable(const ast::Variable* var) {
}
if (auto* r = type->UnwrapAll()->As<sem::MultisampledTexture>()) {
if (r->dim() != sem::TextureDimension::k2d) {
if (r->dim() != ast::TextureDimension::k2d) {
diagnostics_.add_error("Only 2d multisampled textures are supported",
var->source());
return false;

6
src/resolver/resolver.h
View File

@@ -251,6 +251,12 @@ class Resolver {
bool ValidateVectorConstructor(const sem::Vector* vec_type,
const ast::ExpressionList& values);
/// @returns the sem::Type for the ast::Type `ty`, building it if it
/// hasn't been constructed already. If an error is raised, nullptr is
/// returned.
/// @param ty the ast::Type
sem::Type* Type(ast::Type* ty);
/// @returns the semantic information for the array `arr`, building it if it
/// hasn't been constructed already. If an error is raised, nullptr is
/// returned.

114
src/resolver/type_validation_test.cc
View File

@@ -536,17 +536,17 @@ INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
namespace MultisampledTextureTests {
struct DimensionParams {
sem::TextureDimension dim;
ast::TextureDimension dim;
bool is_valid;
};
static constexpr DimensionParams dimension_cases[] = {
DimensionParams{sem::TextureDimension::k1d, false},
DimensionParams{sem::TextureDimension::k2d, true},
DimensionParams{sem::TextureDimension::k2dArray, false},
DimensionParams{sem::TextureDimension::k3d, false},
DimensionParams{sem::TextureDimension::kCube, false},
DimensionParams{sem::TextureDimension::kCubeArray, false}};
DimensionParams{ast::TextureDimension::k1d, false},
DimensionParams{ast::TextureDimension::k2d, true},
DimensionParams{ast::TextureDimension::k2dArray, false},
DimensionParams{ast::TextureDimension::k3d, false},
DimensionParams{ast::TextureDimension::kCube, false},
DimensionParams{ast::TextureDimension::kCubeArray, false}};
using MultisampledTextureDimensionTest = ResolverTestWithParam<DimensionParams>;
TEST_P(MultisampledTextureDimensionTest, All) {
@@ -594,7 +594,7 @@ using MultisampledTextureTypeTest = ResolverTestWithParam<TypeParams>;
TEST_P(MultisampledTextureTypeTest, All) {
auto& params = GetParam();
Global("a",
create<sem::MultisampledTexture>(sem::TextureDimension::k2d,
create<sem::MultisampledTexture>(ast::TextureDimension::k2d,
params.type_func(ty)),
ast::StorageClass::kUniformConstant, nullptr,
ast::DecorationList{
@@ -616,25 +616,25 @@ INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
namespace StorageTextureTests {
struct DimensionParams {
sem::TextureDimension dim;
ast::TextureDimension dim;
bool is_valid;
};
static constexpr DimensionParams Dimension_cases[] = {
DimensionParams{sem::TextureDimension::k1d, true},
DimensionParams{sem::TextureDimension::k2d, true},
DimensionParams{sem::TextureDimension::k2dArray, true},
DimensionParams{sem::TextureDimension::k3d, true},
DimensionParams{sem::TextureDimension::kCube, false},
DimensionParams{sem::TextureDimension::kCubeArray, false}};
DimensionParams{ast::TextureDimension::k1d, true},
DimensionParams{ast::TextureDimension::k2d, true},
DimensionParams{ast::TextureDimension::k2dArray, true},
DimensionParams{ast::TextureDimension::k3d, true},
DimensionParams{ast::TextureDimension::kCube, false},
DimensionParams{ast::TextureDimension::kCubeArray, false}};
using StorageTextureDimensionTest = ResolverTestWithParam<DimensionParams>;
TEST_P(StorageTextureDimensionTest, All) {
auto& params = GetParam();
Global("a",
create<sem::StorageTexture>(params.dim, sem::ImageFormat::kR32Uint,
create<sem::StorageTexture>(params.dim, ast::ImageFormat::kR32Uint,
sem::StorageTexture::SubtypeFor(
sem::ImageFormat::kR32Uint, Types())),
ast::ImageFormat::kR32Uint, Types())),
ast::StorageClass::kUniformConstant, nullptr,
ast::DecorationList{
create<ast::BindingDecoration>(0),
@@ -652,46 +652,46 @@ INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
testing::ValuesIn(Dimension_cases));
struct FormatParams {
sem::ImageFormat format;
ast::ImageFormat format;
bool is_valid;
};
static constexpr FormatParams format_cases[] = {
FormatParams{sem::ImageFormat::kBgra8Unorm, false},
FormatParams{sem::ImageFormat::kBgra8UnormSrgb, false},
FormatParams{sem::ImageFormat::kR16Float, false},
FormatParams{sem::ImageFormat::kR16Sint, false},
FormatParams{sem::ImageFormat::kR16Uint, false},
FormatParams{sem::ImageFormat::kR32Float, true},
FormatParams{sem::ImageFormat::kR32Sint, true},
FormatParams{sem::ImageFormat::kR32Uint, true},
FormatParams{sem::ImageFormat::kR8Sint, false},
FormatParams{sem::ImageFormat::kR8Snorm, false},
FormatParams{sem::ImageFormat::kR8Uint, false},
FormatParams{sem::ImageFormat::kR8Unorm, false},
FormatParams{sem::ImageFormat::kRg11B10Float, false},
FormatParams{sem::ImageFormat::kRg16Float, false},
FormatParams{sem::ImageFormat::kRg16Sint, false},
FormatParams{sem::ImageFormat::kRg16Uint, false},
FormatParams{sem::ImageFormat::kRg32Float, true},
FormatParams{sem::ImageFormat::kRg32Sint, true},
FormatParams{sem::ImageFormat::kRg32Uint, true},
FormatParams{sem::ImageFormat::kRg8Sint, false},
FormatParams{sem::ImageFormat::kRg8Snorm, false},
FormatParams{sem::ImageFormat::kRg8Uint, false},
FormatParams{sem::ImageFormat::kRg8Unorm, false},
FormatParams{sem::ImageFormat::kRgb10A2Unorm, false},
FormatParams{sem::ImageFormat::kRgba16Float, true},
FormatParams{sem::ImageFormat::kRgba16Sint, true},
FormatParams{sem::ImageFormat::kRgba16Uint, true},
FormatParams{sem::ImageFormat::kRgba32Float, true},
FormatParams{sem::ImageFormat::kRgba32Sint, true},
FormatParams{sem::ImageFormat::kRgba32Uint, true},
FormatParams{sem::ImageFormat::kRgba8Sint, true},
FormatParams{sem::ImageFormat::kRgba8Snorm, true},
FormatParams{sem::ImageFormat::kRgba8Uint, true},
FormatParams{sem::ImageFormat::kRgba8Unorm, true},
FormatParams{sem::ImageFormat::kRgba8UnormSrgb, false}};
FormatParams{ast::ImageFormat::kBgra8Unorm, false},
FormatParams{ast::ImageFormat::kBgra8UnormSrgb, false},
FormatParams{ast::ImageFormat::kR16Float, false},
FormatParams{ast::ImageFormat::kR16Sint, false},
FormatParams{ast::ImageFormat::kR16Uint, false},
FormatParams{ast::ImageFormat::kR32Float, true},
FormatParams{ast::ImageFormat::kR32Sint, true},
FormatParams{ast::ImageFormat::kR32Uint, true},
FormatParams{ast::ImageFormat::kR8Sint, false},
FormatParams{ast::ImageFormat::kR8Snorm, false},
FormatParams{ast::ImageFormat::kR8Uint, false},
FormatParams{ast::ImageFormat::kR8Unorm, false},
FormatParams{ast::ImageFormat::kRg11B10Float, false},
FormatParams{ast::ImageFormat::kRg16Float, false},
FormatParams{ast::ImageFormat::kRg16Sint, false},
FormatParams{ast::ImageFormat::kRg16Uint, false},
FormatParams{ast::ImageFormat::kRg32Float, true},
FormatParams{ast::ImageFormat::kRg32Sint, true},
FormatParams{ast::ImageFormat::kRg32Uint, true},
FormatParams{ast::ImageFormat::kRg8Sint, false},
FormatParams{ast::ImageFormat::kRg8Snorm, false},
FormatParams{ast::ImageFormat::kRg8Uint, false},
FormatParams{ast::ImageFormat::kRg8Unorm, false},
FormatParams{ast::ImageFormat::kRgb10A2Unorm, false},
FormatParams{ast::ImageFormat::kRgba16Float, true},
FormatParams{ast::ImageFormat::kRgba16Sint, true},
FormatParams{ast::ImageFormat::kRgba16Uint, true},
FormatParams{ast::ImageFormat::kRgba32Float, true},
FormatParams{ast::ImageFormat::kRgba32Sint, true},
FormatParams{ast::ImageFormat::kRgba32Uint, true},
FormatParams{ast::ImageFormat::kRgba8Sint, true},
FormatParams{ast::ImageFormat::kRgba8Snorm, true},
FormatParams{ast::ImageFormat::kRgba8Uint, true},
FormatParams{ast::ImageFormat::kRgba8Unorm, true},
FormatParams{ast::ImageFormat::kRgba8UnormSrgb, false}};
using StorageTextureFormatTest = ResolverTestWithParam<FormatParams>;
TEST_P(StorageTextureFormatTest, All) {
@@ -705,7 +705,7 @@ TEST_P(StorageTextureFormatTest, All) {
Global("a",
create<sem::StorageTexture>(
sem::TextureDimension::k1d, params.format,
ast::TextureDimension::k1d, params.format,
sem::StorageTexture::SubtypeFor(params.format, Types())),
ast::StorageClass::kUniformConstant, nullptr,
ast::DecorationList{
@@ -715,7 +715,7 @@ TEST_P(StorageTextureFormatTest, All) {
Global("b",
create<sem::StorageTexture>(
sem::TextureDimension::k2d, params.format,
ast::TextureDimension::k2d, params.format,
sem::StorageTexture::SubtypeFor(params.format, Types())),
ast::StorageClass::kUniformConstant, nullptr,
ast::DecorationList{
@@ -725,7 +725,7 @@ TEST_P(StorageTextureFormatTest, All) {
Global("c",
create<sem::StorageTexture>(
sem::TextureDimension::k2dArray, params.format,
ast::TextureDimension::k2dArray, params.format,
sem::StorageTexture::SubtypeFor(params.format, Types())),
ast::StorageClass::kUniformConstant, nullptr,
ast::DecorationList{
@@ -735,7 +735,7 @@ TEST_P(StorageTextureFormatTest, All) {
Global("d",
create<sem::StorageTexture>(
sem::TextureDimension::k3d, params.format,
ast::TextureDimension::k3d, params.format,
sem::StorageTexture::SubtypeFor(params.format, Types())),
ast::StorageClass::kUniformConstant, nullptr,
ast::DecorationList{