src/tint/lang/wgsl/resolver/assignment_validation_test.cc - dawn - Git at Google

 // Copyright 2021 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 "src/tint/lang/wgsl/resolver/resolver.h"

 #include "gmock/gmock.h"
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 #include "src/tint/lang/wgsl/resolver/resolver_helper_test.h"

 namespace tint::resolver {
 namespace {

 using namespace tint::core::fluent_types;     // NOLINT
 using namespace tint::core::number_suffixes;  // NOLINT

 using ResolverAssignmentValidationTest = ResolverTest;

 TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
     // struct S { m : i32 };
     // @group(0) @binding(0)
     // var<storage,read> a : S;
     auto* s = Structure("S", Vector{
                                  Member("m", ty.i32()),
                              });
     GlobalVar(Source{{12, 34}}, "a", ty.Of(s), core::AddressSpace::kStorage, core::Access::kRead,
               Binding(0_a), Group(0_a));

     WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               "56:78 error: cannot store into a read-only type 'ref<storage, "
               "i32, read>'");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypes) {
     // {
     //  var a : i32 = 2i;
     //  a = 2.3;
     // }

     auto* var = Var("a", ty.i32(), Expr(2_i));

     auto* assign = Assign(Source{{12, 34}}, "a", 2.3_f);
     WrapInFunction(var, assign);

     ASSERT_FALSE(r()->Resolve());

     EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'f32' to 'i32'");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignArraysWithDifferentSizeExpressions_Pass) {
     // const len = 4u;
     // {
     //   var a : array<f32, 4u>;
     //   var b : array<f32, len>;
     //   a = b;
     // }

     GlobalConst("len", Expr(4_u));

     auto* a = Var("a", ty.array<f32, 4>());
     auto* b = Var("b", ty.array(ty.f32(), "len"));

     auto* assign = Assign(Source{{12, 34}}, "a", "b");
     WrapInFunction(a, b, assign);

     ASSERT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignArraysWithDifferentSizeExpressions_Fail) {
     // const len = 5u;
     // {
     //   var a : array<f32, 4u>;
     //   var b : array<f32, len>;
     //   a = b;
     // }

     GlobalConst("len", Expr(5_u));

     auto* a = Var("a", ty.array<f32, 4>());
     auto* b = Var("b", ty.array(ty.f32(), "len"));

     auto* assign = Assign(Source{{12, 34}}, "a", "b");
     WrapInFunction(a, b, assign);

     ASSERT_FALSE(r()->Resolve());

     EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'array<f32, 5>' to 'array<f32, 4>'");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesInBlockStatement_Pass) {
     // {
     //  var a : i32 = 2i;
     //  a = 2i
     // }
     auto* var = Var("a", ty.i32(), Expr(2_i));
     WrapInFunction(var, Assign("a", 2_i));

     ASSERT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypesInBlockStatement_Fail) {
     // {
     //  var a : i32 = 2i;
     //  a = 2.3;
     // }

     auto* var = Var("a", ty.i32(), Expr(2_i));
     WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2.3_f));

     ASSERT_FALSE(r()->Resolve());

     EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'f32' to 'i32'");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypesInNestedBlockStatement_Fail) {
     // {
     //  {
     //   var a : i32 = 2i;
     //   a = 2.3;
     //  }
     // }

     auto* var = Var("a", ty.i32(), Expr(2_i));
     auto* inner_block = Block(Decl(var), Assign(Source{{12, 34}}, "a", 2.3_f));
     auto* outer_block = Block(inner_block);
     WrapInFunction(outer_block);

     ASSERT_FALSE(r()->Resolve());

     EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'f32' to 'i32'");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypes_Pass) {
     // var a : i32 = 1i;
     // a = 2i;
     // a = 3;
     WrapInFunction(Var("a", ty.i32(), Expr(1_i)),  //
                    Assign("a", 2_i),               //
                    Assign("a", 3_a));

     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesThroughAlias_Pass) {
     // alias myint = u32;
     // var a : myint = 1u;
     // a = 2u;
     // a = 3;
     auto* myint = Alias("myint", ty.u32());
     WrapInFunction(Var("a", ty.Of(myint), Expr(1_u)),  //
                    Assign("a", 2_u),                   //
                    Assign("a", 3_a));

     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesInferRHSLoad_Pass) {
     // var a : i32 = 2i;
     // var b : i32 = 3i;
     // a = b;
     WrapInFunction(Var("a", ty.i32(), Expr(2_i)),  //
                    Var("b", ty.i32(), Expr(3_i)),  //
                    Assign("a", "b"));

     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
     // var a : i32;
     // let b : ptr<function,i32> = &a;
     // *b = 2i;
     WrapInFunction(Var("a", ty.i32(), core::AddressSpace::kFunction, Expr(2_i)),  //
                    Let("b", ty.ptr<function, i32>(), AddressOf(Expr("a"))),       //
                    Assign(Deref("b"), 2_i));

     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignMaterializedThroughPointer_Pass) {
     // var a : i32;
     // let b : ptr<function,i32> = &a;
     // *b = 2;
     auto* var_a = Var("a", ty.i32(), core::AddressSpace::kFunction, Expr(2_i));
     auto* var_b = Let("b", ty.ptr<function, i32>(), AddressOf(Expr("a")));
     WrapInFunction(var_a, var_b, Assign(Deref("b"), 2_a));

     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToScalar_Fail) {
     // var my_var : i32 = 2i;
     // 1 = my_var;

     WrapInFunction(Var("my_var", ty.i32(), Expr(2_i)),  //
                    Assign(Expr(Source{{12, 34}}, 1_i), "my_var"));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value expression of type 'i32')");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToOverride_Fail) {
     // override a : i32 = 2i;
     // {
     //  a = 2i
     // }
     Override(Source{{56, 78}}, "a", ty.i32(), Expr(2_i));
     WrapInFunction(Assign(Expr(Source{{12, 34}}, "a"), 2_i));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to override 'a'
 12:34 note: 'override' variables are immutable
 56:78 note: override 'a' declared here)");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToLet_Fail) {
     // {
     //  let a : i32 = 2i;
     //  a = 2i
     // }
     WrapInFunction(Let(Source{{56, 78}}, "a", ty.i32(), Expr(2_i)),  //
                    Assign(Expr(Source{{12, 34}}, "a"), 2_i));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to let 'a'
 12:34 note: 'let' variables are immutable
 56:78 note: let 'a' declared here)");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToConst_Fail) {
     // {
     //  const a : i32 = 2i;
     //  a = 2i
     // }
     WrapInFunction(Const(Source{{56, 78}}, "a", ty.i32(), Expr(2_i)),  //
                    Assign(Expr(Source{{12, 34}}, "a"), 2_i));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to const 'a'
 12:34 note: 'const' variables are immutable
 56:78 note: const 'a' declared here)");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToParam_Fail) {
     Func("foo", Vector{Param(Source{{56, 78}}, "arg", ty.i32())}, ty.void_(),
          Vector{
              Assign(Expr(Source{{12, 34}}, "arg"), Expr(1_i)),
              Return(),
          });

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               R"(12:34 error: cannot assign to parameter 'arg'
 12:34 note: parameters are immutable
 56:78 note: parameter 'arg' declared here)");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToLetMember_Fail) {
     // struct S { i : i32 }
     // {
     //  let a : S;
     //  a.i = 2i
     // }
     Structure("S", Vector{Member("i", ty.i32())});
     WrapInFunction(Let(Source{{98, 76}}, "a", ty("S"), Call("S")),  //
                    Assign(MemberAccessor(Source{{12, 34}}, Expr(Source{{56, 78}}, "a"), "i"), 2_i));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value expression of type 'i32'
 56:78 note: 'let' variables are immutable
 98:76 note: let 'a' declared here)");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Handle) {
     // var a : texture_storage_1d<rgba8unorm, write>;
     // var b : texture_storage_1d<rgba8unorm, write>;
     // a = b;

     auto make_type = [&] {
         return ty.storage_texture(core::type::TextureDimension::k1d, core::TexelFormat::kRgba8Unorm,
                                   core::Access::kWrite);
     };

     GlobalVar("a", make_type(), Binding(0_a), Group(0_a));
     GlobalVar("b", make_type(), Binding(1_a), Group(0_a));

     WrapInFunction(Assign(Source{{56, 78}}, "a", "b"));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "56:78 error: storage type of assignment must be constructible");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Atomic) {
     // struct S { a : atomic<i32>; };
     // @group(0) @binding(0) var<storage, read_write> v : S;
     // v.a = v.a;

     auto* s = Structure("S", Vector{
                                  Member("a", ty.atomic(ty.i32())),
                              });
     GlobalVar(Source{{12, 34}}, "v", ty.Of(s), core::AddressSpace::kStorage,
               core::Access::kReadWrite, Binding(0_a), Group(0_a));

     WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "56:78 error: storage type of assignment must be constructible");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_RuntimeArray) {
     // struct S { a : array<f32>; };
     // @group(0) @binding(0) var<storage, read_write> v : S;
     // v.a = v.a;

     auto* s = Structure("S", Vector{
                                  Member("a", ty.array(ty.f32())),
                              });
     GlobalVar(Source{{12, 34}}, "v", ty.Of(s), core::AddressSpace::kStorage,
               core::Access::kReadWrite, Binding(0_a), Group(0_a));

     WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "56:78 error: storage type of assignment must be constructible");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToPhony_NonConstructibleStruct_Fail) {
     // struct S {
     //   arr: array<i32>;
     // };
     // @group(0) @binding(0) var<storage, read_write> s : S;
     // fn f() {
     //   _ = s;
     // }
     auto* s = Structure("S", Vector{
                                  Member("arr", ty.array<i32>()),
                              });
     GlobalVar("s", ty.Of(s), core::AddressSpace::kStorage, Group(0_a), Binding(0_a));

     WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s")));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               "12:34 error: cannot assign 'S' to '_'. "
               "'_' can only be assigned a constructible, pointer, texture or "
               "sampler type");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
     // struct S {
     //   arr: array<i32>;
     // };
     // @group(0) @binding(0) var<storage, read_write> s : S;
     // fn f() {
     //   _ = s.arr;
     // }
     auto* s = Structure("S", Vector{
                                  Member("arr", ty.array<i32>()),
                              });
     GlobalVar("s", ty.Of(s), core::AddressSpace::kStorage, Group(0_a), Binding(0_a));

     WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr")));

     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               "12:34 error: cannot assign 'array<i32>' to '_'. "
               "'_' can only be assigned a constructible, pointer, texture or sampler "
               "type");
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) {
     // struct S {
     //   i:   i32;
     //   arr: array<i32>;
     // };
     // struct U {
     //   i:   i32;
     // };
     // @group(0) @binding(0) var tex texture_2d;
     // @group(0) @binding(1) var smp sampler;
     // @group(0) @binding(2) var<uniform> u : U;
     // @group(0) @binding(3) var<storage, read_write> s : S;
     // var<workgroup> wg : array<f32, 10>
     // fn f() {
     //   _ = 1i;
     //   _ = 2u;
     //   _ = 3.0f;
     //   _ = 4;
     //   _ = 5.0;
     //   _ = vec2(6);
     //   _ = vec3(7.0);
     //   _ = vec4<bool>();
     //   _ = tex;
     //   _ = smp;
     //   _ = &s;
     //   _ = s.i;
     //   _ = &s.arr;
     //   _ = u;
     //   _ = u.i;
     //   _ = wg;
     //   _ = wg[3i];
     // }
     auto* S = Structure("S", Vector{
                                  Member("i", ty.i32()),
                                  Member("arr", ty.array<i32>()),
                              });
     auto* U = Structure("U", Vector{
                                  Member("i", ty.i32()),
                              });
     GlobalVar("tex", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(0_a),
               Binding(0_a));
     GlobalVar("smp", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a), Binding(1_a));
     GlobalVar("u", ty.Of(U), core::AddressSpace::kUniform, Group(0_a), Binding(2_a));
     GlobalVar("s", ty.Of(S), core::AddressSpace::kStorage, Group(0_a), Binding(3_a));
     GlobalVar("wg", ty.array<f32, 10>(), core::AddressSpace::kWorkgroup);

     WrapInFunction(Assign(Phony(), 1_i),                                    //
                    Assign(Phony(), 2_u),                                    //
                    Assign(Phony(), 3_f),                                    //
                    Assign(Phony(), 4_a),                                    //
                    Assign(Phony(), 5.0_a),                                  //
                    Assign(Phony(), Call<vec2<Infer>>(6_a)),                 //
                    Assign(Phony(), Call<vec3<Infer>>(7.0_a)),               //
                    Assign(Phony(), Call<vec4<bool>>()),                     //
                    Assign(Phony(), "tex"),                                  //
                    Assign(Phony(), "smp"),                                  //
                    Assign(Phony(), AddressOf("s")),                         //
                    Assign(Phony(), MemberAccessor("s", "i")),               //
                    Assign(Phony(), AddressOf(MemberAccessor("s", "arr"))),  //
                    Assign(Phony(), "u"),                                    //
                    Assign(Phony(), MemberAccessor("u", "i")),               //
                    Assign(Phony(), "wg"),                                   //
                    Assign(Phony(), IndexAccessor("wg", 3_i)));

     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }

 }  // namespace
 }  // namespace tint::resolver
	// Copyright 2021 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 "src/tint/lang/wgsl/resolver/resolver.h"

	#include "gmock/gmock.h"
	#include "src/tint/lang/core/type/storage_texture.h"
	#include "src/tint/lang/core/type/texture_dimension.h"
	#include "src/tint/lang/wgsl/resolver/resolver_helper_test.h"

	namespace tint::resolver {
	namespace {

	using namespace tint::core::fluent_types; // NOLINT
	using namespace tint::core::number_suffixes; // NOLINT

	using ResolverAssignmentValidationTest = ResolverTest;

	TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
	// struct S { m : i32 };
	// @group(0) @binding(0)
	// var<storage,read> a : S;
	auto* s = Structure("S", Vector{
	Member("m", ty.i32()),
	});
	GlobalVar(Source{{12, 34}}, "a", ty.Of(s), core::AddressSpace::kStorage, core::Access::kRead,
	Binding(0_a), Group(0_a));

	WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(),
	"56:78 error: cannot store into a read-only type 'ref<storage, "
	"i32, read>'");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypes) {
	// {
	// var a : i32 = 2i;
	// a = 2.3;
	// }

	auto* var = Var("a", ty.i32(), Expr(2_i));

	auto* assign = Assign(Source{{12, 34}}, "a", 2.3_f);
	WrapInFunction(var, assign);

	ASSERT_FALSE(r()->Resolve());

	EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'f32' to 'i32'");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignArraysWithDifferentSizeExpressions_Pass) {
	// const len = 4u;
	// {
	// var a : array<f32, 4u>;
	// var b : array<f32, len>;
	// a = b;
	// }

	GlobalConst("len", Expr(4_u));

	auto* a = Var("a", ty.array<f32, 4>());
	auto* b = Var("b", ty.array(ty.f32(), "len"));

	auto* assign = Assign(Source{{12, 34}}, "a", "b");
	WrapInFunction(a, b, assign);

	ASSERT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignArraysWithDifferentSizeExpressions_Fail) {
	// const len = 5u;
	// {
	// var a : array<f32, 4u>;
	// var b : array<f32, len>;
	// a = b;
	// }

	GlobalConst("len", Expr(5_u));

	auto* a = Var("a", ty.array<f32, 4>());
	auto* b = Var("b", ty.array(ty.f32(), "len"));

	auto* assign = Assign(Source{{12, 34}}, "a", "b");
	WrapInFunction(a, b, assign);

	ASSERT_FALSE(r()->Resolve());

	EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'array<f32, 5>' to 'array<f32, 4>'");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesInBlockStatement_Pass) {
	// {
	// var a : i32 = 2i;
	// a = 2i
	// }
	auto* var = Var("a", ty.i32(), Expr(2_i));
	WrapInFunction(var, Assign("a", 2_i));

	ASSERT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypesInBlockStatement_Fail) {
	// {
	// var a : i32 = 2i;
	// a = 2.3;
	// }

	auto* var = Var("a", ty.i32(), Expr(2_i));
	WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2.3_f));

	ASSERT_FALSE(r()->Resolve());

	EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'f32' to 'i32'");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypesInNestedBlockStatement_Fail) {
	// {
	// {
	// var a : i32 = 2i;
	// a = 2.3;
	// }
	// }

	auto* var = Var("a", ty.i32(), Expr(2_i));
	auto* inner_block = Block(Decl(var), Assign(Source{{12, 34}}, "a", 2.3_f));
	auto* outer_block = Block(inner_block);
	WrapInFunction(outer_block);

	ASSERT_FALSE(r()->Resolve());

	EXPECT_EQ(r()->error(), "12:34 error: cannot assign 'f32' to 'i32'");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypes_Pass) {
	// var a : i32 = 1i;
	// a = 2i;
	// a = 3;
	WrapInFunction(Var("a", ty.i32(), Expr(1_i)), //
	Assign("a", 2_i), //
	Assign("a", 3_a));

	EXPECT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesThroughAlias_Pass) {
	// alias myint = u32;
	// var a : myint = 1u;
	// a = 2u;
	// a = 3;
	auto* myint = Alias("myint", ty.u32());
	WrapInFunction(Var("a", ty.Of(myint), Expr(1_u)), //
	Assign("a", 2_u), //
	Assign("a", 3_a));

	EXPECT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesInferRHSLoad_Pass) {
	// var a : i32 = 2i;
	// var b : i32 = 3i;
	// a = b;
	WrapInFunction(Var("a", ty.i32(), Expr(2_i)), //
	Var("b", ty.i32(), Expr(3_i)), //
	Assign("a", "b"));

	EXPECT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
	// var a : i32;
	// let b : ptr<function,i32> = &a;
	// *b = 2i;
	WrapInFunction(Var("a", ty.i32(), core::AddressSpace::kFunction, Expr(2_i)), //
	Let("b", ty.ptr<function, i32>(), AddressOf(Expr("a"))), //
	Assign(Deref("b"), 2_i));

	EXPECT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignMaterializedThroughPointer_Pass) {
	// var a : i32;
	// let b : ptr<function,i32> = &a;
	// *b = 2;
	auto* var_a = Var("a", ty.i32(), core::AddressSpace::kFunction, Expr(2_i));
	auto* var_b = Let("b", ty.ptr<function, i32>(), AddressOf(Expr("a")));
	WrapInFunction(var_a, var_b, Assign(Deref("b"), 2_a));

	EXPECT_TRUE(r()->Resolve()) << r()->error();
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToScalar_Fail) {
	// var my_var : i32 = 2i;
	// 1 = my_var;

	WrapInFunction(Var("my_var", ty.i32(), Expr(2_i)), //
	Assign(Expr(Source{{12, 34}}, 1_i), "my_var"));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value expression of type 'i32')");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToOverride_Fail) {
	// override a : i32 = 2i;
	// {
	// a = 2i
	// }
	Override(Source{{56, 78}}, "a", ty.i32(), Expr(2_i));
	WrapInFunction(Assign(Expr(Source{{12, 34}}, "a"), 2_i));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to override 'a'
	12:34 note: 'override' variables are immutable
	56:78 note: override 'a' declared here)");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToLet_Fail) {
	// {
	// let a : i32 = 2i;
	// a = 2i
	// }
	WrapInFunction(Let(Source{{56, 78}}, "a", ty.i32(), Expr(2_i)), //
	Assign(Expr(Source{{12, 34}}, "a"), 2_i));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to let 'a'
	12:34 note: 'let' variables are immutable
	56:78 note: let 'a' declared here)");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToConst_Fail) {
	// {
	// const a : i32 = 2i;
	// a = 2i
	// }
	WrapInFunction(Const(Source{{56, 78}}, "a", ty.i32(), Expr(2_i)), //
	Assign(Expr(Source{{12, 34}}, "a"), 2_i));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to const 'a'
	12:34 note: 'const' variables are immutable
	56:78 note: const 'a' declared here)");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToParam_Fail) {
	Func("foo", Vector{Param(Source{{56, 78}}, "arg", ty.i32())}, ty.void_(),
	Vector{
	Assign(Expr(Source{{12, 34}}, "arg"), Expr(1_i)),
	Return(),
	});

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(),
	R"(12:34 error: cannot assign to parameter 'arg'
	12:34 note: parameters are immutable
	56:78 note: parameter 'arg' declared here)");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToLetMember_Fail) {
	// struct S { i : i32 }
	// {
	// let a : S;
	// a.i = 2i
	// }
	Structure("S", Vector{Member("i", ty.i32())});
	WrapInFunction(Let(Source{{98, 76}}, "a", ty("S"), Call("S")), //
	Assign(MemberAccessor(Source{{12, 34}}, Expr(Source{{56, 78}}, "a"), "i"), 2_i));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value expression of type 'i32'
	56:78 note: 'let' variables are immutable
	98:76 note: let 'a' declared here)");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Handle) {
	// var a : texture_storage_1d<rgba8unorm, write>;
	// var b : texture_storage_1d<rgba8unorm, write>;
	// a = b;

	auto make_type = [&] {
	return ty.storage_texture(core::type::TextureDimension::k1d, core::TexelFormat::kRgba8Unorm,
	core::Access::kWrite);
	};

	GlobalVar("a", make_type(), Binding(0_a), Group(0_a));
	GlobalVar("b", make_type(), Binding(1_a), Group(0_a));

	WrapInFunction(Assign(Source{{56, 78}}, "a", "b"));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), "56:78 error: storage type of assignment must be constructible");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Atomic) {
	// struct S { a : atomic<i32>; };
	// @group(0) @binding(0) var<storage, read_write> v : S;
	// v.a = v.a;

	auto* s = Structure("S", Vector{
	Member("a", ty.atomic(ty.i32())),
	});
	GlobalVar(Source{{12, 34}}, "v", ty.Of(s), core::AddressSpace::kStorage,
	core::Access::kReadWrite, Binding(0_a), Group(0_a));

	WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), "56:78 error: storage type of assignment must be constructible");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_RuntimeArray) {
	// struct S { a : array<f32>; };
	// @group(0) @binding(0) var<storage, read_write> v : S;
	// v.a = v.a;

	auto* s = Structure("S", Vector{
	Member("a", ty.array(ty.f32())),
	});
	GlobalVar(Source{{12, 34}}, "v", ty.Of(s), core::AddressSpace::kStorage,
	core::Access::kReadWrite, Binding(0_a), Group(0_a));

	WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("v", "a"), MemberAccessor("v", "a")));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(), "56:78 error: storage type of assignment must be constructible");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToPhony_NonConstructibleStruct_Fail) {
	// struct S {
	// arr: array<i32>;
	// };
	// @group(0) @binding(0) var<storage, read_write> s : S;
	// fn f() {
	// _ = s;
	// }
	auto* s = Structure("S", Vector{
	Member("arr", ty.array<i32>()),
	});
	GlobalVar("s", ty.Of(s), core::AddressSpace::kStorage, Group(0_a), Binding(0_a));

	WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s")));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(),
	"12:34 error: cannot assign 'S' to '_'. "
	"'_' can only be assigned a constructible, pointer, texture or "
	"sampler type");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
	// struct S {
	// arr: array<i32>;
	// };
	// @group(0) @binding(0) var<storage, read_write> s : S;
	// fn f() {
	// _ = s.arr;
	// }
	auto* s = Structure("S", Vector{
	Member("arr", ty.array<i32>()),
	});
	GlobalVar("s", ty.Of(s), core::AddressSpace::kStorage, Group(0_a), Binding(0_a));

	WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr")));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(),
	"12:34 error: cannot assign 'array<i32>' to '_'. "
	"'_' can only be assigned a constructible, pointer, texture or sampler "
	"type");
	}

	TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) {
	// struct S {
	// i: i32;
	// arr: array<i32>;
	// };
	// struct U {
	// i: i32;
	// };
	// @group(0) @binding(0) var tex texture_2d;
	// @group(0) @binding(1) var smp sampler;
	// @group(0) @binding(2) var<uniform> u : U;
	// @group(0) @binding(3) var<storage, read_write> s : S;
	// var<workgroup> wg : array<f32, 10>
	// fn f() {
	// _ = 1i;
	// _ = 2u;
	// _ = 3.0f;
	// _ = 4;
	// _ = 5.0;
	// _ = vec2(6);
	// _ = vec3(7.0);
	// _ = vec4<bool>();
	// _ = tex;
	// _ = smp;
	// _ = &s;
	// _ = s.i;
	// _ = &s.arr;
	// _ = u;
	// _ = u.i;
	// _ = wg;
	// _ = wg[3i];
	// }
	auto* S = Structure("S", Vector{
	Member("i", ty.i32()),
	Member("arr", ty.array<i32>()),
	});
	auto* U = Structure("U", Vector{
	Member("i", ty.i32()),
	});
	GlobalVar("tex", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(0_a),
	Binding(0_a));
	GlobalVar("smp", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a), Binding(1_a));
	GlobalVar("u", ty.Of(U), core::AddressSpace::kUniform, Group(0_a), Binding(2_a));
	GlobalVar("s", ty.Of(S), core::AddressSpace::kStorage, Group(0_a), Binding(3_a));
	GlobalVar("wg", ty.array<f32, 10>(), core::AddressSpace::kWorkgroup);

	WrapInFunction(Assign(Phony(), 1_i), //
	Assign(Phony(), 2_u), //
	Assign(Phony(), 3_f), //
	Assign(Phony(), 4_a), //
	Assign(Phony(), 5.0_a), //
	Assign(Phony(), Call<vec2<Infer>>(6_a)), //
	Assign(Phony(), Call<vec3<Infer>>(7.0_a)), //
	Assign(Phony(), Call<vec4<bool>>()), //
	Assign(Phony(), "tex"), //
	Assign(Phony(), "smp"), //
	Assign(Phony(), AddressOf("s")), //
	Assign(Phony(), MemberAccessor("s", "i")), //
	Assign(Phony(), AddressOf(MemberAccessor("s", "arr"))), //
	Assign(Phony(), "u"), //
	Assign(Phony(), MemberAccessor("u", "i")), //
	Assign(Phony(), "wg"), //
	Assign(Phony(), IndexAccessor("wg", 3_i)));

	EXPECT_TRUE(r()->Resolve()) << r()->error();
	}

	} // namespace
	} // namespace tint::resolver