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

ProgramBuilder: Fixup last few uses of sem::Type* 

With typ::Type.

Involves decoupling the use of named types as sub-types of other types,
otherwise ty.array("x", Structure(...)) produces an AST tree with
duplicated AST nodes.

Bug: tint:724
Change-Id: I2b4e904dc23bb554a75d4612f6543f1911f469bd
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/48693
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Ben Clayton 2021-04-23 15:41:34 +00:00 committed by Commit Bot service account
parent 099ceb2050
commit 3b3cf5f2d3
6 changed files with 170 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BUILD.gn
View File

@ -387,6 +387,8 @@ libtint_source_set("libtint_core_all_src") {
"ast/type.h",
"ast/type_constructor_expression.cc",
"ast/type_constructor_expression.h",
"ast/type_name.cc",
"ast/type_name.h",
"ast/u32.cc",
"ast/u32.h",
"ast/uint_literal.cc",

2
src/CMakeLists.txt
View File

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

47
src/ast/type_name.cc Normal file
View File

@ -0,0 +1,47 @@
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/ast/type_name.h"
#include "src/program_builder.h"
TINT_INSTANTIATE_TYPEINFO(tint::ast::TypeName);
namespace tint {
namespace ast {
TypeName::TypeName(ProgramID program_id, const Source& source, Symbol name)
: Base(program_id, source),
name_(name),
type_name_("__type_name_" + name.to_str()) {}
TypeName::~TypeName() = default;
TypeName::TypeName(TypeName&&) = default;
std::string TypeName::type_name() const {
return type_name_;
}
std::string TypeName::FriendlyName(const SymbolTable& symbols) const {
return symbols.NameFor(name_);
}
TypeName* TypeName::Clone(CloneContext* ctx) const {
auto src = ctx->Clone(source());
return ctx->dst->create<TypeName>(src, name_);
}
} // namespace ast
} // namespace tint

62
src/ast/type_name.h Normal file
View File

@ -0,0 +1,62 @@
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef SRC_AST_TYPE_NAME_H_
#define SRC_AST_TYPE_NAME_H_
#include <string>
#include "src/ast/type.h"
namespace tint {
namespace ast {
/// A named type (i.e. struct or alias)
class TypeName : public Castable<TypeName, Type> {
public:
/// Constructor
/// @param program_id the identifier of the program that owns this node
/// @param source the source of this node
/// @param name the type name
TypeName(ProgramID program_id, const Source& source, Symbol name);
/// Move constructor
TypeName(TypeName&&);
/// Destructor
~TypeName() override;
/// @return the type name
const Symbol& name() const { return name_; }
/// @returns the name for th type
std::string type_name() const override;
/// @param symbols the program's symbol table
/// @returns the name for this type that closely resembles how it would be
/// declared in WGSL.
std::string FriendlyName(const SymbolTable& symbols) const override;
/// Clones this type and all transitive types using the `CloneContext` `ctx`.
/// @param ctx the clone context
/// @return the newly cloned type
TypeName* Clone(CloneContext* ctx) const override;
private:
Symbol name_;
std::string const type_name_;
};
} // namespace ast
} // namespace tint
#endif // SRC_AST_TYPE_NAME_H_

14
src/program_builder.cc
View File

@ -16,6 +16,7 @@
#include "src/ast/assignment_statement.h"
#include "src/ast/call_statement.h"
#include "src/ast/type_name.h"
#include "src/ast/variable_decl_statement.h"
#include "src/debug.h"
#include "src/demangler.h"
@ -91,7 +92,7 @@ sem::Type* ProgramBuilder::TypeOf(ast::Expression* expr) const {
}
ast::ConstructorExpression* ProgramBuilder::ConstructValueFilledWith(
sem::Type* type,
typ::Type type,
int elem_value) {
auto* unwrapped_type = type->UnwrapAliasIfNeeded();
if (unwrapped_type->Is<sem::Bool>()) {
@ -129,6 +130,17 @@ ast::ConstructorExpression* ProgramBuilder::ConstructValueFilledWith(
return nullptr;
}
typ::Type ProgramBuilder::TypesBuilder::MaybeCreateTypename(
typ::Type type) const {
if (auto* alias = type.ast->As<ast::Alias>()) {
return {builder->create<ast::TypeName>(alias->symbol()), type.sem};
}
if (auto* str = type.ast->As<ast::Struct>()) {
return {builder->create<ast::TypeName>(str->name()), type.sem};
}
return type;
}
ProgramBuilder::TypesBuilder::TypesBuilder(ProgramBuilder* pb) : builder(pb) {}
ast::Statement* ProgramBuilder::WrapInStatement(ast::Literal* lit) {

66
src/program_builder.h
View File

@ -343,7 +343,7 @@ class ProgramBuilder {
/// @return the tint AST type for the C type `T`.
template <typename T>
sem::Type* Of() const {
typ::Type Of() const {
return CToAST<T>::get(this);
}
@ -558,6 +558,7 @@ class ProgramBuilder {
typ::Array array(typ::Type subtype,
uint32_t n = 0,
ast::DecorationList decos = {}) const {
subtype = MaybeCreateTypename(subtype);
return {builder->create<ast::Array>(subtype, n, decos),
builder->create<sem::ArrayType>(subtype, n, decos)};
}
@ -567,6 +568,7 @@ class ProgramBuilder {
/// @param stride the array stride
/// @return the tint AST type for a array of size `n` of type `T`
typ::Array array(typ::Type subtype, uint32_t n, uint32_t stride) const {
subtype = MaybeCreateTypename(subtype);
return array(subtype, n,
{builder->create<ast::StrideDecoration>(stride)});
}
@ -590,6 +592,7 @@ class ProgramBuilder {
/// @returns the alias pointer
template <typename NAME>
typ::Alias alias(NAME&& name, typ::Type type) const {
type = MaybeCreateTypename(type);
auto sym = builder->Sym(std::forward<NAME>(name));
return {
builder->create<ast::Alias>(sym, type),
@ -603,6 +606,7 @@ class ProgramBuilder {
/// @returns the access control qualifier type
typ::AccessControl access(ast::AccessControl::Access access,
typ::Type type) const {
type = MaybeCreateTypename(type);
return {builder->create<ast::AccessControl>(access, type),
builder->create<sem::AccessControl>(access, type)};
}
@ -612,6 +616,7 @@ class ProgramBuilder {
/// @return the pointer to `type` with the given ast::StorageClass
typ::Pointer pointer(typ::Type type,
ast::StorageClass storage_class) const {
type = MaybeCreateTypename(type);
return {builder->create<ast::Pointer>(type, storage_class),
builder->create<sem::Pointer>(type, storage_class)};
}
@ -673,12 +678,18 @@ class ProgramBuilder {
builder->create<sem::StorageTexture>(dims, format, sem_subtype)};
}
/// If ty is a ast::Struct or ast::Alias, the returned type is an
/// ast::TypeName of the given type's name, otherwise type is returned.
/// @param type the type
/// @return either type or a pointer to a new ast::TypeName
typ::Type MaybeCreateTypename(typ::Type type) const;
private:
/// CToAST<T> is specialized for various `T` types and each specialization
/// contains a single static `get()` method for obtaining the corresponding
/// AST type for the C type `T`.
/// `get()` has the signature:
/// `static sem::Type* get(Types* t)`
/// `static typ::Type get(Types* t)`
template <typename T>
struct CToAST {};
@ -840,7 +851,7 @@ class ProgramBuilder {
/// @return an `ast::TypeConstructorExpression` of `type` constructed with the
/// values `args`.
template <typename... ARGS>
ast::TypeConstructorExpression* Construct(sem::Type* type, ARGS&&... args) {
ast::TypeConstructorExpression* Construct(typ::Type type, ARGS&&... args) {
return create<ast::TypeConstructorExpression>(
type, ExprList(std::forward<ARGS>(args)...));
}
@ -853,7 +864,7 @@ class ProgramBuilder {
/// @param elem_value the initial or element value (for vec and mat) to
/// construct with
/// @return the constructor expression
ast::ConstructorExpression* ConstructValueFilledWith(sem::Type* type,
ast::ConstructorExpression* ConstructValueFilledWith(typ::Type type,
int elem_value = 0);
/// @param args the arguments for the vector constructor
@ -994,10 +1005,11 @@ class ProgramBuilder {
/// @returns a `ast::Variable` with the given name, storage and type
template <typename NAME>
ast::Variable* Var(NAME&& name,
sem::Type* type,
typ::Type type,
ast::StorageClass storage,
ast::Expression* constructor = nullptr,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::Variable>(Sym(std::forward<NAME>(name)), storage, type,
false, constructor, decorations);
}
@ -1012,10 +1024,11 @@ class ProgramBuilder {
template <typename NAME>
ast::Variable* Var(const Source& source,
NAME&& name,
sem::Type* type,
typ::Type type,
ast::StorageClass storage,
ast::Expression* constructor = nullptr,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::Variable>(source, Sym(std::forward<NAME>(name)), storage,
type, false, constructor, decorations);
}
@ -1027,9 +1040,10 @@ class ProgramBuilder {
/// @returns a constant `ast::Variable` with the given name and type
template <typename NAME>
ast::Variable* Const(NAME&& name,
sem::Type* type,
typ::Type type,
ast::Expression* constructor = nullptr,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::Variable>(Sym(std::forward<NAME>(name)),
ast::StorageClass::kNone, type, true,
constructor, decorations);
@ -1044,9 +1058,10 @@ class ProgramBuilder {
template <typename NAME>
ast::Variable* Const(const Source& source,
NAME&& name,
sem::Type* type,
typ::Type type,
ast::Expression* constructor = nullptr,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::Variable>(source, Sym(std::forward<NAME>(name)),
ast::StorageClass::kNone, type, true,
constructor, decorations);
@ -1058,8 +1073,9 @@ class ProgramBuilder {
/// @returns a constant `ast::Variable` with the given name and type
template <typename NAME>
ast::Variable* Param(NAME&& name,
sem::Type* type,
typ::Type type,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::Variable>(Sym(std::forward<NAME>(name)),
ast::StorageClass::kNone, type, true, nullptr,
decorations);
@ -1073,8 +1089,9 @@ class ProgramBuilder {
template <typename NAME>
ast::Variable* Param(const Source& source,
NAME&& name,
sem::Type* type,
typ::Type type,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::Variable>(source, Sym(std::forward<NAME>(name)),
ast::StorageClass::kNone, type, true, nullptr,
decorations);
@ -1089,7 +1106,7 @@ class ProgramBuilder {
/// global variable with the ast::Module.
template <typename NAME>
ast::Variable* Global(NAME&& name,
sem::Type* type,
typ::Type type,
ast::StorageClass storage,
ast::Expression* constructor = nullptr,
ast::DecorationList decorations = {}) {
@ -1110,7 +1127,7 @@ class ProgramBuilder {
template <typename NAME>
ast::Variable* Global(const Source& source,
NAME&& name,
sem::Type* type,
typ::Type type,
ast::StorageClass storage,
ast::Expression* constructor = nullptr,
ast::DecorationList decorations = {}) {
@ -1263,10 +1280,11 @@ class ProgramBuilder {
ast::Function* Func(const Source& source,
NAME&& name,
ast::VariableList params,
sem::Type* type,
typ::Type type,
ast::StatementList body,
ast::DecorationList decorations = {},
ast::DecorationList return_type_decorations = {}) {
type = ty.MaybeCreateTypename(type);
auto* func =
create<ast::Function>(source, Sym(std::forward<NAME>(name)), params,
type, create<ast::BlockStatement>(body),
@ -1287,10 +1305,11 @@ class ProgramBuilder {
template <typename NAME>
ast::Function* Func(NAME&& name,
ast::VariableList params,
sem::Type* type,
typ::Type type,
ast::StatementList body,
ast::DecorationList decorations = {},
ast::DecorationList return_type_decorations = {}) {
type = ty.MaybeCreateTypename(type);
auto* func = create<ast::Function>(Sym(std::forward<NAME>(name)), params,
type, create<ast::BlockStatement>(body),
decorations, return_type_decorations);
@ -1373,8 +1392,9 @@ class ProgramBuilder {
template <typename NAME>
ast::StructMember* Member(const Source& source,
NAME&& name,
sem::Type* type,
typ::Type type,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::StructMember>(source, Sym(std::forward<NAME>(name)),
type, std::move(decorations));
}
@ -1386,8 +1406,9 @@ class ProgramBuilder {
/// @returns the struct member pointer
template <typename NAME>
ast::StructMember* Member(NAME&& name,
sem::Type* type,
typ::Type type,
ast::DecorationList decorations = {}) {
type = ty.MaybeCreateTypename(type);
return create<ast::StructMember>(source_, Sym(std::forward<NAME>(name)),
type, std::move(decorations));
}
@ -1398,7 +1419,8 @@ class ProgramBuilder {
/// @param type the struct member type
/// @returns the struct member pointer
template <typename NAME>
ast::StructMember* Member(uint32_t offset, NAME&& name, sem::Type* type) {
ast::StructMember* Member(uint32_t offset, NAME&& name, typ::Type type) {
type = ty.MaybeCreateTypename(type);
return create<ast::StructMember>(
source_, Sym(std::forward<NAME>(name)), type,
ast::DecorationList{
@ -1665,31 +1687,31 @@ class ProgramBuilder {
// Various template specializations for ProgramBuilder::TypesBuilder::CToAST.
template <>
struct ProgramBuilder::TypesBuilder::CToAST<ProgramBuilder::i32> {
static sem::Type* get(const ProgramBuilder::TypesBuilder* t) {
static typ::Type get(const ProgramBuilder::TypesBuilder* t) {
return t->i32();
}
};
template <>
struct ProgramBuilder::TypesBuilder::CToAST<ProgramBuilder::u32> {
static sem::Type* get(const ProgramBuilder::TypesBuilder* t) {
static typ::Type get(const ProgramBuilder::TypesBuilder* t) {
return t->u32();
}
};
template <>
struct ProgramBuilder::TypesBuilder::CToAST<ProgramBuilder::f32> {
static sem::Type* get(const ProgramBuilder::TypesBuilder* t) {
static typ::Type get(const ProgramBuilder::TypesBuilder* t) {
return t->f32();
}
};
template <>
struct ProgramBuilder::TypesBuilder::CToAST<bool> {
static sem::Type* get(const ProgramBuilder::TypesBuilder* t) {
static typ::Type get(const ProgramBuilder::TypesBuilder* t) {
return t->bool_();
}
};
template <>
struct ProgramBuilder::TypesBuilder::CToAST<void> {
static sem::Type* get(const ProgramBuilder::TypesBuilder* t) {
static typ::Type get(const ProgramBuilder::TypesBuilder* t) {
return t->void_();
}
};