src/resolver/var_let_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/ast/struct_block_decoration.h"

            
            #include "src/resolver/resolver.h"

            
            #include "src/resolver/resolver_test_helper.h"

            
            #include "src/sem/reference_type.h"


            #include "gmock/gmock.h"


            namespace tint {

            
            namespace resolver {

            
            namespace {


            struct ResolverVarLetTest : public resolver::TestHelper,

            
                                        public testing::Test {};


            TEST_F(ResolverVarLetTest, TypeOfVar) {

            
              // struct S { i : i32; }

            
              // alias A = S;

            
              // fn F(){

            
              //   var i : i32;

            
              //   var u : u32;

            
              //   var f : f32;

            
              //   var b : bool;

            
              //   var s : S;

            
              //   var a : A;

            
              // }


              auto* S = Structure("S", {Member("i", ty.i32())});

            
              auto* A = Alias("A", ty.Of(S));


              auto* i = Var("i", ty.i32(), ast::StorageClass::kNone);

            
              auto* u = Var("u", ty.u32(), ast::StorageClass::kNone);

            
              auto* f = Var("f", ty.f32(), ast::StorageClass::kNone);

            
              auto* b = Var("b", ty.bool_(), ast::StorageClass::kNone);

            
              auto* s = Var("s", ty.Of(S), ast::StorageClass::kNone);

            
              auto* a = Var("a", ty.Of(A), ast::StorageClass::kNone);


              Func("F", {}, ty.void_(),

            
                   {

            
                       Decl(i),

            
                       Decl(u),

            
                       Decl(f),

            
                       Decl(b),

            
                       Decl(s),

            
                       Decl(a),

            
                   });


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


              // `var` declarations are always of reference type

            
              ASSERT_TRUE(TypeOf(i)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(u)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(f)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(b)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(s)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(a)->Is<sem::Reference>());


              EXPECT_TRUE(TypeOf(i)->As<sem::Reference>()->StoreType()->Is<sem::I32>());

            
              EXPECT_TRUE(TypeOf(u)->As<sem::Reference>()->StoreType()->Is<sem::U32>());

            
              EXPECT_TRUE(TypeOf(f)->As<sem::Reference>()->StoreType()->Is<sem::F32>());

            
              EXPECT_TRUE(TypeOf(b)->As<sem::Reference>()->StoreType()->Is<sem::Bool>());

            
              EXPECT_TRUE(TypeOf(s)->As<sem::Reference>()->StoreType()->Is<sem::Struct>());

            
              EXPECT_TRUE(TypeOf(a)->As<sem::Reference>()->StoreType()->Is<sem::Struct>());

            
            }


            TEST_F(ResolverVarLetTest, TypeOfLet) {

            
              // struct S { i : i32; }

            
              // fn F(){

            
              //   var v : i32;

            
              //   let i : i32 = 1;

            
              //   let u : u32 = 1u;

            
              //   let f : f32 = 1.;

            
              //   let b : bool = true;

            
              //   let s : S = S(1);

            
              //   let a : A = A(1);

            
              //   let p : pointer<function, i32> = &V;

            
              // }


              auto* S = Structure("S", {Member("i", ty.i32())});

            
              auto* A = Alias("A", ty.Of(S));


              auto* v = Var("v", ty.i32(), ast::StorageClass::kNone);

            
              auto* i = Const("i", ty.i32(), Expr(1));

            
              auto* u = Const("u", ty.u32(), Expr(1u));

            
              auto* f = Const("f", ty.f32(), Expr(1.f));

            
              auto* b = Const("b", ty.bool_(), Expr(true));

            
              auto* s = Const("s", ty.Of(S), Construct(ty.Of(S), Expr(1)));

            
              auto* a = Const("a", ty.Of(A), Construct(ty.Of(A), Expr(1)));

            
              auto* p =

            
                  Const("p", ty.pointer<i32>(ast::StorageClass::kFunction), AddressOf(v));


              Func("F", {}, ty.void_(),

            
                   {

            
                       Decl(v),

            
                       Decl(i),

            
                       Decl(u),

            
                       Decl(f),

            
                       Decl(b),

            
                       Decl(s),

            
                       Decl(a),

            
                       Decl(p),

            
                   });


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


              // `let` declarations are always of the storage type

            
              EXPECT_TRUE(TypeOf(i)->Is<sem::I32>());

            
              EXPECT_TRUE(TypeOf(u)->Is<sem::U32>());

            
              EXPECT_TRUE(TypeOf(f)->Is<sem::F32>());

            
              EXPECT_TRUE(TypeOf(b)->Is<sem::Bool>());

            
              EXPECT_TRUE(TypeOf(s)->Is<sem::Struct>());

            
              EXPECT_TRUE(TypeOf(a)->Is<sem::Struct>());

            
              ASSERT_TRUE(TypeOf(p)->Is<sem::Pointer>());

            
              EXPECT_TRUE(TypeOf(p)->As<sem::Pointer>()->StoreType()->Is<sem::I32>());

            
            }


            TEST_F(ResolverVarLetTest, DefaultVarStorageClass) {

            
              // https://gpuweb.github.io/gpuweb/wgsl/#storage-class


              auto* buf = Structure("S", {Member("m", ty.i32())},

            
                                    {create<ast::StructBlockDecoration>()});

            
              auto* function = Var("f", ty.i32());

            
              auto* private_ = Global("p", ty.i32(), ast::StorageClass::kPrivate);

            
              auto* workgroup = Global("w", ty.i32(), ast::StorageClass::kWorkgroup);

            
              auto* uniform = Global("ub", ty.Of(buf), ast::StorageClass::kUniform,

            
                                     ast::DecorationList{

            
                                         create<ast::BindingDecoration>(0),

            
                                         create<ast::GroupDecoration>(0),

            
                                     });

            
              auto* storage = Global("sb", ty.Of(buf), ast::StorageClass::kStorage,

            
                                     ast::DecorationList{

            
                                         create<ast::BindingDecoration>(1),

            
                                         create<ast::GroupDecoration>(0),

            
                                     });

            
              auto* handle = Global("h", ty.depth_texture(ast::TextureDimension::k2d),

            
                                    ast::DecorationList{

            
                                        create<ast::BindingDecoration>(2),

            
                                        create<ast::GroupDecoration>(0),

            
                                    });


              WrapInFunction(function);


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


              ASSERT_TRUE(TypeOf(function)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(private_)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(workgroup)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(uniform)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(storage)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(handle)->Is<sem::Reference>());


              EXPECT_EQ(TypeOf(function)->As<sem::Reference>()->Access(),

            
                        ast::Access::kReadWrite);

            
              EXPECT_EQ(TypeOf(private_)->As<sem::Reference>()->Access(),

            
                        ast::Access::kReadWrite);

            
              EXPECT_EQ(TypeOf(workgroup)->As<sem::Reference>()->Access(),

            
                        ast::Access::kReadWrite);

            
              EXPECT_EQ(TypeOf(uniform)->As<sem::Reference>()->Access(),

            
                        ast::Access::kRead);

            
              EXPECT_EQ(TypeOf(storage)->As<sem::Reference>()->Access(),

            
                        ast::Access::kRead);

            
              EXPECT_EQ(TypeOf(handle)->As<sem::Reference>()->Access(), ast::Access::kRead);

            
            }


            TEST_F(ResolverVarLetTest, ExplicitVarStorageClass) {

            
              // https://gpuweb.github.io/gpuweb/wgsl/#storage-class


              auto* buf = Structure("S", {Member("m", ty.i32())},

            
                                    {create<ast::StructBlockDecoration>()});

            
              auto* storage = Global("sb", ty.Of(buf), ast::StorageClass::kStorage,

            
                                     ast::Access::kReadWrite,

            
                                     ast::DecorationList{

            
                                         create<ast::BindingDecoration>(1),

            
                                         create<ast::GroupDecoration>(0),

            
                                     });


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


              ASSERT_TRUE(TypeOf(storage)->Is<sem::Reference>());


              EXPECT_EQ(TypeOf(storage)->As<sem::Reference>()->Access(),

            
                        ast::Access::kReadWrite);

            
            }


            TEST_F(ResolverVarLetTest, LetInheritsAccessFromOriginatingVariable) {

            
              // struct Inner {

            
              //    arr: array<i32, 4>;

            
              // }

            
              // [[block]] struct S {

            
              //    inner: Inner;

            
              // }

            
              // [[group(0), binding(0)]] var<storage, read_write> s : S;

            
              // fn f() {

            
              //   let p = &s.inner.arr[2];

            
              // }

            
              auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});

            
              auto* buf = Structure("S", {Member("inner", ty.Of(inner))},

            
                                    {create<ast::StructBlockDecoration>()});

            
              auto* storage = Global("s", ty.Of(buf), ast::StorageClass::kStorage,

            
                                     ast::Access::kReadWrite,

            
                                     ast::DecorationList{

            
                                         create<ast::BindingDecoration>(0),

            
                                         create<ast::GroupDecoration>(0),

            
                                     });


              auto* expr =

            
                  IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4);

            
              auto* ptr = Const("p", nullptr, AddressOf(expr));


              WrapInFunction(ptr);


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


              ASSERT_TRUE(TypeOf(expr)->Is<sem::Reference>());

            
              ASSERT_TRUE(TypeOf(ptr)->Is<sem::Pointer>());


              EXPECT_EQ(TypeOf(expr)->As<sem::Reference>()->Access(),

            
                        ast::Access::kReadWrite);

            
              EXPECT_EQ(TypeOf(ptr)->As<sem::Pointer>()->Access(), ast::Access::kReadWrite);

            
            }


            }  // 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/ast/struct_block_decoration.h"
	#include "src/resolver/resolver.h"
	#include "src/resolver/resolver_test_helper.h"
	#include "src/sem/reference_type.h"

	#include "gmock/gmock.h"

	namespace tint {
	namespace resolver {
	namespace {

	struct ResolverVarLetTest : public resolver::TestHelper,
	public testing::Test {};

	TEST_F(ResolverVarLetTest, TypeOfVar) {
	// struct S { i : i32; }
	// alias A = S;
	// fn F(){
	// var i : i32;
	// var u : u32;
	// var f : f32;
	// var b : bool;
	// var s : S;
	// var a : A;
	// }

	auto* S = Structure("S", {Member("i", ty.i32())});
	auto* A = Alias("A", ty.Of(S));

	auto* i = Var("i", ty.i32(), ast::StorageClass::kNone);
	auto* u = Var("u", ty.u32(), ast::StorageClass::kNone);
	auto* f = Var("f", ty.f32(), ast::StorageClass::kNone);
	auto* b = Var("b", ty.bool_(), ast::StorageClass::kNone);
	auto* s = Var("s", ty.Of(S), ast::StorageClass::kNone);
	auto* a = Var("a", ty.Of(A), ast::StorageClass::kNone);

	Func("F", {}, ty.void_(),
	{
	Decl(i),
	Decl(u),
	Decl(f),
	Decl(b),
	Decl(s),
	Decl(a),
	});

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

	// `var` declarations are always of reference type
	ASSERT_TRUE(TypeOf(i)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(u)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(f)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(b)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(s)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(a)->Is<sem::Reference>());

	EXPECT_TRUE(TypeOf(i)->As<sem::Reference>()->StoreType()->Is<sem::I32>());
	EXPECT_TRUE(TypeOf(u)->As<sem::Reference>()->StoreType()->Is<sem::U32>());
	EXPECT_TRUE(TypeOf(f)->As<sem::Reference>()->StoreType()->Is<sem::F32>());
	EXPECT_TRUE(TypeOf(b)->As<sem::Reference>()->StoreType()->Is<sem::Bool>());
	EXPECT_TRUE(TypeOf(s)->As<sem::Reference>()->StoreType()->Is<sem::Struct>());
	EXPECT_TRUE(TypeOf(a)->As<sem::Reference>()->StoreType()->Is<sem::Struct>());
	}

	TEST_F(ResolverVarLetTest, TypeOfLet) {
	// struct S { i : i32; }
	// fn F(){
	// var v : i32;
	// let i : i32 = 1;
	// let u : u32 = 1u;
	// let f : f32 = 1.;
	// let b : bool = true;
	// let s : S = S(1);
	// let a : A = A(1);
	// let p : pointer<function, i32> = &V;
	// }

	auto* S = Structure("S", {Member("i", ty.i32())});
	auto* A = Alias("A", ty.Of(S));

	auto* v = Var("v", ty.i32(), ast::StorageClass::kNone);
	auto* i = Const("i", ty.i32(), Expr(1));
	auto* u = Const("u", ty.u32(), Expr(1u));
	auto* f = Const("f", ty.f32(), Expr(1.f));
	auto* b = Const("b", ty.bool_(), Expr(true));
	auto* s = Const("s", ty.Of(S), Construct(ty.Of(S), Expr(1)));
	auto* a = Const("a", ty.Of(A), Construct(ty.Of(A), Expr(1)));
	auto* p =
	Const("p", ty.pointer<i32>(ast::StorageClass::kFunction), AddressOf(v));

	Func("F", {}, ty.void_(),
	{
	Decl(v),
	Decl(i),
	Decl(u),
	Decl(f),
	Decl(b),
	Decl(s),
	Decl(a),
	Decl(p),
	});

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

	// `let` declarations are always of the storage type
	EXPECT_TRUE(TypeOf(i)->Is<sem::I32>());
	EXPECT_TRUE(TypeOf(u)->Is<sem::U32>());
	EXPECT_TRUE(TypeOf(f)->Is<sem::F32>());
	EXPECT_TRUE(TypeOf(b)->Is<sem::Bool>());
	EXPECT_TRUE(TypeOf(s)->Is<sem::Struct>());
	EXPECT_TRUE(TypeOf(a)->Is<sem::Struct>());
	ASSERT_TRUE(TypeOf(p)->Is<sem::Pointer>());
	EXPECT_TRUE(TypeOf(p)->As<sem::Pointer>()->StoreType()->Is<sem::I32>());
	}

	TEST_F(ResolverVarLetTest, DefaultVarStorageClass) {
	// https://gpuweb.github.io/gpuweb/wgsl/#storage-class

	auto* buf = Structure("S", {Member("m", ty.i32())},
	{create<ast::StructBlockDecoration>()});
	auto* function = Var("f", ty.i32());
	auto* private_ = Global("p", ty.i32(), ast::StorageClass::kPrivate);
	auto* workgroup = Global("w", ty.i32(), ast::StorageClass::kWorkgroup);
	auto* uniform = Global("ub", ty.Of(buf), ast::StorageClass::kUniform,
	ast::DecorationList{
	create<ast::BindingDecoration>(0),
	create<ast::GroupDecoration>(0),
	});
	auto* storage = Global("sb", ty.Of(buf), ast::StorageClass::kStorage,
	ast::DecorationList{
	create<ast::BindingDecoration>(1),
	create<ast::GroupDecoration>(0),
	});
	auto* handle = Global("h", ty.depth_texture(ast::TextureDimension::k2d),
	ast::DecorationList{
	create<ast::BindingDecoration>(2),
	create<ast::GroupDecoration>(0),
	});

	WrapInFunction(function);

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

	ASSERT_TRUE(TypeOf(function)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(private_)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(workgroup)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(uniform)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(storage)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(handle)->Is<sem::Reference>());

	EXPECT_EQ(TypeOf(function)->As<sem::Reference>()->Access(),
	ast::Access::kReadWrite);
	EXPECT_EQ(TypeOf(private_)->As<sem::Reference>()->Access(),
	ast::Access::kReadWrite);
	EXPECT_EQ(TypeOf(workgroup)->As<sem::Reference>()->Access(),
	ast::Access::kReadWrite);
	EXPECT_EQ(TypeOf(uniform)->As<sem::Reference>()->Access(),
	ast::Access::kRead);
	EXPECT_EQ(TypeOf(storage)->As<sem::Reference>()->Access(),
	ast::Access::kRead);
	EXPECT_EQ(TypeOf(handle)->As<sem::Reference>()->Access(), ast::Access::kRead);
	}

	TEST_F(ResolverVarLetTest, ExplicitVarStorageClass) {
	// https://gpuweb.github.io/gpuweb/wgsl/#storage-class

	auto* buf = Structure("S", {Member("m", ty.i32())},
	{create<ast::StructBlockDecoration>()});
	auto* storage = Global("sb", ty.Of(buf), ast::StorageClass::kStorage,
	ast::Access::kReadWrite,
	ast::DecorationList{
	create<ast::BindingDecoration>(1),
	create<ast::GroupDecoration>(0),
	});

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

	ASSERT_TRUE(TypeOf(storage)->Is<sem::Reference>());

	EXPECT_EQ(TypeOf(storage)->As<sem::Reference>()->Access(),
	ast::Access::kReadWrite);
	}

	TEST_F(ResolverVarLetTest, LetInheritsAccessFromOriginatingVariable) {
	// struct Inner {
	// arr: array<i32, 4>;
	// }
	// [[block]] struct S {
	// inner: Inner;
	// }
	// [[group(0), binding(0)]] var<storage, read_write> s : S;
	// fn f() {
	// let p = &s.inner.arr[2];
	// }
	auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
	auto* buf = Structure("S", {Member("inner", ty.Of(inner))},
	{create<ast::StructBlockDecoration>()});
	auto* storage = Global("s", ty.Of(buf), ast::StorageClass::kStorage,
	ast::Access::kReadWrite,
	ast::DecorationList{
	create<ast::BindingDecoration>(0),
	create<ast::GroupDecoration>(0),
	});

	auto* expr =
	IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4);
	auto* ptr = Const("p", nullptr, AddressOf(expr));

	WrapInFunction(ptr);

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

	ASSERT_TRUE(TypeOf(expr)->Is<sem::Reference>());
	ASSERT_TRUE(TypeOf(ptr)->Is<sem::Pointer>());

	EXPECT_EQ(TypeOf(expr)->As<sem::Reference>()->Access(),
	ast::Access::kReadWrite);
	EXPECT_EQ(TypeOf(ptr)->As<sem::Pointer>()->Access(), ast::Access::kReadWrite);
	}

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