| // Copyright 2024 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include <string> | |
| #include "src/tint/lang/core/number.h" | |
| #include "src/tint/lang/core/type/storage_texture.h" | |
| #include "src/tint/lang/core/type/texture_dimension.h" | |
| #include "src/tint/lang/wgsl/ast/expression.h" | |
| #include "src/tint/lang/wgsl/ast/type.h" | |
| #include "src/tint/lang/wgsl/common/validation_mode.h" | |
| #include "src/tint/lang/wgsl/resolver/resolver.h" | |
| #include "src/tint/lang/wgsl/resolver/resolver_helper_test.h" | |
| #include "src/tint/utils/text/string.h" | |
| #include "gmock/gmock.h" | |
| namespace tint::resolver { | |
| namespace { | |
| using namespace tint::core::fluent_types; // NOLINT | |
| using namespace tint::core::number_suffixes; // NOLINT | |
| using ExpressionList = Vector<const ast::Expression*, 8>; | |
| class ResolverCompatibilityModeTest : public ResolverTest { | |
| protected: | |
| ResolverCompatibilityModeTest() { | |
| resolver_ = std::make_unique<Resolver>(this, wgsl::AllowedFeatures::Everything(), | |
| wgsl::ValidationMode::kCompat); | |
| } | |
| }; | |
| template <typename T> | |
| class ResolverCompatibilityModeTestWithParam : public TestHelper, public testing::TestWithParam<T> { | |
| protected: | |
| ResolverCompatibilityModeTestWithParam() { | |
| resolver_ = std::make_unique<Resolver>(this, wgsl::AllowedFeatures::Everything(), | |
| wgsl::ValidationMode::kCompat); | |
| } | |
| }; | |
| using ResolverCompatibilityModeTest_StorageTexture = ResolverCompatibilityModeTestWithParam< | |
| std::tuple<core::type::TextureDimension, core::TexelFormat>>; | |
| TEST_P(ResolverCompatibilityModeTest_StorageTexture, RGStorageTextures) { | |
| // @group(2) @binding(1) var tex: texture_storage_xxx<formatxxx, read_write> | |
| auto dim = std::get<0>(GetParam()); | |
| auto fmt = std::get<1>(GetParam()); | |
| auto t = ty.storage_texture(Source{{12, 34}}, dim, fmt, core::Access::kReadWrite); | |
| GlobalVar("tex", t, | |
| Vector{ | |
| Group(2_a), | |
| Binding(1_a), | |
| }); | |
| StringStream err; | |
| err << "12:34 error: format " << fmt | |
| << " is not supported as a storage texture in compatibility mode"; | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), err.str()); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverCompatibilityModeTest, | |
| ResolverCompatibilityModeTest_StorageTexture, | |
| testing::Combine(testing::Values(core::type::TextureDimension::k1d, | |
| core::type::TextureDimension::k2d, | |
| core::type::TextureDimension::k2dArray, | |
| core::type::TextureDimension::k3d), | |
| testing::Values(core::TexelFormat::kRg32Float, | |
| core::TexelFormat::kRg32Sint, | |
| core::TexelFormat::kRg32Uint))); | |
| TEST_F(ResolverCompatibilityModeTest, SampleMask_Parameter) { | |
| // @fragment | |
| // fn main(@builtin(sample_mask) mask : u32) { | |
| // } | |
| Func("main", | |
| Vector{Param( | |
| "mask", ty.i32(), | |
| Vector{ | |
| create<ast::BuiltinAttribute>(Source{{12, 34}}, core::BuiltinValue::kSampleMask), | |
| })}, | |
| ty.void_(), Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@builtin(sample_mask)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleMask_ReturnValue) { | |
| // @fragment | |
| // fn main() -> @builtin(sample_mask) u32 { | |
| // return 0; | |
| // } | |
| Func("main", Empty, ty.u32(), | |
| Vector{ | |
| Return(0_u), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| create<ast::BuiltinAttribute>(Source{{12, 34}}, core::BuiltinValue::kSampleMask), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@builtin(sample_mask)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleMask_StructMember) { | |
| // struct S { | |
| // @builtin(sample_mask) mask : u32, | |
| // } | |
| Structure("S", Vector{ | |
| Member("mask", ty.u32(), | |
| Vector{ | |
| create<ast::BuiltinAttribute>(Source{{12, 34}}, | |
| core::BuiltinValue::kSampleMask), | |
| }), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@builtin(sample_mask)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleIndex_Parameter) { | |
| // @fragment | |
| // fn main(@builtin(sample_index) mask : u32) { | |
| // } | |
| Func("main", | |
| Vector{Param( | |
| "mask", ty.i32(), | |
| Vector{ | |
| create<ast::BuiltinAttribute>(Source{{12, 34}}, core::BuiltinValue::kSampleIndex), | |
| })}, | |
| ty.void_(), Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@builtin(sample_index)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleIndex_ReturnValue) { | |
| // @fragment | |
| // fn main() -> @builtin(sample_index) u32 { | |
| // return 0; | |
| // } | |
| Func("main", Empty, ty.u32(), | |
| Vector{ | |
| Return(0_u), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| create<ast::BuiltinAttribute>(Source{{12, 34}}, core::BuiltinValue::kSampleIndex), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@builtin(sample_index)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleIndex_StructMember) { | |
| // struct S { | |
| // @builtin(sample_index) mask : u32, | |
| // } | |
| Structure("S", Vector{ | |
| Member("mask", ty.u32(), | |
| Vector{ | |
| create<ast::BuiltinAttribute>(Source{{12, 34}}, | |
| core::BuiltinValue::kSampleIndex), | |
| }), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@builtin(sample_index)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, LinearInterpolation_Parameter) { | |
| // @fragment | |
| // fn main(@location(1) @interpolate(linear) value : f32) { | |
| // } | |
| Func("main", | |
| Vector{Param("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kLinear, | |
| core::InterpolationSampling::kCenter), | |
| })}, | |
| ty.void_(), Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: use of '@interpolate(linear)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, LinearInterpolation_StructMember) { | |
| // struct S { | |
| // @location(1) @interpolate(linear) value : f32, | |
| // } | |
| Structure("S", Vector{ | |
| Member("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kLinear, | |
| core::InterpolationSampling::kCenter), | |
| }), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: use of '@interpolate(linear)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleInterpolation_Parameter) { | |
| // @fragment | |
| // fn main(@location(1) @interpolate(perspective, sample) value : f32) { | |
| // } | |
| Func("main", | |
| Vector{Param("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kPerspective, | |
| core::InterpolationSampling::kSample), | |
| })}, | |
| ty.void_(), Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@interpolate(..., sample)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, SampleInterpolation_StructMember) { | |
| // struct S { | |
| // @location(1) @interpolate(perspective, sample) value : f32, | |
| // } | |
| Structure("S", | |
| Vector{ | |
| Member("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kPerspective, | |
| core::InterpolationSampling::kSample), | |
| }), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of '@interpolate(..., sample)' is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, FirstInterpolation_Parameter) { | |
| // @fragment | |
| // fn main(@location(1) @interpolate(flat, first) value : f32) { | |
| // } | |
| Func("main", | |
| Vector{Param("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kFlat, | |
| core::InterpolationSampling::kFirst), | |
| })}, | |
| ty.void_(), Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: flat interpolation must use 'either' sampling parameter in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, FirstInterpolation_StructMember) { | |
| // struct S { | |
| // @location(1) @interpolate(flat, first) value : f32, | |
| // } | |
| Structure("S", Vector{ | |
| Member("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kFlat, | |
| core::InterpolationSampling::kFirst), | |
| }), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: flat interpolation must use 'either' sampling parameter in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, FlatNoneInterpolation_Parameter) { | |
| // @fragment | |
| // fn main(@location(1) @interpolate(flat) value : f32) { | |
| // } | |
| Func("main", | |
| Vector{Param("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kFlat, | |
| core::InterpolationSampling::kUndefined), | |
| })}, | |
| ty.void_(), Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: flat interpolation must use 'either' sampling parameter in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest, FlatNoneInterpolation_StructMember) { | |
| // struct S { | |
| // @location(1) @interpolate(flat) value : f32, | |
| // } | |
| Structure("S", Vector{ | |
| Member("value", ty.f32(), | |
| Vector{ | |
| Location(1_i), | |
| Interpolate(Source{{12, 34}}, core::InterpolationType::kFlat, | |
| core::InterpolationSampling::kUndefined), | |
| }), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: flat interpolation must use 'either' sampling parameter in compatibility mode)"); | |
| } | |
| class ResolverCompatibilityModeTest_TextureLoad : public ResolverCompatibilityModeTest { | |
| protected: | |
| void add_call_param(std::string name, ast::Type type, ExpressionList* call_params) { | |
| const std::string type_name = type->identifier->symbol.Name(); | |
| if (tint::HasPrefix(type_name, "texture")) { | |
| GlobalVar(name, type, Binding(0_a), Group(0_a)); | |
| } else { | |
| GlobalVar(name, type, core::AddressSpace::kPrivate); | |
| } | |
| call_params->Push(Expr(Source{{12, 34}}, name)); | |
| } | |
| }; | |
| TEST_F(ResolverCompatibilityModeTest_TextureLoad, TextureDepth2D) { | |
| // textureLoad(someDepthTexture2D, coords, level) | |
| const ast::Type coords_type = ty.vec2(ty.i32()); | |
| auto texture_type = ty.depth_texture(core::type::TextureDimension::k2d); | |
| ExpressionList call_params; | |
| add_call_param("texture", texture_type, &call_params); | |
| add_call_param("coords", coords_type, &call_params); | |
| add_call_param("level", ty.i32(), &call_params); | |
| auto* expr = Call("textureLoad", call_params); | |
| WrapInFunction(expr); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of texture_depth_2d with textureLoad is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest_TextureLoad, TextureDepth2DArray) { | |
| // textureLoad(someDepthTexture2DArray, coords, layer, level) | |
| const ast::Type coords_type = ty.vec2(ty.i32()); | |
| auto texture_type = ty.depth_texture(core::type::TextureDimension::k2dArray); | |
| ExpressionList call_params; | |
| add_call_param("texture", texture_type, &call_params); | |
| add_call_param("coords", coords_type, &call_params); | |
| add_call_param("array_index", ty.i32(), &call_params); | |
| add_call_param("level", ty.i32(), &call_params); | |
| auto* expr = Call("textureLoad", call_params); | |
| WrapInFunction(expr); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of texture_depth_2d_array with textureLoad is not allowed in compatibility mode)"); | |
| } | |
| TEST_F(ResolverCompatibilityModeTest_TextureLoad, TextureDepthMultisampled2D) { | |
| // textureLoad(someDepthTextureMultisampled2D, coords, sample_index) | |
| const ast::Type coords_type = ty.vec2(ty.i32()); | |
| auto texture_type = ty.depth_multisampled_texture(core::type::TextureDimension::k2d); | |
| ExpressionList call_params; | |
| add_call_param("texture", texture_type, &call_params); | |
| add_call_param("coords", coords_type, &call_params); | |
| add_call_param("sample_index", ty.i32(), &call_params); | |
| auto* expr = Call("textureLoad", call_params); | |
| WrapInFunction(expr); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| R"(12:34 error: use of texture_depth_multisampled_2d with textureLoad is not allowed in compatibility mode)"); | |
| } | |
| } // namespace | |
| } // namespace tint::resolver |