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

Rename semantic to sem

Browse Source 
* Rename namespace semantic to sem
* Rename directory src/semantic/ to src/sem/

Bug: tint:724
Change-Id: I76383b821fbca7f1037a803c497b595a706dcb06
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/48120
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
Antonio Maiorano
2021-04-16 19:07:51 +00:00
committed by Commit Bot service account
parent 26cd48603d
commit 5cd71b8c0a
174 changed files with 847 additions and 866 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/resolver/host_shareable_validation_test.cc
View File

@@ -16,7 +16,7 @@
#include "gmock/gmock.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/struct.h"
#include "src/sem/struct.h"
#include "src/type/access_control_type.h"
namespace tint {

16
src/resolver/intrinsic_test.cc
View File

@@ -29,11 +29,11 @@
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/call.h"
#include "src/semantic/function.h"
#include "src/semantic/member_accessor_expression.h"
#include "src/semantic/statement.h"
#include "src/semantic/variable.h"
#include "src/sem/call.h"
#include "src/sem/function.h"
#include "src/sem/member_accessor_expression.h"
#include "src/sem/statement.h"
#include "src/sem/variable.h"
#include "src/type/access_control_type.h"
#include "src/type/sampled_texture_type.h"
@@ -44,7 +44,7 @@ namespace tint {
namespace resolver {
namespace {
using IntrinsicType = semantic::IntrinsicType;
using IntrinsicType = sem::IntrinsicType;
using ResolverIntrinsicTest = ResolverTest;
@@ -1678,7 +1678,7 @@ INSTANTIATE_TEST_SUITE_P(
testing::ValuesIn(ast::intrinsic::test::TextureOverloadCase::ValidCases()));
std::string to_str(const std::string& function,
const semantic::ParameterList& params) {
const sem::ParameterList& params) {
std::stringstream out;
out << function << "(";
bool first = true;
@@ -1686,7 +1686,7 @@ std::string to_str(const std::string& function,
if (!first) {
out << ", ";
}
out << semantic::str(param.usage);
out << sem::str(param.usage);
first = false;
}
out << ")";

94
src/resolver/resolver.cc
View File

@@ -34,13 +34,13 @@
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/ast/workgroup_decoration.h"
#include "src/semantic/array.h"
#include "src/semantic/call.h"
#include "src/semantic/function.h"
#include "src/semantic/member_accessor_expression.h"
#include "src/semantic/statement.h"
#include "src/semantic/struct.h"
#include "src/semantic/variable.h"
#include "src/sem/array.h"
#include "src/sem/call.h"
#include "src/sem/function.h"
#include "src/sem/member_accessor_expression.h"
#include "src/sem/statement.h"
#include "src/sem/struct.h"
#include "src/sem/variable.h"
#include "src/type/access_control_type.h"
#include "src/utils/get_or_create.h"
#include "src/utils/math.h"
@@ -49,7 +49,7 @@ namespace tint {
namespace resolver {
namespace {
using IntrinsicType = tint::semantic::IntrinsicType;
using IntrinsicType = tint::sem::IntrinsicType;
// Helper class that temporarily assigns a value to a reference for the scope of
// the object. Once the ScopedAssignment is destructed, the original value is
@@ -394,7 +394,7 @@ bool Resolver::ValidateEntryPoint(const ast::Function* func) {
// Persistent state is used to track which builtins and locations have already
// been seen, in order to catch conflicts.
// TODO(jrprice): This state could be stored in FunctionInfo instead, and then
// passed to semantic::Function since it would be useful there too.
// passed to sem::Function since it would be useful there too.
std::unordered_set<ast::Builtin> builtins;
std::unordered_set<uint32_t> locations;
enum class ParamOrRetType {
@@ -594,15 +594,15 @@ bool Resolver::Function(ast::Function* func) {
switch (func->pipeline_stage()) {
case ast::PipelineStage::kVertex:
info->pipeline_stage_uses.emplace(
semantic::PipelineStageUsage::kVertexInput);
sem::PipelineStageUsage::kVertexInput);
break;
case ast::PipelineStage::kFragment:
info->pipeline_stage_uses.emplace(
semantic::PipelineStageUsage::kFragmentInput);
sem::PipelineStageUsage::kFragmentInput);
break;
case ast::PipelineStage::kCompute:
info->pipeline_stage_uses.emplace(
semantic::PipelineStageUsage::kComputeInput);
sem::PipelineStageUsage::kComputeInput);
break;
case ast::PipelineStage::kNone:
break;
@@ -626,15 +626,15 @@ bool Resolver::Function(ast::Function* func) {
switch (func->pipeline_stage()) {
case ast::PipelineStage::kVertex:
info->pipeline_stage_uses.emplace(
semantic::PipelineStageUsage::kVertexOutput);
sem::PipelineStageUsage::kVertexOutput);
break;
case ast::PipelineStage::kFragment:
info->pipeline_stage_uses.emplace(
semantic::PipelineStageUsage::kFragmentOutput);
sem::PipelineStageUsage::kFragmentOutput);
break;
case ast::PipelineStage::kCompute:
info->pipeline_stage_uses.emplace(
semantic::PipelineStageUsage::kComputeOutput);
sem::PipelineStageUsage::kComputeOutput);
break;
case ast::PipelineStage::kNone:
break;
@@ -677,10 +677,10 @@ bool Resolver::Statements(const ast::StatementList& stmts) {
bool Resolver::Statement(ast::Statement* stmt) {
auto* sem_statement =
builder_->create<semantic::Statement>(stmt, current_block_->block);
builder_->create<sem::Statement>(stmt, current_block_->block);
builder_->Sem().Add(stmt, sem_statement);
ScopedAssignment<semantic::Statement*> sa(current_statement_, sem_statement);
ScopedAssignment<sem::Statement*> sa(current_statement_, sem_statement);
if (auto* a = stmt->As<ast::AssignmentStatement>()) {
return Assignment(a);
@@ -790,10 +790,9 @@ bool Resolver::IfStatement(ast::IfStatement* stmt) {
// not a BlockStatement.
constexpr ast::BlockStatement* no_block_statement = nullptr;
auto* sem_else_stmt =
builder_->create<semantic::Statement>(else_stmt, no_block_statement);
builder_->create<sem::Statement>(else_stmt, no_block_statement);
builder_->Sem().Add(else_stmt, sem_else_stmt);
ScopedAssignment<semantic::Statement*> sa(current_statement_,
sem_else_stmt);
ScopedAssignment<sem::Statement*> sa(current_statement_, sem_else_stmt);
if (!Expression(else_stmt->condition())) {
return false;
}
@@ -916,7 +915,7 @@ bool Resolver::Call(ast::CallExpression* call) {
auto name = builder_->Symbols().NameFor(ident->symbol());
auto intrinsic_type = semantic::ParseIntrinsicType(name);
auto intrinsic_type = sem::ParseIntrinsicType(name);
if (intrinsic_type != IntrinsicType::kNone) {
if (!IntrinsicCall(call, intrinsic_type)) {
return false;
@@ -970,7 +969,7 @@ bool Resolver::Call(ast::CallExpression* call) {
}
bool Resolver::IntrinsicCall(ast::CallExpression* call,
semantic::IntrinsicType intrinsic_type) {
sem::IntrinsicType intrinsic_type) {
std::vector<type::Type*> arg_tys;
arg_tys.reserve(call->params().size());
for (auto* expr : call->params()) {
@@ -985,8 +984,8 @@ bool Resolver::IntrinsicCall(ast::CallExpression* call,
return false;
}
builder_->Sem().Add(call, builder_->create<semantic::Call>(
call, result.intrinsic, current_statement_));
builder_->Sem().Add(call, builder_->create<sem::Call>(call, result.intrinsic,
current_statement_));
SetType(call, result.intrinsic->ReturnType());
return true;
}
@@ -1186,7 +1185,7 @@ bool Resolver::Identifier(ast::IdentifierExpression* expr) {
}
std::string name = builder_->Symbols().NameFor(symbol);
if (semantic::ParseIntrinsicType(name) != IntrinsicType::kNone) {
if (sem::ParseIntrinsicType(name) != IntrinsicType::kNone) {
diagnostics_.add_error("missing '(' for intrinsic call",
expr->source().End());
return false;
@@ -1213,7 +1212,7 @@ bool Resolver::MemberAccessor(ast::MemberAccessorExpression* expr) {
auto* str = Structure(ty);
auto symbol = expr->member()->symbol();
const semantic::StructMember* member = nullptr;
const sem::StructMember* member = nullptr;
for (auto* m : str->members) {
if (m->Declaration()->symbol() == symbol) {
ret = m->Declaration()->type();
@@ -1234,7 +1233,7 @@ bool Resolver::MemberAccessor(ast::MemberAccessorExpression* expr) {
ret = builder_->create<type::Pointer>(ret, ptr->storage_class());
}
builder_->Sem().Add(expr, builder_->create<semantic::StructMemberAccess>(
builder_->Sem().Add(expr, builder_->create<sem::StructMemberAccess>(
expr, ret, current_statement_, member));
} else if (auto* vec = data_type->As<type::Vector>()) {
std::string str = builder_->Symbols().NameFor(expr->member()->symbol());
@@ -1302,8 +1301,8 @@ bool Resolver::MemberAccessor(ast::MemberAccessorExpression* expr) {
static_cast<uint32_t>(size));
}
builder_->Sem().Add(
expr, builder_->create<semantic::Swizzle>(expr, ret, current_statement_,
std::move(swizzle)));
expr, builder_->create<sem::Swizzle>(expr, ret, current_statement_,
std::move(swizzle)));
} else {
diagnostics_.add_error(
"invalid use of member accessor on a non-vector/non-struct " +
@@ -1682,9 +1681,9 @@ void Resolver::CreateSemanticNodes() const {
for (auto it : variable_to_info_) {
auto* var = it.first;
auto* info = it.second;
auto* sem_var = builder_->create<semantic::Variable>(var, info->type,
info->storage_class);
std::vector<const semantic::VariableUser*> users;
auto* sem_var =
builder_->create<sem::Variable>(var, info->type, info->storage_class);
std::vector<const sem::VariableUser*> users;
for (auto* user : info->users) {
// Create semantic node for the identifier expression if necessary
auto* sem_expr = sem.Get(user);
@@ -1692,14 +1691,14 @@ void Resolver::CreateSemanticNodes() const {
auto* type = expr_info_.at(user).type;
auto* stmt = expr_info_.at(user).statement;
auto* sem_user =
builder_->create<semantic::VariableUser>(user, type, stmt, sem_var);
builder_->create<sem::VariableUser>(user, type, stmt, sem_var);
sem_var->AddUser(sem_user);
sem.Add(user, sem_user);
} else {
auto* sem_user = sem_expr->As<semantic::VariableUser>();
auto* sem_user = sem_expr->As<sem::VariableUser>();
if (!sem_user) {
TINT_ICE(builder_->Diagnostics())
<< "expected semantic::VariableUser, got "
<< "expected sem::VariableUser, got "
<< sem_expr->TypeInfo().name;
}
sem_var->AddUser(sem_user);
@@ -1709,7 +1708,7 @@ void Resolver::CreateSemanticNodes() const {
}
auto remap_vars = [&sem](const std::vector<VariableInfo*>& in) {
std::vector<const semantic::Variable*> out;
std::vector<const sem::Variable*> out;
out.reserve(in.size());
for (auto* info : in) {
out.emplace_back(sem.Get(info->declaration));
@@ -1718,12 +1717,12 @@ void Resolver::CreateSemanticNodes() const {
};
// Create semantic nodes for all ast::Functions
std::unordered_map<FunctionInfo*, semantic::Function*> func_info_to_sem_func;
std::unordered_map<FunctionInfo*, sem::Function*> func_info_to_sem_func;
for (auto it : function_to_info_) {
auto* func = it.first;
auto* info = it.second;
auto* sem_func = builder_->create<semantic::Function>(
auto* sem_func = builder_->create<sem::Function>(
info->declaration, remap_vars(info->parameters),
remap_vars(info->referenced_module_vars),
remap_vars(info->local_referenced_module_vars), info->return_statements,
@@ -1737,8 +1736,7 @@ void Resolver::CreateSemanticNodes() const {
auto* call = it.first;
auto info = it.second;
auto* sem_func = func_info_to_sem_func.at(info.function);
sem.Add(call,
builder_->create<semantic::Call>(call, sem_func, info.statement));
sem.Add(call, builder_->create<sem::Call>(call, sem_func, info.statement));
}
// Create semantic nodes for all remaining expression types
@@ -1749,8 +1747,8 @@ void Resolver::CreateSemanticNodes() const {
// Expression has already been assigned a semantic node
continue;
}
sem.Add(expr, builder_->create<semantic::Expression>(expr, info.type,
info.statement));
sem.Add(expr,
builder_->create<sem::Expression>(expr, info.type, info.statement));
}
// Create semantic nodes for all structs
@@ -1758,7 +1756,7 @@ void Resolver::CreateSemanticNodes() const {
auto* str = it.first;
auto* info = it.second;
builder_->Sem().Add(
str, builder_->create<semantic::Struct>(
str, builder_->create<sem::Struct>(
str, std::move(info->members), info->align, info->size,
info->size_no_padding, info->storage_class_usage,
info->pipeline_stage_uses));
@@ -1829,7 +1827,7 @@ bool Resolver::DefaultAlignAndSize(type::Type* ty,
return false;
}
const semantic::Array* Resolver::Array(type::Array* arr, const Source& source) {
const sem::Array* Resolver::Array(type::Array* arr, const Source& source) {
if (auto* sem = builder_->Sem().Get(arr)) {
// Semantic info already constructed for this array type
return sem;
@@ -1851,12 +1849,12 @@ const semantic::Array* Resolver::Array(type::Array* arr, const Source& source) {
return nullptr;
}
auto create_semantic = [&](uint32_t stride) -> semantic::Array* {
auto create_semantic = [&](uint32_t stride) -> sem::Array* {
auto align = el_align;
// WebGPU requires runtime arrays have at least one element, but the AST
// records an element count of 0 for it.
auto size = std::max<uint32_t>(arr->size(), 1) * stride;
auto* sem = builder_->create<semantic::Array>(arr, align, size, stride);
auto* sem = builder_->create<sem::Array>(arr, align, size, stride);
builder_->Sem().Add(arr, sem);
return sem;
};
@@ -1956,7 +1954,7 @@ Resolver::StructInfo* Resolver::Structure(type::Struct* str) {
return nullptr;
}
semantic::StructMemberList sem_members;
sem::StructMemberList sem_members;
sem_members.reserve(str->impl()->members().size());
// Calculate the effective size and alignment of each field, and the overall
@@ -2036,7 +2034,7 @@ Resolver::StructInfo* Resolver::Structure(type::Struct* str) {
offset = utils::RoundUp(align, offset);
auto* sem_member =
builder_->create<semantic::StructMember>(member, offset, align, size);
builder_->create<sem::StructMember>(member, offset, align, size);
builder_->Sem().Add(member, sem_member);
sem_members.emplace_back(sem_member);

34
src/resolver/resolver.h
View File

@@ -24,7 +24,7 @@
#include "src/intrinsic_table.h"
#include "src/program_builder.h"
#include "src/scope_stack.h"
#include "src/semantic/struct.h"
#include "src/sem/struct.h"
#include "src/utils/unique_vector.h"
namespace tint {
@@ -45,10 +45,10 @@ class SwitchStatement;
class UnaryOpExpression;
class Variable;
} // namespace ast
namespace semantic {
namespace sem {
class Array;
class Statement;
} // namespace semantic
} // namespace sem
namespace type {
class Struct;
} // namespace type
@@ -94,7 +94,7 @@ class Resolver {
private:
/// Structure holding semantic information about a variable.
/// Used to build the semantic::Variable nodes at the end of resolving.
/// Used to build the sem::Variable nodes at the end of resolving.
struct VariableInfo {
VariableInfo(ast::Variable* decl, type::Type* type);
~VariableInfo();
@@ -106,7 +106,7 @@ class Resolver {
};
/// Structure holding semantic information about a function.
/// Used to build the semantic::Function nodes at the end of resolving.
/// Used to build the sem::Function nodes at the end of resolving.
struct FunctionInfo {
explicit FunctionInfo(ast::Function* decl);
~FunctionInfo();
@@ -122,32 +122,32 @@ class Resolver {
};
/// Structure holding semantic information about an expression.
/// Used to build the semantic::Expression nodes at the end of resolving.
/// Used to build the sem::Expression nodes at the end of resolving.
struct ExpressionInfo {
type::Type* type;
semantic::Statement* statement;
sem::Statement* statement;
};
/// Structure holding semantic information about a call expression to an
/// ast::Function.
/// Used to build the semantic::Call nodes at the end of resolving.
/// Used to build the sem::Call nodes at the end of resolving.
struct FunctionCallInfo {
FunctionInfo* function;
semantic::Statement* statement;
sem::Statement* statement;
};
/// Structure holding semantic information about a struct.
/// Used to build the semantic::Struct nodes at the end of resolving.
/// Used to build the sem::Struct nodes at the end of resolving.
struct StructInfo {
StructInfo();
~StructInfo();
std::vector<const semantic::StructMember*> members;
std::vector<const sem::StructMember*> members;
uint32_t align = 0;
uint32_t size = 0;
uint32_t size_no_padding = 0;
std::unordered_set<ast::StorageClass> storage_class_usage;
std::unordered_set<semantic::PipelineStageUsage> pipeline_stage_uses;
std::unordered_set<sem::PipelineStageUsage> pipeline_stage_uses;
};
/// Structure holding semantic information about a block (i.e. scope), such as
@@ -188,7 +188,7 @@ class Resolver {
/// @returns true on success, false on error
bool ResolveInternal();
/// Creates the nodes and adds them to the semantic::Info mappings of the
/// Creates the nodes and adds them to the sem::Info mappings of the
/// ProgramBuilder.
void CreateSemanticNodes() const;
@@ -225,7 +225,7 @@ class Resolver {
bool Function(ast::Function*);
bool Identifier(ast::IdentifierExpression*);
bool IfStatement(ast::IfStatement*);
bool IntrinsicCall(ast::CallExpression*, semantic::IntrinsicType);
bool IntrinsicCall(ast::CallExpression*, sem::IntrinsicType);
bool MemberAccessor(ast::MemberAccessorExpression*);
bool Statement(ast::Statement*);
bool Statements(const ast::StatementList&);
@@ -253,7 +253,7 @@ class Resolver {
/// returned.
/// @param arr the Array to get semantic information for
/// @param source the Source of the ast node with this array as its type
const semantic::Array* Array(type::Array* arr, const Source& source);
const sem::Array* Array(type::Array* arr, const Source& source);
/// @returns the StructInfo for the structure `str`, building it if it hasn't
/// been constructed already. If an error is raised, nullptr is returned.
@@ -291,7 +291,7 @@ class Resolver {
/// @param expr the expression
type::Type* TypeOf(ast::Expression* expr);
/// Creates a semantic::Expression node with the resolved type `type`, and
/// Creates a sem::Expression node with the resolved type `type`, and
/// assigns this semantic node to the expression `expr`.
/// @param expr the expression
/// @param type the resolved type
@@ -325,7 +325,7 @@ class Resolver {
std::unordered_map<type::Struct*, StructInfo*> struct_info_;
std::unordered_map<type::Type*, type::Type*> type_to_canonical_;
FunctionInfo* current_function_ = nullptr;
semantic::Statement* current_statement_ = nullptr;
sem::Statement* current_statement_ = nullptr;
BlockAllocator<VariableInfo> variable_infos_;
BlockAllocator<FunctionInfo> function_infos_;
BlockAllocator<StructInfo> struct_infos_;

27
src/resolver/resolver_test.cc
View File

@@ -31,11 +31,11 @@
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/call.h"
#include "src/semantic/function.h"
#include "src/semantic/member_accessor_expression.h"
#include "src/semantic/statement.h"
#include "src/semantic/variable.h"
#include "src/sem/call.h"
#include "src/sem/function.h"
#include "src/sem/member_accessor_expression.h"
#include "src/sem/statement.h"
#include "src/sem/variable.h"
#include "src/type/access_control_type.h"
#include "src/type/sampled_texture_type.h"
@@ -902,10 +902,10 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct) {
auto* ptr = TypeOf(mem)->As<type::Pointer>();
EXPECT_TRUE(ptr->type()->Is<type::F32>());
ASSERT_TRUE(Sem().Get(mem)->Is<semantic::StructMemberAccess>());
ASSERT_TRUE(Sem().Get(mem)->Is<sem::StructMemberAccess>());
EXPECT_EQ(Sem()
.Get(mem)
->As<semantic::StructMemberAccess>()
->As<sem::StructMemberAccess>()
->Member()
->Declaration()
->symbol(),
@@ -932,7 +932,7 @@ TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) {
auto* ptr = TypeOf(mem)->As<type::Pointer>();
EXPECT_TRUE(ptr->type()->Is<type::F32>());
ASSERT_TRUE(Sem().Get(mem)->Is<semantic::StructMemberAccess>());
ASSERT_TRUE(Sem().Get(mem)->Is<sem::StructMemberAccess>());
}
TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
@@ -947,8 +947,8 @@ TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
ASSERT_TRUE(TypeOf(mem)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(mem)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(mem)->As<type::Vector>()->size(), 4u);
ASSERT_TRUE(Sem().Get(mem)->Is<semantic::Swizzle>());
EXPECT_THAT(Sem().Get(mem)->As<semantic::Swizzle>()->Indices(),
ASSERT_TRUE(Sem().Get(mem)->Is<sem::Swizzle>());
EXPECT_THAT(Sem().Get(mem)->As<sem::Swizzle>()->Indices(),
ElementsAre(0, 2, 1, 3));
}
@@ -965,9 +965,8 @@ TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle_SingleElement) {
auto* ptr = TypeOf(mem)->As<type::Pointer>();
ASSERT_TRUE(ptr->type()->Is<type::F32>());
ASSERT_TRUE(Sem().Get(mem)->Is<semantic::Swizzle>());
EXPECT_THAT(Sem().Get(mem)->As<semantic::Swizzle>()->Indices(),
ElementsAre(2));
ASSERT_TRUE(Sem().Get(mem)->Is<sem::Swizzle>());
EXPECT_THAT(Sem().Get(mem)->As<sem::Swizzle>()->Indices(), ElementsAre(2));
}
TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
@@ -1019,7 +1018,7 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
ASSERT_TRUE(TypeOf(mem)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(mem)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(mem)->As<type::Vector>()->size(), 2u);
ASSERT_TRUE(Sem().Get(mem)->Is<semantic::Swizzle>());
ASSERT_TRUE(Sem().Get(mem)->Is<sem::Swizzle>());
}
TEST_F(ResolverTest, Expr_MemberAccessor_InBinaryOp) {

13
src/resolver/resolver_test_helper.h
View File

@@ -21,9 +21,9 @@
#include "gtest/gtest.h"
#include "src/program_builder.h"
#include "src/resolver/resolver.h"
#include "src/semantic/expression.h"
#include "src/semantic/statement.h"
#include "src/semantic/variable.h"
#include "src/sem/expression.h"
#include "src/sem/statement.h"
#include "src/sem/variable.h"
namespace tint {
namespace resolver {
@@ -69,12 +69,11 @@ class TestHelper : public ProgramBuilder {
/// Returns the semantic variable for the given identifier expression.
/// @param expr the identifier expression
/// @return the resolved semantic::Variable of the identifier, or nullptr if
/// @return the resolved sem::Variable of the identifier, or nullptr if
/// the expression did not resolve to a variable.
const semantic::Variable* VarOf(ast::Expression* expr) {
const sem::Variable* VarOf(ast::Expression* expr) {
auto* sem_ident = Sem().Get(expr);
auto* var_user =
sem_ident ? sem_ident->As<semantic::VariableUser>() : nullptr;
auto* var_user = sem_ident ? sem_ident->As<sem::VariableUser>() : nullptr;
return var_user ? var_user->Variable() : nullptr;
}

2
src/resolver/storage_class_validation_test.cc
View File

@@ -16,7 +16,7 @@
#include "gmock/gmock.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/struct.h"
#include "src/sem/struct.h"
#include "src/type/access_control_type.h"
namespace tint {

2
src/resolver/struct_layout_test.cc
View File

@@ -17,7 +17,7 @@
#include "gmock/gmock.h"
#include "src/ast/struct_block_decoration.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/struct.h"
#include "src/sem/struct.h"
namespace tint {
namespace resolver {

43
src/resolver/struct_pipeline_stage_use_test.cc
View File

@@ -17,7 +17,7 @@
#include "gmock/gmock.h"
#include "src/ast/stage_decoration.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/struct.h"
#include "src/sem/struct.h"
using ::testing::UnorderedElementsAre;
@@ -76,7 +76,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderParam) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kVertexInput));
UnorderedElementsAre(sem::PipelineStageUsage::kVertexInput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderReturnType) {
@@ -90,9 +90,8 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderReturnType) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kVertexOutput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kVertexOutput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderParam) {
@@ -106,9 +105,8 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderParam) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kFragmentInput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kFragmentInput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderReturnType) {
@@ -122,9 +120,8 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderReturnType) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kFragmentOutput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kFragmentOutput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) {
@@ -139,9 +136,8 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kComputeInput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kComputeInput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedMultipleStages) {
@@ -158,11 +154,10 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedMultipleStages) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kVertexInput,
semantic::PipelineStageUsage::kVertexOutput,
semantic::PipelineStageUsage::kFragmentInput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kVertexInput,
sem::PipelineStageUsage::kVertexOutput,
sem::PipelineStageUsage::kFragmentInput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderParamViaAlias) {
@@ -177,9 +172,8 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderParamViaAlias) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kFragmentInput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kFragmentInput));
}
TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderReturnTypeViaAlias) {
@@ -194,9 +188,8 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderReturnTypeViaAlias) {
auto* sem = Sem().Get(s);
ASSERT_NE(sem, nullptr);
EXPECT_THAT(
sem->PipelineStageUses(),
UnorderedElementsAre(semantic::PipelineStageUsage::kFragmentOutput));
EXPECT_THAT(sem->PipelineStageUses(),
UnorderedElementsAre(sem::PipelineStageUsage::kFragmentOutput));
}
} // namespace

2
src/resolver/struct_storage_class_use_test.cc
View File

@@ -16,7 +16,7 @@
#include "gmock/gmock.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/struct.h"
#include "src/sem/struct.h"
using ::testing::UnorderedElementsAre;

14
src/resolver/validation_test.cc
View File

@@ -29,11 +29,11 @@
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
#include "src/resolver/resolver_test_helper.h"
#include "src/semantic/call.h"
#include "src/semantic/function.h"
#include "src/semantic/member_accessor_expression.h"
#include "src/semantic/statement.h"
#include "src/semantic/variable.h"
#include "src/sem/call.h"
#include "src/sem/function.h"
#include "src/sem/member_accessor_expression.h"
#include "src/sem/statement.h"
#include "src/sem/variable.h"
#include "src/type/access_control_type.h"
#include "src/type/sampled_texture_type.h"
@@ -51,7 +51,7 @@ class FakeStmt : public ast::Statement {
FakeStmt(ProgramID program_id, Source source)
: ast::Statement(program_id, source) {}
FakeStmt* Clone(CloneContext*) const override { return nullptr; }
void to_str(const semantic::Info&, std::ostream& out, size_t) const override {
void to_str(const sem::Info&, std::ostream& out, size_t) const override {
out << "Fake";
}
};
@@ -61,7 +61,7 @@ class FakeExpr : public ast::Expression {
FakeExpr(ProgramID program_id, Source source)
: ast::Expression(program_id, source) {}
FakeExpr* Clone(CloneContext*) const override { return nullptr; }
void to_str(const semantic::Info&, std::ostream&, size_t) const override {}
void to_str(const sem::Info&, std::ostream&, size_t) const override {}
};
TEST_F(ResolverValidationTest, Error_WithEmptySource) {