Import Tint changes from Dawn
Changes:
- f6d95d32448dec268d24b4529e5c49cc44ce9c2c Rename TypeFlags and TypeFlag. by dan sinclair <dsinclair@chromium.org>
- 28a7827981dd644d52b1affbd2860917c7fb641c Rename type Base methods by dan sinclair <dsinclair@chromium.org>
- 7c9e639e359c97d42ef1071211d47942eef837de tint: const eval of mix builtin by Antonio Maiorano <amaiorano@google.com>
GitOrigin-RevId: f6d95d32448dec268d24b4529e5c49cc44ce9c2c
Change-Id: Ifd77e1d36fcf5d147fb1c6d724499f8e436c8ae8
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/113940
Commit-Queue: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index 8a58c70..7e36750 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -520,9 +520,9 @@
@const fn max<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
@const fn min<T: fia_fiu32_f16>(T, T) -> T
@const fn min<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-fn mix<T: f32_f16>(T, T, T) -> T
-fn mix<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-fn mix<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
+@const fn mix<T: fa_f32_f16>(T, T, T) -> T
+@const fn mix<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@const fn mix<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
@const fn modf<T: fa_f32_f16>(@test_value(-1.5) T) -> __modf_result<T>
@const fn modf<N: num, T: fa_f32_f16>(@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T>
@const fn normalize<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index ff23562..81495f7 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -497,7 +497,7 @@
/// @returns the de-aliased array count pointer
template <typename T, typename... ARGS>
traits::EnableIf<traits::IsTypeOrDerived<T, type::ArrayCount> ||
- traits::IsTypeOrDerived<T, type::StructMemberBase>,
+ traits::IsTypeOrDerived<T, type::StructMember>,
T>*
create(ARGS&&... args) {
AssertNotMoved();
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index 6469897..da73215 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -416,7 +416,7 @@
utils::Vector<const sem::Constant*, 4> conv_els;
conv_els.Reserve(elements.Length());
std::function<const type::Type*(size_t idx)> target_el_ty;
- if (auto* str = target_ty->As<type::StructBase>()) {
+ if (auto* str = target_ty->As<type::Struct>()) {
if (str->Members().Length() != elements.Length()) {
TINT_ICE(Resolver, builder.Diagnostics())
<< "const-eval conversion of structure has mismatched element counts";
@@ -494,7 +494,7 @@
}
return nullptr;
},
- [&](const type::StructBase* s) -> const ImplConstant* {
+ [&](const type::Struct* s) -> const ImplConstant* {
utils::Hashmap<const type::Type*, const ImplConstant*, 8> zero_by_type;
utils::Vector<const sem::Constant*, 4> zeros;
zeros.Reserve(s->Members().Length());
@@ -1449,7 +1449,7 @@
}
ConstEval::Result ConstEval::MemberAccess(const sem::Expression* obj_expr,
- const type::StructMemberBase* member) {
+ const type::StructMember* member) {
auto obj_val = obj_expr->ConstantValue();
if (!obj_val) {
return nullptr;
@@ -2864,6 +2864,49 @@
return TransformElements(builder, ty, transform, args[0], args[1]);
}
+ConstEval::Result ConstEval::mix(const type::Type* ty,
+ utils::VectorRef<const sem::Constant*> args,
+ const Source& source) {
+ auto transform = [&](const sem::Constant* c0, const sem::Constant* c1, size_t index) {
+ auto create = [&](auto e1, auto e2) -> ImplResult {
+ using NumberT = decltype(e1);
+ // e3 is either a vector or a scalar
+ NumberT e3;
+ auto* c2 = args[2];
+ if (c2->Type()->Is<type::Vector>()) {
+ e3 = c2->Index(index)->As<NumberT>();
+ } else {
+ e3 = c2->As<NumberT>();
+ }
+ // Implement as `e1 * (1 - e3) + e2 * e3)` instead of as `e1 + e3 * (e2 - e1)` to avoid
+ // float precision loss when e1 and e2 significantly differ in magnitude.
+ auto one_sub_e3 = Sub(source, NumberT{1}, e3);
+ if (!one_sub_e3) {
+ return utils::Failure;
+ }
+ auto e1_mul_one_sub_e3 = Mul(source, e1, one_sub_e3.Get());
+ if (!e1_mul_one_sub_e3) {
+ return utils::Failure;
+ }
+ auto e2_mul_e3 = Mul(source, e2, e3);
+ if (!e2_mul_e3) {
+ return utils::Failure;
+ }
+ auto r = Add(source, e1_mul_one_sub_e3.Get(), e2_mul_e3.Get());
+ if (!r) {
+ return utils::Failure;
+ }
+ return CreateElement(builder, source, c0->Type(), r.Get());
+ };
+ return Dispatch_fa_f32_f16(create, c0, c1);
+ };
+ auto r = TransformElements(builder, ty, transform, args[0], args[1]);
+ if (!r) {
+ AddNote("when calculating mix", source);
+ }
+ return r;
+}
+
ConstEval::Result ConstEval::modf(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
diff --git a/src/tint/resolver/const_eval.h b/src/tint/resolver/const_eval.h
index d7d370d..fa5c0ee 100644
--- a/src/tint/resolver/const_eval.h
+++ b/src/tint/resolver/const_eval.h
@@ -35,7 +35,7 @@
class Expression;
} // namespace tint::sem
namespace tint::type {
-class StructMemberBase;
+class StructMember;
} // namespace tint::type
namespace tint::resolver {
@@ -94,7 +94,7 @@
/// @param obj the object being accessed
/// @param member the member
/// @return the result of the member access, or null if the value cannot be calculated
- Result MemberAccess(const sem::Expression* obj, const type::StructMemberBase* member);
+ Result MemberAccess(const sem::Expression* obj, const type::StructMember* member);
/// @param ty the result type
/// @param vector the vector being swizzled
@@ -757,6 +757,15 @@
utils::VectorRef<const sem::Constant*> args,
const Source& source);
+ /// mix builtin
+ /// @param ty the expression type
+ /// @param args the input arguments
+ /// @param source the source location
+ /// @return the result value, or null if the value cannot be calculated
+ Result mix(const type::Type* ty,
+ utils::VectorRef<const sem::Constant*> args,
+ const Source& source);
+
/// modf builtin
/// @param ty the expression type
/// @param args the input arguments
diff --git a/src/tint/resolver/const_eval_builtin_test.cc b/src/tint/resolver/const_eval_builtin_test.cc
index 8da5af4..4abf09e 100644
--- a/src/tint/resolver/const_eval_builtin_test.cc
+++ b/src/tint/resolver/const_eval_builtin_test.cc
@@ -179,7 +179,7 @@
CheckConstant(value, expected_case.values[0], expected_case.flags);
}
} else {
- EXPECT_FALSE(r()->Resolve());
+ ASSERT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), c.expected.Failure().error);
}
}
@@ -1733,6 +1733,94 @@
MinCases<AFloat>(),
MinCases<f32>(),
MinCases<f16>()))));
+
+template <typename T>
+std::vector<Case> MixCases() {
+ auto r = std::vector<Case>{
+ C({T(0), T(1), T(0)}, T(0)), //
+ C({T(0), T(1), T(1)}, T(1)), //
+ C({T(0), T(1), T(2)}, T(2)), //
+ C({T(0), T(1), T::Highest()}, T::Highest()), //
+ C({T::Lowest(), T::Highest(), T(1)}, T::Highest()), //
+ C({T::Lowest(), T::Highest(), T(0)}, T::Lowest()), //
+ C({T(0), T(1), T(0.25)}, T(0.25)), //
+ C({T(0), T(1), T(0.5)}, T(0.5)), //
+ C({T(0), T(1), T(0.75)}, T(0.75)), //
+ C({T(0), T(1000), T(0.25)}, T(250)), //
+ C({T(0), T(1000), T(0.5)}, T(500)), //
+ C({T(0), T(1000), T(0.75)}, T(750)), //
+ // Swap e1 and e2//
+ C({T(1), T(0), T(0)}, T(1)), //
+ C({T(1), T(0), T(1)}, T(0)), //
+ C({T(1), T(0), T(2)}, T(-1)), //
+ C({T::Highest(), T::Lowest(), T(1)}, T::Lowest()), //
+ C({T::Highest(), T::Lowest(), T(0)}, T::Highest()), //
+ C({T(1), T(0), T(0.25)}, T(0.75)), //
+ C({T(1), T(0), T(0.5)}, T(0.5)), //
+ C({T(1), T(0), T(0.75)}, T(0.25)), //
+ C({T(1000), T(0), T(0.25)}, T(750)), //
+ C({T(1000), T(0), T(0.5)}, T(500)), //
+ C({T(1000), T(0), T(0.75)}, T(250)),
+
+ // mix(vec, vec, vec) cases
+ C({Vec(T(0), T(0), T(0)), //
+ Vec(T(1), T(1), T(1)), //
+ Vec(T(0), T(1), T(2))},
+ Vec(T(0), T(1), T(2))),
+
+ // mix(vec, vec, scalar) cases
+ C({Vec(T(0), T(1), T(0)), //
+ Vec(T(1), T(0), T(1000)), //
+ Val(T(0.25))},
+ Vec(T(0.25), T(0.75), T(250))),
+ };
+ // Can't interpolate lowest value for f16 because (1 - lowest) is not representable as f16.
+ if constexpr (!std::is_same_v<T, f16>) {
+ ConcatInto(r, std::vector<Case>{
+ C({T(0), T(1), T::Lowest()}, T::Lowest()),
+ C({T(1), T(0), T::Highest()}, T::Lowest()),
+ });
+ }
+
+ auto error_msg = [](auto a, const char* op, auto b) {
+ return "12:34 error: " + OverflowErrorMessage(a, op, b) + R"(
+12:34 note: when calculating mix)";
+ };
+ auto kLargeValue = T{T::Highest() / 2};
+ // Test f16 separately as it overflows for a different reason at the boundary inputs.
+ // Specifically, (1 - lowest) fails for f16 because the result is not representable.
+ if constexpr (!std::is_same_v<T, f16>) {
+ ConcatInto( //
+ r,
+ std::vector<Case>{
+ E({T(0), T::Highest(), T::Highest()}, error_msg(T::Highest(), "*", T::Highest())),
+ E({T(0), T::Lowest(), T::Lowest()}, error_msg(T::Lowest(), "*", T::Lowest())),
+ E({T::Highest(), T(0), T::Lowest()}, error_msg(T::Highest(), "*", T::Highest())),
+ E({-kLargeValue, kLargeValue, T(2)},
+ error_msg(T{-kLargeValue * T(1 - 2)}, "+", T{kLargeValue * T(2)})),
+ });
+ } else {
+ ConcatInto( //
+ r,
+ std::vector<Case>{
+ E({T(0), T::Highest(), T::Highest()}, error_msg(T::Highest(), "*", T::Highest())),
+ E({T(0), T::Lowest(), T::Lowest()}, error_msg(T(1), "-", T::Lowest())),
+ E({T::Highest(), T(0), T::Lowest()}, error_msg(T(1), "-", T::Lowest())),
+ E({-kLargeValue, kLargeValue, T(2)},
+ error_msg(T{-kLargeValue * T(1 - 2)}, "+", T{kLargeValue * T(2)})),
+ });
+ }
+
+ return r;
+}
+INSTANTIATE_TEST_SUITE_P( //
+ Mix,
+ ResolverConstEvalBuiltinTest,
+ testing::Combine(testing::Values(sem::BuiltinType::kMix),
+ testing::ValuesIn(Concat(MixCases<AFloat>(), //
+ MixCases<f32>(), //
+ MixCases<f16>()))));
+
template <typename T>
std::vector<Case> ModfCases() {
return {
diff --git a/src/tint/resolver/const_eval_test.h b/src/tint/resolver/const_eval_test.h
index 120a077..a8858f4 100644
--- a/src/tint/resolver/const_eval_test.h
+++ b/src/tint/resolver/const_eval_test.h
@@ -101,7 +101,8 @@
[&](const auto& expected) {
using T = std::decay_t<decltype(expected)>;
- ASSERT_TRUE(std::holds_alternative<T>(got_scalar));
+ ASSERT_TRUE(std::holds_alternative<T>(got_scalar))
+ << "Scalar variant index: " << got_scalar.index();
auto got = std::get<T>(got_scalar);
if constexpr (std::is_same_v<bool, T>) {
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index f6b87f3..e6fd3df 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -57,7 +57,7 @@
/// A special type that matches all TypeMatchers
class Any final : public Castable<Any, type::Type> {
public:
- Any() : Base(type::TypeFlags{}) {}
+ Any() : Base(type::Flags{}) {}
~Any() override = default;
// Stub implementations for type::Type conformance.
diff --git a/src/tint/resolver/intrinsic_table.inl b/src/tint/resolver/intrinsic_table.inl
index 3ca1d07..bda6238 100644
--- a/src/tint/resolver/intrinsic_table.inl
+++ b/src/tint/resolver/intrinsic_table.inl
@@ -11441,36 +11441,36 @@
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[26],
+ /* template types */ &kTemplateTypes[23],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[468],
/* return matcher indices */ &kMatcherIndices[3],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::mix,
},
{
/* [263] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[26],
+ /* template types */ &kTemplateTypes[23],
/* template numbers */ &kTemplateNumbers[4],
/* parameters */ &kParameters[471],
/* return matcher indices */ &kMatcherIndices[30],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::mix,
},
{
/* [264] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[26],
+ /* template types */ &kTemplateTypes[23],
/* template numbers */ &kTemplateNumbers[4],
/* parameters */ &kParameters[474],
/* return matcher indices */ &kMatcherIndices[30],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::mix,
},
{
/* [265] */
@@ -14294,9 +14294,9 @@
},
{
/* [52] */
- /* fn mix<T : f32_f16>(T, T, T) -> T */
- /* fn mix<N : num, T : f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
- /* fn mix<N : num, T : f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
+ /* fn mix<T : fa_f32_f16>(T, T, T) -> T */
+ /* fn mix<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
+ /* fn mix<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
/* num overloads */ 3,
/* overloads */ &kOverloads[262],
},
diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc
index 4849c4c..bb17bae 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -1483,68 +1483,6 @@
// clang-format on
));
-struct IntrinsicTableAbstractTernaryTest_NonConstEval : public ResolverTestWithParam<Case> {
- std::unique_ptr<IntrinsicTable> table = IntrinsicTable::Create(*this);
-};
-
-TEST_P(IntrinsicTableAbstractTernaryTest_NonConstEval, MatchMix) {
- auto* arg_a = GetParam().arg_a(*this);
- auto* arg_b = GetParam().arg_b(*this);
- auto* arg_c = GetParam().arg_c(*this);
- auto builtin = table->Lookup(sem::BuiltinType::kMix, utils::Vector{arg_a, arg_b, arg_c},
- sem::EvaluationStage::kConstant, Source{{12, 34}});
-
- bool matched = builtin.sem != nullptr;
- bool expected_match = GetParam().expected_match;
- EXPECT_EQ(matched, expected_match) << Diagnostics().str();
-
- auto* result = builtin.sem ? builtin.sem->ReturnType() : nullptr;
- auto* expected_result = GetParam().expected_result(*this);
- EXPECT_TYPE(result, expected_result);
-
- auto* param_a = builtin.sem ? builtin.sem->Parameters()[0]->Type() : nullptr;
- auto* expected_param_a = GetParam().expected_param_a(*this);
- EXPECT_TYPE(param_a, expected_param_a);
-
- auto* param_b = builtin.sem ? builtin.sem->Parameters()[1]->Type() : nullptr;
- auto* expected_param_b = GetParam().expected_param_b(*this);
- EXPECT_TYPE(param_b, expected_param_b);
-
- auto* param_c = builtin.sem ? builtin.sem->Parameters()[2]->Type() : nullptr;
- auto* expected_param_c = GetParam().expected_param_c(*this);
- EXPECT_TYPE(param_c, expected_param_c);
-}
-
-INSTANTIATE_TEST_SUITE_P(
- AFloat_f32,
- IntrinsicTableAbstractTernaryTest_NonConstEval,
- testing::Values( // clang-format off
- // result | param a | param b | param c | arg a | arg b | arg c
- Case::Create<f32, f32, f32, f32, AFloat, AFloat, AFloat>(),
- Case::Create<f32, f32, f32, f32, AFloat, AFloat, f32>(),
- Case::Create<f32, f32, f32, f32, AFloat, f32, AFloat>(),
- Case::Create<f32, f32, f32, f32, AFloat, f32, f32>(),
- Case::Create<f32, f32, f32, f32, f32, AFloat, AFloat>(),
- Case::Create<f32, f32, f32, f32, f32, AFloat, f32>(),
- Case::Create<f32, f32, f32, f32, f32, f32, AFloat>()
- // clang-format on
- ));
-
-INSTANTIATE_TEST_SUITE_P(
- VecAFloat_Vecf32,
- IntrinsicTableAbstractTernaryTest_NonConstEval,
- testing::Values( // clang-format off
- // result | param a | param b | param c | arg a | arg b | arg c
- Case::Create<f32V, f32V, f32V, f32V, AFloatV, AFloatV, AFloatV>(),
- Case::Create<f32V, f32V, f32V, f32V, AFloatV, AFloatV, f32V>(),
- Case::Create<f32V, f32V, f32V, f32V, AFloatV, f32V, AFloatV>(),
- Case::Create<f32V, f32V, f32V, f32V, AFloatV, f32V, f32V>(),
- Case::Create<f32V, f32V, f32V, f32V, f32V, AFloatV, AFloatV>(),
- Case::Create<f32V, f32V, f32V, f32V, f32V, AFloatV, f32V>(),
- Case::Create<f32V, f32V, f32V, f32V, f32V, f32V, AFloatV> ()
- // clang-format on
- ));
-
} // namespace AbstractTernaryTests
} // namespace
diff --git a/src/tint/sem/struct.h b/src/tint/sem/struct.h
index ac535ec..a05a96a 100644
--- a/src/tint/sem/struct.h
+++ b/src/tint/sem/struct.h
@@ -32,13 +32,13 @@
class StructMember;
} // namespace tint::sem
namespace tint::type {
-class StructMemberBase;
+class StructMember;
} // namespace tint::type
namespace tint::sem {
/// Struct holds the semantic information for structures.
-class Struct final : public Castable<Struct, type::StructBase> {
+class Struct final : public Castable<Struct, type::Struct> {
public:
/// Constructor
/// @param declaration the AST structure declaration
@@ -73,7 +73,7 @@
};
/// StructMember holds the semantic information for structure members.
-class StructMember final : public Castable<StructMember, type::StructMemberBase> {
+class StructMember final : public Castable<StructMember, type::StructMember> {
public:
/// Constructor
/// @param declaration the AST declaration node
diff --git a/src/tint/transform/promote_initializers_to_let.cc b/src/tint/transform/promote_initializers_to_let.cc
index 3b1ea7f..391a7f2 100644
--- a/src/tint/transform/promote_initializers_to_let.cc
+++ b/src/tint/transform/promote_initializers_to_let.cc
@@ -42,7 +42,7 @@
// Returns true if the expression should be hoisted to a new let statement before the
// expression's statement.
auto should_hoist = [&](const sem::Expression* expr) {
- if (!expr->Type()->IsAnyOf<type::Array, type::StructBase>()) {
+ if (!expr->Type()->IsAnyOf<type::Array, type::Struct>()) {
// We only care about array and struct initializers
return false;
}
diff --git a/src/tint/type/abstract_numeric.cc b/src/tint/type/abstract_numeric.cc
index b689153..390488e 100644
--- a/src/tint/type/abstract_numeric.cc
+++ b/src/tint/type/abstract_numeric.cc
@@ -19,7 +19,7 @@
namespace tint::type {
AbstractNumeric::AbstractNumeric()
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/array.cc b/src/tint/type/array.cc
index f8b2e0f..ad903fa 100644
--- a/src/tint/type/array.cc
+++ b/src/tint/type/array.cc
@@ -27,20 +27,20 @@
namespace {
-TypeFlags FlagsFrom(const Type* element, const ArrayCount* count) {
- TypeFlags flags;
+type::Flags FlagsFrom(const Type* element, const ArrayCount* count) {
+ type::Flags flags;
// Only constant-expression sized arrays are constructible
if (count->Is<ConstantArrayCount>()) {
if (element->IsConstructible()) {
- flags.Add(TypeFlag::kConstructable);
+ flags.Add(Flag::kConstructable);
}
if (element->HasCreationFixedFootprint()) {
- flags.Add(TypeFlag::kCreationFixedFootprint);
+ flags.Add(Flag::kCreationFixedFootprint);
}
}
if (!count->Is<RuntimeArrayCount>()) {
if (element->HasFixedFootprint()) {
- flags.Add(TypeFlag::kFixedFootprint);
+ flags.Add(Flag::kFixedFootprint);
}
}
return flags;
diff --git a/src/tint/type/atomic.cc b/src/tint/type/atomic.cc
index 749959c..e850874 100644
--- a/src/tint/type/atomic.cc
+++ b/src/tint/type/atomic.cc
@@ -23,7 +23,7 @@
namespace tint::type {
Atomic::Atomic(const type::Type* subtype)
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
}),
diff --git a/src/tint/type/bool.cc b/src/tint/type/bool.cc
index 7cde72c..a76228d 100644
--- a/src/tint/type/bool.cc
+++ b/src/tint/type/bool.cc
@@ -21,7 +21,7 @@
namespace tint::type {
Bool::Bool()
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/f16.cc b/src/tint/type/f16.cc
index aecefa4..4243cb8 100644
--- a/src/tint/type/f16.cc
+++ b/src/tint/type/f16.cc
@@ -21,7 +21,7 @@
namespace tint::type {
F16::F16()
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/f32.cc b/src/tint/type/f32.cc
index f9ff7ee..ea86008 100644
--- a/src/tint/type/f32.cc
+++ b/src/tint/type/f32.cc
@@ -21,7 +21,7 @@
namespace tint::type {
F32::F32()
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/i32.cc b/src/tint/type/i32.cc
index 5a242e4..fb3d258 100644
--- a/src/tint/type/i32.cc
+++ b/src/tint/type/i32.cc
@@ -21,7 +21,7 @@
namespace tint::type {
I32::I32()
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/manager.h b/src/tint/type/manager.h
index 2e587c3..0515b14 100644
--- a/src/tint/type/manager.h
+++ b/src/tint/type/manager.h
@@ -91,7 +91,7 @@
/// pointer is returned.
template <typename TYPE,
typename _ = std::enable_if<traits::IsTypeOrDerived<TYPE, ArrayCount> ||
- traits::IsTypeOrDerived<TYPE, StructMemberBase>>,
+ traits::IsTypeOrDerived<TYPE, StructMember>>,
typename... ARGS>
TYPE* GetNode(ARGS&&... args) {
return nodes_.Get<TYPE>(std::forward<ARGS>(args)...);
@@ -119,8 +119,8 @@
size_t operator()(const tint::type::Node& type) const {
if (const auto* ac = type.As<tint::type::ArrayCount>()) {
return ac->Hash();
- } else if (type.Is<tint::type::StructMemberBase>()) {
- return tint::TypeInfo::Of<tint::type::StructMemberBase>().full_hashcode;
+ } else if (type.Is<tint::type::StructMember>()) {
+ return tint::TypeInfo::Of<tint::type::StructMember>().full_hashcode;
}
TINT_ASSERT(Type, false && "Unreachable");
return 0;
@@ -139,7 +139,7 @@
return ac->Equals(*bc);
}
return false;
- } else if (a.Is<tint::type::StructMemberBase>()) {
+ } else if (a.Is<tint::type::StructMember>()) {
return &a == &b;
}
TINT_ASSERT(Type, false && "Unreachable");
diff --git a/src/tint/type/matrix.cc b/src/tint/type/matrix.cc
index d73d190..063ac88 100644
--- a/src/tint/type/matrix.cc
+++ b/src/tint/type/matrix.cc
@@ -23,7 +23,7 @@
namespace tint::type {
Matrix::Matrix(const Vector* column_type, uint32_t columns)
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/pointer.cc b/src/tint/type/pointer.cc
index 286e90c..c59170c 100644
--- a/src/tint/type/pointer.cc
+++ b/src/tint/type/pointer.cc
@@ -23,7 +23,7 @@
namespace tint::type {
Pointer::Pointer(const Type* subtype, ast::AddressSpace address_space, ast::Access access)
- : Base(TypeFlags{}), subtype_(subtype), address_space_(address_space), access_(access) {
+ : Base(type::Flags{}), subtype_(subtype), address_space_(address_space), access_(access) {
TINT_ASSERT(Type, !subtype->Is<Reference>());
TINT_ASSERT(Type, access != ast::Access::kUndefined);
}
diff --git a/src/tint/type/reference.cc b/src/tint/type/reference.cc
index 93cb7f2..0541f84 100644
--- a/src/tint/type/reference.cc
+++ b/src/tint/type/reference.cc
@@ -22,7 +22,7 @@
namespace tint::type {
Reference::Reference(const Type* subtype, ast::AddressSpace address_space, ast::Access access)
- : Base(TypeFlags{}), subtype_(subtype), address_space_(address_space), access_(access) {
+ : Base(type::Flags{}), subtype_(subtype), address_space_(address_space), access_(access) {
TINT_ASSERT(Type, !subtype->Is<Reference>());
TINT_ASSERT(Type, access != ast::Access::kUndefined);
}
diff --git a/src/tint/type/sampler.cc b/src/tint/type/sampler.cc
index f49d525..c49a8ef 100644
--- a/src/tint/type/sampler.cc
+++ b/src/tint/type/sampler.cc
@@ -21,7 +21,7 @@
namespace tint::type {
-Sampler::Sampler(ast::SamplerKind kind) : Base(TypeFlags{}), kind_(kind) {}
+Sampler::Sampler(ast::SamplerKind kind) : Base(type::Flags{}), kind_(kind) {}
Sampler::Sampler(Sampler&&) = default;
diff --git a/src/tint/type/struct.cc b/src/tint/type/struct.cc
index a72aa0f..778a600 100644
--- a/src/tint/type/struct.cc
+++ b/src/tint/type/struct.cc
@@ -22,27 +22,27 @@
#include "src/tint/symbol_table.h"
#include "src/tint/utils/hash.h"
-TINT_INSTANTIATE_TYPEINFO(tint::type::StructBase);
-TINT_INSTANTIATE_TYPEINFO(tint::type::StructMemberBase);
+TINT_INSTANTIATE_TYPEINFO(tint::type::Struct);
+TINT_INSTANTIATE_TYPEINFO(tint::type::StructMember);
namespace tint::type {
namespace {
-TypeFlags FlagsFrom(utils::VectorRef<const StructMemberBase*> members) {
- TypeFlags flags{
- TypeFlag::kConstructable,
- TypeFlag::kCreationFixedFootprint,
- TypeFlag::kFixedFootprint,
+type::Flags FlagsFrom(utils::VectorRef<const StructMember*> members) {
+ type::Flags flags{
+ Flag::kConstructable,
+ Flag::kCreationFixedFootprint,
+ Flag::kFixedFootprint,
};
for (auto* member : members) {
if (!member->Type()->IsConstructible()) {
- flags.Remove(TypeFlag::kConstructable);
+ flags.Remove(Flag::kConstructable);
}
if (!member->Type()->HasFixedFootprint()) {
- flags.Remove(TypeFlag::kFixedFootprint);
+ flags.Remove(Flag::kFixedFootprint);
}
if (!member->Type()->HasCreationFixedFootprint()) {
- flags.Remove(TypeFlag::kCreationFixedFootprint);
+ flags.Remove(Flag::kCreationFixedFootprint);
}
}
return flags;
@@ -50,12 +50,12 @@
} // namespace
-StructBase::StructBase(tint::Source source,
- Symbol name,
- utils::VectorRef<const StructMemberBase*> members,
- uint32_t align,
- uint32_t size,
- uint32_t size_no_padding)
+Struct::Struct(tint::Source source,
+ Symbol name,
+ utils::VectorRef<const StructMember*> members,
+ uint32_t align,
+ uint32_t size,
+ uint32_t size_no_padding)
: Base(FlagsFrom(members)),
source_(source),
name_(name),
@@ -64,20 +64,20 @@
size_(size),
size_no_padding_(size_no_padding) {}
-StructBase::~StructBase() = default;
+Struct::~Struct() = default;
-size_t StructBase::Hash() const {
- return utils::Hash(TypeInfo::Of<StructBase>().full_hashcode, name_);
+size_t Struct::Hash() const {
+ return utils::Hash(TypeInfo::Of<Struct>().full_hashcode, name_);
}
-bool StructBase::Equals(const Type& other) const {
- if (auto* o = other.As<StructBase>()) {
+bool Struct::Equals(const Type& other) const {
+ if (auto* o = other.As<Struct>()) {
return o->name_ == name_;
}
return false;
}
-const StructMemberBase* StructBase::FindMember(Symbol name) const {
+const StructMember* Struct::FindMember(Symbol name) const {
for (auto* member : members_) {
if (member->Name() == name) {
return member;
@@ -86,22 +86,22 @@
return nullptr;
}
-uint32_t StructBase::Align() const {
+uint32_t Struct::Align() const {
return align_;
}
-uint32_t StructBase::Size() const {
+uint32_t Struct::Size() const {
return size_;
}
-std::string StructBase::FriendlyName(const SymbolTable& symbols) const {
+std::string Struct::FriendlyName(const SymbolTable& symbols) const {
return symbols.NameFor(name_);
}
-std::string StructBase::Layout(const tint::SymbolTable& symbols) const {
+std::string Struct::Layout(const tint::SymbolTable& symbols) const {
std::stringstream ss;
- auto member_name_of = [&](const StructMemberBase* sm) { return symbols.NameFor(sm->Name()); };
+ auto member_name_of = [&](const StructMember* sm) { return symbols.NameFor(sm->Name()); };
if (Members().IsEmpty()) {
return {};
@@ -164,14 +164,14 @@
return ss.str();
}
-StructMemberBase::StructMemberBase(tint::Source source,
- Symbol name,
- const type::Type* type,
- uint32_t index,
- uint32_t offset,
- uint32_t align,
- uint32_t size,
- std::optional<uint32_t> location)
+StructMember::StructMember(tint::Source source,
+ Symbol name,
+ const type::Type* type,
+ uint32_t index,
+ uint32_t offset,
+ uint32_t align,
+ uint32_t size,
+ std::optional<uint32_t> location)
: source_(source),
name_(name),
type_(type),
@@ -181,6 +181,6 @@
size_(size),
location_(location) {}
-StructMemberBase::~StructMemberBase() = default;
+StructMember::~StructMember() = default;
} // namespace tint::type
diff --git a/src/tint/type/struct.h b/src/tint/type/struct.h
index b9daec9..8946714 100644
--- a/src/tint/type/struct.h
+++ b/src/tint/type/struct.h
@@ -29,7 +29,7 @@
// Forward declarations
namespace tint::type {
-class StructMemberBase;
+class StructMember;
} // namespace tint::type
namespace tint::type {
@@ -44,8 +44,8 @@
kComputeOutput,
};
-/// StructBase holds the Type information for structures.
-class StructBase : public Castable<StructBase, Type> {
+/// Struct holds the Type information for structures.
+class Struct : public Castable<Struct, Type> {
public:
/// Constructor
/// @param source the source of the structure
@@ -55,15 +55,15 @@
/// @param size the byte size of the structure
/// @param size_no_padding size of the members without the end of structure
/// alignment padding
- StructBase(tint::Source source,
- Symbol name,
- utils::VectorRef<const StructMemberBase*> members,
- uint32_t align,
- uint32_t size,
- uint32_t size_no_padding);
+ Struct(tint::Source source,
+ Symbol name,
+ utils::VectorRef<const StructMember*> members,
+ uint32_t align,
+ uint32_t size,
+ uint32_t size_no_padding);
/// Destructor
- ~StructBase() override;
+ ~Struct() override;
/// @returns a hash of the type.
size_t Hash() const override;
@@ -79,11 +79,11 @@
Symbol Name() const { return name_; }
/// @returns the members of the structure
- utils::VectorRef<const StructMemberBase*> Members() const { return members_; }
+ utils::VectorRef<const StructMember*> Members() const { return members_; }
/// @param name the member name to look for
/// @returns the member with the given name, or nullptr if it was not found.
- const StructMemberBase* FindMember(Symbol name) const;
+ const StructMember* FindMember(Symbol name) const;
/// @returns the byte alignment of the structure
/// @note this may differ from the alignment of a structure member of this
@@ -145,29 +145,27 @@
std::string Layout(const tint::SymbolTable& symbols) const;
/// @param concrete the conversion-rank ordered concrete versions of this abstract structure.
- void SetConcreteTypes(utils::VectorRef<const StructBase*> concrete) {
- concrete_types_ = concrete;
- }
+ void SetConcreteTypes(utils::VectorRef<const Struct*> concrete) { concrete_types_ = concrete; }
/// @returns the conversion-rank ordered concrete versions of this abstract structure, or an
/// empty vector if this structure is not abstract.
/// @note only structures returned by builtins may be abstract (e.g. modf, frexp)
- utils::VectorRef<const StructBase*> ConcreteTypes() const { return concrete_types_; }
+ utils::VectorRef<const Struct*> ConcreteTypes() const { return concrete_types_; }
private:
const tint::Source source_;
const Symbol name_;
- const utils::Vector<const StructMemberBase*, 4> members_;
+ const utils::Vector<const StructMember*, 4> members_;
const uint32_t align_;
const uint32_t size_;
const uint32_t size_no_padding_;
std::unordered_set<ast::AddressSpace> address_space_usage_;
std::unordered_set<PipelineStageUsage> pipeline_stage_uses_;
- utils::Vector<const StructBase*, 2> concrete_types_;
+ utils::Vector<const Struct*, 2> concrete_types_;
};
-/// StructMemberBase holds the type information for structure members.
-class StructMemberBase : public Castable<StructMemberBase, Node> {
+/// StructMember holds the type information for structure members.
+class StructMember : public Castable<StructMember, Node> {
public:
/// Constructor
/// @param source the source of the struct member
@@ -178,17 +176,17 @@
/// @param align the byte alignment of the member
/// @param size the byte size of the member
/// @param location the location attribute, if present
- StructMemberBase(tint::Source source,
- Symbol name,
- const type::Type* type,
- uint32_t index,
- uint32_t offset,
- uint32_t align,
- uint32_t size,
- std::optional<uint32_t> location);
+ StructMember(tint::Source source,
+ Symbol name,
+ const type::Type* type,
+ uint32_t index,
+ uint32_t offset,
+ uint32_t align,
+ uint32_t size,
+ std::optional<uint32_t> location);
/// Destructor
- ~StructMemberBase() override;
+ ~StructMember() override;
/// @returns the source the struct member
const tint::Source& Source() const { return source_; }
@@ -198,10 +196,10 @@
/// Sets the owning structure to `s`
/// @param s the new structure owner
- void SetStruct(const StructBase* s) { struct_ = s; }
+ void SetStruct(const Struct* s) { struct_ = s; }
/// @returns the structure that owns this member
- const StructBase* Struct() const { return struct_; }
+ const type::Struct* Struct() const { return struct_; }
/// @returns the type of the member
const type::Type* Type() const { return type_; }
@@ -224,7 +222,7 @@
private:
const tint::Source source_;
const Symbol name_;
- const StructBase* struct_;
+ const type::Struct* struct_;
const type::Type* type_;
const uint32_t index_;
const uint32_t offset_;
diff --git a/src/tint/type/struct_test.cc b/src/tint/type/struct_test.cc
index 55e1517..ae9a249 100644
--- a/src/tint/type/struct_test.cc
+++ b/src/tint/type/struct_test.cc
@@ -24,27 +24,27 @@
TEST_F(TypeStructTest, Creation) {
auto name = Sym("S");
- auto* s = create<StructBase>(Source{}, name, utils::Empty, 4u /* align */, 8u /* size */,
- 16u /* size_no_padding */);
+ auto* s = create<Struct>(Source{}, name, utils::Empty, 4u /* align */, 8u /* size */,
+ 16u /* size_no_padding */);
EXPECT_EQ(s->Align(), 4u);
EXPECT_EQ(s->Size(), 8u);
EXPECT_EQ(s->SizeNoPadding(), 16u);
}
TEST_F(TypeStructTest, Hash) {
- auto* a = create<StructBase>(Source{}, Sym("a"), utils::Empty, 4u /* align */, 4u /* size */,
- 4u /* size_no_padding */);
- auto* b = create<StructBase>(Source{}, Sym("b"), utils::Empty, 4u /* align */, 4u /* size */,
- 4u /* size_no_padding */);
+ auto* a = create<Struct>(Source{}, Sym("a"), utils::Empty, 4u /* align */, 4u /* size */,
+ 4u /* size_no_padding */);
+ auto* b = create<Struct>(Source{}, Sym("b"), utils::Empty, 4u /* align */, 4u /* size */,
+ 4u /* size_no_padding */);
EXPECT_NE(a->Hash(), b->Hash());
}
TEST_F(TypeStructTest, Equals) {
- auto* a = create<StructBase>(Source{}, Sym("a"), utils::Empty, 4u /* align */, 4u /* size */,
- 4u /* size_no_padding */);
- auto* b = create<StructBase>(Source{}, Sym("b"), utils::Empty, 4u /* align */, 4u /* size */,
- 4u /* size_no_padding */);
+ auto* a = create<Struct>(Source{}, Sym("a"), utils::Empty, 4u /* align */, 4u /* size */,
+ 4u /* size_no_padding */);
+ auto* b = create<Struct>(Source{}, Sym("b"), utils::Empty, 4u /* align */, 4u /* size */,
+ 4u /* size_no_padding */);
EXPECT_TRUE(a->Equals(*a));
EXPECT_FALSE(a->Equals(*b));
@@ -53,8 +53,8 @@
TEST_F(TypeStructTest, FriendlyName) {
auto name = Sym("my_struct");
- auto* s = create<StructBase>(Source{}, name, utils::Empty, 4u /* align */, 4u /* size */,
- 4u /* size_no_padding */);
+ auto* s = create<Struct>(Source{}, name, utils::Empty, 4u /* align */, 4u /* size */,
+ 4u /* size_no_padding */);
EXPECT_EQ(s->FriendlyName(Symbols()), "my_struct");
}
diff --git a/src/tint/type/texture.cc b/src/tint/type/texture.cc
index eedd273..0aa8549 100644
--- a/src/tint/type/texture.cc
+++ b/src/tint/type/texture.cc
@@ -18,7 +18,7 @@
namespace tint::type {
-Texture::Texture(ast::TextureDimension dim) : Base(TypeFlags{}), dim_(dim) {}
+Texture::Texture(ast::TextureDimension dim) : Base(type::Flags{}), dim_(dim) {}
Texture::Texture(Texture&&) = default;
diff --git a/src/tint/type/type.cc b/src/tint/type/type.cc
index 1eead35..d7bccc0 100644
--- a/src/tint/type/type.cc
+++ b/src/tint/type/type.cc
@@ -34,7 +34,7 @@
namespace tint::type {
-Type::Type(TypeFlags flags) : flags_(flags) {
+Type::Type(type::Flags flags) : flags_(flags) {
if (IsConstructible()) {
TINT_ASSERT(Type, HasCreationFixedFootprint());
}
@@ -180,7 +180,7 @@
[&](const Vector* v) { return v->type()->HoldsAbstract(); },
[&](const Matrix* m) { return m->type()->HoldsAbstract(); },
[&](const Array* a) { return a->ElemType()->HoldsAbstract(); },
- [&](const StructBase* s) {
+ [&](const Struct* s) {
for (auto* m : s->Members()) {
if (m->Type()->HoldsAbstract()) {
return true;
@@ -238,7 +238,7 @@
}
return kNoConversion;
},
- [&](const StructBase* from_str) {
+ [&](const Struct* from_str) {
auto concrete_tys = from_str->ConcreteTypes();
for (size_t i = 0; i < concrete_tys.Length(); i++) {
if (concrete_tys[i] == to) {
diff --git a/src/tint/type/type.h b/src/tint/type/type.h
index 187b566..00e1752 100644
--- a/src/tint/type/type.h
+++ b/src/tint/type/type.h
@@ -30,7 +30,7 @@
namespace tint::type {
-enum TypeFlag {
+enum Flag {
/// Type is constructable.
/// @see https://gpuweb.github.io/gpuweb/wgsl/#constructible-types
kConstructable,
@@ -42,15 +42,12 @@
kFixedFootprint,
};
-/// An alias to utils::EnumSet<TypeFlag>
-using TypeFlags = utils::EnumSet<TypeFlag>;
+/// An alias to utils::EnumSet<Flag>
+using Flags = utils::EnumSet<Flag>;
/// Base class for a type in the system
class Type : public Castable<Type, Node> {
public:
- /// Alias to TypeFlag
- using Flag = TypeFlag;
-
/// Move constructor
Type(Type&&);
~Type() override;
@@ -83,7 +80,7 @@
virtual uint32_t Align() const;
/// @returns the flags on the type
- TypeFlags Flags() { return flags_; }
+ type::Flags Flags() { return flags_; }
/// @returns true if type is constructable
/// https://gpuweb.github.io/gpuweb/wgsl/#constructible-types
@@ -197,10 +194,10 @@
protected:
/// Constructor
/// @param flags the flags of this type
- explicit Type(TypeFlags flags);
+ explicit Type(type::Flags flags);
/// The flags of this type.
- const TypeFlags flags_;
+ const type::Flags flags_;
};
} // namespace tint::type
diff --git a/src/tint/type/type_test.cc b/src/tint/type/type_test.cc
index 133f521..48b44dd 100644
--- a/src/tint/type/type_test.cc
+++ b/src/tint/type/type_test.cc
@@ -45,54 +45,54 @@
const Matrix* mat4x3_af = create<Matrix>(vec3_af, 4u);
const Reference* ref_u32 =
create<Reference>(u32, ast::AddressSpace::kPrivate, ast::Access::kReadWrite);
- const StructBase* str_f32 = create<StructBase>(Source{},
- Sym("str_f32"),
- utils::Vector{
- create<StructMemberBase>(
- /* source */ Source{},
- /* name */ Sym("x"),
- /* type */ f32,
- /* index */ 0u,
- /* offset */ 0u,
- /* align */ 4u,
- /* size */ 4u,
- /* location */ std::nullopt),
- },
- /* align*/ 4u,
- /* size*/ 4u,
- /* size_no_padding*/ 4u);
- const StructBase* str_f16 = create<StructBase>(Source{},
- Sym("str_f16"),
- utils::Vector{
- create<StructMemberBase>(
- /* source */ Source{},
- /* name */ Sym("x"),
- /* type */ f16,
- /* index */ 0u,
- /* offset */ 0u,
- /* align */ 4u,
- /* size */ 4u,
- /* location */ std::nullopt),
- },
- /* align*/ 4u,
- /* size*/ 4u,
- /* size_no_padding*/ 4u);
- StructBase* str_af = create<StructBase>(Source{},
- Sym("str_af"),
- utils::Vector{
- create<StructMemberBase>(
- /* source */ Source{},
- /* name */ Sym("x"),
- /* type */ af,
- /* index */ 0u,
- /* offset */ 0u,
- /* align */ 4u,
- /* size */ 4u,
- /* location */ std::nullopt),
- },
- /* align*/ 4u,
- /* size*/ 4u,
- /* size_no_padding*/ 4u);
+ const Struct* str_f32 = create<Struct>(Source{},
+ Sym("str_f32"),
+ utils::Vector{
+ create<StructMember>(
+ /* source */ Source{},
+ /* name */ Sym("x"),
+ /* type */ f32,
+ /* index */ 0u,
+ /* offset */ 0u,
+ /* align */ 4u,
+ /* size */ 4u,
+ /* location */ std::nullopt),
+ },
+ /* align*/ 4u,
+ /* size*/ 4u,
+ /* size_no_padding*/ 4u);
+ const Struct* str_f16 = create<Struct>(Source{},
+ Sym("str_f16"),
+ utils::Vector{
+ create<StructMember>(
+ /* source */ Source{},
+ /* name */ Sym("x"),
+ /* type */ f16,
+ /* index */ 0u,
+ /* offset */ 0u,
+ /* align */ 4u,
+ /* size */ 4u,
+ /* location */ std::nullopt),
+ },
+ /* align*/ 4u,
+ /* size*/ 4u,
+ /* size_no_padding*/ 4u);
+ Struct* str_af = create<Struct>(Source{},
+ Sym("str_af"),
+ utils::Vector{
+ create<StructMember>(
+ /* source */ Source{},
+ /* name */ Sym("x"),
+ /* type */ af,
+ /* index */ 0u,
+ /* offset */ 0u,
+ /* align */ 4u,
+ /* size */ 4u,
+ /* location */ std::nullopt),
+ },
+ /* align*/ 4u,
+ /* size*/ 4u,
+ /* size_no_padding*/ 4u);
const Array* arr_i32 = create<Array>(
/* element */ i32,
/* count */ create<ConstantArrayCount>(5u),
diff --git a/src/tint/type/u32.cc b/src/tint/type/u32.cc
index b787c96..fd38cb9 100644
--- a/src/tint/type/u32.cc
+++ b/src/tint/type/u32.cc
@@ -21,7 +21,7 @@
namespace tint::type {
U32::U32()
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/vector.cc b/src/tint/type/vector.cc
index a2b57a4..70b33bc 100644
--- a/src/tint/type/vector.cc
+++ b/src/tint/type/vector.cc
@@ -22,7 +22,7 @@
namespace tint::type {
Vector::Vector(Type const* subtype, uint32_t width)
- : Base(TypeFlags{
+ : Base(type::Flags{
Flag::kConstructable,
Flag::kCreationFixedFootprint,
Flag::kFixedFootprint,
diff --git a/src/tint/type/void.cc b/src/tint/type/void.cc
index aaeca91..b993dfe 100644
--- a/src/tint/type/void.cc
+++ b/src/tint/type/void.cc
@@ -20,7 +20,7 @@
namespace tint::type {
-Void::Void() : Base(TypeFlags{}) {}
+Void::Void() : Base(type::Flags{}) {}
Void::Void(Void&&) = default;
