139 lines
4.1 KiB
C++
139 lines
4.1 KiB
C++
// 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/program_builder.h"
|
|
|
|
#include "src/ast/assignment_statement.h"
|
|
#include "src/ast/call_statement.h"
|
|
#include "src/ast/variable_decl_statement.h"
|
|
#include "src/debug.h"
|
|
#include "src/demangler.h"
|
|
#include "src/sem/expression.h"
|
|
#include "src/sem/variable.h"
|
|
|
|
namespace tint {
|
|
|
|
ProgramBuilder::VarOptionals::~VarOptionals() = default;
|
|
|
|
ProgramBuilder::ProgramBuilder()
|
|
: id_(ProgramID::New()),
|
|
ast_(ast_nodes_.Create<ast::Module>(id_, Source{})) {}
|
|
|
|
ProgramBuilder::ProgramBuilder(ProgramBuilder&& rhs)
|
|
: id_(std::move(rhs.id_)),
|
|
types_(std::move(rhs.types_)),
|
|
ast_nodes_(std::move(rhs.ast_nodes_)),
|
|
sem_nodes_(std::move(rhs.sem_nodes_)),
|
|
ast_(rhs.ast_),
|
|
sem_(std::move(rhs.sem_)),
|
|
symbols_(std::move(rhs.symbols_)),
|
|
diagnostics_(std::move(rhs.diagnostics_)) {
|
|
rhs.MarkAsMoved();
|
|
}
|
|
|
|
ProgramBuilder::~ProgramBuilder() = default;
|
|
|
|
ProgramBuilder& ProgramBuilder::operator=(ProgramBuilder&& rhs) {
|
|
rhs.MarkAsMoved();
|
|
AssertNotMoved();
|
|
id_ = std::move(rhs.id_);
|
|
types_ = std::move(rhs.types_);
|
|
ast_nodes_ = std::move(rhs.ast_nodes_);
|
|
sem_nodes_ = std::move(rhs.sem_nodes_);
|
|
ast_ = rhs.ast_;
|
|
sem_ = std::move(rhs.sem_);
|
|
symbols_ = std::move(rhs.symbols_);
|
|
diagnostics_ = std::move(rhs.diagnostics_);
|
|
|
|
return *this;
|
|
}
|
|
|
|
ProgramBuilder ProgramBuilder::Wrap(const Program* program) {
|
|
ProgramBuilder builder;
|
|
builder.id_ = program->ID();
|
|
builder.types_ = sem::Manager::Wrap(program->Types());
|
|
builder.ast_ = builder.create<ast::Module>(
|
|
program->AST().source, program->AST().GlobalDeclarations());
|
|
builder.sem_ = sem::Info::Wrap(program->Sem());
|
|
builder.symbols_ = program->Symbols();
|
|
builder.diagnostics_ = program->Diagnostics();
|
|
return builder;
|
|
}
|
|
|
|
bool ProgramBuilder::IsValid() const {
|
|
return !diagnostics_.contains_errors();
|
|
}
|
|
|
|
void ProgramBuilder::MarkAsMoved() {
|
|
AssertNotMoved();
|
|
moved_ = true;
|
|
}
|
|
|
|
void ProgramBuilder::AssertNotMoved() const {
|
|
if (moved_) {
|
|
TINT_ICE(ProgramBuilder, const_cast<ProgramBuilder*>(this)->diagnostics_)
|
|
<< "Attempting to use ProgramBuilder after it has been moved";
|
|
}
|
|
}
|
|
|
|
const sem::Type* ProgramBuilder::TypeOf(const ast::Expression* expr) const {
|
|
auto* sem = Sem().Get(expr);
|
|
return sem ? sem->Type() : nullptr;
|
|
}
|
|
|
|
const sem::Type* ProgramBuilder::TypeOf(const ast::Variable* var) const {
|
|
auto* sem = Sem().Get(var);
|
|
return sem ? sem->Type() : nullptr;
|
|
}
|
|
|
|
const sem::Type* ProgramBuilder::TypeOf(const ast::Type* type) const {
|
|
return Sem().Get(type);
|
|
}
|
|
|
|
const sem::Type* ProgramBuilder::TypeOf(const ast::TypeDecl* type_decl) const {
|
|
return Sem().Get(type_decl);
|
|
}
|
|
|
|
const ast::TypeName* ProgramBuilder::TypesBuilder::Of(
|
|
const ast::TypeDecl* decl) const {
|
|
return type_name(decl->name);
|
|
}
|
|
|
|
ProgramBuilder::TypesBuilder::TypesBuilder(ProgramBuilder* pb) : builder(pb) {}
|
|
|
|
const ast::Statement* ProgramBuilder::WrapInStatement(
|
|
const ast::Expression* expr) {
|
|
// Create a temporary variable of inferred type from expr.
|
|
return Decl(Const(symbols_.New(), nullptr, expr));
|
|
}
|
|
|
|
const ast::VariableDeclStatement* ProgramBuilder::WrapInStatement(
|
|
const ast::Variable* v) {
|
|
return create<ast::VariableDeclStatement>(v);
|
|
}
|
|
|
|
const ast::Statement* ProgramBuilder::WrapInStatement(
|
|
const ast::Statement* stmt) {
|
|
return stmt;
|
|
}
|
|
|
|
const ast::Function* ProgramBuilder::WrapInFunction(
|
|
const ast::StatementList stmts) {
|
|
return Func("test_function", {}, ty.void_(), std::move(stmts),
|
|
{create<ast::StageDecoration>(ast::PipelineStage::kCompute),
|
|
WorkgroupSize(1, 1, 1)});
|
|
}
|
|
|
|
} // namespace tint
|