Replace Expression::(Is|As)* with Castable
Change-Id: I6ab98ed8b198f1b3b42ce1f09a6c4f992d65fe95
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34316
Reviewed-by: dan sinclair <dsinclair@chromium.org>
diff --git a/src/ast/array_accessor_expression.cc b/src/ast/array_accessor_expression.cc
index 1891f4f..ded7716 100644
--- a/src/ast/array_accessor_expression.cc
+++ b/src/ast/array_accessor_expression.cc
@@ -33,10 +33,6 @@
ArrayAccessorExpression::~ArrayAccessorExpression() = default;
-bool ArrayAccessorExpression::IsArrayAccessor() const {
- return true;
-}
-
bool ArrayAccessorExpression::IsValid() const {
if (array_ == nullptr || !array_->IsValid())
return false;
diff --git a/src/ast/array_accessor_expression.h b/src/ast/array_accessor_expression.h
index f7e5192..0f18d5e 100644
--- a/src/ast/array_accessor_expression.h
+++ b/src/ast/array_accessor_expression.h
@@ -57,9 +57,6 @@
/// @returns the index expression
Expression* idx_expr() const { return idx_expr_; }
- /// @returns true if this is an array accessor expression
- bool IsArrayAccessor() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/array_accessor_expression_test.cc b/src/ast/array_accessor_expression_test.cc
index 92b38fa..e49ba8e 100644
--- a/src/ast/array_accessor_expression_test.cc
+++ b/src/ast/array_accessor_expression_test.cc
@@ -44,7 +44,7 @@
TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) {
ArrayAccessorExpression exp;
- EXPECT_TRUE(exp.IsArrayAccessor());
+ EXPECT_TRUE(exp.Is<ast::ArrayAccessorExpression>());
}
TEST_F(ArrayAccessorExpressionTest, IsValid) {
diff --git a/src/ast/binary_expression.cc b/src/ast/binary_expression.cc
index d43caeb..c14f538 100644
--- a/src/ast/binary_expression.cc
+++ b/src/ast/binary_expression.cc
@@ -34,10 +34,6 @@
BinaryExpression::~BinaryExpression() = default;
-bool BinaryExpression::IsBinary() const {
- return true;
-}
-
bool BinaryExpression::IsValid() const {
if (lhs_ == nullptr || !lhs_->IsValid()) {
return false;
diff --git a/src/ast/binary_expression.h b/src/ast/binary_expression.h
index e96d8da..1431f18 100644
--- a/src/ast/binary_expression.h
+++ b/src/ast/binary_expression.h
@@ -125,9 +125,6 @@
/// @returns the right side expression
Expression* rhs() const { return rhs_; }
- /// @returns true if this is a op expression
- bool IsBinary() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/binary_expression_test.cc b/src/ast/binary_expression_test.cc
index 7727cbd..d056ebc 100644
--- a/src/ast/binary_expression_test.cc
+++ b/src/ast/binary_expression_test.cc
@@ -48,7 +48,7 @@
TEST_F(BinaryExpressionTest, IsBinaryal) {
BinaryExpression r;
- EXPECT_TRUE(r.IsBinary());
+ EXPECT_TRUE(r.Is<ast::BinaryExpression>());
}
TEST_F(BinaryExpressionTest, IsValid) {
diff --git a/src/ast/bitcast_expression.cc b/src/ast/bitcast_expression.cc
index 6d52a2b..4ebfc53 100644
--- a/src/ast/bitcast_expression.cc
+++ b/src/ast/bitcast_expression.cc
@@ -30,10 +30,6 @@
BitcastExpression::BitcastExpression(BitcastExpression&&) = default;
BitcastExpression::~BitcastExpression() = default;
-bool BitcastExpression::IsBitcast() const {
- return true;
-}
-
bool BitcastExpression::IsValid() const {
if (expr_ == nullptr || !expr_->IsValid())
return false;
diff --git a/src/ast/bitcast_expression.h b/src/ast/bitcast_expression.h
index 7a30c9e..a898036 100644
--- a/src/ast/bitcast_expression.h
+++ b/src/ast/bitcast_expression.h
@@ -55,9 +55,6 @@
/// @returns the expression
Expression* expr() const { return expr_; }
- /// @returns true if this is a bitcast expression
- bool IsBitcast() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/bitcast_expression_test.cc b/src/ast/bitcast_expression_test.cc
index 3f02451..9810a2f 100644
--- a/src/ast/bitcast_expression_test.cc
+++ b/src/ast/bitcast_expression_test.cc
@@ -45,7 +45,7 @@
TEST_F(BitcastExpressionTest, IsBitcast) {
BitcastExpression exp;
- EXPECT_TRUE(exp.IsBitcast());
+ EXPECT_TRUE(exp.Is<ast::BitcastExpression>());
}
TEST_F(BitcastExpressionTest, IsValid) {
diff --git a/src/ast/call_expression.cc b/src/ast/call_expression.cc
index 13c5efc..c17a146 100644
--- a/src/ast/call_expression.cc
+++ b/src/ast/call_expression.cc
@@ -31,10 +31,6 @@
CallExpression::~CallExpression() = default;
-bool CallExpression::IsCall() const {
- return true;
-}
-
bool CallExpression::IsValid() const {
if (func_ == nullptr || !func_->IsValid())
return false;
diff --git a/src/ast/call_expression.h b/src/ast/call_expression.h
index c79dffd..0e27008 100644
--- a/src/ast/call_expression.h
+++ b/src/ast/call_expression.h
@@ -54,9 +54,6 @@
/// @returns the parameters
const ExpressionList& params() const { return params_; }
- /// @returns true if this is a call expression
- bool IsCall() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/call_expression_test.cc b/src/ast/call_expression_test.cc
index e736cb7..0da64ec 100644
--- a/src/ast/call_expression_test.cc
+++ b/src/ast/call_expression_test.cc
@@ -49,7 +49,7 @@
TEST_F(CallExpressionTest, IsCall) {
auto* func = create<IdentifierExpression>("func");
CallExpression stmt(func, {});
- EXPECT_TRUE(stmt.IsCall());
+ EXPECT_TRUE(stmt.Is<ast::CallExpression>());
}
TEST_F(CallExpressionTest, IsValid) {
diff --git a/src/ast/constructor_expression.cc b/src/ast/constructor_expression.cc
index 6aae250..1f19ed8 100644
--- a/src/ast/constructor_expression.cc
+++ b/src/ast/constructor_expression.cc
@@ -31,10 +31,6 @@
ConstructorExpression::ConstructorExpression(const Source& source)
: Base(source) {}
-bool ConstructorExpression::IsConstructor() const {
- return true;
-}
-
bool ConstructorExpression::IsScalarConstructor() const {
return false;
}
diff --git a/src/ast/constructor_expression.h b/src/ast/constructor_expression.h
index 9613318..3c9e375 100644
--- a/src/ast/constructor_expression.h
+++ b/src/ast/constructor_expression.h
@@ -29,9 +29,6 @@
public:
~ConstructorExpression() override;
- /// @returns true if this is an constructor expression
- bool IsConstructor() const override;
-
/// @returns true if this is a scalar constructor
virtual bool IsScalarConstructor() const;
/// @returns true if this is a type constructor
diff --git a/src/ast/expression.cc b/src/ast/expression.cc
index 0f77f2e..b21a903 100644
--- a/src/ast/expression.cc
+++ b/src/ast/expression.cc
@@ -14,18 +14,6 @@
#include "src/ast/expression.h"
-#include <assert.h>
-
-#include "src/ast/array_accessor_expression.h"
-#include "src/ast/binary_expression.h"
-#include "src/ast/bitcast_expression.h"
-#include "src/ast/call_expression.h"
-#include "src/ast/constructor_expression.h"
-#include "src/ast/identifier_expression.h"
-#include "src/ast/member_accessor_expression.h"
-#include "src/ast/type/alias_type.h"
-#include "src/ast/unary_op_expression.h"
-
namespace tint {
namespace ast {
@@ -42,116 +30,5 @@
result_type_ = type->UnwrapIfNeeded();
}
-bool Expression::IsArrayAccessor() const {
- return false;
-}
-
-bool Expression::IsBitcast() const {
- return false;
-}
-
-bool Expression::IsCall() const {
- return false;
-}
-
-bool Expression::IsIdentifier() const {
- return false;
-}
-
-bool Expression::IsConstructor() const {
- return false;
-}
-
-bool Expression::IsMemberAccessor() const {
- return false;
-}
-
-bool Expression::IsBinary() const {
- return false;
-}
-
-bool Expression::IsUnaryOp() const {
- return false;
-}
-const ArrayAccessorExpression* Expression::AsArrayAccessor() const {
- assert(IsArrayAccessor());
- return static_cast<const ArrayAccessorExpression*>(this);
-}
-
-const BitcastExpression* Expression::AsBitcast() const {
- assert(IsBitcast());
- return static_cast<const BitcastExpression*>(this);
-}
-
-const BinaryExpression* Expression::AsBinary() const {
- assert(IsBinary());
- return static_cast<const BinaryExpression*>(this);
-}
-
-const CallExpression* Expression::AsCall() const {
- assert(IsCall());
- return static_cast<const CallExpression*>(this);
-}
-
-const ConstructorExpression* Expression::AsConstructor() const {
- assert(IsConstructor());
- return static_cast<const ConstructorExpression*>(this);
-}
-
-const IdentifierExpression* Expression::AsIdentifier() const {
- assert(IsIdentifier());
- return static_cast<const IdentifierExpression*>(this);
-}
-
-const MemberAccessorExpression* Expression::AsMemberAccessor() const {
- assert(IsMemberAccessor());
- return static_cast<const MemberAccessorExpression*>(this);
-}
-
-const UnaryOpExpression* Expression::AsUnaryOp() const {
- assert(IsUnaryOp());
- return static_cast<const UnaryOpExpression*>(this);
-}
-
-ArrayAccessorExpression* Expression::AsArrayAccessor() {
- assert(IsArrayAccessor());
- return static_cast<ArrayAccessorExpression*>(this);
-}
-
-BitcastExpression* Expression::AsBitcast() {
- assert(IsBitcast());
- return static_cast<BitcastExpression*>(this);
-}
-
-BinaryExpression* Expression::AsBinary() {
- assert(IsBinary());
- return static_cast<BinaryExpression*>(this);
-}
-
-CallExpression* Expression::AsCall() {
- assert(IsCall());
- return static_cast<CallExpression*>(this);
-}
-
-ConstructorExpression* Expression::AsConstructor() {
- assert(IsConstructor());
- return static_cast<ConstructorExpression*>(this);
-}
-
-IdentifierExpression* Expression::AsIdentifier() {
- assert(IsIdentifier());
- return static_cast<IdentifierExpression*>(this);
-}
-
-MemberAccessorExpression* Expression::AsMemberAccessor() {
- assert(IsMemberAccessor());
- return static_cast<MemberAccessorExpression*>(this);
-}
-
-UnaryOpExpression* Expression::AsUnaryOp() {
- assert(IsUnaryOp());
- return static_cast<UnaryOpExpression*>(this);
-}
-
} // namespace ast
} // namespace tint
diff --git a/src/ast/expression.h b/src/ast/expression.h
index c4d85d4..1d0807b 100644
--- a/src/ast/expression.h
+++ b/src/ast/expression.h
@@ -25,15 +25,6 @@
namespace tint {
namespace ast {
-class ArrayAccessorExpression;
-class BinaryExpression;
-class BitcastExpression;
-class CallExpression;
-class IdentifierExpression;
-class ConstructorExpression;
-class MemberAccessorExpression;
-class UnaryOpExpression;
-
/// Base expression class
class Expression : public Castable<Expression, Node> {
public:
@@ -51,57 +42,6 @@
return result_type_ ? result_type_->type_name() : "not set";
}
- /// @returns true if this is an array accessor expression
- virtual bool IsArrayAccessor() const;
- /// @returns true if this is a bitcast expression
- virtual bool IsBitcast() const;
- /// @returns true if this is a call expression
- virtual bool IsCall() const;
- /// @returns true if this is an identifier expression
- virtual bool IsIdentifier() const;
- /// @returns true if this is an constructor expression
- virtual bool IsConstructor() const;
- /// @returns true if this is a member accessor expression
- virtual bool IsMemberAccessor() const;
- /// @returns true if this is a binary expression
- virtual bool IsBinary() const;
- /// @returns true if this is a unary op expression
- virtual bool IsUnaryOp() const;
-
- /// @returns the expression as an array accessor
- const ArrayAccessorExpression* AsArrayAccessor() const;
- /// @returns the expression as a bitcast
- const BitcastExpression* AsBitcast() const;
- /// @returns the expression as a call
- const CallExpression* AsCall() const;
- /// @returns the expression as an identifier
- const IdentifierExpression* AsIdentifier() const;
- /// @returns the expression as an constructor
- const ConstructorExpression* AsConstructor() const;
- /// @returns the expression as a member accessor
- const MemberAccessorExpression* AsMemberAccessor() const;
- /// @returns the expression as a binary expression
- const BinaryExpression* AsBinary() const;
- /// @returns the expression as a unary op expression
- const UnaryOpExpression* AsUnaryOp() const;
-
- /// @returns the expression as an array accessor
- ArrayAccessorExpression* AsArrayAccessor();
- /// @returns the expression as a bitcast
- BitcastExpression* AsBitcast();
- /// @returns the expression as a call
- CallExpression* AsCall();
- /// @returns the expression as an identifier
- IdentifierExpression* AsIdentifier();
- /// @returns the expression as an constructor
- ConstructorExpression* AsConstructor();
- /// @returns the expression as a member accessor
- MemberAccessorExpression* AsMemberAccessor();
- /// @returns the expression as a binary expression
- BinaryExpression* AsBinary();
- /// @returns the expression as a unary op expression
- UnaryOpExpression* AsUnaryOp();
-
protected:
/// Constructor
Expression();
diff --git a/src/ast/identifier_expression.cc b/src/ast/identifier_expression.cc
index ecad6ad..cf30ddc 100644
--- a/src/ast/identifier_expression.cc
+++ b/src/ast/identifier_expression.cc
@@ -28,10 +28,6 @@
IdentifierExpression::~IdentifierExpression() = default;
-bool IdentifierExpression::IsIdentifier() const {
- return true;
-}
-
bool IdentifierExpression::IsValid() const {
return !name_.empty();
}
diff --git a/src/ast/identifier_expression.h b/src/ast/identifier_expression.h
index b13fb0e..708648d 100644
--- a/src/ast/identifier_expression.h
+++ b/src/ast/identifier_expression.h
@@ -61,9 +61,6 @@
/// @returns true if this identifier is for an intrinsic
bool IsIntrinsic() const { return intrinsic_ != Intrinsic::kNone; }
- /// @returns true if this is an identifier expression
- bool IsIdentifier() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/identifier_expression_test.cc b/src/ast/identifier_expression_test.cc
index c4c6539..1bef59d 100644
--- a/src/ast/identifier_expression_test.cc
+++ b/src/ast/identifier_expression_test.cc
@@ -38,7 +38,7 @@
TEST_F(IdentifierExpressionTest, IsIdentifier) {
IdentifierExpression i("ident");
- EXPECT_TRUE(i.IsIdentifier());
+ EXPECT_TRUE(i.Is<ast::IdentifierExpression>());
}
TEST_F(IdentifierExpressionTest, IsValid) {
diff --git a/src/ast/member_accessor_expression.cc b/src/ast/member_accessor_expression.cc
index 029c272..64d8aad 100644
--- a/src/ast/member_accessor_expression.cc
+++ b/src/ast/member_accessor_expression.cc
@@ -33,10 +33,6 @@
MemberAccessorExpression::~MemberAccessorExpression() = default;
-bool MemberAccessorExpression::IsMemberAccessor() const {
- return true;
-}
-
bool MemberAccessorExpression::IsValid() const {
if (struct_ == nullptr || !struct_->IsValid()) {
return false;
diff --git a/src/ast/member_accessor_expression.h b/src/ast/member_accessor_expression.h
index 006ef88..2af5839 100644
--- a/src/ast/member_accessor_expression.h
+++ b/src/ast/member_accessor_expression.h
@@ -59,9 +59,6 @@
/// @returns the member expression
IdentifierExpression* member() const { return member_; }
- /// @returns true if this is a member accessor expression
- bool IsMemberAccessor() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/member_accessor_expression_test.cc b/src/ast/member_accessor_expression_test.cc
index 756f65f..ddf5477 100644
--- a/src/ast/member_accessor_expression_test.cc
+++ b/src/ast/member_accessor_expression_test.cc
@@ -46,7 +46,7 @@
TEST_F(MemberAccessorExpressionTest, IsMemberAccessor) {
MemberAccessorExpression stmt;
- EXPECT_TRUE(stmt.IsMemberAccessor());
+ EXPECT_TRUE(stmt.Is<ast::MemberAccessorExpression>());
}
TEST_F(MemberAccessorExpressionTest, IsValid) {
diff --git a/src/ast/unary_op_expression.cc b/src/ast/unary_op_expression.cc
index ed60a62..46d53c6 100644
--- a/src/ast/unary_op_expression.cc
+++ b/src/ast/unary_op_expression.cc
@@ -31,10 +31,6 @@
UnaryOpExpression::~UnaryOpExpression() = default;
-bool UnaryOpExpression::IsUnaryOp() const {
- return true;
-}
-
bool UnaryOpExpression::IsValid() const {
return expr_ != nullptr && expr_->IsValid();
}
diff --git a/src/ast/unary_op_expression.h b/src/ast/unary_op_expression.h
index 67d9e01..7d96fc4 100644
--- a/src/ast/unary_op_expression.h
+++ b/src/ast/unary_op_expression.h
@@ -55,9 +55,6 @@
/// @returns the expression
Expression* expr() const { return expr_; }
- /// @returns true if this is an as expression
- bool IsUnaryOp() const override;
-
/// @returns true if the node is valid
bool IsValid() const override;
diff --git a/src/ast/unary_op_expression_test.cc b/src/ast/unary_op_expression_test.cc
index f474ea9..3717a27 100644
--- a/src/ast/unary_op_expression_test.cc
+++ b/src/ast/unary_op_expression_test.cc
@@ -43,7 +43,7 @@
TEST_F(UnaryOpExpressionTest, IsUnaryOp) {
UnaryOpExpression u;
- EXPECT_TRUE(u.IsUnaryOp());
+ EXPECT_TRUE(u.Is<ast::UnaryOpExpression>());
}
TEST_F(UnaryOpExpressionTest, IsValid) {
diff --git a/src/inspector/inspector.cc b/src/inspector/inspector.cc
index 7a62f3f..655ed3a 100644
--- a/src/inspector/inspector.cc
+++ b/src/inspector/inspector.cc
@@ -124,13 +124,13 @@
}
auto* expression = var->constructor();
- if (!expression->IsConstructor()) {
+ if (!expression->Is<ast::ConstructorExpression>()) {
// This is invalid WGSL, but handling gracefully.
result[constant_id] = Scalar();
continue;
}
- auto* constructor = expression->AsConstructor();
+ auto* constructor = expression->As<ast::ConstructorExpression>();
if (!constructor->IsScalarConstructor()) {
// This is invalid WGSL, but handling gracefully.
result[constant_id] = Scalar();
diff --git a/src/reader/spirv/function.h b/src/reader/spirv/function.h
index 19fe372..d7a71e7 100644
--- a/src/reader/spirv/function.h
+++ b/src/reader/spirv/function.h
@@ -32,6 +32,7 @@
#include "source/opt/type_manager.h"
#include "src/ast/case_statement.h"
#include "src/ast/expression.h"
+#include "src/ast/identifier_expression.h"
#include "src/ast/module.h"
#include "src/ast/statement.h"
#include "src/ast/storage_class.h"
diff --git a/src/reader/wgsl/parser_impl_additive_expression_test.cc b/src/reader/wgsl/parser_impl_additive_expression_test.cc
index 09948cd..7cdfbda 100644
--- a/src/reader/wgsl/parser_impl_additive_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_additive_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kAdd, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -56,17 +56,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kSubtract, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -97,7 +97,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_and_expression_test.cc b/src/reader/wgsl/parser_impl_and_expression_test.cc
index 2131620..5cc8d98 100644
--- a/src/reader/wgsl/parser_impl_and_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_and_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kAnd, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -74,7 +74,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
index d1ea588..457a322 100644
--- a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
+++ b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
@@ -14,6 +14,7 @@
#include "gtest/gtest.h"
#include "src/ast/array_accessor_expression.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/identifier_expression.h"
#include "src/ast/scalar_constructor_expression.h"
#include "src/ast/sint_literal.h"
@@ -33,7 +34,7 @@
ASSERT_FALSE(e.errored);
ASSERT_EQ(e.value.size(), 1u);
- ASSERT_TRUE(e.value[0]->IsIdentifier());
+ ASSERT_TRUE(e.value[0]->Is<ast::IdentifierExpression>());
}
TEST_F(ParserImplTest, ArgumentExpressionList_ParsesMultiple) {
@@ -43,9 +44,9 @@
ASSERT_FALSE(e.errored);
ASSERT_EQ(e.value.size(), 3u);
- ASSERT_TRUE(e.value[0]->IsIdentifier());
- ASSERT_TRUE(e.value[1]->IsConstructor());
- ASSERT_TRUE(e.value[2]->IsBinary());
+ ASSERT_TRUE(e.value[0]->Is<ast::IdentifierExpression>());
+ ASSERT_TRUE(e.value[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e.value[2]->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, ArgumentExpressionList_HandlesMissingExpression) {
diff --git a/src/reader/wgsl/parser_impl_assignment_stmt_test.cc b/src/reader/wgsl/parser_impl_assignment_stmt_test.cc
index dfcadfe..541932d 100644
--- a/src/reader/wgsl/parser_impl_assignment_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_assignment_stmt_test.cc
@@ -40,14 +40,14 @@
ASSERT_NE(e->lhs(), nullptr);
ASSERT_NE(e->rhs(), nullptr);
- ASSERT_TRUE(e->lhs()->IsIdentifier());
- auto* ident = e->lhs()->AsIdentifier();
+ ASSERT_TRUE(e->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = e->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(e->rhs()->IsConstructor());
- ASSERT_TRUE(e->rhs()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(e->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->rhs()->Is<ast::ScalarConstructorExpression>());
- auto* init = e->rhs()->AsConstructor()->AsScalarConstructor();
+ auto* init = e->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_NE(init->literal(), nullptr);
ASSERT_TRUE(init->literal()->IsSint());
EXPECT_EQ(init->literal()->AsSint()->value(), 123);
@@ -65,45 +65,45 @@
ASSERT_NE(e->lhs(), nullptr);
ASSERT_NE(e->rhs(), nullptr);
- ASSERT_TRUE(e->rhs()->IsConstructor());
- ASSERT_TRUE(e->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = e->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(e->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = e->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_NE(init->literal(), nullptr);
ASSERT_TRUE(init->literal()->IsSint());
EXPECT_EQ(init->literal()->AsSint()->value(), 123);
- ASSERT_TRUE(e->lhs()->IsMemberAccessor());
- auto* mem = e->lhs()->AsMemberAccessor();
+ ASSERT_TRUE(e->lhs()->Is<ast::MemberAccessorExpression>());
+ auto* mem = e->lhs()->As<ast::MemberAccessorExpression>();
- ASSERT_TRUE(mem->member()->IsIdentifier());
- auto* ident = mem->member()->AsIdentifier();
+ ASSERT_TRUE(mem->member()->Is<ast::IdentifierExpression>());
+ auto* ident = mem->member()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "d");
- ASSERT_TRUE(mem->structure()->IsArrayAccessor());
- auto* ary = mem->structure()->AsArrayAccessor();
+ ASSERT_TRUE(mem->structure()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = mem->structure()->As<ast::ArrayAccessorExpression>();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
- init = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+ init = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_NE(init->literal(), nullptr);
ASSERT_TRUE(init->literal()->IsSint());
EXPECT_EQ(init->literal()->AsSint()->value(), 2);
- ASSERT_TRUE(ary->array()->IsMemberAccessor());
- mem = ary->array()->AsMemberAccessor();
- ASSERT_TRUE(mem->member()->IsIdentifier());
- ident = mem->member()->AsIdentifier();
+ ASSERT_TRUE(ary->array()->Is<ast::MemberAccessorExpression>());
+ mem = ary->array()->As<ast::MemberAccessorExpression>();
+ ASSERT_TRUE(mem->member()->Is<ast::IdentifierExpression>());
+ ident = mem->member()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "c");
- ASSERT_TRUE(mem->structure()->IsMemberAccessor());
- mem = mem->structure()->AsMemberAccessor();
+ ASSERT_TRUE(mem->structure()->Is<ast::MemberAccessorExpression>());
+ mem = mem->structure()->As<ast::MemberAccessorExpression>();
- ASSERT_TRUE(mem->structure()->IsIdentifier());
- ident = mem->structure()->AsIdentifier();
+ ASSERT_TRUE(mem->structure()->Is<ast::IdentifierExpression>());
+ ident = mem->structure()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(mem->member()->IsIdentifier());
- ident = mem->member()->AsIdentifier();
+ ASSERT_TRUE(mem->member()->Is<ast::IdentifierExpression>());
+ ident = mem->member()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "b");
}
diff --git a/src/reader/wgsl/parser_impl_call_stmt_test.cc b/src/reader/wgsl/parser_impl_call_stmt_test.cc
index a0ce2ed..158f7fc 100644
--- a/src/reader/wgsl/parser_impl_call_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_call_stmt_test.cc
@@ -13,6 +13,7 @@
// limitations under the License.
#include "gtest/gtest.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/call_expression.h"
#include "src/ast/call_statement.h"
#include "src/ast/identifier_expression.h"
@@ -35,8 +36,8 @@
ASSERT_TRUE(e->Is<ast::CallStatement>());
auto* c = e->As<ast::CallStatement>()->expr();
- ASSERT_TRUE(c->func()->IsIdentifier());
- auto* func = c->func()->AsIdentifier();
+ ASSERT_TRUE(c->func()->Is<ast::IdentifierExpression>());
+ auto* func = c->func()->As<ast::IdentifierExpression>();
EXPECT_EQ(func->name(), "a");
EXPECT_EQ(c->params().size(), 0u);
@@ -53,14 +54,14 @@
ASSERT_TRUE(e->Is<ast::CallStatement>());
auto* c = e->As<ast::CallStatement>()->expr();
- ASSERT_TRUE(c->func()->IsIdentifier());
- auto* func = c->func()->AsIdentifier();
+ ASSERT_TRUE(c->func()->Is<ast::IdentifierExpression>());
+ auto* func = c->func()->As<ast::IdentifierExpression>();
EXPECT_EQ(func->name(), "a");
EXPECT_EQ(c->params().size(), 3u);
- EXPECT_TRUE(c->params()[0]->IsConstructor());
- EXPECT_TRUE(c->params()[1]->IsIdentifier());
- EXPECT_TRUE(c->params()[2]->IsBinary());
+ EXPECT_TRUE(c->params()[0]->Is<ast::ConstructorExpression>());
+ EXPECT_TRUE(c->params()[1]->Is<ast::IdentifierExpression>());
+ EXPECT_TRUE(c->params()[2]->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, Statement_Call_Missing_RightParen) {
diff --git a/src/reader/wgsl/parser_impl_const_expr_test.cc b/src/reader/wgsl/parser_impl_const_expr_test.cc
index 4135515..4d13cf7 100644
--- a/src/reader/wgsl/parser_impl_const_expr_test.cc
+++ b/src/reader/wgsl/parser_impl_const_expr_test.cc
@@ -31,25 +31,25 @@
auto e = p->expect_const_expr();
ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(e.errored);
- ASSERT_TRUE(e->IsConstructor());
- ASSERT_TRUE(e->AsConstructor()->IsTypeConstructor());
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::TypeConstructorExpression>());
- auto* t = e->AsConstructor()->AsTypeConstructor();
+ auto* t = e->As<ast::TypeConstructorExpression>();
ASSERT_TRUE(t->type()->Is<ast::type::VectorType>());
EXPECT_EQ(t->type()->As<ast::type::VectorType>()->size(), 2u);
ASSERT_EQ(t->values().size(), 2u);
auto& v = t->values();
- ASSERT_TRUE(v[0]->IsConstructor());
- ASSERT_TRUE(v[0]->AsConstructor()->IsScalarConstructor());
- auto* c = v[0]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(v[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(v[0]->Is<ast::ScalarConstructorExpression>());
+ auto* c = v[0]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(c->literal()->IsFloat());
EXPECT_FLOAT_EQ(c->literal()->AsFloat()->value(), 1.);
- ASSERT_TRUE(v[1]->IsConstructor());
- ASSERT_TRUE(v[1]->AsConstructor()->IsScalarConstructor());
- c = v[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(v[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(v[1]->Is<ast::ScalarConstructorExpression>());
+ c = v[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(c->literal()->IsFloat());
EXPECT_FLOAT_EQ(c->literal()->AsFloat()->value(), 2.);
}
@@ -114,9 +114,9 @@
ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(e.errored);
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsConstructor());
- ASSERT_TRUE(e->AsConstructor()->IsScalarConstructor());
- auto* c = e->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::ScalarConstructorExpression>());
+ auto* c = e->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(c->literal()->IsBool());
EXPECT_TRUE(c->literal()->AsBool()->IsTrue());
}
diff --git a/src/reader/wgsl/parser_impl_elseif_stmt_test.cc b/src/reader/wgsl/parser_impl_elseif_stmt_test.cc
index 1c27a9b..150c7ea 100644
--- a/src/reader/wgsl/parser_impl_elseif_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_elseif_stmt_test.cc
@@ -13,7 +13,9 @@
// limitations under the License.
#include "gtest/gtest.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/else_statement.h"
+#include "src/ast/identifier_expression.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
@@ -32,7 +34,7 @@
ASSERT_TRUE(e.value[0]->Is<ast::ElseStatement>());
ASSERT_NE(e.value[0]->condition(), nullptr);
- ASSERT_TRUE(e.value[0]->condition()->IsBinary());
+ ASSERT_TRUE(e.value[0]->condition()->Is<ast::BinaryExpression>());
EXPECT_EQ(e.value[0]->body()->size(), 2u);
}
@@ -46,12 +48,12 @@
ASSERT_TRUE(e.value[0]->Is<ast::ElseStatement>());
ASSERT_NE(e.value[0]->condition(), nullptr);
- ASSERT_TRUE(e.value[0]->condition()->IsBinary());
+ ASSERT_TRUE(e.value[0]->condition()->Is<ast::BinaryExpression>());
EXPECT_EQ(e.value[0]->body()->size(), 2u);
ASSERT_TRUE(e.value[1]->Is<ast::ElseStatement>());
ASSERT_NE(e.value[1]->condition(), nullptr);
- ASSERT_TRUE(e.value[1]->condition()->IsIdentifier());
+ ASSERT_TRUE(e.value[1]->condition()->Is<ast::IdentifierExpression>());
EXPECT_EQ(e.value[1]->body()->size(), 1u);
}
diff --git a/src/reader/wgsl/parser_impl_equality_expression_test.cc b/src/reader/wgsl/parser_impl_equality_expression_test.cc
index 36cbcef..d73d1a5 100644
--- a/src/reader/wgsl/parser_impl_equality_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_equality_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kEqual, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -56,17 +56,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kNotEqual, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -97,7 +97,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc b/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
index 1338dfa..63f7dd5 100644
--- a/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kXor, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -74,7 +74,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_global_constant_decl_test.cc b/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
index ed6bbf6..fe26ad1 100644
--- a/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
@@ -43,7 +43,7 @@
EXPECT_EQ(e->source().range.end.column, 8u);
ASSERT_NE(e->constructor(), nullptr);
- EXPECT_TRUE(e->constructor()->IsConstructor());
+ EXPECT_TRUE(e->constructor()->Is<ast::ConstructorExpression>());
}
TEST_F(ParserImplTest, GlobalConstantDecl_MissingEqual) {
diff --git a/src/reader/wgsl/parser_impl_global_variable_decl_test.cc b/src/reader/wgsl/parser_impl_global_variable_decl_test.cc
index 80a5d30..b03cd79 100644
--- a/src/reader/wgsl/parser_impl_global_variable_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_variable_decl_test.cc
@@ -14,6 +14,7 @@
#include "gtest/gtest.h"
#include "src/ast/decorated_variable.h"
+#include "src/ast/scalar_constructor_expression.h"
#include "src/ast/type/f32_type.h"
#include "src/ast/variable_decoration.h"
#include "src/reader/wgsl/parser_impl.h"
@@ -69,8 +70,8 @@
EXPECT_EQ(e->source().range.end.column, 11u);
ASSERT_NE(e->constructor(), nullptr);
- ASSERT_TRUE(e->constructor()->IsConstructor());
- ASSERT_TRUE(e->constructor()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(e->constructor()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->constructor()->Is<ast::ScalarConstructorExpression>());
ASSERT_FALSE(e->IsDecorated());
}
diff --git a/src/reader/wgsl/parser_impl_if_stmt_test.cc b/src/reader/wgsl/parser_impl_if_stmt_test.cc
index fc1ac37..efd4248 100644
--- a/src/reader/wgsl/parser_impl_if_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_if_stmt_test.cc
@@ -13,7 +13,9 @@
// limitations under the License.
#include "gtest/gtest.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/else_statement.h"
+#include "src/ast/identifier_expression.h"
#include "src/ast/if_statement.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
@@ -33,7 +35,7 @@
ASSERT_TRUE(e->Is<ast::IfStatement>());
ASSERT_NE(e->condition(), nullptr);
- ASSERT_TRUE(e->condition()->IsBinary());
+ ASSERT_TRUE(e->condition()->Is<ast::BinaryExpression>());
EXPECT_EQ(e->body()->size(), 2u);
EXPECT_EQ(e->else_statements().size(), 0u);
}
@@ -48,12 +50,13 @@
ASSERT_TRUE(e->Is<ast::IfStatement>());
ASSERT_NE(e->condition(), nullptr);
- ASSERT_TRUE(e->condition()->IsBinary());
+ ASSERT_TRUE(e->condition()->Is<ast::BinaryExpression>());
EXPECT_EQ(e->body()->size(), 2u);
ASSERT_EQ(e->else_statements().size(), 2u);
ASSERT_NE(e->else_statements()[0]->condition(), nullptr);
- ASSERT_TRUE(e->else_statements()[0]->condition()->IsIdentifier());
+ ASSERT_TRUE(
+ e->else_statements()[0]->condition()->Is<ast::IdentifierExpression>());
EXPECT_EQ(e->else_statements()[0]->body()->size(), 1u);
ASSERT_EQ(e->else_statements()[1]->condition(), nullptr);
diff --git a/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc b/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
index e1bf011..207fcd9 100644
--- a/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kOr, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -74,7 +74,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_logical_and_expression_test.cc b/src/reader/wgsl/parser_impl_logical_and_expression_test.cc
index e291ce9..7dd5ce3 100644
--- a/src/reader/wgsl/parser_impl_logical_and_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_logical_and_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -74,7 +74,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_logical_or_expression_test.cc b/src/reader/wgsl/parser_impl_logical_or_expression_test.cc
index 006f06f..c5bfaee 100644
--- a/src/reader/wgsl/parser_impl_logical_or_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_logical_or_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -74,7 +74,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc b/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc
index 38f4dac..41a3e8c 100644
--- a/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kMultiply, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -56,17 +56,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kDivide, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -79,17 +79,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kModulo, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -120,7 +120,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc b/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc
index 85b7d3c..b56de58 100644
--- a/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc
@@ -13,6 +13,7 @@
// limitations under the License.
#include "gtest/gtest.h"
+#include "src/ast/binary_expression.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
@@ -27,7 +28,7 @@
ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(e.errored);
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, ParenRhsStmt_MissingLeftParen) {
diff --git a/src/reader/wgsl/parser_impl_postfix_expression_test.cc b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
index 10730da..7eb7ceb 100644
--- a/src/reader/wgsl/parser_impl_postfix_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
@@ -14,6 +14,7 @@
#include "gtest/gtest.h"
#include "src/ast/array_accessor_expression.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/call_expression.h"
#include "src/ast/identifier_expression.h"
#include "src/ast/member_accessor_expression.h"
@@ -36,16 +37,16 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsArrayAccessor());
- auto* ary = e->AsArrayAccessor();
+ ASSERT_TRUE(e->Is<ast::ArrayAccessorExpression>());
+ auto* ary = e->As<ast::ArrayAccessorExpression>();
- ASSERT_TRUE(ary->array()->IsIdentifier());
- auto* ident = ary->array()->AsIdentifier();
+ ASSERT_TRUE(ary->array()->Is<ast::IdentifierExpression>());
+ auto* ident = ary->array()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
- auto* c = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+ auto* c = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(c->literal()->IsSint());
EXPECT_EQ(c->literal()->AsSint()->value(), 1);
}
@@ -58,14 +59,14 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsArrayAccessor());
- auto* ary = e->AsArrayAccessor();
+ ASSERT_TRUE(e->Is<ast::ArrayAccessorExpression>());
+ auto* ary = e->As<ast::ArrayAccessorExpression>();
- ASSERT_TRUE(ary->array()->IsIdentifier());
- auto* ident = ary->array()->AsIdentifier();
+ ASSERT_TRUE(ary->array()->Is<ast::IdentifierExpression>());
+ auto* ident = ary->array()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(ary->idx_expr()->IsBinary());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, PostfixExpression_Array_MissingIndex) {
@@ -106,11 +107,11 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsCall());
- auto* c = e->AsCall();
+ ASSERT_TRUE(e->Is<ast::CallExpression>());
+ auto* c = e->As<ast::CallExpression>();
- ASSERT_TRUE(c->func()->IsIdentifier());
- auto* func = c->func()->AsIdentifier();
+ ASSERT_TRUE(c->func()->Is<ast::IdentifierExpression>());
+ auto* func = c->func()->As<ast::IdentifierExpression>();
EXPECT_EQ(func->name(), "a");
EXPECT_EQ(c->params().size(), 0u);
@@ -124,17 +125,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsCall());
- auto* c = e->AsCall();
+ ASSERT_TRUE(e->Is<ast::CallExpression>());
+ auto* c = e->As<ast::CallExpression>();
- ASSERT_TRUE(c->func()->IsIdentifier());
- auto* func = c->func()->AsIdentifier();
+ ASSERT_TRUE(c->func()->Is<ast::IdentifierExpression>());
+ auto* func = c->func()->As<ast::IdentifierExpression>();
EXPECT_EQ(func->name(), "test");
EXPECT_EQ(c->params().size(), 3u);
- EXPECT_TRUE(c->params()[0]->IsConstructor());
- EXPECT_TRUE(c->params()[1]->IsIdentifier());
- EXPECT_TRUE(c->params()[2]->IsBinary());
+ EXPECT_TRUE(c->params()[0]->Is<ast::ConstructorExpression>());
+ EXPECT_TRUE(c->params()[1]->Is<ast::IdentifierExpression>());
+ EXPECT_TRUE(c->params()[2]->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, PostfixExpression_Call_InvalidArg) {
@@ -174,14 +175,14 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsMemberAccessor());
+ ASSERT_TRUE(e->Is<ast::MemberAccessorExpression>());
- auto* m = e->AsMemberAccessor();
- ASSERT_TRUE(m->structure()->IsIdentifier());
- EXPECT_EQ(m->structure()->AsIdentifier()->name(), "a");
+ auto* m = e->As<ast::MemberAccessorExpression>();
+ ASSERT_TRUE(m->structure()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(m->structure()->As<ast::IdentifierExpression>()->name(), "a");
- ASSERT_TRUE(m->member()->IsIdentifier());
- EXPECT_EQ(m->member()->AsIdentifier()->name(), "b");
+ ASSERT_TRUE(m->member()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(m->member()->As<ast::IdentifierExpression>()->name(), "b");
}
TEST_F(ParserImplTest, PostfixExpression_MemberAccesssor_InvalidIdent) {
@@ -211,7 +212,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_primary_expression_test.cc b/src/reader/wgsl/parser_impl_primary_expression_test.cc
index 24a9c59..10ebcc9 100644
--- a/src/reader/wgsl/parser_impl_primary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_primary_expression_test.cc
@@ -14,6 +14,7 @@
#include "gtest/gtest.h"
#include "src/ast/array_accessor_expression.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/bitcast_expression.h"
#include "src/ast/bool_literal.h"
#include "src/ast/identifier_expression.h"
@@ -38,8 +39,8 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
- auto* ident = e->AsIdentifier();
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
+ auto* ident = e->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
}
@@ -50,33 +51,33 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsConstructor());
- ASSERT_TRUE(e->AsConstructor()->IsTypeConstructor());
- auto* ty = e->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::TypeConstructorExpression>());
+ auto* ty = e->As<ast::TypeConstructorExpression>();
ASSERT_EQ(ty->values().size(), 4u);
const auto& val = ty->values();
- ASSERT_TRUE(val[0]->IsConstructor());
- ASSERT_TRUE(val[0]->AsConstructor()->IsScalarConstructor());
- auto* ident = val[0]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(val[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(val[0]->Is<ast::ScalarConstructorExpression>());
+ auto* ident = val[0]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(ident->literal()->IsSint());
EXPECT_EQ(ident->literal()->AsSint()->value(), 1);
- ASSERT_TRUE(val[1]->IsConstructor());
- ASSERT_TRUE(val[1]->AsConstructor()->IsScalarConstructor());
- ident = val[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(val[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(val[1]->Is<ast::ScalarConstructorExpression>());
+ ident = val[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(ident->literal()->IsSint());
EXPECT_EQ(ident->literal()->AsSint()->value(), 2);
- ASSERT_TRUE(val[2]->IsConstructor());
- ASSERT_TRUE(val[2]->AsConstructor()->IsScalarConstructor());
- ident = val[2]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(val[2]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(val[2]->Is<ast::ScalarConstructorExpression>());
+ ident = val[2]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(ident->literal()->IsSint());
EXPECT_EQ(ident->literal()->AsSint()->value(), 3);
- ASSERT_TRUE(val[3]->IsConstructor());
- ASSERT_TRUE(val[3]->AsConstructor()->IsScalarConstructor());
- ident = val[3]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(val[3]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(val[3]->Is<ast::ScalarConstructorExpression>());
+ ident = val[3]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(ident->literal()->IsSint());
EXPECT_EQ(ident->literal()->AsSint()->value(), 4);
}
@@ -88,9 +89,9 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsConstructor());
- ASSERT_TRUE(e->AsConstructor()->IsTypeConstructor());
- auto* ty = e->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::TypeConstructorExpression>());
+ auto* ty = e->As<ast::TypeConstructorExpression>();
ASSERT_EQ(ty->values().size(), 0u);
}
@@ -142,9 +143,9 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsConstructor());
- ASSERT_TRUE(e->AsConstructor()->IsScalarConstructor());
- auto* init = e->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::ScalarConstructorExpression>());
+ auto* init = e->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
EXPECT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -156,7 +157,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, PrimaryExpression_ParenExpr_MissingRightParen) {
@@ -200,15 +201,15 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsConstructor());
- ASSERT_TRUE(e->AsConstructor()->IsTypeConstructor());
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::TypeConstructorExpression>());
- auto* c = e->AsConstructor()->AsTypeConstructor();
+ auto* c = e->As<ast::TypeConstructorExpression>();
ASSERT_EQ(c->type(), f32);
ASSERT_EQ(c->values().size(), 1u);
- ASSERT_TRUE(c->values()[0]->IsConstructor());
- ASSERT_TRUE(c->values()[0]->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(c->values()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(c->values()[0]->Is<ast::ScalarConstructorExpression>());
}
TEST_F(ParserImplTest, PrimaryExpression_Bitcast) {
@@ -222,13 +223,13 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBitcast());
+ ASSERT_TRUE(e->Is<ast::BitcastExpression>());
- auto* c = e->AsBitcast();
+ auto* c = e->As<ast::BitcastExpression>();
ASSERT_EQ(c->type(), f32);
- ASSERT_TRUE(c->expr()->IsConstructor());
- ASSERT_TRUE(c->expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(c->expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(c->expr()->Is<ast::ScalarConstructorExpression>());
}
TEST_F(ParserImplTest, PrimaryExpression_Bitcast_MissingGreaterThan) {
diff --git a/src/reader/wgsl/parser_impl_relational_expression_test.cc b/src/reader/wgsl/parser_impl_relational_expression_test.cc
index 70f9a70..ffa6840 100644
--- a/src/reader/wgsl/parser_impl_relational_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_relational_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kLessThan, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -56,17 +56,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kGreaterThan, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -79,17 +79,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kLessThanEqual, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -102,17 +102,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kGreaterThanEqual, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -141,7 +141,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_shift_expression_test.cc b/src/reader/wgsl/parser_impl_shift_expression_test.cc
index 4bda7f4..17e7bad 100644
--- a/src/reader/wgsl/parser_impl_shift_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_shift_expression_test.cc
@@ -33,17 +33,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kShiftLeft, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -56,17 +56,17 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsBinary());
- auto* rel = e->AsBinary();
+ ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+ auto* rel = e->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kShiftRight, rel->op());
- ASSERT_TRUE(rel->lhs()->IsIdentifier());
- auto* ident = rel->lhs()->AsIdentifier();
+ ASSERT_TRUE(rel->lhs()->Is<ast::IdentifierExpression>());
+ auto* ident = rel->lhs()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(rel->rhs()->IsConstructor());
- ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
- auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(rel->rhs()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(rel->rhs()->Is<ast::ScalarConstructorExpression>());
+ auto* init = rel->rhs()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsBool());
ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
}
@@ -97,7 +97,7 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsIdentifier());
+ ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_statement_test.cc b/src/reader/wgsl/parser_impl_statement_test.cc
index ec96357..e2bfd20 100644
--- a/src/reader/wgsl/parser_impl_statement_test.cc
+++ b/src/reader/wgsl/parser_impl_statement_test.cc
@@ -13,6 +13,7 @@
// limitations under the License.
#include "gtest/gtest.h"
+#include "src/ast/binary_expression.h"
#include "src/ast/discard_statement.h"
#include "src/ast/return_statement.h"
#include "src/ast/statement.h"
@@ -60,7 +61,7 @@
ASSERT_TRUE(e->Is<ast::ReturnStatement>());
auto* ret = e->As<ast::ReturnStatement>();
ASSERT_NE(ret->value(), nullptr);
- EXPECT_TRUE(ret->value()->IsBinary());
+ EXPECT_TRUE(ret->value()->Is<ast::BinaryExpression>());
}
TEST_F(ParserImplTest, Statement_Return_MissingSemi) {
diff --git a/src/reader/wgsl/parser_impl_unary_expression_test.cc b/src/reader/wgsl/parser_impl_unary_expression_test.cc
index 6817ed7..c846667 100644
--- a/src/reader/wgsl/parser_impl_unary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_unary_expression_test.cc
@@ -34,15 +34,15 @@
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsArrayAccessor());
- auto* ary = e->AsArrayAccessor();
- ASSERT_TRUE(ary->array()->IsIdentifier());
- auto* ident = ary->array()->AsIdentifier();
+ ASSERT_TRUE(e->Is<ast::ArrayAccessorExpression>());
+ auto* ary = e->As<ast::ArrayAccessorExpression>();
+ ASSERT_TRUE(ary->array()->Is<ast::IdentifierExpression>());
+ auto* ident = ary->array()->As<ast::IdentifierExpression>();
EXPECT_EQ(ident->name(), "a");
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
- auto* init = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
+ auto* init = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsSint());
ASSERT_EQ(init->literal()->AsSint()->value(), 2);
}
@@ -54,15 +54,15 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsUnaryOp());
+ ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
- auto* u = e->AsUnaryOp();
+ auto* u = e->As<ast::UnaryOpExpression>();
ASSERT_EQ(u->op(), ast::UnaryOp::kNegation);
- ASSERT_TRUE(u->expr()->IsConstructor());
- ASSERT_TRUE(u->expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(u->expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(u->expr()->Is<ast::ScalarConstructorExpression>());
- auto* init = u->expr()->AsConstructor()->AsScalarConstructor();
+ auto* init = u->expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsSint());
EXPECT_EQ(init->literal()->AsSint()->value(), 1);
}
@@ -84,15 +84,15 @@
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);
- ASSERT_TRUE(e->IsUnaryOp());
+ ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
- auto* u = e->AsUnaryOp();
+ auto* u = e->As<ast::UnaryOpExpression>();
ASSERT_EQ(u->op(), ast::UnaryOp::kNot);
- ASSERT_TRUE(u->expr()->IsConstructor());
- ASSERT_TRUE(u->expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(u->expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(u->expr()->Is<ast::ScalarConstructorExpression>());
- auto* init = u->expr()->AsConstructor()->AsScalarConstructor();
+ auto* init = u->expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(init->literal()->IsSint());
EXPECT_EQ(init->literal()->AsSint()->value(), 1);
}
diff --git a/src/reader/wgsl/parser_impl_variable_stmt_test.cc b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
index 8f83c31..d541af3 100644
--- a/src/reader/wgsl/parser_impl_variable_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
@@ -59,7 +59,7 @@
ASSERT_EQ(e->source().range.end.column, 6u);
ASSERT_NE(e->variable()->constructor(), nullptr);
- EXPECT_TRUE(e->variable()->constructor()->IsConstructor());
+ EXPECT_TRUE(e->variable()->constructor()->Is<ast::ConstructorExpression>());
}
TEST_F(ParserImplTest, VariableStmt_VariableDecl_Invalid) {
diff --git a/src/transform/bound_array_accessors_transform.cc b/src/transform/bound_array_accessors_transform.cc
index 1715c8c..135518e 100644
--- a/src/transform/bound_array_accessors_transform.cc
+++ b/src/transform/bound_array_accessors_transform.cc
@@ -135,24 +135,22 @@
}
bool BoundArrayAccessorsTransform::ProcessExpression(ast::Expression* expr) {
- if (expr->IsArrayAccessor()) {
- return ProcessArrayAccessor(expr->AsArrayAccessor());
- } else if (expr->IsBitcast()) {
- return ProcessExpression(expr->AsBitcast()->expr());
- } else if (expr->IsCall()) {
- auto* c = expr->AsCall();
- if (!ProcessExpression(c->func())) {
+ if (auto* array = expr->As<ast::ArrayAccessorExpression>()) {
+ return ProcessArrayAccessor(array);
+ } else if (auto* bitcast = expr->As<ast::BitcastExpression>()) {
+ return ProcessExpression(bitcast->expr());
+ } else if (auto* call = expr->As<ast::CallExpression>()) {
+ if (!ProcessExpression(call->func())) {
return false;
}
- for (auto* e : c->params()) {
+ for (auto* e : call->params()) {
if (!ProcessExpression(e)) {
return false;
}
}
- } else if (expr->IsIdentifier()) {
+ } else if (expr->Is<ast::IdentifierExpression>()) {
/* nop */
- } else if (expr->IsConstructor()) {
- auto* c = expr->AsConstructor();
+ } else if (auto* c = expr->As<ast::ConstructorExpression>()) {
if (c->IsTypeConstructor()) {
for (auto* e : c->AsTypeConstructor()->values()) {
if (!ProcessExpression(e)) {
@@ -160,14 +158,12 @@
}
}
}
- } else if (expr->IsMemberAccessor()) {
- auto* m = expr->AsMemberAccessor();
+ } else if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
return ProcessExpression(m->structure()) && ProcessExpression(m->member());
- } else if (expr->IsBinary()) {
- auto* b = expr->AsBinary();
+ } else if (auto* b = expr->As<ast::BinaryExpression>()) {
return ProcessExpression(b->lhs()) && ProcessExpression(b->rhs());
- } else if (expr->IsUnaryOp()) {
- return ProcessExpression(expr->AsUnaryOp()->expr());
+ } else if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+ return ProcessExpression(u->expr());
} else {
error_ = "unknown statement in bound array accessors transform";
return false;
@@ -217,10 +213,8 @@
ast::ArrayAccessorExpression* expr,
uint32_t size) {
// Scalar constructor we can re-write the value to be within bounds.
- if (expr->idx_expr()->IsConstructor() &&
- expr->idx_expr()->AsConstructor()->IsScalarConstructor()) {
- auto* lit =
- expr->idx_expr()->AsConstructor()->AsScalarConstructor()->literal();
+ if (auto* c = expr->idx_expr()->As<ast::ScalarConstructorExpression>()) {
+ auto* lit = c->literal();
if (lit->IsSint()) {
int32_t val = lit->AsSint()->value();
if (val < 0) {
diff --git a/src/transform/bound_array_accessors_transform_test.cc b/src/transform/bound_array_accessors_transform_test.cc
index d9aa522..b0e6543 100644
--- a/src/transform/bound_array_accessors_transform_test.cc
+++ b/src/transform/bound_array_accessors_transform_test.cc
@@ -129,25 +129,25 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsCall());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
- auto* idx = ptr->idx_expr()->AsCall();
- ASSERT_TRUE(idx->func()->IsIdentifier());
- EXPECT_EQ(idx->func()->AsIdentifier()->name(), "min");
+ auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+ ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
ASSERT_EQ(idx->params().size(), 2u);
- ASSERT_TRUE(idx->params()[0]->IsConstructor());
- ASSERT_TRUE(idx->params()[0]->AsConstructor()->IsTypeConstructor());
- auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_idx);
- ASSERT_TRUE(idx->params()[1]->IsConstructor());
- ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
- auto* scalar = idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
@@ -192,45 +192,49 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsCall());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
- auto* idx = ptr->idx_expr()->AsCall();
- ASSERT_TRUE(idx->func()->IsIdentifier());
- EXPECT_EQ(idx->func()->AsIdentifier()->name(), "min");
+ auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+ ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
ASSERT_EQ(idx->params().size(), 2u);
- ASSERT_TRUE(idx->params()[0]->IsConstructor());
- ASSERT_TRUE(idx->params()[0]->AsConstructor()->IsTypeConstructor());
- auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
auto* sub = tc->values()[0];
- ASSERT_TRUE(sub->IsArrayAccessor());
- ASSERT_TRUE(sub->AsArrayAccessor()->idx_expr()->IsCall());
+ ASSERT_TRUE(sub->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(sub->As<ast::ArrayAccessorExpression>()
+ ->idx_expr()
+ ->Is<ast::CallExpression>());
- auto* sub_idx = sub->AsArrayAccessor()->idx_expr()->AsCall();
- ASSERT_TRUE(sub_idx->func()->IsIdentifier());
- EXPECT_EQ(sub_idx->func()->AsIdentifier()->name(), "min");
+ auto* sub_idx = sub->As<ast::ArrayAccessorExpression>()
+ ->idx_expr()
+ ->As<ast::CallExpression>();
+ ASSERT_TRUE(sub_idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(sub_idx->func()->As<ast::IdentifierExpression>()->name(), "min");
- ASSERT_TRUE(sub_idx->params()[0]->IsConstructor());
- ASSERT_TRUE(sub_idx->params()[0]->AsConstructor()->IsTypeConstructor());
- tc = sub_idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(sub_idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(sub_idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ tc = sub_idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], b_access_idx);
- ASSERT_TRUE(sub_idx->params()[1]->IsConstructor());
- ASSERT_TRUE(sub_idx->params()[1]->AsConstructor()->IsScalarConstructor());
- auto* scalar = sub_idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(sub_idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(sub_idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ auto* scalar = sub_idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 4u);
- ASSERT_TRUE(idx->params()[1]->IsConstructor());
- ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
- scalar = idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
@@ -265,11 +269,11 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
@@ -313,25 +317,25 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsCall());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
- auto* idx = ptr->idx_expr()->AsCall();
- ASSERT_TRUE(idx->func()->IsIdentifier());
- EXPECT_EQ(idx->func()->AsIdentifier()->name(), "min");
+ auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+ ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
ASSERT_EQ(idx->params().size(), 2u);
- ASSERT_TRUE(idx->params()[0]->IsConstructor());
- ASSERT_TRUE(idx->params()[0]->AsConstructor()->IsTypeConstructor());
- auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_idx);
- ASSERT_TRUE(idx->params()[1]->IsConstructor());
- ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
- auto* scalar = idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
@@ -366,11 +370,11 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsSint());
EXPECT_EQ(scalar->literal()->AsSint()->value(), 0);
@@ -405,11 +409,11 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
@@ -444,11 +448,11 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
@@ -492,24 +496,24 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsCall());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
- auto* idx = ptr->idx_expr()->AsCall();
- ASSERT_TRUE(idx->func()->IsIdentifier());
- EXPECT_EQ(idx->func()->AsIdentifier()->name(), "min");
+ auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+ ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
ASSERT_EQ(idx->params().size(), 2u);
- ASSERT_TRUE(idx->params()[0]->IsConstructor());
- ASSERT_TRUE(idx->params()[0]->AsConstructor()->IsTypeConstructor());
- auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_idx);
- ASSERT_TRUE(idx->params()[1]->IsConstructor());
- ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
- auto* scalar = idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
@@ -544,11 +548,11 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsSint());
EXPECT_EQ(scalar->literal()->AsSint()->value(), 0);
@@ -583,11 +587,11 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
@@ -625,24 +629,24 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32Type>());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
@@ -689,38 +693,38 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
- ASSERT_TRUE(ary->idx_expr()->IsCall());
- auto* idx = ary->idx_expr()->AsCall();
- ASSERT_TRUE(idx->func()->IsIdentifier());
- EXPECT_EQ(idx->func()->AsIdentifier()->name(), "min");
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::CallExpression>());
+ auto* idx = ary->idx_expr()->As<ast::CallExpression>();
+ ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
ASSERT_EQ(idx->params().size(), 2u);
- ASSERT_TRUE(idx->params()[0]->IsConstructor());
- ASSERT_TRUE(idx->params()[0]->AsConstructor()->IsTypeConstructor());
- auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_idx);
- ASSERT_TRUE(idx->params()[1]->IsConstructor());
- ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
- auto* scalar = idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ auto* scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32Type>());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
@@ -768,35 +772,35 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
- ASSERT_TRUE(ptr->idx_expr()->IsCall());
- auto* idx = ptr->idx_expr()->AsCall();
- ASSERT_TRUE(idx->func()->IsIdentifier());
- EXPECT_EQ(idx->func()->AsIdentifier()->name(), "min");
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::CallExpression>());
+ auto* idx = ptr->idx_expr()->As<ast::CallExpression>();
+ ASSERT_TRUE(idx->func()->Is<ast::IdentifierExpression>());
+ EXPECT_EQ(idx->func()->As<ast::IdentifierExpression>()->name(), "min");
ASSERT_EQ(idx->params().size(), 2u);
- ASSERT_TRUE(idx->params()[0]->IsConstructor());
- ASSERT_TRUE(idx->params()[0]->AsConstructor()->IsTypeConstructor());
- auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
+ ASSERT_TRUE(idx->params()[0]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[0]->Is<ast::TypeConstructorExpression>());
+ auto* tc = idx->params()[0]->As<ast::TypeConstructorExpression>();
EXPECT_TRUE(tc->type()->Is<ast::type::U32Type>());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_idx);
- ASSERT_TRUE(idx->params()[1]->IsConstructor());
- ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
- scalar = idx->params()[1]->AsConstructor()->AsScalarConstructor();
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(idx->params()[1]->Is<ast::ScalarConstructorExpression>());
+ scalar = idx->params()[1]->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
@@ -836,24 +840,24 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsSint());
EXPECT_EQ(scalar->literal()->AsSint()->value(), 0);
ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::I32Type>());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsSint());
EXPECT_EQ(scalar->literal()->AsSint()->value(), 1);
@@ -890,24 +894,24 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsSint());
EXPECT_EQ(scalar->literal()->AsSint()->value(), 2);
ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::I32Type>());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsSint());
EXPECT_EQ(scalar->literal()->AsSint()->value(), 0);
@@ -945,24 +949,24 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32Type>());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
@@ -1000,24 +1004,24 @@
ASSERT_TRUE(td()->Determine()) << td()->error();
ASSERT_TRUE(manager()->Run());
- ASSERT_TRUE(ptr->IsArrayAccessor());
+ ASSERT_TRUE(ptr->Is<ast::ArrayAccessorExpression>());
- ASSERT_TRUE(ptr->array()->IsArrayAccessor());
- auto* ary = ptr->array()->AsArrayAccessor();
- ASSERT_TRUE(ary->idx_expr()->IsConstructor());
- ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->array()->Is<ast::ArrayAccessorExpression>());
+ auto* ary = ptr->array()->As<ast::ArrayAccessorExpression>();
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ary->idx_expr()->Is<ast::ScalarConstructorExpression>());
- auto* scalar = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+ auto* scalar = ary->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 2u);
ASSERT_NE(ary->idx_expr()->result_type(), nullptr);
ASSERT_TRUE(ary->idx_expr()->result_type()->Is<ast::type::U32Type>());
- ASSERT_TRUE(ptr->idx_expr()->IsConstructor());
- ASSERT_TRUE(ptr->idx_expr()->AsConstructor()->IsScalarConstructor());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(ptr->idx_expr()->Is<ast::ScalarConstructorExpression>());
- scalar = ptr->idx_expr()->AsConstructor()->AsScalarConstructor();
+ scalar = ptr->idx_expr()->As<ast::ScalarConstructorExpression>();
ASSERT_TRUE(scalar->literal()->IsUint());
EXPECT_EQ(scalar->literal()->AsUint()->value(), 1u);
diff --git a/src/type_determiner.cc b/src/type_determiner.cc
index 6a83e74..6d3a38e 100644
--- a/src/type_determiner.cc
+++ b/src/type_determiner.cc
@@ -289,29 +289,29 @@
return true;
}
- if (expr->IsArrayAccessor()) {
- return DetermineArrayAccessor(expr->AsArrayAccessor());
+ if (auto* a = expr->As<ast::ArrayAccessorExpression>()) {
+ return DetermineArrayAccessor(a);
}
- if (expr->IsBinary()) {
- return DetermineBinary(expr->AsBinary());
+ if (auto* b = expr->As<ast::BinaryExpression>()) {
+ return DetermineBinary(b);
}
- if (expr->IsBitcast()) {
- return DetermineBitcast(expr->AsBitcast());
+ if (auto* b = expr->As<ast::BitcastExpression>()) {
+ return DetermineBitcast(b);
}
- if (expr->IsCall()) {
- return DetermineCall(expr->AsCall());
+ if (auto* c = expr->As<ast::CallExpression>()) {
+ return DetermineCall(c);
}
- if (expr->IsConstructor()) {
- return DetermineConstructor(expr->AsConstructor());
+ if (auto* c = expr->As<ast::ConstructorExpression>()) {
+ return DetermineConstructor(c);
}
- if (expr->IsIdentifier()) {
- return DetermineIdentifier(expr->AsIdentifier());
+ if (auto* i = expr->As<ast::IdentifierExpression>()) {
+ return DetermineIdentifier(i);
}
- if (expr->IsMemberAccessor()) {
- return DetermineMemberAccessor(expr->AsMemberAccessor());
+ if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
+ return DetermineMemberAccessor(m);
}
- if (expr->IsUnaryOp()) {
- return DetermineUnaryOp(expr->AsUnaryOp());
+ if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+ return DetermineUnaryOp(u);
}
set_error(expr->source(), "unknown expression for type determination");
@@ -380,9 +380,7 @@
// The expression has to be an identifier as you can't store function pointers
// but, if it isn't we'll just use the normal result determination to be on
// the safe side.
- if (expr->func()->IsIdentifier()) {
- auto* ident = expr->func()->AsIdentifier();
-
+ if (auto* ident = expr->func()->As<ast::IdentifierExpression>()) {
if (ident->IsIntrinsic()) {
if (!DetermineIntrinsic(ident, expr)) {
return false;
@@ -417,7 +415,7 @@
}
if (!expr->func()->result_type()) {
- auto func_name = expr->func()->AsIdentifier()->name();
+ auto func_name = expr->func()->As<ast::IdentifierExpression>()->name();
set_error(
expr->source(),
"v-0005: function must be declared before use: '" + func_name + "'");
diff --git a/src/validator/validator_impl.cc b/src/validator/validator_impl.cc
index eea936e..c00c998 100644
--- a/src/validator/validator_impl.cc
+++ b/src/validator/validator_impl.cc
@@ -394,8 +394,7 @@
return false;
}
- if (expr->func()->IsIdentifier()) {
- auto* ident = expr->func()->AsIdentifier();
+ if (auto* ident = expr->func()->As<ast::IdentifierExpression>()) {
auto func_name = ident->name();
if (ident->IsIntrinsic()) {
// TODO(sarahM0): validate intrinsics - tied with type-determiner
@@ -441,9 +440,8 @@
return false;
}
- if (assign->lhs()->IsIdentifier()) {
+ if (auto* ident = assign->lhs()->As<ast::IdentifierExpression>()) {
ast::Variable* var;
- auto* ident = assign->lhs()->AsIdentifier();
if (variable_stack_.get(ident->name(), &var)) {
if (var->is_const()) {
add_error(assign->source(), "v-0021",
@@ -477,12 +475,12 @@
if (!expr) {
return false;
}
- if (expr->IsIdentifier()) {
- return ValidateIdentifier(expr->AsIdentifier());
+ if (auto* i = expr->As<ast::IdentifierExpression>()) {
+ return ValidateIdentifier(i);
}
- if (expr->IsCall()) {
- return ValidateCallExpr(expr->AsCall());
+ if (auto* c = expr->As<ast::CallExpression>()) {
+ return ValidateCallExpr(c);
}
return true;
}
diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc
index 0ffbc06..62b46e5 100644
--- a/src/writer/hlsl/generator_impl.cc
+++ b/src/writer/hlsl/generator_impl.cc
@@ -82,12 +82,12 @@
std::string get_buffer_name(ast::Expression* expr) {
for (;;) {
- if (expr->IsIdentifier()) {
- return expr->AsIdentifier()->name();
- } else if (expr->IsMemberAccessor()) {
- expr = expr->AsMemberAccessor()->structure();
- } else if (expr->IsArrayAccessor()) {
- expr = expr->AsArrayAccessor()->array();
+ if (auto* ident = expr->As<ast::IdentifierExpression>()) {
+ return ident->name();
+ } else if (auto* member = expr->As<ast::MemberAccessorExpression>()) {
+ expr = member->structure();
+ } else if (auto* array = expr->As<ast::ArrayAccessorExpression>()) {
+ expr = array->array();
} else {
break;
}
@@ -299,8 +299,7 @@
// If the LHS is an accessor into a storage buffer then we have to
// emit a Store operation instead of an ='s.
- if (stmt->lhs()->IsMemberAccessor()) {
- auto* mem = stmt->lhs()->AsMemberAccessor();
+ if (auto* mem = stmt->lhs()->As<ast::MemberAccessorExpression>()) {
if (is_storage_buffer_access(mem)) {
std::ostringstream accessor_out;
if (!EmitStorageBufferAccessor(pre, accessor_out, mem, stmt->rhs())) {
@@ -310,8 +309,7 @@
out << accessor_out.str() << ";" << std::endl;
return true;
}
- } else if (stmt->lhs()->IsArrayAccessor()) {
- auto* ary = stmt->lhs()->AsArrayAccessor();
+ } else if (auto* ary = stmt->lhs()->As<ast::ArrayAccessorExpression>()) {
if (is_storage_buffer_access(ary)) {
std::ostringstream accessor_out;
if (!EmitStorageBufferAccessor(pre, accessor_out, ary, stmt->rhs())) {
@@ -577,12 +575,12 @@
bool GeneratorImpl::EmitCall(std::ostream& pre,
std::ostream& out,
ast::CallExpression* expr) {
- if (!expr->func()->IsIdentifier()) {
+ auto* ident = expr->func()->As<ast::IdentifierExpression>();
+ if (ident == nullptr) {
error_ = "invalid function name";
return 0;
}
- auto* ident = expr->func()->AsIdentifier();
if (ident->IsIntrinsic()) {
const auto& params = expr->params();
if (ident->intrinsic() == ast::Intrinsic::kSelect) {
@@ -731,7 +729,7 @@
ast::CallExpression* expr) {
make_indent(out);
- auto* ident = expr->func()->AsIdentifier();
+ auto* ident = expr->func()->As<ast::IdentifierExpression>();
auto params = expr->params();
auto* signature = static_cast<const ast::intrinsic::TextureSignature*>(
@@ -801,7 +799,7 @@
std::string GeneratorImpl::generate_builtin_name(ast::CallExpression* expr) {
std::string out;
- auto* ident = expr->func()->AsIdentifier();
+ auto* ident = expr->func()->As<ast::IdentifierExpression>();
switch (ident->intrinsic()) {
case ast::Intrinsic::kAcos:
case ast::Intrinsic::kAsin:
@@ -976,29 +974,29 @@
bool GeneratorImpl::EmitExpression(std::ostream& pre,
std::ostream& out,
ast::Expression* expr) {
- if (expr->IsArrayAccessor()) {
- return EmitArrayAccessor(pre, out, expr->AsArrayAccessor());
+ if (auto* a = expr->As<ast::ArrayAccessorExpression>()) {
+ return EmitArrayAccessor(pre, out, a);
}
- if (expr->IsBinary()) {
- return EmitBinary(pre, out, expr->AsBinary());
+ if (auto* b = expr->As<ast::BinaryExpression>()) {
+ return EmitBinary(pre, out, b);
}
- if (expr->IsBitcast()) {
- return EmitBitcast(pre, out, expr->AsBitcast());
+ if (auto* b = expr->As<ast::BitcastExpression>()) {
+ return EmitBitcast(pre, out, b);
}
- if (expr->IsCall()) {
- return EmitCall(pre, out, expr->AsCall());
+ if (auto* c = expr->As<ast::CallExpression>()) {
+ return EmitCall(pre, out, c);
}
- if (expr->IsConstructor()) {
- return EmitConstructor(pre, out, expr->AsConstructor());
+ if (auto* c = expr->As<ast::ConstructorExpression>()) {
+ return EmitConstructor(pre, out, c);
}
- if (expr->IsIdentifier()) {
- return EmitIdentifier(pre, out, expr->AsIdentifier());
+ if (auto* i = expr->As<ast::IdentifierExpression>()) {
+ return EmitIdentifier(pre, out, i);
}
- if (expr->IsMemberAccessor()) {
- return EmitMemberAccessor(pre, out, expr->AsMemberAccessor());
+ if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
+ return EmitMemberAccessor(pre, out, m);
}
- if (expr->IsUnaryOp()) {
- return EmitUnaryOp(pre, out, expr->AsUnaryOp());
+ if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+ return EmitUnaryOp(pre, out, u);
}
error_ = "unknown expression type: " + expr->str();
@@ -1016,7 +1014,7 @@
bool GeneratorImpl::EmitIdentifier(std::ostream&,
std::ostream& out,
ast::IdentifierExpression* expr) {
- auto* ident = expr->AsIdentifier();
+ auto* ident = expr->As<ast::IdentifierExpression>();
ast::Variable* var = nullptr;
if (global_variables_.get(ident->name(), &var)) {
if (global_is_in_struct(var)) {
@@ -1683,7 +1681,7 @@
std::ostringstream out;
bool first = true;
for (;;) {
- if (expr->IsIdentifier()) {
+ if (expr->Is<ast::IdentifierExpression>()) {
break;
}
@@ -1691,8 +1689,7 @@
out << " + ";
}
first = false;
- if (expr->IsMemberAccessor()) {
- auto* mem = expr->AsMemberAccessor();
+ if (auto* mem = expr->As<ast::MemberAccessorExpression>()) {
auto* res_type = mem->structure()->result_type()->UnwrapAll();
if (res_type->Is<ast::type::StructType>()) {
auto* str_type = res_type->As<ast::type::StructType>()->impl();
@@ -1726,8 +1723,7 @@
}
expr = mem->structure();
- } else if (expr->IsArrayAccessor()) {
- auto* ary = expr->AsArrayAccessor();
+ } else if (auto* ary = expr->As<ast::ArrayAccessorExpression>()) {
auto* ary_type = ary->array()->result_type()->UnwrapAll();
out << "(";
@@ -1885,10 +1881,10 @@
// If it isn't an array or a member accessor we can stop looking as it won't
// be a storage buffer.
auto* ary = expr->array();
- if (ary->IsMemberAccessor()) {
- return is_storage_buffer_access(ary->AsMemberAccessor());
- } else if (ary->IsArrayAccessor()) {
- return is_storage_buffer_access(ary->AsArrayAccessor());
+ if (auto* member = ary->As<ast::MemberAccessorExpression>()) {
+ return is_storage_buffer_access(member);
+ } else if (auto* array = ary->As<ast::ArrayAccessorExpression>()) {
+ return is_storage_buffer_access(array);
}
return false;
}
@@ -1905,17 +1901,16 @@
}
// Check if this is a storage buffer variable
- if (structure->IsIdentifier()) {
- auto* ident = expr->structure()->AsIdentifier();
+ if (auto* ident = expr->structure()->As<ast::IdentifierExpression>()) {
ast::Variable* var = nullptr;
if (!global_variables_.get(ident->name(), &var)) {
return false;
}
return var->storage_class() == ast::StorageClass::kStorageBuffer;
- } else if (structure->IsMemberAccessor()) {
- return is_storage_buffer_access(structure->AsMemberAccessor());
- } else if (structure->IsArrayAccessor()) {
- return is_storage_buffer_access(structure->AsArrayAccessor());
+ } else if (auto* member = structure->As<ast::MemberAccessorExpression>()) {
+ return is_storage_buffer_access(member);
+ } else if (auto* array = structure->As<ast::ArrayAccessorExpression>()) {
+ return is_storage_buffer_access(array);
}
// Technically I don't think this is possible, but if we don't have a struct
diff --git a/src/writer/hlsl/generator_impl.h b/src/writer/hlsl/generator_impl.h
index be2f31b..cbfc7cd 100644
--- a/src/writer/hlsl/generator_impl.h
+++ b/src/writer/hlsl/generator_impl.h
@@ -19,21 +19,28 @@
#include <unordered_map>
#include <unordered_set>
+#include "src/ast/array_accessor_expression.h"
#include "src/ast/assignment_statement.h"
+#include "src/ast/binary_expression.h"
+#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
+#include "src/ast/call_expression.h"
#include "src/ast/case_statement.h"
#include "src/ast/continue_statement.h"
#include "src/ast/discard_statement.h"
+#include "src/ast/identifier_expression.h"
#include "src/ast/if_statement.h"
#include "src/ast/intrinsic.h"
#include "src/ast/literal.h"
#include "src/ast/loop_statement.h"
+#include "src/ast/member_accessor_expression.h"
#include "src/ast/module.h"
#include "src/ast/return_statement.h"
#include "src/ast/scalar_constructor_expression.h"
#include "src/ast/switch_statement.h"
#include "src/ast/type/struct_type.h"
#include "src/ast/type_constructor_expression.h"
+#include "src/ast/unary_op_expression.h"
#include "src/context.h"
#include "src/scope_stack.h"
#include "src/writer/hlsl/namer.h"
diff --git a/src/writer/msl/generator_impl.cc b/src/writer/msl/generator_impl.cc
index 61aec3d..92e4433 100644
--- a/src/writer/msl/generator_impl.cc
+++ b/src/writer/msl/generator_impl.cc
@@ -484,12 +484,13 @@
}
bool GeneratorImpl::EmitCall(ast::CallExpression* expr) {
- if (!expr->func()->IsIdentifier()) {
+ auto* ident = expr->func()->As<ast::IdentifierExpression>();
+
+ if (ident == nullptr) {
error_ = "invalid function name";
return 0;
}
- auto* ident = expr->func()->AsIdentifier();
if (ident->IsIntrinsic()) {
const auto& params = expr->params();
if (ident->intrinsic() == ast::Intrinsic::kOuterProduct) {
@@ -658,7 +659,7 @@
}
bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr) {
- auto* ident = expr->func()->AsIdentifier();
+ auto* ident = expr->func()->As<ast::IdentifierExpression>();
auto params = expr->params();
auto* signature = static_cast<const ast::intrinsic::TextureSignature*>(
@@ -1094,29 +1095,29 @@
}
bool GeneratorImpl::EmitExpression(ast::Expression* expr) {
- if (expr->IsArrayAccessor()) {
- return EmitArrayAccessor(expr->AsArrayAccessor());
+ if (auto* a = expr->As<ast::ArrayAccessorExpression>()) {
+ return EmitArrayAccessor(a);
}
- if (expr->IsBinary()) {
- return EmitBinary(expr->AsBinary());
+ if (auto* b = expr->As<ast::BinaryExpression>()) {
+ return EmitBinary(b);
}
- if (expr->IsBitcast()) {
- return EmitBitcast(expr->AsBitcast());
+ if (auto* b = expr->As<ast::BitcastExpression>()) {
+ return EmitBitcast(b);
}
- if (expr->IsCall()) {
- return EmitCall(expr->AsCall());
+ if (auto* c = expr->As<ast::CallExpression>()) {
+ return EmitCall(c);
}
- if (expr->IsConstructor()) {
- return EmitConstructor(expr->AsConstructor());
+ if (auto* c = expr->As<ast::ConstructorExpression>()) {
+ return EmitConstructor(c);
}
- if (expr->IsIdentifier()) {
- return EmitIdentifier(expr->AsIdentifier());
+ if (auto* i = expr->As<ast::IdentifierExpression>()) {
+ return EmitIdentifier(i);
}
- if (expr->IsMemberAccessor()) {
- return EmitMemberAccessor(expr->AsMemberAccessor());
+ if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
+ return EmitMemberAccessor(m);
}
- if (expr->IsUnaryOp()) {
- return EmitUnaryOp(expr->AsUnaryOp());
+ if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+ return EmitUnaryOp(u);
}
error_ = "unknown expression type: " + expr->str();
@@ -1501,7 +1502,7 @@
}
bool GeneratorImpl::EmitIdentifier(ast::IdentifierExpression* expr) {
- auto* ident = expr->AsIdentifier();
+ auto* ident = expr->As<ast::IdentifierExpression>();
ast::Variable* var = nullptr;
if (global_variables_.get(ident->name(), &var)) {
if (global_is_in_struct(var)) {
diff --git a/src/writer/msl/generator_impl.h b/src/writer/msl/generator_impl.h
index ca95151..2b8a687 100644
--- a/src/writer/msl/generator_impl.h
+++ b/src/writer/msl/generator_impl.h
@@ -19,22 +19,29 @@
#include <string>
#include <unordered_map>
+#include "src/ast/array_accessor_expression.h"
#include "src/ast/assignment_statement.h"
+#include "src/ast/binary_expression.h"
+#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
+#include "src/ast/call_expression.h"
#include "src/ast/case_statement.h"
#include "src/ast/continue_statement.h"
#include "src/ast/discard_statement.h"
#include "src/ast/else_statement.h"
+#include "src/ast/identifier_expression.h"
#include "src/ast/if_statement.h"
#include "src/ast/intrinsic.h"
#include "src/ast/literal.h"
#include "src/ast/loop_statement.h"
+#include "src/ast/member_accessor_expression.h"
#include "src/ast/module.h"
#include "src/ast/return_statement.h"
#include "src/ast/scalar_constructor_expression.h"
#include "src/ast/switch_statement.h"
#include "src/ast/type/struct_type.h"
#include "src/ast/type_constructor_expression.h"
+#include "src/ast/unary_op_expression.h"
#include "src/scope_stack.h"
#include "src/writer/msl/namer.h"
#include "src/writer/text_generator.h"
diff --git a/src/writer/pack_coord_arrayidx.cc b/src/writer/pack_coord_arrayidx.cc
index 8004c0a..6fb9b6d 100644
--- a/src/writer/pack_coord_arrayidx.cc
+++ b/src/writer/pack_coord_arrayidx.cc
@@ -26,13 +26,10 @@
namespace {
ast::TypeConstructorExpression* AsVectorConstructor(ast::Expression* expr) {
- if (!expr->IsConstructor())
- return nullptr;
- auto* constructor = expr->AsConstructor();
- if (!constructor->IsTypeConstructor()) {
+ auto* type_constructor = expr->As<ast::TypeConstructorExpression>();
+ if (type_constructor == nullptr) {
return nullptr;
}
- auto* type_constructor = constructor->AsTypeConstructor();
if (!type_constructor->type()->Is<ast::type::VectorType>()) {
return nullptr;
}
diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index 0f577c1..ef9dc6f 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -484,29 +484,29 @@
}
uint32_t Builder::GenerateExpression(ast::Expression* expr) {
- if (expr->IsArrayAccessor()) {
- return GenerateAccessorExpression(expr->AsArrayAccessor());
+ if (auto* a = expr->As<ast::ArrayAccessorExpression>()) {
+ return GenerateAccessorExpression(a);
}
- if (expr->IsBinary()) {
- return GenerateBinaryExpression(expr->AsBinary());
+ if (auto* b = expr->As<ast::BinaryExpression>()) {
+ return GenerateBinaryExpression(b);
}
- if (expr->IsBitcast()) {
- return GenerateBitcastExpression(expr->AsBitcast());
+ if (auto* b = expr->As<ast::BitcastExpression>()) {
+ return GenerateBitcastExpression(b);
}
- if (expr->IsCall()) {
- return GenerateCallExpression(expr->AsCall());
+ if (auto* c = expr->As<ast::CallExpression>()) {
+ return GenerateCallExpression(c);
}
- if (expr->IsConstructor()) {
- return GenerateConstructorExpression(nullptr, expr->AsConstructor(), false);
+ if (auto* c = expr->As<ast::ConstructorExpression>()) {
+ return GenerateConstructorExpression(nullptr, c, false);
}
- if (expr->IsIdentifier()) {
- return GenerateIdentifierExpression(expr->AsIdentifier());
+ if (auto* i = expr->As<ast::IdentifierExpression>()) {
+ return GenerateIdentifierExpression(i);
}
- if (expr->IsMemberAccessor()) {
- return GenerateAccessorExpression(expr->AsMemberAccessor());
+ if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
+ return GenerateAccessorExpression(m);
}
- if (expr->IsUnaryOp()) {
- return GenerateUnaryOpExpression(expr->AsUnaryOp());
+ if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+ return GenerateUnaryOpExpression(u);
}
error_ = "unknown expression type: " + expr->str();
@@ -672,13 +672,13 @@
bool Builder::GenerateGlobalVariable(ast::Variable* var) {
uint32_t init_id = 0;
if (var->has_constructor()) {
- if (!var->constructor()->IsConstructor()) {
+ if (!var->constructor()->Is<ast::ConstructorExpression>()) {
error_ = "scalar constructor expected";
return false;
}
init_id = GenerateConstructorExpression(
- var, var->constructor()->AsConstructor(), true);
+ var, var->constructor()->As<ast::ConstructorExpression>(), true);
if (init_id == 0) {
return false;
}
@@ -981,7 +981,8 @@
}
uint32_t Builder::GenerateAccessorExpression(ast::Expression* expr) {
- assert(expr->IsArrayAccessor() || expr->IsMemberAccessor());
+ assert(expr->Is<ast::ArrayAccessorExpression>() ||
+ expr->Is<ast::MemberAccessorExpression>());
// Gather a list of all the member and array accessors that are in this chain.
// The list is built in reverse order as that's the order we need to access
@@ -989,12 +990,12 @@
std::vector<ast::Expression*> accessors;
ast::Expression* source = expr;
while (true) {
- if (source->IsArrayAccessor()) {
+ if (auto* array = source->As<ast::ArrayAccessorExpression>()) {
accessors.insert(accessors.begin(), source);
- source = source->AsArrayAccessor()->array();
- } else if (source->IsMemberAccessor()) {
+ source = array->array();
+ } else if (auto* member = source->As<ast::MemberAccessorExpression>()) {
accessors.insert(accessors.begin(), source);
- source = source->AsMemberAccessor()->structure();
+ source = member->structure();
} else {
break;
}
@@ -1010,9 +1011,8 @@
// If our initial access is into an array of non-scalar types, and that array
// is not a pointer, then we need to load that array into a variable in order
// to access chain into the array.
- if (accessors[0]->IsArrayAccessor()) {
- auto* ary_res_type =
- accessors[0]->AsArrayAccessor()->array()->result_type();
+ if (auto* array = accessors[0]->As<ast::ArrayAccessorExpression>()) {
+ auto* ary_res_type = array->array()->result_type();
if (!ary_res_type->Is<ast::type::PointerType>() &&
(ary_res_type->Is<ast::type::ArrayType>() &&
@@ -1043,12 +1043,12 @@
std::vector<uint32_t> access_chain_indices;
for (auto* accessor : accessors) {
- if (accessor->IsArrayAccessor()) {
- if (!GenerateArrayAccessor(accessor->AsArrayAccessor(), &info)) {
+ if (auto* array = accessor->As<ast::ArrayAccessorExpression>()) {
+ if (!GenerateArrayAccessor(array, &info)) {
return 0;
}
- } else if (accessor->IsMemberAccessor()) {
- if (!GenerateMemberAccessor(accessor->AsMemberAccessor(), &info)) {
+ } else if (auto* member = accessor->As<ast::MemberAccessorExpression>()) {
+ if (!GenerateMemberAccessor(member, &info)) {
return 0;
}
@@ -1170,19 +1170,20 @@
}
bool Builder::is_constructor_const(ast::Expression* expr, bool is_global_init) {
- if (!expr->IsConstructor()) {
+ auto* constructor = expr->As<ast::ConstructorExpression>();
+ if (constructor == nullptr) {
return false;
}
- if (expr->AsConstructor()->IsScalarConstructor()) {
+ if (constructor->Is<ast::ScalarConstructorExpression>()) {
return true;
}
- auto* tc = expr->AsConstructor()->AsTypeConstructor();
+ auto* tc = constructor->AsTypeConstructor();
auto* result_type = tc->type()->UnwrapAll();
for (size_t i = 0; i < tc->values().size(); ++i) {
auto* e = tc->values()[i];
- if (!e->IsConstructor()) {
+ if (!e->Is<ast::ConstructorExpression>()) {
if (is_global_init) {
error_ = "constructor must be a constant expression";
return false;
@@ -1197,16 +1198,16 @@
}
if (result_type->Is<ast::type::VectorType>() &&
- !e->AsConstructor()->IsScalarConstructor()) {
+ !e->Is<ast::ScalarConstructorExpression>()) {
return false;
}
// This should all be handled by |is_constructor_const| call above
- if (!e->AsConstructor()->IsScalarConstructor()) {
+ if (!e->Is<ast::ScalarConstructorExpression>()) {
continue;
}
- auto* sc = e->AsConstructor()->AsScalarConstructor();
+ auto* sc = e->As<ast::ScalarConstructorExpression>();
ast::type::Type* subtype = result_type->UnwrapAll();
if (subtype->Is<ast::type::VectorType>()) {
subtype = subtype->As<ast::type::VectorType>()->type()->UnwrapAll();
@@ -1279,8 +1280,8 @@
for (auto* e : values) {
uint32_t id = 0;
if (constructor_is_const) {
- id = GenerateConstructorExpression(nullptr, e->AsConstructor(),
- is_global_init);
+ id = GenerateConstructorExpression(
+ nullptr, e->As<ast::ConstructorExpression>(), is_global_init);
} else {
id = GenerateExpression(e);
id = GenerateLoadIfNeeded(e->result_type(), id);
@@ -1751,13 +1752,13 @@
}
uint32_t Builder::GenerateCallExpression(ast::CallExpression* expr) {
- if (!expr->func()->IsIdentifier()) {
+ auto* ident = expr->func()->As<ast::IdentifierExpression>();
+
+ if (ident == nullptr) {
error_ = "invalid function name";
return 0;
}
- auto* ident = expr->func()->AsIdentifier();
-
if (ident->IsIntrinsic()) {
return GenerateIntrinsic(ident, expr);
}
@@ -1826,7 +1827,7 @@
if (call->params().empty()) {
error_ = "missing param for runtime array length";
return 0;
- } else if (!call->params()[0]->IsMemberAccessor()) {
+ } else if (!call->params()[0]->Is<ast::MemberAccessorExpression>()) {
if (call->params()[0]->result_type()->Is<ast::type::PointerType>()) {
error_ = "pointer accessors not supported yet";
} else {
@@ -1834,7 +1835,7 @@
}
return 0;
}
- auto* accessor = call->params()[0]->AsMemberAccessor();
+ auto* accessor = call->params()[0]->As<ast::MemberAccessorExpression>();
auto struct_id = GenerateExpression(accessor->structure());
if (struct_id == 0) {
return 0;
diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h
index a8ed01c..d78a9a2 100644
--- a/src/writer/spirv/builder.h
+++ b/src/writer/spirv/builder.h
@@ -22,15 +22,21 @@
#include <vector>
#include "spirv/unified1/spirv.h"
+#include "src/ast/array_accessor_expression.h"
#include "src/ast/assignment_statement.h"
+#include "src/ast/binary_expression.h"
+#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
#include "src/ast/builtin.h"
+#include "src/ast/call_expression.h"
#include "src/ast/continue_statement.h"
#include "src/ast/discard_statement.h"
#include "src/ast/else_statement.h"
+#include "src/ast/identifier_expression.h"
#include "src/ast/if_statement.h"
#include "src/ast/literal.h"
#include "src/ast/loop_statement.h"
+#include "src/ast/member_accessor_expression.h"
#include "src/ast/module.h"
#include "src/ast/return_statement.h"
#include "src/ast/struct_member.h"
@@ -43,6 +49,7 @@
#include "src/ast/type/struct_type.h"
#include "src/ast/type/vector_type.h"
#include "src/ast/type_constructor_expression.h"
+#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/context.h"
#include "src/scope_stack.h"
diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc
index 5fa37cb..6942a34 100644
--- a/src/writer/wgsl/generator_impl.cc
+++ b/src/writer/wgsl/generator_impl.cc
@@ -193,29 +193,29 @@
}
bool GeneratorImpl::EmitExpression(ast::Expression* expr) {
- if (expr->IsArrayAccessor()) {
- return EmitArrayAccessor(expr->AsArrayAccessor());
+ if (auto* a = expr->As<ast::ArrayAccessorExpression>()) {
+ return EmitArrayAccessor(a);
}
- if (expr->IsBinary()) {
- return EmitBinary(expr->AsBinary());
+ if (auto* b = expr->As<ast::BinaryExpression>()) {
+ return EmitBinary(b);
}
- if (expr->IsBitcast()) {
- return EmitBitcast(expr->AsBitcast());
+ if (auto* b = expr->As<ast::BitcastExpression>()) {
+ return EmitBitcast(b);
}
- if (expr->IsCall()) {
- return EmitCall(expr->AsCall());
+ if (auto* c = expr->As<ast::CallExpression>()) {
+ return EmitCall(c);
}
- if (expr->IsIdentifier()) {
- return EmitIdentifier(expr->AsIdentifier());
+ if (auto* i = expr->As<ast::IdentifierExpression>()) {
+ return EmitIdentifier(i);
}
- if (expr->IsConstructor()) {
- return EmitConstructor(expr->AsConstructor());
+ if (auto* c = expr->As<ast::ConstructorExpression>()) {
+ return EmitConstructor(c);
}
- if (expr->IsMemberAccessor()) {
- return EmitMemberAccessor(expr->AsMemberAccessor());
+ if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
+ return EmitMemberAccessor(m);
}
- if (expr->IsUnaryOp()) {
- return EmitUnaryOp(expr->AsUnaryOp());
+ if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+ return EmitUnaryOp(u);
}
error_ = "unknown expression type";
@@ -337,7 +337,7 @@
}
bool GeneratorImpl::EmitIdentifier(ast::IdentifierExpression* expr) {
- auto* ident = expr->AsIdentifier();
+ auto* ident = expr->As<ast::IdentifierExpression>();
out_ << ident->name();
return true;
}
diff --git a/src/writer/wgsl/generator_impl.h b/src/writer/wgsl/generator_impl.h
index 77fd16d..1de0b9d 100644
--- a/src/writer/wgsl/generator_impl.h
+++ b/src/writer/wgsl/generator_impl.h
@@ -20,7 +20,10 @@
#include "src/ast/array_accessor_expression.h"
#include "src/ast/assignment_statement.h"
+#include "src/ast/binary_expression.h"
+#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
+#include "src/ast/call_expression.h"
#include "src/ast/case_statement.h"
#include "src/ast/constructor_expression.h"
#include "src/ast/continue_statement.h"
@@ -29,6 +32,7 @@
#include "src/ast/identifier_expression.h"
#include "src/ast/if_statement.h"
#include "src/ast/loop_statement.h"
+#include "src/ast/member_accessor_expression.h"
#include "src/ast/module.h"
#include "src/ast/return_statement.h"
#include "src/ast/scalar_constructor_expression.h"
@@ -37,6 +41,7 @@
#include "src/ast/type/struct_type.h"
#include "src/ast/type/type.h"
#include "src/ast/type_constructor_expression.h"
+#include "src/ast/unary_op_expression.h"
#include "src/ast/variable.h"
#include "src/writer/text_generator.h"
