Consistent formatting for Dawn/Tint.
This CL updates the clang format files to have a single shared format
between Dawn and Tint. The major changes are tabs are 4 spaces, lines
are 100 columns and namespaces are not indented.
Bug: dawn:1339
Change-Id: I4208742c95643998d9fd14e77a9cc558071ded39
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/87603
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
diff --git a/src/tint/resolver/array_accessor_test.cc b/src/tint/resolver/array_accessor_test.cc
index 87e28c82..d227ce4 100644
--- a/src/tint/resolver/array_accessor_test.cc
+++ b/src/tint/resolver/array_accessor_test.cc
@@ -24,286 +24,277 @@
using ResolverIndexAccessorTest = ResolverTest;
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_F32) {
- Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1.0f));
- WrapInFunction(acc);
+ Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
+ auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 1.0f));
+ WrapInFunction(acc);
- EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(),
- "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
+ EXPECT_FALSE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
}
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic_Ref) {
- Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
- auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
- auto* acc = IndexAccessor("my_var", idx);
- WrapInFunction(Decl(idx), acc);
+ Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
+ auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
+ auto* acc = IndexAccessor("my_var", idx);
+ WrapInFunction(Decl(idx), acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) {
- Global("my_var", ty.mat4x4<f32>(), ast::StorageClass::kPrivate);
- auto* idx = Var("idx", ty.u32(), Expr(3u));
- auto* idy = Var("idy", ty.u32(), Expr(2u));
- auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy);
- WrapInFunction(Decl(idx), Decl(idy), acc);
+ Global("my_var", ty.mat4x4<f32>(), ast::StorageClass::kPrivate);
+ auto* idx = Var("idx", ty.u32(), Expr(3u));
+ auto* idy = Var("idy", ty.u32(), Expr(2u));
+ auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy);
+ WrapInFunction(Decl(idx), Decl(idy), acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverIndexAccessorTest, Matrix_Dynamic) {
- GlobalConst("my_const", ty.mat2x3<f32>(), Construct(ty.mat2x3<f32>()));
- auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
- auto* acc = IndexAccessor("my_const", Expr(Source{{12, 34}}, idx));
- WrapInFunction(Decl(idx), acc);
+ GlobalConst("my_const", ty.mat2x3<f32>(), Construct(ty.mat2x3<f32>()));
+ auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
+ auto* acc = IndexAccessor("my_const", Expr(Source{{12, 34}}, idx));
+ WrapInFunction(Decl(idx), acc);
- EXPECT_TRUE(r()->Resolve());
- EXPECT_EQ(r()->error(), "");
+ EXPECT_TRUE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "");
}
TEST_F(ResolverIndexAccessorTest, Matrix_XDimension_Dynamic) {
- GlobalConst("my_var", ty.mat4x4<f32>(), Construct(ty.mat4x4<f32>()));
- auto* idx = Var("idx", ty.u32(), Expr(3u));
- auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, idx));
- WrapInFunction(Decl(idx), acc);
+ GlobalConst("my_var", ty.mat4x4<f32>(), Construct(ty.mat4x4<f32>()));
+ auto* idx = Var("idx", ty.u32(), Expr(3u));
+ auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, idx));
+ WrapInFunction(Decl(idx), acc);
- EXPECT_TRUE(r()->Resolve());
- EXPECT_EQ(r()->error(), "");
+ EXPECT_TRUE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "");
}
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimension_Dynamic) {
- GlobalConst("my_var", ty.mat4x4<f32>(), Construct(ty.mat4x4<f32>()));
- auto* idx = Var("idy", ty.u32(), Expr(2u));
- auto* acc =
- IndexAccessor(IndexAccessor("my_var", Expr(Source{{12, 34}}, idx)), 1);
- WrapInFunction(Decl(idx), acc);
+ GlobalConst("my_var", ty.mat4x4<f32>(), Construct(ty.mat4x4<f32>()));
+ auto* idx = Var("idy", ty.u32(), Expr(2u));
+ auto* acc = IndexAccessor(IndexAccessor("my_var", Expr(Source{{12, 34}}, idx)), 1);
+ WrapInFunction(Decl(idx), acc);
- EXPECT_TRUE(r()->Resolve());
- EXPECT_EQ(r()->error(), "");
+ EXPECT_TRUE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "");
}
TEST_F(ResolverIndexAccessorTest, Matrix) {
- Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
+ Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", 2);
- WrapInFunction(acc);
+ auto* acc = IndexAccessor("my_var", 2);
+ WrapInFunction(acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
- ASSERT_NE(TypeOf(acc), nullptr);
- ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
+ ASSERT_NE(TypeOf(acc), nullptr);
+ ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
- auto* ref = TypeOf(acc)->As<sem::Reference>();
- ASSERT_TRUE(ref->StoreType()->Is<sem::Vector>());
- EXPECT_EQ(ref->StoreType()->As<sem::Vector>()->Width(), 3u);
+ auto* ref = TypeOf(acc)->As<sem::Reference>();
+ ASSERT_TRUE(ref->StoreType()->Is<sem::Vector>());
+ EXPECT_EQ(ref->StoreType()->As<sem::Vector>()->Width(), 3u);
}
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
- Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
+ Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor(IndexAccessor("my_var", 2), 1);
- WrapInFunction(acc);
+ auto* acc = IndexAccessor(IndexAccessor("my_var", 2), 1);
+ WrapInFunction(acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
- ASSERT_NE(TypeOf(acc), nullptr);
- ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
+ ASSERT_NE(TypeOf(acc), nullptr);
+ ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
- auto* ref = TypeOf(acc)->As<sem::Reference>();
- EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
+ auto* ref = TypeOf(acc)->As<sem::Reference>();
+ EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
}
TEST_F(ResolverIndexAccessorTest, Vector_F32) {
- Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2.0f));
- WrapInFunction(acc);
+ Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+ auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, 2.0f));
+ WrapInFunction(acc);
- EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(),
- "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
+ EXPECT_FALSE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
}
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) {
- Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
- auto* idx = Var("idx", ty.i32(), Expr(2));
- auto* acc = IndexAccessor("my_var", idx);
- WrapInFunction(Decl(idx), acc);
+ Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+ auto* idx = Var("idx", ty.i32(), Expr(2));
+ auto* acc = IndexAccessor("my_var", idx);
+ WrapInFunction(Decl(idx), acc);
- EXPECT_TRUE(r()->Resolve());
+ EXPECT_TRUE(r()->Resolve());
}
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic) {
- GlobalConst("my_var", ty.vec3<f32>(), Construct(ty.vec3<f32>()));
- auto* idx = Var("idx", ty.i32(), Expr(2));
- auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, idx));
- WrapInFunction(Decl(idx), acc);
+ GlobalConst("my_var", ty.vec3<f32>(), Construct(ty.vec3<f32>()));
+ auto* idx = Var("idx", ty.i32(), Expr(2));
+ auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, idx));
+ WrapInFunction(Decl(idx), acc);
- EXPECT_TRUE(r()->Resolve());
+ EXPECT_TRUE(r()->Resolve());
}
TEST_F(ResolverIndexAccessorTest, Vector) {
- Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+ Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", 2);
- WrapInFunction(acc);
+ auto* acc = IndexAccessor("my_var", 2);
+ WrapInFunction(acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
- ASSERT_NE(TypeOf(acc), nullptr);
- ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
+ ASSERT_NE(TypeOf(acc), nullptr);
+ ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
- auto* ref = TypeOf(acc)->As<sem::Reference>();
- EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
+ auto* ref = TypeOf(acc)->As<sem::Reference>();
+ EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
}
TEST_F(ResolverIndexAccessorTest, Array) {
- auto* idx = Expr(2);
- Global("my_var", ty.array<f32, 3>(), ast::StorageClass::kPrivate);
+ auto* idx = Expr(2);
+ Global("my_var", ty.array<f32, 3>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", idx);
- WrapInFunction(acc);
+ auto* acc = IndexAccessor("my_var", idx);
+ WrapInFunction(acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
- ASSERT_NE(TypeOf(acc), nullptr);
- ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
+ ASSERT_NE(TypeOf(acc), nullptr);
+ ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
- auto* ref = TypeOf(acc)->As<sem::Reference>();
- EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
+ auto* ref = TypeOf(acc)->As<sem::Reference>();
+ EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
}
TEST_F(ResolverIndexAccessorTest, Alias_Array) {
- auto* aary = Alias("myarrty", ty.array<f32, 3>());
+ auto* aary = Alias("myarrty", ty.array<f32, 3>());
- Global("my_var", ty.Of(aary), ast::StorageClass::kPrivate);
+ Global("my_var", ty.Of(aary), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", 2);
- WrapInFunction(acc);
+ auto* acc = IndexAccessor("my_var", 2);
+ WrapInFunction(acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
- ASSERT_NE(TypeOf(acc), nullptr);
- ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
+ ASSERT_NE(TypeOf(acc), nullptr);
+ ASSERT_TRUE(TypeOf(acc)->Is<sem::Reference>());
- auto* ref = TypeOf(acc)->As<sem::Reference>();
- EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
+ auto* ref = TypeOf(acc)->As<sem::Reference>();
+ EXPECT_TRUE(ref->StoreType()->Is<sem::F32>());
}
TEST_F(ResolverIndexAccessorTest, Array_Constant) {
- GlobalConst("my_var", ty.array<f32, 3>(), array<f32, 3>());
+ GlobalConst("my_var", ty.array<f32, 3>(), array<f32, 3>());
- auto* acc = IndexAccessor("my_var", 2);
- WrapInFunction(acc);
+ auto* acc = IndexAccessor("my_var", 2);
+ WrapInFunction(acc);
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
- ASSERT_NE(TypeOf(acc), nullptr);
- EXPECT_TRUE(TypeOf(acc)->Is<sem::F32>());
+ ASSERT_NE(TypeOf(acc), nullptr);
+ EXPECT_TRUE(TypeOf(acc)->Is<sem::F32>());
}
TEST_F(ResolverIndexAccessorTest, Array_Dynamic_I32) {
- // let a : array<f32, 3> = 0;
- // var idx : i32 = 0;
- // var f : f32 = a[idx];
- auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
- auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
- auto* f = Var("f", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, idx)));
- Func("my_func", ast::VariableList{}, ty.void_(),
- {
- Decl(a),
- Decl(idx),
- Decl(f),
- },
- ast::AttributeList{});
+ // let a : array<f32, 3> = 0;
+ // var idx : i32 = 0;
+ // var f : f32 = a[idx];
+ auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
+ auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
+ auto* f = Var("f", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, idx)));
+ Func("my_func", ast::VariableList{}, ty.void_(),
+ {
+ Decl(a),
+ Decl(idx),
+ Decl(f),
+ },
+ ast::AttributeList{});
- EXPECT_TRUE(r()->Resolve());
- EXPECT_EQ(r()->error(), "");
+ EXPECT_TRUE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "");
}
TEST_F(ResolverIndexAccessorTest, Array_Literal_F32) {
- // let a : array<f32, 3>;
- // var f : f32 = a[2.0f];
- auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
- auto* f =
- Var("a_2", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, 2.0f)));
- Func("my_func", ast::VariableList{}, ty.void_(),
- {
- Decl(a),
- Decl(f),
- },
- ast::AttributeList{});
- EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(),
- "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
+ // let a : array<f32, 3>;
+ // var f : f32 = a[2.0f];
+ auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
+ auto* f = Var("a_2", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, 2.0f)));
+ Func("my_func", ast::VariableList{}, ty.void_(),
+ {
+ Decl(a),
+ Decl(f),
+ },
+ ast::AttributeList{});
+ EXPECT_FALSE(r()->Resolve());
+ EXPECT_EQ(r()->error(), "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
}
TEST_F(ResolverIndexAccessorTest, Array_Literal_I32) {
- // let a : array<f32, 3>;
- // var f : f32 = a[2];
- auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
- auto* f = Var("a_2", ty.f32(), IndexAccessor("a", 2));
- Func("my_func", ast::VariableList{}, ty.void_(),
- {
- Decl(a),
- Decl(f),
- },
- ast::AttributeList{});
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ // let a : array<f32, 3>;
+ // var f : f32 = a[2];
+ auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
+ auto* f = Var("a_2", ty.f32(), IndexAccessor("a", 2));
+ Func("my_func", ast::VariableList{}, ty.void_(),
+ {
+ Decl(a),
+ Decl(f),
+ },
+ ast::AttributeList{});
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverIndexAccessorTest, EXpr_Deref_FuncGoodParent) {
- // fn func(p: ptr<function, vec4<f32>>) -> f32 {
- // let idx: u32 = u32();
- // let x: f32 = (*p)[idx];
- // return x;
- // }
- auto* p =
- Param("p", ty.pointer(ty.vec4<f32>(), ast::StorageClass::kFunction));
- auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
- auto* star_p = Deref(p);
- auto* accessor_expr = IndexAccessor(Source{{12, 34}}, star_p, idx);
- auto* x = Var("x", ty.f32(), accessor_expr);
- Func("func", {p}, ty.f32(), {Decl(idx), Decl(x), Return(x)});
+ // fn func(p: ptr<function, vec4<f32>>) -> f32 {
+ // let idx: u32 = u32();
+ // let x: f32 = (*p)[idx];
+ // return x;
+ // }
+ auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::StorageClass::kFunction));
+ auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
+ auto* star_p = Deref(p);
+ auto* accessor_expr = IndexAccessor(Source{{12, 34}}, star_p, idx);
+ auto* x = Var("x", ty.f32(), accessor_expr);
+ Func("func", {p}, ty.f32(), {Decl(idx), Decl(x), Return(x)});
- EXPECT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverIndexAccessorTest, EXpr_Deref_FuncBadParent) {
- // fn func(p: ptr<function, vec4<f32>>) -> f32 {
- // let idx: u32 = u32();
- // let x: f32 = *p[idx];
- // return x;
- // }
- auto* p =
- Param("p", ty.pointer(ty.vec4<f32>(), ast::StorageClass::kFunction));
- auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
- auto* accessor_expr = IndexAccessor(Source{{12, 34}}, p, idx);
- auto* star_p = Deref(accessor_expr);
- auto* x = Var("x", ty.f32(), star_p);
- Func("func", {p}, ty.f32(), {Decl(idx), Decl(x), Return(x)});
+ // fn func(p: ptr<function, vec4<f32>>) -> f32 {
+ // let idx: u32 = u32();
+ // let x: f32 = *p[idx];
+ // return x;
+ // }
+ auto* p = Param("p", ty.pointer(ty.vec4<f32>(), ast::StorageClass::kFunction));
+ auto* idx = Let("idx", ty.u32(), Construct(ty.u32()));
+ auto* accessor_expr = IndexAccessor(Source{{12, 34}}, p, idx);
+ auto* star_p = Deref(accessor_expr);
+ auto* x = Var("x", ty.f32(), star_p);
+ Func("func", {p}, ty.f32(), {Decl(idx), Decl(x), Return(x)});
- EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(
- r()->error(),
- "12:34 error: cannot index type 'ptr<function, vec4<f32>, read_write>'");
+ EXPECT_FALSE(r()->Resolve());
+ EXPECT_EQ(r()->error(),
+ "12:34 error: cannot index type 'ptr<function, vec4<f32>, read_write>'");
}
TEST_F(ResolverIndexAccessorTest, Exr_Deref_BadParent) {
- // var param: vec4<f32>
- // let x: f32 = *(¶m)[0];
- auto* param = Var("param", ty.vec4<f32>());
- auto* idx = Var("idx", ty.u32(), Construct(ty.u32()));
- auto* addressOf_expr = AddressOf(param);
- auto* accessor_expr = IndexAccessor(Source{{12, 34}}, addressOf_expr, idx);
- auto* star_p = Deref(accessor_expr);
- auto* x = Var("x", ty.f32(), star_p);
- WrapInFunction(param, idx, x);
+ // var param: vec4<f32>
+ // let x: f32 = *(¶m)[0];
+ auto* param = Var("param", ty.vec4<f32>());
+ auto* idx = Var("idx", ty.u32(), Construct(ty.u32()));
+ auto* addressOf_expr = AddressOf(param);
+ auto* accessor_expr = IndexAccessor(Source{{12, 34}}, addressOf_expr, idx);
+ auto* star_p = Deref(accessor_expr);
+ auto* x = Var("x", ty.f32(), star_p);
+ WrapInFunction(param, idx, x);
- EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(
- r()->error(),
- "12:34 error: cannot index type 'ptr<function, vec4<f32>, read_write>'");
+ EXPECT_FALSE(r()->Resolve());
+ EXPECT_EQ(r()->error(),
+ "12:34 error: cannot index type 'ptr<function, vec4<f32>, read_write>'");
}
} // namespace
