encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BUILD.gn
View File

@ -498,7 +498,6 @@ libtint_source_set("libtint_core_all_src") {
"symbol_table.cc",
"symbol_table.h",
"traits.h",
"typepair.h",
"transform/binding_point.h",
"transform/binding_remapper.cc",
"transform/binding_remapper.h",
@ -522,6 +521,7 @@ libtint_source_set("libtint_core_all_src") {
"transform/transform.h",
"transform/vertex_pulling.cc",
"transform/vertex_pulling.h",
"typepair.h",
"utils/get_or_create.h",
"utils/hash.h",
"utils/math.h",

2
src/CMakeLists.txt
View File

@ -172,6 +172,8 @@ set(TINT_LIB_SRCS
ast/type_name.h
ast/ast_type.cc # TODO(bclayton) - rename to type.cc
ast/type.h
ast/type_name.cc
ast/type_name.h
ast/u32.cc
ast/u32.h
ast/uint_literal.cc

6
src/ast/function.cc
View File

@ -27,7 +27,7 @@ Function::Function(ProgramID program_id,
const Source& source,
Symbol symbol,
VariableList params,
sem::Type* return_type,
typ::Type return_type,
BlockStatement* body,
DecorationList decorations,
DecorationList return_type_decorations)
@ -45,7 +45,7 @@ Function::Function(ProgramID program_id,
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(param, program_id);
}
TINT_ASSERT(symbol_.IsValid());
TINT_ASSERT(return_type_);
TINT_ASSERT(return_type_.sem);
for (auto* deco : decorations_) {
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(deco, program_id);
}
@ -81,7 +81,7 @@ Function* Function::Clone(CloneContext* ctx) const {
auto src = ctx->Clone(source());
auto sym = ctx->Clone(symbol());
auto p = ctx->Clone(params_);
auto* ret = ctx->Clone(return_type_);
auto ret = ctx->Clone(return_type_);
auto* b = ctx->Clone(body_);
auto decos = ctx->Clone(decorations_);
auto ret_decos = ctx->Clone(return_type_decorations_);

7
src/ast/function.h
View File

@ -28,6 +28,7 @@
#include "src/ast/location_decoration.h"
#include "src/ast/pipeline_stage.h"
#include "src/ast/variable.h"
#include "src/typepair.h"
namespace tint {
namespace ast {
@ -48,7 +49,7 @@ class Function : public Castable<Function, Node> {
const Source& source,
Symbol symbol,
VariableList params,
sem::Type* return_type,
typ::Type return_type,
BlockStatement* body,
DecorationList decorations,
DecorationList return_type_decorations);
@ -76,7 +77,7 @@ class Function : public Castable<Function, Node> {
bool IsEntryPoint() const { return pipeline_stage() != PipelineStage::kNone; }
/// @returns the function return type.
sem::Type* return_type() const { return return_type_; }
typ::Type return_type() const { return return_type_; }
/// @returns the decorations attached to the function return type.
const DecorationList& return_type_decorations() const {
@ -114,7 +115,7 @@ class Function : public Castable<Function, Node> {
Symbol const symbol_;
VariableList const params_;
sem::Type* const return_type_;
typ::Type const return_type_;
BlockStatement* const body_;
DecorationList const decorations_;
DecorationList const return_type_decorations_;

2
src/ast/pointer.cc
View File

@ -23,7 +23,7 @@ namespace ast {
Pointer::Pointer(ProgramID program_id,
const Source& source,
Type* subtype,
Type* const subtype,
ast::StorageClass storage_class)
: Base(program_id, source),
subtype_(subtype),

6
src/ast/pointer.h
View File

@ -33,14 +33,14 @@ class Pointer : public Castable<Pointer, Type> {
/// @param storage_class the storage class of the pointer
Pointer(ProgramID program_id,
const Source& source,
Type* subtype,
Type* const subtype,
ast::StorageClass storage_class);
/// Move constructor
Pointer(Pointer&&);
~Pointer() override;
/// @returns the pointee type
Type* type() const { return subtype_; }
Type* type() const { return const_cast<Type*>(subtype_); }
/// @returns the storage class of the pointer
ast::StorageClass storage_class() const { return storage_class_; }
@ -58,7 +58,7 @@ class Pointer : public Castable<Pointer, Type> {
Pointer* Clone(CloneContext* ctx) const override;
private:
Type* const subtype_;
Type const* const subtype_;
ast::StorageClass const storage_class_;
};

2
src/ast/sampled_texture.cc
View File

@ -24,7 +24,7 @@ namespace ast {
SampledTexture::SampledTexture(ProgramID program_id,
const Source& source,
TextureDimension dim,
Type* type)
Type const* type)
: Base(program_id, source, dim), type_(type) {
TINT_ASSERT(type_);
}

6
src/ast/sampled_texture.h
View File

@ -33,13 +33,13 @@ class SampledTexture : public Castable<SampledTexture, Texture> {
SampledTexture(ProgramID program_id,
const Source& source,
TextureDimension dim,
Type* type);
Type const* type);
/// Move constructor
SampledTexture(SampledTexture&&);
~SampledTexture() override;
/// @returns the subtype of the sampled texture
Type* type() const { return type_; }
Type* type() const { return const_cast<Type*>(type_); }
/// @returns the name for this type
std::string type_name() const override;
@ -55,7 +55,7 @@ class SampledTexture : public Castable<SampledTexture, Texture> {
SampledTexture* Clone(CloneContext* ctx) const override;
private:
Type* const type_;
Type const* const type_;
};
} // namespace ast

12
src/ast/variable.cc
View File

@ -27,13 +27,13 @@ Variable::Variable(ProgramID program_id,
const Source& source,
const Symbol& sym,
StorageClass declared_storage_class,
const sem::Type* declared_type,
const typ::Type type,
bool is_const,
Expression* constructor,
DecorationList decorations)
: Base(program_id, source),
symbol_(sym),
declared_type_(declared_type),
type_(type),
is_const_(is_const),
constructor_(constructor),
decorations_(std::move(decorations)),
@ -41,7 +41,7 @@ Variable::Variable(ProgramID program_id,
TINT_ASSERT(symbol_.IsValid());
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(symbol_, program_id);
// no type means we must have a constructor to infer it
TINT_ASSERT(declared_type_ || constructor);
TINT_ASSERT(type_.sem || constructor);
TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(constructor, program_id);
}
@ -73,7 +73,7 @@ uint32_t Variable::constant_id() const {
Variable* Variable::Clone(CloneContext* ctx) const {
auto src = ctx->Clone(source());
auto sym = ctx->Clone(symbol());
auto* ty = ctx->Clone(declared_type());
auto ty = ctx->Clone(type());
auto* ctor = ctx->Clone(constructor());
auto decos = ctx->Clone(decorations());
return ctx->dst->create<Variable>(src, sym, declared_storage_class(), ty,
@ -90,8 +90,8 @@ void Variable::info_to_str(const sem::Info& sem,
out << (var_sem ? var_sem->StorageClass() : declared_storage_class())
<< std::endl;
make_indent(out, indent);
if (declared_type_) {
out << declared_type_->type_name() << std::endl;
if (type_.sem) {
out << type_->type_name() << std::endl;
}
}

14
src/ast/variable.h
View File

@ -95,7 +95,7 @@ class Variable : public Castable<Variable, Node> {
/// @param source the variable source
/// @param sym the variable symbol
/// @param declared_storage_class the declared storage class
/// @param declared_type the declared variable type
/// @param type the declared variable type
/// @param is_const true if the variable is const
/// @param constructor the constructor expression
/// @param decorations the variable decorations
@ -103,7 +103,7 @@ class Variable : public Castable<Variable, Node> {
const Source& source,
const Symbol& sym,
StorageClass declared_storage_class,
const sem::Type* declared_type,
typ::Type type,
bool is_const,
Expression* constructor,
DecorationList decorations);
@ -116,9 +116,11 @@ class Variable : public Castable<Variable, Node> {
const Symbol& symbol() const { return symbol_; }
/// @returns the declared type
sem::Type* declared_type() const {
return const_cast<sem::Type*>(declared_type_);
}
// TODO(crbug.com/tint/697): Remove and use type() instead
sem::Type* declared_type() const { return const_cast<sem::Type*>(type_.sem); }
/// @returns the variable type
typ::Type type() const { return type_; }
/// @returns the declared storage class
StorageClass declared_storage_class() const {
@ -177,7 +179,7 @@ class Variable : public Castable<Variable, Node> {
Symbol const symbol_;
// The value type if a const or formal paramter, and the store type if a var
const sem::Type* const declared_type_;
typ::Type const type_;
bool const is_const_;
Expression* const constructor_;
DecorationList const decorations_;

2
src/ast/vector.cc
View File

@ -23,7 +23,7 @@ namespace ast {
Vector::Vector(ProgramID program_id,
const Source& source,
Type* subtype,
Type const* subtype,
uint32_t size)
: Base(program_id, source), subtype_(subtype), size_(size) {
TINT_ASSERT(size_ > 1);

6
src/ast/vector.h
View File

@ -32,14 +32,14 @@ class Vector : public Castable<Vector, Type> {
/// @param size the number of elements in the vector
Vector(ProgramID program_id,
const Source& source,
Type* subtype,
Type const* subtype,
uint32_t size);
/// Move constructor
Vector(Vector&&);
~Vector() override;
/// @returns the type of the vector elements
Type* type() const { return subtype_; }
Type* type() const { return const_cast<Type*>(subtype_); }
/// @returns the size of the vector
uint32_t size() const { return size_; }
@ -57,7 +57,7 @@ class Vector : public Castable<Vector, Type> {
Vector* Clone(CloneContext* ctx) const override;
private:
Type* const subtype_;
Type const* const subtype_;
uint32_t const size_;
};

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);

3
src/sem/vector_type.cc
View File

@ -21,7 +21,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::sem::Vector);
namespace tint {
namespace sem {
Vector::Vector(Type* subtype, uint32_t size) : subtype_(subtype), size_(size) {
Vector::Vector(Type const* subtype, uint32_t size)
: subtype_(subtype), size_(size) {
TINT_ASSERT(size_ > 1);
TINT_ASSERT(size_ < 5);
}

6
src/sem/vector_type.h
View File

@ -28,13 +28,13 @@ class Vector : public Castable<Vector, Type> {
/// Constructor
/// @param subtype the vector element type
/// @param size the number of elements in the vector
Vector(Type* subtype, uint32_t size);
Vector(Type const* subtype, uint32_t size);
/// Move constructor
Vector(Vector&&);
~Vector() override;
/// @returns the type of the vector elements
Type* type() const { return subtype_; }
Type* type() const { return const_cast<Type*>(subtype_); }
/// @returns the size of the vector
uint32_t size() const { return size_; }
@ -52,7 +52,7 @@ class Vector : public Castable<Vector, Type> {
Vector* Clone(CloneContext* ctx) const override;
private:
Type* const subtype_;
Type const* const subtype_;
uint32_t const size_;
};

2
src/transform/transform.cc
View File

@ -49,7 +49,7 @@ ast::Function* Transform::CloneWithStatementsAtStart(
auto source = ctx->Clone(in->source());
auto symbol = ctx->Clone(in->symbol());
auto params = ctx->Clone(in->params());
auto* return_type = ctx->Clone(in->return_type());
auto return_type = ctx->Clone(in->return_type());
auto* body = ctx->dst->create<ast::BlockStatement>(
ctx->Clone(in->body()->source()), statements);
auto decos = ctx->Clone(in->decorations());