src/resolver/assignment_validation_test.cc - tint - Git at Google

 // Copyright 2021 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "src/resolver/resolver.h"

 #include "gmock/gmock.h"
 #include "src/ast/struct_block_attribute.h"
 #include "src/resolver/resolver_test_helper.h"
 #include "src/sem/storage_texture_type.h"

 namespace tint {
 namespace resolver {
 namespace {

 using ResolverAssignmentValidationTest = ResolverTest;

 TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
   // [[block]] struct S { m : i32 };
   // @group(0) @binding(0)
   // var<storage,read> a : S;
   auto* s = Structure("S", {Member("m", ty.i32())},
                       {create<ast::StructBlockAttribute>()});
   Global(Source{{12, 34}}, "a", ty.Of(s), ast::StorageClass::kStorage,
          ast::Access::kRead,
          ast::AttributeList{
              create<ast::BindingAttribute>(0),
              create<ast::GroupAttribute>(0),
          });

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

   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 = 2;
   //  a = 2.3;
   // }

   auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));

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

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

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

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

   GlobalConst("len", nullptr, Expr(4u));

   auto* a = Var("a", ty.array(ty.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) {
   // let len = 5u;
   // {
   //   var a : array<f32, 4>;
   //   var b : array<f32, len>;
   //   a = b;
   // }

   GlobalConst("len", nullptr, Expr(5u));

   auto* a = Var("a", ty.array(ty.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 = 2;
   //  a = 2
   // }
   auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
   WrapInFunction(var, Assign("a", 2));

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

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

   auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
   WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2.3f));

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

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

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

   auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
   auto* inner_block = Block(Decl(var), Assign(Source{{12, 34}}, "a", 2.3f));
   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, AssignToScalar_Fail) {
   // var my_var : i32 = 2;
   // 1 = my_var;

   auto* var = Var("my_var", ty.i32(), ast::StorageClass::kNone, Expr(2));
   WrapInFunction(var, Assign(Expr(Source{{12, 34}}, 1), "my_var"));

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

 TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypes_Pass) {
   // var a : i32 = 2;
   // a = 2
   auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
   WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2));

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

 TEST_F(ResolverAssignmentValidationTest,
        AssignCompatibleTypesThroughAlias_Pass) {
   // alias myint = i32;
   // var a : myint = 2;
   // a = 2
   auto* myint = Alias("myint", ty.i32());
   auto* var = Var("a", ty.Of(myint), ast::StorageClass::kNone, Expr(2));
   WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2));

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

 TEST_F(ResolverAssignmentValidationTest,
        AssignCompatibleTypesInferRHSLoad_Pass) {
   // var a : i32 = 2;
   // var b : i32 = 3;
   // a = b;
   auto* var_a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
   auto* var_b = Var("b", ty.i32(), ast::StorageClass::kNone, Expr(3));
   WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, "a", "b"));

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

 TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
   // var a : i32;
   // let b : ptr<function,i32> = &a;
   // *b = 2;
   const auto func = ast::StorageClass::kFunction;
   auto* var_a = Var("a", ty.i32(), func, Expr(2));
   auto* var_b = Const("b", ty.pointer<int>(func), AddressOf(Expr("a")));
   WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, Deref("b"), 2));

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

 TEST_F(ResolverAssignmentValidationTest, AssignToConstant_Fail) {
   // {
   //  let a : i32 = 2;
   //  a = 2
   // }
   auto* var = Const("a", ty.i32(), Expr(2));
   WrapInFunction(var, Assign(Expr(Source{{12, 34}}, "a"), 2));

   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(r()->error(),
             "12:34 error: cannot assign to const\nnote: 'a' is 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(ast::TextureDimension::k1d,
                               ast::TexelFormat::kRgba8Unorm,
                               ast::Access::kWrite);
   };

   Global("a", make_type(), ast::StorageClass::kNone,
          ast::AttributeList{
              create<ast::BindingAttribute>(0),
              create<ast::GroupAttribute>(0),
          });
   Global("b", make_type(), ast::StorageClass::kNone,
          ast::AttributeList{
              create<ast::BindingAttribute>(1),
              create<ast::GroupAttribute>(0),
          });

   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) {
   // [[block]] struct S { a : atomic<i32>; };
   // @group(0) @binding(0) var<storage, read_write> v : S;
   // v.a = v.a;

   auto* s = Structure("S", {Member("a", ty.atomic(ty.i32()))},
                       {create<ast::StructBlockAttribute>()});
   Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kStorage,
          ast::Access::kReadWrite,
          ast::AttributeList{
              create<ast::BindingAttribute>(0),
              create<ast::GroupAttribute>(0),
          });

   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) {
   // [[block]] struct S { a : array<f32>; };
   // @group(0) @binding(0) var<storage, read_write> v : S;
   // v.a = v.a;

   auto* s = Structure("S", {Member("a", ty.array(ty.f32()))},
                       {create<ast::StructBlockAttribute>()});
   Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kStorage,
          ast::Access::kReadWrite,
          ast::AttributeList{
              create<ast::BindingAttribute>(0),
              create<ast::GroupAttribute>(0),
          });

   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) {
   // [[block]]
   // struct S {
   //   arr: array<i32>;
   // };
   // @group(0) @binding(0) var<storage, read_write> s : S;
   // fn f() {
   //   _ = s;
   // }
   auto* s = Structure("S", {Member("arr", ty.array<i32>())}, {StructBlock()});
   Global("s", ty.Of(s), ast::StorageClass::kStorage, GroupAndBinding(0, 0));

   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) {
   // [[block]]
   // struct S {
   //   arr: array<i32>;
   // };
   // @group(0) @binding(0) var<storage, read_write> s : S;
   // fn f() {
   //   _ = s.arr;
   // }
   auto* s = Structure("S", {Member("arr", ty.array<i32>())}, {StructBlock()});
   Global("s", ty.Of(s), ast::StorageClass::kStorage, GroupAndBinding(0, 0));

   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) {
   // [[block]]
   // struct S {
   //   i:   i32;
   //   arr: array<i32>;
   // };
   // [[block]]
   // 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() {
   //   _ = 1;
   //   _ = 2u;
   //   _ = 3.0;
   //   _ = vec2<bool>();
   //   _ = tex;
   //   _ = smp;
   //   _ = &s;
   //   _ = s.i;
   //   _ = &s.arr;
   //   _ = u;
   //   _ = u.i;
   //   _ = wg;
   //   _ = wg[3];
   // }
   auto* S = Structure("S",
                       {
                           Member("i", ty.i32()),
                           Member("arr", ty.array<i32>()),
                       },
                       {StructBlock()});
   auto* U = Structure("U", {Member("i", ty.i32())}, {StructBlock()});
   Global("tex", ty.sampled_texture(ast::TextureDimension::k2d, ty.f32()),
          GroupAndBinding(0, 0));
   Global("smp", ty.sampler(ast::SamplerKind::kSampler), GroupAndBinding(0, 1));
   Global("u", ty.Of(U), ast::StorageClass::kUniform, GroupAndBinding(0, 2));
   Global("s", ty.Of(S), ast::StorageClass::kStorage, GroupAndBinding(0, 3));
   Global("wg", ty.array<f32, 10>(), ast::StorageClass::kWorkgroup);

   WrapInFunction(Assign(Phony(), 1),                                      //
                  Assign(Phony(), 2),                                      //
                  Assign(Phony(), 3),                                      //
                  Assign(Phony(), vec2<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)));

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

 }  // namespace
 }  // namespace resolver
 }  // namespace tint
	// Copyright 2021 The Tint Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "src/resolver/resolver.h"

	#include "gmock/gmock.h"
	#include "src/ast/struct_block_attribute.h"
	#include "src/resolver/resolver_test_helper.h"
	#include "src/sem/storage_texture_type.h"

	namespace tint {
	namespace resolver {
	namespace {

	using ResolverAssignmentValidationTest = ResolverTest;

	TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
	// [[block]] struct S { m : i32 };
	// @group(0) @binding(0)
	// var<storage,read> a : S;
	auto* s = Structure("S", {Member("m", ty.i32())},
	{create<ast::StructBlockAttribute>()});
	Global(Source{{12, 34}}, "a", ty.Of(s), ast::StorageClass::kStorage,
	ast::Access::kRead,
	ast::AttributeList{
	create<ast::BindingAttribute>(0),
	create<ast::GroupAttribute>(0),
	});

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

	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 = 2;
	// a = 2.3;
	// }

	auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));

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

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

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

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

	GlobalConst("len", nullptr, Expr(4u));

	auto* a = Var("a", ty.array(ty.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) {
	// let len = 5u;
	// {
	// var a : array<f32, 4>;
	// var b : array<f32, len>;
	// a = b;
	// }

	GlobalConst("len", nullptr, Expr(5u));

	auto* a = Var("a", ty.array(ty.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 = 2;
	// a = 2
	// }
	auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
	WrapInFunction(var, Assign("a", 2));

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

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

	auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
	WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2.3f));

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

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

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

	auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
	auto* inner_block = Block(Decl(var), Assign(Source{{12, 34}}, "a", 2.3f));
	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, AssignToScalar_Fail) {
	// var my_var : i32 = 2;
	// 1 = my_var;

	auto* var = Var("my_var", ty.i32(), ast::StorageClass::kNone, Expr(2));
	WrapInFunction(var, Assign(Expr(Source{{12, 34}}, 1), "my_var"));

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

	TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypes_Pass) {
	// var a : i32 = 2;
	// a = 2
	auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
	WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2));

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

	TEST_F(ResolverAssignmentValidationTest,
	AssignCompatibleTypesThroughAlias_Pass) {
	// alias myint = i32;
	// var a : myint = 2;
	// a = 2
	auto* myint = Alias("myint", ty.i32());
	auto* var = Var("a", ty.Of(myint), ast::StorageClass::kNone, Expr(2));
	WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2));

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

	TEST_F(ResolverAssignmentValidationTest,
	AssignCompatibleTypesInferRHSLoad_Pass) {
	// var a : i32 = 2;
	// var b : i32 = 3;
	// a = b;
	auto* var_a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
	auto* var_b = Var("b", ty.i32(), ast::StorageClass::kNone, Expr(3));
	WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, "a", "b"));

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

	TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
	// var a : i32;
	// let b : ptr<function,i32> = &a;
	// *b = 2;
	const auto func = ast::StorageClass::kFunction;
	auto* var_a = Var("a", ty.i32(), func, Expr(2));
	auto* var_b = Const("b", ty.pointer<int>(func), AddressOf(Expr("a")));
	WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, Deref("b"), 2));

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

	TEST_F(ResolverAssignmentValidationTest, AssignToConstant_Fail) {
	// {
	// let a : i32 = 2;
	// a = 2
	// }
	auto* var = Const("a", ty.i32(), Expr(2));
	WrapInFunction(var, Assign(Expr(Source{{12, 34}}, "a"), 2));

	EXPECT_FALSE(r()->Resolve());
	EXPECT_EQ(r()->error(),
	"12:34 error: cannot assign to const\nnote: 'a' is 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(ast::TextureDimension::k1d,
	ast::TexelFormat::kRgba8Unorm,
	ast::Access::kWrite);
	};

	Global("a", make_type(), ast::StorageClass::kNone,
	ast::AttributeList{
	create<ast::BindingAttribute>(0),
	create<ast::GroupAttribute>(0),
	});
	Global("b", make_type(), ast::StorageClass::kNone,
	ast::AttributeList{
	create<ast::BindingAttribute>(1),
	create<ast::GroupAttribute>(0),
	});

	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) {
	// [[block]] struct S { a : atomic<i32>; };
	// @group(0) @binding(0) var<storage, read_write> v : S;
	// v.a = v.a;

	auto* s = Structure("S", {Member("a", ty.atomic(ty.i32()))},
	{create<ast::StructBlockAttribute>()});
	Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kStorage,
	ast::Access::kReadWrite,
	ast::AttributeList{
	create<ast::BindingAttribute>(0),
	create<ast::GroupAttribute>(0),
	});

	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) {
	// [[block]] struct S { a : array<f32>; };
	// @group(0) @binding(0) var<storage, read_write> v : S;
	// v.a = v.a;

	auto* s = Structure("S", {Member("a", ty.array(ty.f32()))},
	{create<ast::StructBlockAttribute>()});
	Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kStorage,
	ast::Access::kReadWrite,
	ast::AttributeList{
	create<ast::BindingAttribute>(0),
	create<ast::GroupAttribute>(0),
	});

	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) {
	// [[block]]
	// struct S {
	// arr: array<i32>;
	// };
	// @group(0) @binding(0) var<storage, read_write> s : S;
	// fn f() {
	// _ = s;
	// }
	auto* s = Structure("S", {Member("arr", ty.array<i32>())}, {StructBlock()});
	Global("s", ty.Of(s), ast::StorageClass::kStorage, GroupAndBinding(0, 0));

	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) {
	// [[block]]
	// struct S {
	// arr: array<i32>;
	// };
	// @group(0) @binding(0) var<storage, read_write> s : S;
	// fn f() {
	// _ = s.arr;
	// }
	auto* s = Structure("S", {Member("arr", ty.array<i32>())}, {StructBlock()});
	Global("s", ty.Of(s), ast::StorageClass::kStorage, GroupAndBinding(0, 0));

	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) {
	// [[block]]
	// struct S {
	// i: i32;
	// arr: array<i32>;
	// };
	// [[block]]
	// 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() {
	// _ = 1;
	// _ = 2u;
	// _ = 3.0;
	// _ = vec2<bool>();
	// _ = tex;
	// _ = smp;
	// _ = &s;
	// _ = s.i;
	// _ = &s.arr;
	// _ = u;
	// _ = u.i;
	// _ = wg;
	// _ = wg[3];
	// }
	auto* S = Structure("S",
	{
	Member("i", ty.i32()),
	Member("arr", ty.array<i32>()),
	},
	{StructBlock()});
	auto* U = Structure("U", {Member("i", ty.i32())}, {StructBlock()});
	Global("tex", ty.sampled_texture(ast::TextureDimension::k2d, ty.f32()),
	GroupAndBinding(0, 0));
	Global("smp", ty.sampler(ast::SamplerKind::kSampler), GroupAndBinding(0, 1));
	Global("u", ty.Of(U), ast::StorageClass::kUniform, GroupAndBinding(0, 2));
	Global("s", ty.Of(S), ast::StorageClass::kStorage, GroupAndBinding(0, 3));
	Global("wg", ty.array<f32, 10>(), ast::StorageClass::kWorkgroup);

	WrapInFunction(Assign(Phony(), 1), //
	Assign(Phony(), 2), //
	Assign(Phony(), 3), //
	Assign(Phony(), vec2<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)));

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

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