encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-09 21:47:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

wgsl parser: replace almost all sem::Type* with typ::Type where possible

Browse Source 
All that remains in the wgsl parser that references sem::Type* are
the register_constructed funcs/types, and adding an ast::ExternalTexture
type.

Also:

* Added specialization of OperatorArrow for type::TypePairs that returns
the value by reference so that operator-> can chain properly.

* In a few places where we expect the type to implicitly cast to a
pointer for a bool expression, e.g. `if (type)` or `TINT_ASSERT(type)`,
I added access to the `.sem` member of the TypePair. I tried adding an
implicit cast to bool, but this results in ambiguity in gtest for
equality comparisons.

* Constified more type pointers in type nodes

* Replaced header includes with forward declares in wgsl/parser_impl.h

Bug: tint:724
Change-Id: Ie0875aa4d4a5e830e3466ac40c63cd185f357200
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/48881
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Antonio Maiorano
2021-04-26 14:19:55 +00:00
committed by Commit Bot service account
parent 6e2ed30be3
commit 73fdc16c33
23 changed files with 259 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
src/reader/wgsl/parser_impl.cc
View File

@@ -15,13 +15,25 @@
#include "src/reader/wgsl/parser_impl.h"
#include "src/ast/access_decoration.h"
#include "src/ast/array.h"
#include "src/ast/assignment_statement.h"
#include "src/ast/bitcast_expression.h"
#include "src/ast/break_statement.h"
#include "src/ast/call_statement.h"
#include "src/ast/constant_id_decoration.h"
#include "src/ast/continue_statement.h"
#include "src/ast/discard_statement.h"
#include "src/ast/fallthrough_statement.h"
#include "src/ast/if_statement.h"
#include "src/ast/loop_statement.h"
#include "src/ast/return_statement.h"
#include "src/ast/stage_decoration.h"
#include "src/ast/struct_block_decoration.h"
#include "src/ast/switch_statement.h"
#include "src/ast/type_name.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/ast/vector.h"
#include "src/ast/workgroup_decoration.h"
#include "src/reader/wgsl/lexer.h"
#include "src/sem/access_control_type.h"
@@ -185,7 +197,7 @@ ParserImpl::FunctionHeader::FunctionHeader(const FunctionHeader&) = default;
ParserImpl::FunctionHeader::FunctionHeader(Source src,
std::string n,
ast::VariableList p,
sem::Type* ret_ty,
typ::Type ret_ty,
ast::DecorationList ret_decos)
: source(src),
name(n),
@@ -198,6 +210,21 @@ ParserImpl::FunctionHeader::~FunctionHeader() = default;
ParserImpl::FunctionHeader& ParserImpl::FunctionHeader::operator=(
const FunctionHeader& rhs) = default;
ParserImpl::VarDeclInfo::VarDeclInfo() = default;
ParserImpl::VarDeclInfo::VarDeclInfo(const VarDeclInfo&) = default;
ParserImpl::VarDeclInfo::VarDeclInfo(Source source_in,
std::string name_in,
ast::StorageClass storage_class_in,
typ::Type type_in)
: source(std::move(source_in)),
name(std::move(name_in)),
storage_class(storage_class_in),
type(type_in) {}
ParserImpl::VarDeclInfo::~VarDeclInfo() = default;
ParserImpl::ParserImpl(Source::File const* file)
: lexer_(std::make_unique<Lexer>(file->path, &file->content)) {}
@@ -519,14 +546,14 @@ Maybe<ParserImpl::VarDeclInfo> ParserImpl::variable_decl() {
// | sampled_texture_type LESS_THAN type_decl GREATER_THAN
// | multisampled_texture_type LESS_THAN type_decl GREATER_THAN
// | storage_texture_type LESS_THAN image_storage_type GREATER_THAN
Maybe<sem::Type*> ParserImpl::texture_sampler_types() {
Maybe<typ::Type> ParserImpl::texture_sampler_types() {
auto type = sampler_type();
if (type.matched)
return type;
type = depth_texture_type();
if (type.matched)
return type.value;
return type;
type = external_texture_type();
if (type.matched)
@@ -540,7 +567,9 @@ Maybe<sem::Type*> ParserImpl::texture_sampler_types() {
if (subtype.errored)
return Failure::kErrored;
return builder_.create<sem::SampledTexture>(dim.value, subtype.value);
return typ::Type{
builder_.create<ast::SampledTexture>(dim.value, subtype.value),
builder_.create<sem::SampledTexture>(dim.value, subtype.value)};
}
auto ms_dim = multisampled_texture_type();
@@ -551,8 +580,9 @@ Maybe<sem::Type*> ParserImpl::texture_sampler_types() {
if (subtype.errored)
return Failure::kErrored;
return builder_.create<sem::MultisampledTexture>(ms_dim.value,
subtype.value);
return typ::Type{
builder_.create<ast::MultisampledTexture>(ms_dim.value, subtype.value),
builder_.create<sem::MultisampledTexture>(ms_dim.value, subtype.value)};
}
auto storage = storage_texture_type();
@@ -565,10 +595,14 @@ Maybe<sem::Type*> ParserImpl::texture_sampler_types() {
if (format.errored)
return Failure::kErrored;
auto* subtype =
auto* subtype = ast::StorageTexture::SubtypeFor(format.value, builder_);
auto* subtype_sem =
sem::StorageTexture::SubtypeFor(format.value, builder_.Types());
return builder_.create<sem::StorageTexture>(storage.value, format.value,
subtype);
return typ::Type{builder_.create<ast::StorageTexture>(
storage.value, format.value, subtype),
builder_.create<sem::StorageTexture>(
storage.value, format.value, subtype_sem)};
}
return Failure::kNoMatch;
@@ -577,12 +611,15 @@ Maybe<sem::Type*> ParserImpl::texture_sampler_types() {
// sampler_type
// : SAMPLER
// | SAMPLER_COMPARISON
Maybe<sem::Type*> ParserImpl::sampler_type() {
Maybe<typ::Type> ParserImpl::sampler_type() {
if (match(Token::Type::kSampler))
return builder_.create<sem::Sampler>(ast::SamplerKind::kSampler);
return typ::Type{builder_.create<ast::Sampler>(ast::SamplerKind::kSampler),
builder_.create<sem::Sampler>(ast::SamplerKind::kSampler)};
if (match(Token::Type::kComparisonSampler))
return builder_.create<sem::Sampler>(ast::SamplerKind::kComparisonSampler);
return typ::Type{
builder_.create<ast::Sampler>(ast::SamplerKind::kComparisonSampler),
builder_.create<sem::Sampler>(ast::SamplerKind::kComparisonSampler)};
return Failure::kNoMatch;
}
@@ -618,9 +655,10 @@ Maybe<ast::TextureDimension> ParserImpl::sampled_texture_type() {
// external_texture_type
// : TEXTURE_EXTERNAL
Maybe<sem::Type*> ParserImpl::external_texture_type() {
Maybe<typ::Type> ParserImpl::external_texture_type() {
if (match(Token::Type::kTextureExternal)) {
return builder_.create<sem::ExternalTexture>();
// TODO(crbug.com/tint/724): builder_.create<ast::ExternalTexture>()
return typ::Type{nullptr, builder_.create<sem::ExternalTexture>()};
}
return Failure::kNoMatch;
@@ -658,19 +696,26 @@ Maybe<ast::TextureDimension> ParserImpl::storage_texture_type() {
// | TEXTURE_DEPTH_2D_ARRAY
// | TEXTURE_DEPTH_CUBE
// | TEXTURE_DEPTH_CUBE_ARRAY
Maybe<sem::Type*> ParserImpl::depth_texture_type() {
Maybe<typ::Type> ParserImpl::depth_texture_type() {
if (match(Token::Type::kTextureDepth2d))
return builder_.create<sem::DepthTexture>(ast::TextureDimension::k2d);
return typ::Type{
builder_.create<ast::DepthTexture>(ast::TextureDimension::k2d),
builder_.create<sem::DepthTexture>(ast::TextureDimension::k2d)};
if (match(Token::Type::kTextureDepth2dArray))
return builder_.create<sem::DepthTexture>(ast::TextureDimension::k2dArray);
return typ::Type{
builder_.create<ast::DepthTexture>(ast::TextureDimension::k2dArray),
builder_.create<sem::DepthTexture>(ast::TextureDimension::k2dArray)};
if (match(Token::Type::kTextureDepthCube))
return builder_.create<sem::DepthTexture>(ast::TextureDimension::kCube);
return typ::Type{
builder_.create<ast::DepthTexture>(ast::TextureDimension::kCube),
builder_.create<sem::DepthTexture>(ast::TextureDimension::kCube)};
if (match(Token::Type::kTextureDepthCubeArray))
return builder_.create<sem::DepthTexture>(
ast::TextureDimension::kCubeArray);
return typ::Type{
builder_.create<ast::DepthTexture>(ast::TextureDimension::kCubeArray),
builder_.create<sem::DepthTexture>(ast::TextureDimension::kCubeArray)};
return Failure::kNoMatch;
}
@@ -906,7 +951,7 @@ Maybe<ast::StorageClass> ParserImpl::variable_storage_decoration() {
// type_alias
// : TYPE IDENT EQUAL type_decl
Maybe<sem::Type*> ParserImpl::type_alias() {
Maybe<typ::Type> ParserImpl::type_alias() {
auto t = peek();
if (!t.IsType())
return Failure::kNoMatch;
@@ -928,11 +973,14 @@ Maybe<sem::Type*> ParserImpl::type_alias() {
if (!type.matched)
return add_error(peek(), "invalid type alias");
// TODO(crbug.com/tint/724): remove
auto* alias = builder_.create<sem::Alias>(
builder_.Symbols().Register(name.value), type.value);
register_constructed(name.value, alias);
return alias;
return typ::Type{builder_.create<ast::Alias>(
builder_.Symbols().Register(name.value), type.value),
alias};
}
// type_decl
@@ -979,55 +1027,58 @@ Maybe<typ::Type> ParserImpl::type_decl() {
Maybe<typ::Type> ParserImpl::type_decl(ast::DecorationList& decos) {
auto t = peek();
if (match(Token::Type::kIdentifier)) {
// TODO(crbug.com/tint/697): Remove
auto* ty = get_constructed(t.to_str());
if (ty == nullptr)
return add_error(t, "unknown constructed type '" + t.to_str() + "'");
// TODO(crbug.com/tint/724): builder_.create<ast::TypeName>(t.to_str())
return typ::Type{nullptr, ty};
return typ::Type{
builder_.create<ast::TypeName>(builder_.Symbols().Register(t.to_str())),
ty};
}
if (match(Token::Type::kBool))
return typ::Type{nullptr, builder_.create<sem::Bool>()};
return typ::Type{builder_.create<ast::Bool>(),
builder_.create<sem::Bool>()};
if (match(Token::Type::kF32))
return typ::Type{nullptr, builder_.create<sem::F32>()};
return typ::Type{builder_.create<ast::F32>(), builder_.create<sem::F32>()};
if (match(Token::Type::kI32))
return typ::Type{nullptr, builder_.create<sem::I32>()};
return typ::Type{builder_.create<ast::I32>(), builder_.create<sem::I32>()};
if (match(Token::Type::kU32))
return typ::Type{nullptr, builder_.create<sem::U32>()};
return typ::Type{builder_.create<ast::U32>(), builder_.create<sem::U32>()};
if (t.IsVec2() || t.IsVec3() || t.IsVec4()) {
next(); // Consume the peek
return from_deprecated(expect_type_decl_vector(t));
return expect_type_decl_vector(t);
}
if (match(Token::Type::kPtr))
return from_deprecated(expect_type_decl_pointer());
return expect_type_decl_pointer();
if (match(Token::Type::kArray)) {
return from_deprecated(expect_type_decl_array(std::move(decos)));
return expect_type_decl_array(std::move(decos));
}
if (t.IsMat2x2() || t.IsMat2x3() || t.IsMat2x4() || t.IsMat3x2() ||
t.IsMat3x3() || t.IsMat3x4() || t.IsMat4x2() || t.IsMat4x3() ||
t.IsMat4x4()) {
next(); // Consume the peek
return from_deprecated(expect_type_decl_matrix(t));
return expect_type_decl_matrix(t);
}
auto texture_or_sampler = texture_sampler_types();
if (texture_or_sampler.errored)
return Failure::kErrored;
if (texture_or_sampler.matched)
return typ::Type{nullptr, texture_or_sampler.value};
return texture_or_sampler;
return Failure::kNoMatch;
}
Expect<sem::Type*> ParserImpl::expect_type(const std::string& use) {
Expect<typ::Type> ParserImpl::expect_type(const std::string& use) {
auto type = type_decl();
if (type.errored)
return Failure::kErrored;
@@ -1036,10 +1087,10 @@ Expect<sem::Type*> ParserImpl::expect_type(const std::string& use) {
return type.value;
}
Expect<sem::Type*> ParserImpl::expect_type_decl_pointer() {
Expect<typ::Type> ParserImpl::expect_type_decl_pointer() {
const char* use = "ptr declaration";
return expect_lt_gt_block(use, [&]() -> Expect<sem::Type*> {
return expect_lt_gt_block(use, [&]() -> Expect<typ::Type> {
auto sc = expect_storage_class(use);
if (sc.errored)
return Failure::kErrored;
@@ -1051,11 +1102,12 @@ Expect<sem::Type*> ParserImpl::expect_type_decl_pointer() {
if (subtype.errored)
return Failure::kErrored;
return builder_.create<sem::Pointer>(subtype.value, sc.value);
return typ::Type{builder_.create<ast::Pointer>(subtype.value, sc.value),
builder_.create<sem::Pointer>(subtype.value, sc.value)};
});
}
Expect<sem::Type*> ParserImpl::expect_type_decl_vector(Token t) {
Expect<typ::Type> ParserImpl::expect_type_decl_vector(Token t) {
uint32_t count = 2;
if (t.IsVec3())
count = 3;
@@ -1068,14 +1120,15 @@ Expect<sem::Type*> ParserImpl::expect_type_decl_vector(Token t) {
if (subtype.errored)
return Failure::kErrored;
return builder_.create<sem::Vector>(subtype.value, count);
return typ::Type{builder_.create<ast::Vector>(subtype.value.ast, count),
builder_.create<sem::Vector>(subtype.value.sem, count)};
}
Expect<sem::Type*> ParserImpl::expect_type_decl_array(
Expect<typ::Type> ParserImpl::expect_type_decl_array(
ast::DecorationList decos) {
const char* use = "array declaration";
return expect_lt_gt_block(use, [&]() -> Expect<sem::Type*> {
return expect_lt_gt_block(use, [&]() -> Expect<typ::Type> {
auto subtype = expect_type(use);
if (subtype.errored)
return Failure::kErrored;
@@ -1088,11 +1141,13 @@ Expect<sem::Type*> ParserImpl::expect_type_decl_array(
size = val.value;
}
return create<sem::ArrayType>(subtype.value, size, std::move(decos));
return typ::Type{
create<ast::Array>(subtype.value, size, decos),
create<sem::ArrayType>(subtype.value, size, std::move(decos))};
});
}
Expect<sem::Type*> ParserImpl::expect_type_decl_matrix(Token t) {
Expect<typ::Type> ParserImpl::expect_type_decl_matrix(Token t) {
uint32_t rows = 2;
uint32_t columns = 2;
if (t.IsMat3x2() || t.IsMat3x3() || t.IsMat3x4()) {
@@ -1112,7 +1167,8 @@ Expect<sem::Type*> ParserImpl::expect_type_decl_matrix(Token t) {
if (subtype.errored)
return Failure::kErrored;
return builder_.create<sem::Matrix>(subtype.value, rows, columns);
return typ::Type{builder_.create<ast::Matrix>(subtype.value, rows, columns),
builder_.create<sem::Matrix>(subtype.value, rows, columns)};
}
// storage_class
@@ -1263,11 +1319,12 @@ Maybe<ast::Function*> ParserImpl::function_decl(ast::DecorationList& decos) {
// function_type_decl
// : type_decl
// | VOID
Maybe<sem::Type*> ParserImpl::function_type_decl() {
Maybe<typ::Type> ParserImpl::function_type_decl() {
if (match(Token::Type::kVoid))
return builder_.create<sem::Void>();
return typ::Type{builder_.create<ast::Void>(),
builder_.create<sem::Void>()};
return to_deprecated(type_decl());
return type_decl();
}
// function_header
@@ -1297,7 +1354,7 @@ Maybe<ParserImpl::FunctionHeader> ParserImpl::function_header() {
}
}
sem::Type* return_type = nullptr;
typ::Type return_type;
ast::DecorationList return_decorations;
if (match(Token::Type::kArrow)) {
@@ -1318,7 +1375,7 @@ Maybe<ParserImpl::FunctionHeader> ParserImpl::function_header() {
return_type = type.value;
}
if (return_type->Is<sem::Void>()) {
if (return_type.ast->Is<ast::Void>()) {
// crbug.com/tint/677: void has been removed from the language
deprecated(tok.source(),
"omit '-> void' for functions that do not return a value");

96
src/reader/wgsl/parser_impl.h
View File

@@ -23,15 +23,6 @@
#include <vector>
#include "src/ast/access_control.h"
#include "src/ast/assignment_statement.h"
#include "src/ast/break_statement.h"
#include "src/ast/call_statement.h"
#include "src/ast/continue_statement.h"
#include "src/ast/if_statement.h"
#include "src/ast/loop_statement.h"
#include "src/ast/return_statement.h"
#include "src/ast/switch_statement.h"
#include "src/ast/variable_decl_statement.h"
#include "src/program_builder.h"
#include "src/reader/wgsl/parser_impl_detail.h"
#include "src/reader/wgsl/token.h"
@@ -39,6 +30,18 @@
#include "src/typepair.h"
namespace tint {
namespace ast {
class AssignmentStatement;
class BreakStatement;
class CallStatement;
class ContinueStatement;
class IfStatement;
class LoopStatement;
class ReturnStatement;
class SwitchStatement;
class VariableDeclStatement;
} // namespace ast
namespace reader {
namespace wgsl {
@@ -236,7 +239,7 @@ class ParserImpl {
FunctionHeader(Source src,
std::string n,
ast::VariableList p,
sem::Type* ret_ty,
typ::Type ret_ty,
ast::DecorationList ret_decos);
/// Destructor
~FunctionHeader();
@@ -252,13 +255,30 @@ class ParserImpl {
/// Function parameters
ast::VariableList params;
/// Function return type
sem::Type* return_type;
typ::Type return_type;
/// Function return type decorations
ast::DecorationList return_type_decorations;
};
/// VarDeclInfo contains the parsed information for variable declaration.
struct VarDeclInfo {
/// Constructor
VarDeclInfo();
/// Copy constructor
/// @param other the VarDeclInfo to copy
VarDeclInfo(const VarDeclInfo& other);
/// Constructor
/// @param source_in variable declaration source
/// @param name_in variable name
/// @param storage_class_in variable storage class
/// @param type_in variable type
VarDeclInfo(Source source_in,
std::string name_in,
ast::StorageClass storage_class_in,
typ::Type type_in);
/// Destructor
~VarDeclInfo();
/// Variable declaration source
Source source;
/// Variable name
@@ -266,7 +286,7 @@ class ParserImpl {
/// Variable storage class
ast::StorageClass storage_class;
/// Variable type
sem::Type* type;
typ::Type type;
};
/// Creates a new parser using the given file
@@ -376,16 +396,10 @@ class ParserImpl {
Maybe<ast::StorageClass> variable_storage_decoration();
/// Parses a `type_alias` grammar element
/// @returns the type alias or nullptr on error
Maybe<sem::Type*> type_alias();
Maybe<typ::Type> type_alias();
/// Parses a `type_decl` grammar element
/// @returns the parsed Type or nullptr if none matched.
Maybe<typ::Type> type_decl();
/// TODO(crbug.com/tint/724): Temporary until type_decl() returns
/// Maybe<ast::Type*>
/// @returns the parsed Type or nullptr if none matched.
Maybe<sem::Type*> type_decl_DEPRECATED() {
return to_deprecated(type_decl());
}
/// Parses a `type_decl` grammar element with the given pre-parsed
/// decorations.
/// @param decos the list of decorations for the type.
@@ -416,10 +430,10 @@ class ParserImpl {
Maybe<ast::Function*> function_decl(ast::DecorationList& decos);
/// Parses a `texture_sampler_types` grammar element
/// @returns the parsed Type or nullptr if none matched.
Maybe<sem::Type*> texture_sampler_types();
Maybe<typ::Type> texture_sampler_types();
/// Parses a `sampler_type` grammar element
/// @returns the parsed Type or nullptr if none matched.
Maybe<sem::Type*> sampler_type();
Maybe<typ::Type> sampler_type();
/// Parses a `multisampled_texture_type` grammar element
/// @returns returns the multisample texture dimension or kNone if none
/// matched.
@@ -433,17 +447,17 @@ class ParserImpl {
Maybe<ast::TextureDimension> storage_texture_type();
/// Parses a `depth_texture_type` grammar element
/// @returns the parsed Type or nullptr if none matched.
Maybe<sem::Type*> depth_texture_type();
Maybe<typ::Type> depth_texture_type();
/// Parses a 'texture_external_type' grammar element
/// @returns the parsed Type or nullptr if none matched
Maybe<sem::Type*> external_texture_type();
Maybe<typ::Type> external_texture_type();
/// Parses a `image_storage_type` grammar element
/// @param use a description of what was being parsed if an error was raised
/// @returns returns the image format or kNone if none matched.
Expect<ast::ImageFormat> expect_image_storage_type(const std::string& use);
/// Parses a `function_type_decl` grammar element
/// @returns the parsed type or nullptr otherwise
Maybe<sem::Type*> function_type_decl();
Maybe<typ::Type> function_type_decl();
/// Parses a `function_header` grammar element
/// @returns the parsed function header
Maybe<FunctionHeader> function_header();
@@ -655,30 +669,6 @@ class ParserImpl {
Expect<ast::Decoration*> expect_decoration();
private:
// TODO(crbug.com/tint/724): Helper to convert Maybe<typ::Type> to
// Maybe<sem::Type*> while we convert code
Maybe<sem::Type*> to_deprecated(const Maybe<typ::Type>& tp) {
if (tp.errored) {
return Failure::kErrored;
}
if (!tp.matched) {
return Failure::kNoMatch;
}
return tp.value;
}
//// TODO(crbug.com/tint/724): Helper to convert Maybe<sem::Type*> to
/// Maybe<typ::Type> while we / convert code
Maybe<typ::Type> from_deprecated(const Maybe<sem::Type*>& tp) {
if (tp.errored) {
return Failure::kErrored;
}
if (!tp.matched) {
return Failure::kNoMatch;
}
return typ::Type{nullptr, tp.value};
}
/// ReturnType resolves to the return type for the function or lambda F.
template <typename F>
using ReturnType = typename std::result_of<F()>::type;
@@ -831,12 +821,12 @@ class ParserImpl {
/// Used to ensure that all decorations are consumed.
bool expect_decorations_consumed(const ast::DecorationList& list);
Expect<sem::Type*> expect_type_decl_pointer();
Expect<sem::Type*> expect_type_decl_vector(Token t);
Expect<sem::Type*> expect_type_decl_array(ast::DecorationList decos);
Expect<sem::Type*> expect_type_decl_matrix(Token t);
Expect<typ::Type> expect_type_decl_pointer();
Expect<typ::Type> expect_type_decl_vector(Token t);
Expect<typ::Type> expect_type_decl_array(ast::DecorationList decos);
Expect<typ::Type> expect_type_decl_matrix(Token t);
Expect<sem::Type*> expect_type(const std::string& use);
Expect<typ::Type> expect_type(const std::string& use);
Maybe<ast::Statement*> non_block_statement();
Maybe<ast::Statement*> for_header_initializer();

1
src/reader/wgsl/parser_impl_break_stmt_test.cc
View File

@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/ast/break_statement.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
namespace tint {

1
src/reader/wgsl/parser_impl_call_stmt_test.cc
View File

@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/ast/call_statement.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
namespace tint {

1
src/reader/wgsl/parser_impl_continue_stmt_test.cc
View File

@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/ast/continue_statement.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
namespace tint {

12
src/reader/wgsl/parser_impl_detail.h
View File

@@ -16,6 +16,7 @@
#define SRC_READER_WGSL_PARSER_IMPL_DETAIL_H_
#include <memory>
#include "src/typepair.h"
namespace tint {
namespace reader {
@@ -62,6 +63,17 @@ struct OperatorArrow<T*> {
static inline T* ptr(T* val) { return val; }
};
/// OperatorArrow template specialization for TypePair<T, U>.
template <typename T, typename U>
struct OperatorArrow<typ::TypePair<T, U>> {
/// type resolves to the same as input type to allow for operator-> chaining
using type = typ::TypePair<T, U>;
/// @param val the value held by `ParserImpl::Expect<T>` or
/// `ParserImpl::Maybe<T>`.
/// @return `val`.
static inline type& ptr(type& val) { return val; }
};
} // namespace detail
} // namespace wgsl
} // namespace reader

2
src/reader/wgsl/parser_impl_statement_test.cc
View File

@@ -12,6 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/ast/break_statement.h"
#include "src/ast/continue_statement.h"
#include "src/ast/discard_statement.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"

102
src/reader/wgsl/parser_impl_type_decl_test.cc
View File

@@ -22,7 +22,7 @@ namespace {
TEST_F(ParserImplTest, TypeDecl_Invalid) {
auto p = parser("1234");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_EQ(t.errored, false);
EXPECT_EQ(t.matched, false);
EXPECT_EQ(t.value, nullptr);
@@ -40,7 +40,7 @@ TEST_F(ParserImplTest, TypeDecl_Identifier) {
p->register_constructed("A", alias_type);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -55,7 +55,7 @@ TEST_F(ParserImplTest, TypeDecl_Identifier) {
TEST_F(ParserImplTest, TypeDecl_Identifier_NotFound) {
auto p = parser("B");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -69,7 +69,7 @@ TEST_F(ParserImplTest, TypeDecl_Bool) {
auto& builder = p->builder();
auto* bool_type = builder.create<sem::Bool>();
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -83,7 +83,7 @@ TEST_F(ParserImplTest, TypeDecl_F32) {
auto& builder = p->builder();
auto* float_type = builder.create<sem::F32>();
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -97,7 +97,7 @@ TEST_F(ParserImplTest, TypeDecl_I32) {
auto& builder = p->builder();
auto* int_type = builder.create<sem::I32>();
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -111,7 +111,7 @@ TEST_F(ParserImplTest, TypeDecl_U32) {
auto& builder = p->builder();
auto* uint_type = builder.create<sem::U32>();
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -133,7 +133,7 @@ class VecTest : public ParserImplTestWithParam<VecData> {};
TEST_P(VecTest, Parse) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -152,7 +152,7 @@ class VecMissingGreaterThanTest : public ParserImplTestWithParam<VecData> {};
TEST_P(VecMissingGreaterThanTest, Handles_Missing_GreaterThan) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -170,7 +170,7 @@ class VecMissingLessThanTest : public ParserImplTestWithParam<VecData> {};
TEST_P(VecMissingLessThanTest, Handles_Missing_GreaterThan) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -188,7 +188,7 @@ class VecBadType : public ParserImplTestWithParam<VecData> {};
TEST_P(VecBadType, Handles_Unknown_Type) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -206,7 +206,7 @@ class VecMissingType : public ParserImplTestWithParam<VecData> {};
TEST_P(VecMissingType, Handles_Missing_Type) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -221,7 +221,7 @@ INSTANTIATE_TEST_SUITE_P(ParserImplTest,
TEST_F(ParserImplTest, TypeDecl_Ptr) {
auto p = parser("ptr<function, f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -235,7 +235,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr) {
TEST_F(ParserImplTest, TypeDecl_Ptr_ToVec) {
auto p = parser("ptr<function, vec2<f32>>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -253,7 +253,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_ToVec) {
TEST_F(ParserImplTest, TypeDecl_Ptr_MissingLessThan) {
auto p = parser("ptr private, f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -263,7 +263,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_MissingLessThan) {
TEST_F(ParserImplTest, TypeDecl_Ptr_MissingGreaterThan) {
auto p = parser("ptr<function, f32");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -273,7 +273,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_MissingGreaterThan) {
TEST_F(ParserImplTest, TypeDecl_Ptr_MissingComma) {
auto p = parser("ptr<function f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -283,7 +283,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_MissingComma) {
TEST_F(ParserImplTest, TypeDecl_Ptr_MissingStorageClass) {
auto p = parser("ptr<, f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -293,7 +293,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_MissingStorageClass) {
TEST_F(ParserImplTest, TypeDecl_Ptr_MissingParams) {
auto p = parser("ptr<>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -303,7 +303,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_MissingParams) {
TEST_F(ParserImplTest, TypeDecl_Ptr_MissingType) {
auto p = parser("ptr<function,>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -313,7 +313,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_MissingType) {
TEST_F(ParserImplTest, TypeDecl_Ptr_BadStorageClass) {
auto p = parser("ptr<unknown, f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -323,7 +323,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_BadStorageClass) {
TEST_F(ParserImplTest, TypeDecl_Ptr_BadType) {
auto p = parser("ptr<function, unknown>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -333,7 +333,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_BadType) {
TEST_F(ParserImplTest, TypeDecl_Array) {
auto p = parser("array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -349,7 +349,7 @@ TEST_F(ParserImplTest, TypeDecl_Array) {
TEST_F(ParserImplTest, TypeDecl_Array_Stride) {
auto p = parser("[[stride(16)]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -369,7 +369,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Stride) {
TEST_F(ParserImplTest, TypeDecl_Array_Runtime_Stride) {
auto p = parser("[[stride(16)]] array<f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -388,7 +388,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Runtime_Stride) {
TEST_F(ParserImplTest, TypeDecl_Array_MultipleDecorations_OneBlock) {
auto p = parser("[[stride(16), stride(32)]] array<f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -409,7 +409,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_MultipleDecorations_OneBlock) {
TEST_F(ParserImplTest, TypeDecl_Array_MultipleDecorations_MultipleBlocks) {
auto p = parser("[[stride(16)]] [[stride(32)]] array<f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -430,7 +430,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_MultipleDecorations_MultipleBlocks) {
TEST_F(ParserImplTest, TypeDecl_Array_Decoration_MissingArray) {
auto p = parser("[[stride(16)]] f32");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -440,7 +440,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Decoration_MissingArray) {
TEST_F(ParserImplTest, TypeDecl_Array_Decoration_MissingClosingAttr) {
auto p = parser("[[stride(16) array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -450,7 +450,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Decoration_MissingClosingAttr) {
TEST_F(ParserImplTest, TypeDecl_Array_Decoration_UnknownDecoration) {
auto p = parser("[[unknown 16]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -460,7 +460,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Decoration_UnknownDecoration) {
TEST_F(ParserImplTest, TypeDecl_Array_Stride_MissingLeftParen) {
auto p = parser("[[stride 4)]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -470,7 +470,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Stride_MissingLeftParen) {
TEST_F(ParserImplTest, TypeDecl_Array_Stride_MissingRightParen) {
auto p = parser("[[stride(4]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -480,7 +480,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Stride_MissingRightParen) {
TEST_F(ParserImplTest, TypeDecl_Array_Stride_MissingValue) {
auto p = parser("[[stride()]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -491,7 +491,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Stride_MissingValue) {
TEST_F(ParserImplTest, TypeDecl_Array_Stride_InvalidValue) {
auto p = parser("[[stride(invalid)]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -502,7 +502,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Stride_InvalidValue) {
TEST_F(ParserImplTest, TypeDecl_Array_Stride_InvalidValue_Negative) {
auto p = parser("[[stride(-1)]] array<f32, 5>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -512,7 +512,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Stride_InvalidValue_Negative) {
TEST_F(ParserImplTest, TypeDecl_Array_Runtime) {
auto p = parser("array<u32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -526,7 +526,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Runtime) {
TEST_F(ParserImplTest, TypeDecl_Array_Runtime_Vec) {
auto p = parser("array<vec4<u32>>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -540,7 +540,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_Runtime_Vec) {
TEST_F(ParserImplTest, TypeDecl_Array_BadType) {
auto p = parser("array<unknown, 3>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -550,7 +550,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_BadType) {
TEST_F(ParserImplTest, TypeDecl_Array_ZeroSize) {
auto p = parser("array<f32, 0>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -560,7 +560,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_ZeroSize) {
TEST_F(ParserImplTest, TypeDecl_Array_NegativeSize) {
auto p = parser("array<f32, -1>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -570,7 +570,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_NegativeSize) {
TEST_F(ParserImplTest, TypeDecl_Array_BadSize) {
auto p = parser("array<f32, invalid>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -580,7 +580,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_BadSize) {
TEST_F(ParserImplTest, TypeDecl_Array_MissingLessThan) {
auto p = parser("array f32>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -590,7 +590,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_MissingLessThan) {
TEST_F(ParserImplTest, TypeDecl_Array_MissingGreaterThan) {
auto p = parser("array<f32");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -600,7 +600,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_MissingGreaterThan) {
TEST_F(ParserImplTest, TypeDecl_Array_MissingComma) {
auto p = parser("array<f32 3>");
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -623,7 +623,7 @@ class MatrixTest : public ParserImplTestWithParam<MatrixData> {};
TEST_P(MatrixTest, Parse) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -651,7 +651,7 @@ class MatrixMissingGreaterThanTest
TEST_P(MatrixMissingGreaterThanTest, Handles_Missing_GreaterThan) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -675,7 +675,7 @@ class MatrixMissingLessThanTest : public ParserImplTestWithParam<MatrixData> {};
TEST_P(MatrixMissingLessThanTest, Handles_Missing_GreaterThan) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -699,7 +699,7 @@ class MatrixBadType : public ParserImplTestWithParam<MatrixData> {};
TEST_P(MatrixBadType, Handles_Unknown_Type) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -723,7 +723,7 @@ class MatrixMissingType : public ParserImplTestWithParam<MatrixData> {};
TEST_P(MatrixMissingType, Handles_Missing_Type) {
auto params = GetParam();
auto p = parser(params.input);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.errored);
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
@@ -748,7 +748,7 @@ TEST_F(ParserImplTest, TypeDecl_Sampler) {
auto& builder = p->builder();
auto type = builder.ty.sampler(ast::SamplerKind::kSampler);
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr) << p->error();
@@ -764,7 +764,7 @@ TEST_F(ParserImplTest, TypeDecl_Texture) {
auto* type = builder.create<sem::SampledTexture>(ast::TextureDimension::kCube,
ty.f32());
auto t = p->type_decl_DEPRECATED();
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
ASSERT_NE(t.value, nullptr);