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

Add a symbol to the Identifier AST node 

This CL adds a Symbol to the identifier to represent the name. The name
still exists but will be removed in a future CL when the namers are in
place.

Change-Id: Ic3cc8ad0d99e3bea6eb1ff1ce212e7de67991aec
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/35460
Commit-Queue: dan sinclair <dsinclair@chromium.org>
Auto-Submit: dan sinclair <dsinclair@chromium.org>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
dan sinclair 2020-12-11 19:16:13 +00:00 committed by Commit Bot service account
parent 5b3c9f1c62
commit 6b59bf45aa
113 changed files with 2525 additions and 1750 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/ast/array_accessor_expression_test.cc
View File

@ -24,8 +24,8 @@ namespace {
using ArrayAccessorExpressionTest = TestHelper;
TEST_F(ArrayAccessorExpressionTest, Create) {
auto* ary = create<IdentifierExpression>("ary");
auto* idx = create<IdentifierExpression>("idx");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(ary, idx);
ASSERT_EQ(exp.array(), ary);
@ -33,8 +33,8 @@ TEST_F(ArrayAccessorExpressionTest, Create) {
}
TEST_F(ArrayAccessorExpressionTest, CreateWithSource) {
auto* ary = create<IdentifierExpression>("ary");
auto* idx = create<IdentifierExpression>("idx");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(Source{Source::Location{20, 2}}, ary, idx);
auto src = exp.source();
@ -43,58 +43,58 @@ TEST_F(ArrayAccessorExpressionTest, CreateWithSource) {
}
TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) {
auto* ary = create<IdentifierExpression>("ary");
auto* idx = create<IdentifierExpression>("idx");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(ary, idx);
EXPECT_TRUE(exp.Is<ArrayAccessorExpression>());
}
TEST_F(ArrayAccessorExpressionTest, IsValid) {
auto* ary = create<IdentifierExpression>("ary");
auto* idx = create<IdentifierExpression>("idx");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(ary, idx);
EXPECT_TRUE(exp.IsValid());
}
TEST_F(ArrayAccessorExpressionTest, IsValid_MissingArray) {
auto* idx = create<IdentifierExpression>("idx");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(nullptr, idx);
EXPECT_FALSE(exp.IsValid());
}
TEST_F(ArrayAccessorExpressionTest, IsValid_MissingIndex) {
auto* ary = create<IdentifierExpression>("ary");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
ArrayAccessorExpression exp(ary, nullptr);
EXPECT_FALSE(exp.IsValid());
}
TEST_F(ArrayAccessorExpressionTest, IsValid_InvalidArray) {
auto* ary = create<IdentifierExpression>("");
auto* idx = create<IdentifierExpression>("idx");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(ary, idx);
EXPECT_FALSE(exp.IsValid());
}
TEST_F(ArrayAccessorExpressionTest, IsValid_InvalidIndex) {
auto* ary = create<IdentifierExpression>("ary");
auto* idx = create<IdentifierExpression>("");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
ArrayAccessorExpression exp(ary, idx);
EXPECT_FALSE(exp.IsValid());
}
TEST_F(ArrayAccessorExpressionTest, ToStr) {
auto* ary = create<IdentifierExpression>("ary");
auto* idx = create<IdentifierExpression>("idx");
auto* ary = create<IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx = create<IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ArrayAccessorExpression exp(ary, idx);
std::ostringstream out;
exp.to_str(out, 2);
EXPECT_EQ(out.str(), R"( ArrayAccessor[not set]{
EXPECT_EQ(demangle(out.str()), R"( ArrayAccessor[not set]{
Identifier[not set]{ary}
Identifier[not set]{idx}
}

34
src/ast/assignment_statement_test.cc
View File

@ -24,8 +24,8 @@ namespace {
using AssignmentStatementTest = TestHelper;
TEST_F(AssignmentStatementTest, Creation) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(lhs, rhs);
EXPECT_EQ(stmt.lhs(), lhs);
@ -33,8 +33,8 @@ TEST_F(AssignmentStatementTest, Creation) {
}
TEST_F(AssignmentStatementTest, CreationWithSource) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(Source{Source::Location{20, 2}}, lhs, rhs);
auto src = stmt.source();
@ -43,58 +43,58 @@ TEST_F(AssignmentStatementTest, CreationWithSource) {
}
TEST_F(AssignmentStatementTest, IsAssign) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(lhs, rhs);
EXPECT_TRUE(stmt.Is<AssignmentStatement>());
}
TEST_F(AssignmentStatementTest, IsValid) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(lhs, rhs);
EXPECT_TRUE(stmt.IsValid());
}
TEST_F(AssignmentStatementTest, IsValid_MissingLHS) {
auto* rhs = create<IdentifierExpression>("rhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(nullptr, rhs);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(AssignmentStatementTest, IsValid_MissingRHS) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
AssignmentStatement stmt(lhs, nullptr);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(AssignmentStatementTest, IsValid_InvalidLHS) {
auto* lhs = create<IdentifierExpression>("");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(lhs, rhs);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(AssignmentStatementTest, IsValid_InvalidRHS) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
AssignmentStatement stmt(lhs, rhs);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(AssignmentStatementTest, ToStr) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
AssignmentStatement stmt(lhs, rhs);
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Assignment{
EXPECT_EQ(demangle(out.str()), R"( Assignment{
Identifier[not set]{lhs}
Identifier[not set]{rhs}
}

38
src/ast/binary_expression_test.cc
View File

@ -26,8 +26,8 @@ namespace {
using BinaryExpressionTest = TestHelper;
TEST_F(BinaryExpressionTest, Creation) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
EXPECT_EQ(r.lhs(), lhs);
@ -36,8 +36,8 @@ TEST_F(BinaryExpressionTest, Creation) {
}
TEST_F(BinaryExpressionTest, Creation_WithSource) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(Source{Source::Location{20, 2}}, BinaryOp::kEqual, lhs,
rhs);
@ -47,67 +47,67 @@ TEST_F(BinaryExpressionTest, Creation_WithSource) {
}
TEST_F(BinaryExpressionTest, IsBinary) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
EXPECT_TRUE(r.Is<BinaryExpression>());
}
TEST_F(BinaryExpressionTest, IsValid) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
EXPECT_TRUE(r.IsValid());
}
TEST_F(BinaryExpressionTest, IsValid_Null_LHS) {
auto* rhs = create<IdentifierExpression>("rhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kEqual, nullptr, rhs);
EXPECT_FALSE(r.IsValid());
}
TEST_F(BinaryExpressionTest, IsValid_Invalid_LHS) {
auto* lhs = create<IdentifierExpression>("");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
EXPECT_FALSE(r.IsValid());
}
TEST_F(BinaryExpressionTest, IsValid_Null_RHS) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
BinaryExpression r(BinaryOp::kEqual, lhs, nullptr);
EXPECT_FALSE(r.IsValid());
}
TEST_F(BinaryExpressionTest, IsValid_Invalid_RHS) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
EXPECT_FALSE(r.IsValid());
}
TEST_F(BinaryExpressionTest, IsValid_Binary_None) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kNone, lhs, rhs);
EXPECT_FALSE(r.IsValid());
}
TEST_F(BinaryExpressionTest, ToStr) {
auto* lhs = create<IdentifierExpression>("lhs");
auto* rhs = create<IdentifierExpression>("rhs");
auto* lhs = create<IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs = create<IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
std::ostringstream out;
r.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Binary[not set]{
EXPECT_EQ(demangle(out.str()), R"( Binary[not set]{
Identifier[not set]{lhs}
equal
Identifier[not set]{rhs}

16
src/ast/bitcast_expression_test.cc
View File

@ -26,7 +26,7 @@ using BitcastExpressionTest = TestHelper;
TEST_F(BitcastExpressionTest, Create) {
type::F32 f32;
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
BitcastExpression exp(&f32, expr);
ASSERT_EQ(exp.type(), &f32);
@ -35,7 +35,7 @@ TEST_F(BitcastExpressionTest, Create) {
TEST_F(BitcastExpressionTest, CreateWithSource) {
type::F32 f32;
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
BitcastExpression exp(Source{Source::Location{20, 2}}, &f32, expr);
auto src = exp.source();
@ -45,7 +45,7 @@ TEST_F(BitcastExpressionTest, CreateWithSource) {
TEST_F(BitcastExpressionTest, IsBitcast) {
type::F32 f32;
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
BitcastExpression exp(&f32, expr);
EXPECT_TRUE(exp.Is<BitcastExpression>());
@ -53,14 +53,14 @@ TEST_F(BitcastExpressionTest, IsBitcast) {
TEST_F(BitcastExpressionTest, IsValid) {
type::F32 f32;
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
BitcastExpression exp(&f32, expr);
EXPECT_TRUE(exp.IsValid());
}
TEST_F(BitcastExpressionTest, IsValid_MissingType) {
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
BitcastExpression exp(nullptr, expr);
EXPECT_FALSE(exp.IsValid());
@ -75,20 +75,20 @@ TEST_F(BitcastExpressionTest, IsValid_MissingExpr) {
TEST_F(BitcastExpressionTest, IsValid_InvalidExpr) {
type::F32 f32;
auto* expr = create<IdentifierExpression>("");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
BitcastExpression e(&f32, expr);
EXPECT_FALSE(e.IsValid());
}
TEST_F(BitcastExpressionTest, ToStr) {
type::F32 f32;
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
BitcastExpression exp(&f32, expr);
std::ostringstream out;
exp.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Bitcast[not set]<__f32>{
EXPECT_EQ(demangle(out.str()), R"( Bitcast[not set]<__f32>{
Identifier[not set]{expr}
}
)");

4
src/ast/builder.h
View File

@ -206,13 +206,13 @@ class Builder {
/// @param name the identifier name
/// @return an IdentifierExpression with the given name
IdentifierExpression* Expr(const std::string& name) {
return create<IdentifierExpression>(name);
return create<IdentifierExpression>(mod->RegisterSymbol(name), name);
}
/// @param name the identifier name
/// @return an IdentifierExpression with the given name
IdentifierExpression* Expr(const char* name) {
return create<IdentifierExpression>(name);
return create<IdentifierExpression>(mod->RegisterSymbol(name), name);
}
/// @param value the boolean value

45
src/ast/call_expression_test.cc
View File

@ -24,10 +24,12 @@ namespace {
using CallExpressionTest = TestHelper;
TEST_F(CallExpressionTest, Creation) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
ExpressionList params;
params.push_back(create<IdentifierExpression>("param1"));
params.push_back(create<IdentifierExpression>("param2"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param2"), "param2"));
CallExpression stmt(func, params);
EXPECT_EQ(stmt.func(), func);
@ -39,7 +41,7 @@ TEST_F(CallExpressionTest, Creation) {
}
TEST_F(CallExpressionTest, Creation_WithSource) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
CallExpression stmt(Source{Source::Location{20, 2}}, func, {});
auto src = stmt.source();
EXPECT_EQ(src.range.begin.line, 20u);
@ -47,13 +49,13 @@ TEST_F(CallExpressionTest, Creation_WithSource) {
}
TEST_F(CallExpressionTest, IsCall) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
CallExpression stmt(func, {});
EXPECT_TRUE(stmt.Is<CallExpression>());
}
TEST_F(CallExpressionTest, IsValid) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
CallExpression stmt(func, {});
EXPECT_TRUE(stmt.IsValid());
}
@ -64,40 +66,43 @@ TEST_F(CallExpressionTest, IsValid_MissingFunction) {
}
TEST_F(CallExpressionTest, IsValid_NullParam) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
ExpressionList params;
params.push_back(create<IdentifierExpression>("param1"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
params.push_back(nullptr);
params.push_back(create<IdentifierExpression>("param2"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param2"), "param2"));
CallExpression stmt(func, params);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(CallExpressionTest, IsValid_InvalidFunction) {
auto* func = create<IdentifierExpression>("");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
ExpressionList params;
params.push_back(create<IdentifierExpression>("param1"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
CallExpression stmt(func, params);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(CallExpressionTest, IsValid_InvalidParam) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
ExpressionList params;
params.push_back(create<IdentifierExpression>(""));
params.push_back(create<IdentifierExpression>(mod.RegisterSymbol(""), ""));
CallExpression stmt(func, params);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(CallExpressionTest, ToStr_NoParams) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
CallExpression stmt(func, {});
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Call[not set]{
EXPECT_EQ(demangle(out.str()), R"( Call[not set]{
Identifier[not set]{func}
(
)
@ -106,15 +111,17 @@ TEST_F(CallExpressionTest, ToStr_NoParams) {
}
TEST_F(CallExpressionTest, ToStr_WithParams) {
auto* func = create<IdentifierExpression>("func");
auto* func = create<IdentifierExpression>(mod.RegisterSymbol("func"), "func");
ExpressionList params;
params.push_back(create<IdentifierExpression>("param1"));
params.push_back(create<IdentifierExpression>("param2"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param1"), "param1"));
params.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("param2"), "param2"));
CallExpression stmt(func, params);
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Call[not set]{
EXPECT_EQ(demangle(out.str()), R"( Call[not set]{
Identifier[not set]{func}
(
Identifier[not set]{param1}

11
src/ast/call_statement_test.cc
View File

@ -25,7 +25,8 @@ namespace {
using CallStatementTest = TestHelper;
TEST_F(CallStatementTest, Creation) {
auto* expr = create<CallExpression>(create<IdentifierExpression>("func"),
auto* expr = create<CallExpression>(
create<IdentifierExpression>(mod.RegisterSymbol("func"), "func"),
ExpressionList{});
CallStatement c(expr);
@ -38,7 +39,8 @@ TEST_F(CallStatementTest, IsCall) {
}
TEST_F(CallStatementTest, IsValid) {
CallStatement c(create<CallExpression>(create<IdentifierExpression>("func"),
CallStatement c(create<CallExpression>(
create<IdentifierExpression>(mod.RegisterSymbol("func"), "func"),
ExpressionList{}));
EXPECT_TRUE(c.IsValid());
}
@ -55,12 +57,13 @@ TEST_F(CallStatementTest, IsValid_InvalidExpr) {
}
TEST_F(CallStatementTest, ToStr) {
CallStatement c(create<CallExpression>(create<IdentifierExpression>("func"),
CallStatement c(create<CallExpression>(
create<IdentifierExpression>(mod.RegisterSymbol("func"), "func"),
ExpressionList{}));
std::ostringstream out;
c.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Call[not set]{
EXPECT_EQ(demangle(out.str()), R"( Call[not set]{
Identifier[not set]{func}
(
)

14
src/ast/identifier_expression.cc
View File

@ -22,28 +22,30 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::IdentifierExpression);
namespace tint {
namespace ast {
IdentifierExpression::IdentifierExpression(const std::string& name)
: Base(), name_(name) {}
IdentifierExpression::IdentifierExpression(Symbol sym, const std::string& name)
: Base(), sym_(sym), name_(name) {}
IdentifierExpression::IdentifierExpression(const Source& source,
Symbol sym,
const std::string& name)
: Base(source), name_(name) {}
: Base(source), sym_(sym), name_(name) {}
IdentifierExpression::IdentifierExpression(IdentifierExpression&&) = default;
IdentifierExpression::~IdentifierExpression() = default;
IdentifierExpression* IdentifierExpression::Clone(CloneContext* ctx) const {
return ctx->mod->create<IdentifierExpression>(ctx->Clone(source()), name_);
return ctx->mod->create<IdentifierExpression>(ctx->Clone(source()), sym_,
name_);
}
bool IdentifierExpression::IsValid() const {
return !name_.empty();
return sym_.IsValid();
}
void IdentifierExpression::to_str(std::ostream& out, size_t indent) const {
make_indent(out, indent);
out << "Identifier[" << result_type_str() << "]{" << name_ << "}"
out << "Identifier[" << result_type_str() << "]{" << sym_.to_str() << "}"
<< std::endl;
}

12
src/ast/identifier_expression.h
View File

@ -21,6 +21,7 @@
#include "src/ast/expression.h"
#include "src/ast/intrinsic.h"
#include "src/symbol.h"
namespace tint {
namespace ast {
@ -29,16 +30,22 @@ namespace ast {
class IdentifierExpression : public Castable<IdentifierExpression, Expression> {
public:
/// Constructor
/// @param sym the symbol for the identifier
/// @param name the name
explicit IdentifierExpression(const std::string& name);
explicit IdentifierExpression(Symbol sym, const std::string& name);
/// Constructor
/// @param source the source
/// @param sym the symbol for the identifier
/// @param name the name
IdentifierExpression(const Source& source, const std::string& name);
IdentifierExpression(const Source& source,
Symbol sym,
const std::string& name);
/// Move constructor
IdentifierExpression(IdentifierExpression&&);
~IdentifierExpression() override;
/// @returns the symbol for the identifier
Symbol symbol() const { return sym_; }
/// @returns the name part of the identifier
std::string name() const { return name_; }
@ -82,6 +89,7 @@ class IdentifierExpression : public Castable<IdentifierExpression, Expression> {
Intrinsic intrinsic_ = Intrinsic::kNone;
std::unique_ptr<intrinsic::Signature> intrinsic_sig_;
Symbol sym_;
std::string name_;
};

20
src/ast/identifier_expression_test.cc
View File

@ -23,12 +23,15 @@ namespace {
using IdentifierExpressionTest = TestHelper;
TEST_F(IdentifierExpressionTest, Creation) {
IdentifierExpression i("ident");
IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
EXPECT_EQ(i.symbol(), Symbol(1));
EXPECT_EQ(i.name(), "ident");
}
TEST_F(IdentifierExpressionTest, Creation_WithSource) {
IdentifierExpression i(Source{Source::Location{20, 2}}, "ident");
IdentifierExpression i(Source{Source::Location{20, 2}},
mod.RegisterSymbol("ident"), "ident");
EXPECT_EQ(i.symbol(), Symbol(1));
EXPECT_EQ(i.name(), "ident");
auto src = i.source();
@ -37,25 +40,20 @@ TEST_F(IdentifierExpressionTest, Creation_WithSource) {
}
TEST_F(IdentifierExpressionTest, IsIdentifier) {
IdentifierExpression i("ident");
IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
EXPECT_TRUE(i.Is<IdentifierExpression>());
}
TEST_F(IdentifierExpressionTest, IsValid) {
IdentifierExpression i("ident");
IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
EXPECT_TRUE(i.IsValid());
}
TEST_F(IdentifierExpressionTest, IsValid_BlankName) {
IdentifierExpression i("");
EXPECT_FALSE(i.IsValid());
}
TEST_F(IdentifierExpressionTest, ToStr) {
IdentifierExpression i("ident");
IdentifierExpression i(mod.RegisterSymbol("ident"), "ident");
std::ostringstream out;
i.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Identifier[not set]{ident}
EXPECT_EQ(demangle(out.str()), R"( Identifier[not set]{ident}
)");
}

48
src/ast/if_statement_test.cc
View File

@ -25,7 +25,7 @@ namespace {
using IfStatementTest = TestHelper;
TEST_F(IfStatementTest, Creation) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -43,7 +43,7 @@ TEST_F(IfStatementTest, IsIf) {
}
TEST_F(IfStatementTest, IsValid) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -52,14 +52,15 @@ TEST_F(IfStatementTest, IsValid) {
}
TEST_F(IfStatementTest, IsValid_WithElseStatements) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
IfStatement stmt(
Source{}, cond, body,
{
create<ElseStatement>(create<IdentifierExpression>("Ident"),
create<ElseStatement>(create<IdentifierExpression>(
mod.RegisterSymbol("Ident"), "Ident"),
create<BlockStatement>()),
create<ElseStatement>(create<BlockStatement>()),
});
@ -75,7 +76,7 @@ TEST_F(IfStatementTest, IsValid_MissingCondition) {
}
TEST_F(IfStatementTest, IsValid_InvalidCondition) {
auto* cond = create<IdentifierExpression>("");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -84,7 +85,7 @@ TEST_F(IfStatementTest, IsValid_InvalidCondition) {
}
TEST_F(IfStatementTest, IsValid_NullBodyStatement) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
body->append(nullptr);
@ -94,7 +95,7 @@ TEST_F(IfStatementTest, IsValid_NullBodyStatement) {
}
TEST_F(IfStatementTest, IsValid_InvalidBodyStatement) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
body->append(create<IfStatement>(Source{}, nullptr, create<BlockStatement>(),
@ -105,14 +106,15 @@ TEST_F(IfStatementTest, IsValid_InvalidBodyStatement) {
}
TEST_F(IfStatementTest, IsValid_NullElseStatement) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
IfStatement stmt(
Source{}, cond, body,
{
create<ElseStatement>(create<IdentifierExpression>("Ident"),
create<ElseStatement>(create<IdentifierExpression>(
mod.RegisterSymbol("Ident"), "Ident"),
create<BlockStatement>()),
create<ElseStatement>(create<BlockStatement>()),
nullptr,
@ -121,20 +123,21 @@ TEST_F(IfStatementTest, IsValid_NullElseStatement) {
}
TEST_F(IfStatementTest, IsValid_InvalidElseStatement) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
IfStatement stmt(Source{}, cond, body,
{
create<ElseStatement>(create<IdentifierExpression>(""),
create<ElseStatement>(create<IdentifierExpression>(
mod.RegisterSymbol(""), ""),
create<BlockStatement>()),
});
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(IfStatementTest, IsValid_MultipleElseWiththoutCondition) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -147,7 +150,7 @@ TEST_F(IfStatementTest, IsValid_MultipleElseWiththoutCondition) {
}
TEST_F(IfStatementTest, IsValid_ElseNotLast) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -155,14 +158,15 @@ TEST_F(IfStatementTest, IsValid_ElseNotLast) {
Source{}, cond, body,
{
create<ElseStatement>(create<BlockStatement>()),
create<ElseStatement>(create<IdentifierExpression>("ident"),
create<ElseStatement>(create<IdentifierExpression>(
mod.RegisterSymbol("ident"), "ident"),
create<BlockStatement>()),
});
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(IfStatementTest, ToStr) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -170,7 +174,7 @@ TEST_F(IfStatementTest, ToStr) {
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( If{
EXPECT_EQ(demangle(out.str()), R"( If{
(
Identifier[not set]{cond}
)
@ -182,7 +186,7 @@ TEST_F(IfStatementTest, ToStr) {
}
TEST_F(IfStatementTest, ToStr_WithElseStatements) {
auto* cond = create<IdentifierExpression>("cond");
auto* cond = create<IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>());
@ -193,16 +197,18 @@ TEST_F(IfStatementTest, ToStr_WithElseStatements) {
else_body->append(create<DiscardStatement>());
else_body->append(create<DiscardStatement>());
IfStatement stmt(Source{}, cond, body,
IfStatement stmt(
Source{}, cond, body,
{
create<ElseStatement>(
create<IdentifierExpression>("ident"), else_if_body),
create<ElseStatement>(create<IdentifierExpression>(
mod.RegisterSymbol("ident"), "ident"),
else_if_body),
create<ElseStatement>(else_body),
});
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( If{
EXPECT_EQ(demangle(out.str()), R"( If{
(
Identifier[not set]{cond}
)

48
src/ast/member_accessor_expression_test.cc
View File

@ -26,8 +26,10 @@ namespace {
using MemberAccessorExpressionTest = TestHelper;
TEST_F(MemberAccessorExpressionTest, Creation) {
auto* str = create<IdentifierExpression>("structure");
auto* mem = create<IdentifierExpression>("member");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(str, mem);
EXPECT_EQ(stmt.structure(), str);
@ -35,8 +37,10 @@ TEST_F(MemberAccessorExpressionTest, Creation) {
}
TEST_F(MemberAccessorExpressionTest, Creation_WithSource) {
auto* str = create<IdentifierExpression>("structure");
auto* mem = create<IdentifierExpression>("member");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(Source{Source::Location{20, 2}}, str, mem);
auto src = stmt.source();
@ -45,59 +49,69 @@ TEST_F(MemberAccessorExpressionTest, Creation_WithSource) {
}
TEST_F(MemberAccessorExpressionTest, IsMemberAccessor) {
auto* str = create<IdentifierExpression>("structure");
auto* mem = create<IdentifierExpression>("member");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(str, mem);
EXPECT_TRUE(stmt.Is<MemberAccessorExpression>());
}
TEST_F(MemberAccessorExpressionTest, IsValid) {
auto* str = create<IdentifierExpression>("structure");
auto* mem = create<IdentifierExpression>("member");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(str, mem);
EXPECT_TRUE(stmt.IsValid());
}
TEST_F(MemberAccessorExpressionTest, IsValid_NullStruct) {
auto* mem = create<IdentifierExpression>("member");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(nullptr, mem);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(MemberAccessorExpressionTest, IsValid_InvalidStruct) {
auto* str = create<IdentifierExpression>("");
auto* mem = create<IdentifierExpression>("member");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(str, mem);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(MemberAccessorExpressionTest, IsValid_NullMember) {
auto* str = create<IdentifierExpression>("structure");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
MemberAccessorExpression stmt(str, nullptr);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(MemberAccessorExpressionTest, IsValid_InvalidMember) {
auto* str = create<IdentifierExpression>("structure");
auto* mem = create<IdentifierExpression>("");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
auto* mem = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
MemberAccessorExpression stmt(str, mem);
EXPECT_FALSE(stmt.IsValid());
}
TEST_F(MemberAccessorExpressionTest, ToStr) {
auto* str = create<IdentifierExpression>("structure");
auto* mem = create<IdentifierExpression>("member");
auto* str = create<IdentifierExpression>(mod.RegisterSymbol("structure"),
"structure");
auto* mem =
create<IdentifierExpression>(mod.RegisterSymbol("member"), "member");
MemberAccessorExpression stmt(str, mem);
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( MemberAccessor[not set]{
EXPECT_EQ(demangle(out.str()), R"( MemberAccessor[not set]{
Identifier[not set]{structure}
Identifier[not set]{member}
}

6
src/ast/module.cc
View File

@ -38,6 +38,10 @@ Module Module::Clone() {
}
void Module::Clone(CloneContext* ctx) {
// Symbol table must be cloned first so that the resulting module has the
// symbols before we start the tree mutations.
ctx->mod->symbol_table_ = symbol_table_;
for (auto* ty : constructed_types_) {
ctx->mod->constructed_types_.emplace_back(ctx->Clone(ty));
}
@ -47,8 +51,6 @@ void Module::Clone(CloneContext* ctx) {
for (auto* func : functions_) {
ctx->mod->functions_.emplace_back(ctx->Clone(func));
}
ctx->mod->symbol_table_ = symbol_table_;
}
Function* Module::FindFunctionBySymbol(Symbol sym) const {

12
src/ast/return_statement_test.cc
View File

@ -26,7 +26,7 @@ namespace {
using ReturnStatementTest = TestHelper;
TEST_F(ReturnStatementTest, Creation) {
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ReturnStatement r(Source{}, expr);
EXPECT_EQ(r.value(), expr);
@ -50,7 +50,7 @@ TEST_F(ReturnStatementTest, HasValue_WithoutValue) {
}
TEST_F(ReturnStatementTest, HasValue_WithValue) {
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ReturnStatement r(Source{}, expr);
EXPECT_TRUE(r.has_value());
}
@ -61,23 +61,23 @@ TEST_F(ReturnStatementTest, IsValid_WithoutValue) {
}
TEST_F(ReturnStatementTest, IsValid_WithValue) {
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ReturnStatement r(Source{}, expr);
EXPECT_TRUE(r.IsValid());
}
TEST_F(ReturnStatementTest, IsValid_InvalidValue) {
auto* expr = create<IdentifierExpression>("");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
ReturnStatement r(Source{}, expr);
EXPECT_FALSE(r.IsValid());
}
TEST_F(ReturnStatementTest, ToStr_WithValue) {
auto* expr = create<IdentifierExpression>("expr");
auto* expr = create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ReturnStatement r(Source{}, expr);
std::ostringstream out;
r.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Return{
EXPECT_EQ(demangle(out.str()), R"( Return{
{
Identifier[not set]{expr}
}

30
src/ast/switch_statement_test.cc
View File

@ -34,7 +34,8 @@ TEST_F(SwitchStatementTest, Creation) {
CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 1));
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
CaseStatementList body;
auto* case_stmt = create<CaseStatement>(lit, create<BlockStatement>());
body.push_back(case_stmt);
@ -46,7 +47,8 @@ TEST_F(SwitchStatementTest, Creation) {
}
TEST_F(SwitchStatementTest, Creation_WithSource) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
SwitchStatement stmt(Source{Source::Location{20, 2}}, ident,
CaseStatementList());
@ -61,7 +63,8 @@ TEST_F(SwitchStatementTest, IsSwitch) {
CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2));
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
CaseStatementList body;
body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
@ -75,7 +78,8 @@ TEST_F(SwitchStatementTest, IsValid) {
CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2));
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
CaseStatementList body;
body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
@ -102,7 +106,7 @@ TEST_F(SwitchStatementTest, IsValid_Invalid_Condition) {
CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2));
auto* ident = create<IdentifierExpression>("");
auto* ident = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
CaseStatementList body;
body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
@ -116,7 +120,8 @@ TEST_F(SwitchStatementTest, IsValid_Null_BodyStatement) {
CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2));
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
CaseStatementList body;
body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
body.push_back(nullptr);
@ -126,7 +131,8 @@ TEST_F(SwitchStatementTest, IsValid_Null_BodyStatement) {
}
TEST_F(SwitchStatementTest, IsValid_Invalid_BodyStatement) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
auto* case_body = create<BlockStatement>();
case_body->append(nullptr);
@ -139,12 +145,13 @@ TEST_F(SwitchStatementTest, IsValid_Invalid_BodyStatement) {
}
TEST_F(SwitchStatementTest, ToStr_Empty) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
SwitchStatement stmt(ident, {});
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Switch{
EXPECT_EQ(demangle(out.str()), R"( Switch{
Identifier[not set]{ident}
{
}
@ -158,14 +165,15 @@ TEST_F(SwitchStatementTest, ToStr) {
CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2));
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
CaseStatementList body;
body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
SwitchStatement stmt(ident, body);
std::ostringstream out;
stmt.to_str(out, 2);
EXPECT_EQ(out.str(), R"( Switch{
EXPECT_EQ(demangle(out.str()), R"( Switch{
Identifier[not set]{ident}
{
Case 2{

31
src/ast/type_constructor_expression_test.cc
View File

@ -32,7 +32,8 @@ using TypeConstructorExpressionTest = TestHelper;
TEST_F(TypeConstructorExpressionTest, Creation) {
type::F32 f32;
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
TypeConstructorExpression t(&f32, expr);
EXPECT_EQ(t.type(), &f32);
@ -43,7 +44,8 @@ TEST_F(TypeConstructorExpressionTest, Creation) {
TEST_F(TypeConstructorExpressionTest, Creation_WithSource) {
type::F32 f32;
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
TypeConstructorExpression t(Source{Source::Location{20, 2}}, &f32, expr);
auto src = t.source();
@ -54,7 +56,8 @@ TEST_F(TypeConstructorExpressionTest, Creation_WithSource) {
TEST_F(TypeConstructorExpressionTest, IsTypeConstructor) {
type::F32 f32;
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
TypeConstructorExpression t(&f32, expr);
EXPECT_TRUE(t.Is<TypeConstructorExpression>());
@ -63,7 +66,8 @@ TEST_F(TypeConstructorExpressionTest, IsTypeConstructor) {
TEST_F(TypeConstructorExpressionTest, IsValid) {
type::F32 f32;
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
TypeConstructorExpression t(&f32, expr);
EXPECT_TRUE(t.IsValid());
@ -79,7 +83,8 @@ TEST_F(TypeConstructorExpressionTest, IsValid_EmptyValue) {
TEST_F(TypeConstructorExpressionTest, IsValid_NullType) {
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
TypeConstructorExpression t(nullptr, expr);
EXPECT_FALSE(t.IsValid());
@ -88,7 +93,8 @@ TEST_F(TypeConstructorExpressionTest, IsValid_NullType) {
TEST_F(TypeConstructorExpressionTest, IsValid_NullValue) {
type::F32 f32;
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"));
expr.push_back(nullptr);
TypeConstructorExpression t(&f32, expr);
@ -98,7 +104,7 @@ TEST_F(TypeConstructorExpressionTest, IsValid_NullValue) {
TEST_F(TypeConstructorExpressionTest, IsValid_InvalidValue) {
type::F32 f32;
ExpressionList expr;
expr.push_back(create<IdentifierExpression>(""));
expr.push_back(create<IdentifierExpression>(mod.RegisterSymbol(""), ""));
TypeConstructorExpression t(&f32, expr);
EXPECT_FALSE(t.IsValid());
@ -108,14 +114,17 @@ TEST_F(TypeConstructorExpressionTest, ToStr) {
type::F32 f32;
type::Vector vec(&f32, 3);
ExpressionList expr;
expr.push_back(create<IdentifierExpression>("expr_1"));
expr.push_back(create<IdentifierExpression>("expr_2"));
expr.push_back(create<IdentifierExpression>("expr_3"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr_1"), "expr_1"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr_2"), "expr_2"));
expr.push_back(
create<IdentifierExpression>(mod.RegisterSymbol("expr_3"), "expr_3"));
TypeConstructorExpression t(&vec, expr);
std::ostringstream out;
t.to_str(out, 2);
EXPECT_EQ(out.str(), R"( TypeConstructor[not set]{
EXPECT_EQ(demangle(out.str()), R"( TypeConstructor[not set]{
__vec_3__f32
Identifier[not set]{expr_1}
Identifier[not set]{expr_2}

19
src/ast/unary_op_expression_test.cc
View File

@ -26,7 +26,8 @@ namespace {
using UnaryOpExpressionTest = TestHelper;
TEST_F(UnaryOpExpressionTest, Creation) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
UnaryOpExpression u(UnaryOp::kNot, ident);
EXPECT_EQ(u.op(), UnaryOp::kNot);
@ -34,7 +35,8 @@ TEST_F(UnaryOpExpressionTest, Creation) {
}
TEST_F(UnaryOpExpressionTest, Creation_WithSource) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
UnaryOpExpression u(Source{Source::Location{20, 2}}, UnaryOp::kNot, ident);
auto src = u.source();
EXPECT_EQ(src.range.begin.line, 20u);
@ -42,13 +44,15 @@ TEST_F(UnaryOpExpressionTest, Creation_WithSource) {
}
TEST_F(UnaryOpExpressionTest, IsUnaryOp) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
UnaryOpExpression u(UnaryOp::kNot, ident);
EXPECT_TRUE(u.Is<UnaryOpExpression>());
}
TEST_F(UnaryOpExpressionTest, IsValid) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
UnaryOpExpression u(UnaryOp::kNot, ident);
EXPECT_TRUE(u.IsValid());
}
@ -59,17 +63,18 @@ TEST_F(UnaryOpExpressionTest, IsValid_NullExpression) {
}
TEST_F(UnaryOpExpressionTest, IsValid_InvalidExpression) {
auto* ident = create<IdentifierExpression>("");
auto* ident = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
UnaryOpExpression u(UnaryOp::kNot, ident);
EXPECT_FALSE(u.IsValid());
}
TEST_F(UnaryOpExpressionTest, ToStr) {
auto* ident = create<IdentifierExpression>("ident");
auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
UnaryOpExpression u(UnaryOp::kNot, ident);
std::ostringstream out;
u.to_str(out, 2);
EXPECT_EQ(out.str(), R"( UnaryOp[not set]{
EXPECT_EQ(demangle(out.str()), R"( UnaryOp[not set]{
not
Identifier[not set]{ident}
}

11
src/ast/variable_test.cc
View File

@ -84,7 +84,7 @@ TEST_F(VariableTest, IsValid_WithConstructor) {
StorageClass::kNone,
&t,
false,
create<IdentifierExpression>("ident"),
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"),
ast::VariableDecorationList{}};
EXPECT_TRUE(v.IsValid());
}
@ -115,7 +115,7 @@ TEST_F(VariableTest, IsValid_InvalidConstructor) {
StorageClass::kNone,
&t,
false,
create<IdentifierExpression>(""),
create<IdentifierExpression>(mod.RegisterSymbol(""), ""),
ast::VariableDecorationList{}};
EXPECT_FALSE(v.IsValid());
}
@ -162,8 +162,9 @@ TEST_F(VariableTest, ConstantId) {
TEST_F(VariableTest, Decorated_to_str) {
type::F32 t;
auto* var = create<Variable>(Source{}, "my_var", StorageClass::kFunction, &t,
false, create<IdentifierExpression>("expr"),
auto* var = create<Variable>(
Source{}, "my_var", StorageClass::kFunction, &t, false,
create<IdentifierExpression>(mod.RegisterSymbol("expr"), "expr"),
VariableDecorationList{
create<BindingDecoration>(2, Source{}),
create<SetDecoration>(1, Source{}),
@ -171,7 +172,7 @@ TEST_F(VariableTest, Decorated_to_str) {
std::ostringstream out;
var->to_str(out, 2);
EXPECT_EQ(out.str(), R"( Variable{
EXPECT_EQ(demangle(out.str()), R"( Variable{
Decorations{
BindingDecoration{2}
SetDecoration{1}

91
src/inspector/inspector_test.cc
View File

@ -98,7 +98,8 @@ class InspectorHelper {
std::string callee,
ast::FunctionDecorationList decorations = {}) {
auto* body = create<ast::BlockStatement>();
auto* ident_expr = create<ast::IdentifierExpression>(callee);
auto* ident_expr = create<ast::IdentifierExpression>(
mod()->RegisterSymbol(callee), callee);
auto* call_expr =
create<ast::CallExpression>(ident_expr, ast::ExpressionList());
body->append(create<ast::CallStatement>(call_expr));
@ -152,8 +153,8 @@ class InspectorHelper {
std::string in, out;
std::tie(in, out) = inout;
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(out),
create<ast::IdentifierExpression>(in)));
create<ast::IdentifierExpression>(mod()->RegisterSymbol(out), out),
create<ast::IdentifierExpression>(mod()->RegisterSymbol(in), in)));
}
body->append(create<ast::ReturnStatement>(Source{}));
return create<ast::Function>(Source{}, mod()->RegisterSymbol(name), name,
@ -179,10 +180,11 @@ class InspectorHelper {
std::string in, out;
std::tie(in, out) = inout;
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(out),
create<ast::IdentifierExpression>(in)));
create<ast::IdentifierExpression>(mod()->RegisterSymbol(out), out),
create<ast::IdentifierExpression>(mod()->RegisterSymbol(in), in)));
}
auto* ident_expr = create<ast::IdentifierExpression>(callee);
auto* ident_expr = create<ast::IdentifierExpression>(
mod()->RegisterSymbol(callee), callee);
auto* call_expr =
create<ast::CallExpression>(ident_expr, ast::ExpressionList());
body->append(create<ast::CallStatement>(call_expr));
@ -442,10 +444,14 @@ class InspectorHelper {
std::tie(member_idx, member_type) = member;
std::string member_name = StructMemberName(member_idx, member_type);
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("local" + member_name),
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("local" + member_name),
"local" + member_name),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(struct_name),
create<ast::IdentifierExpression>(member_name))));
create<ast::IdentifierExpression>(
mod()->RegisterSymbol(struct_name), struct_name),
create<ast::IdentifierExpression>(
mod()->RegisterSymbol(member_name), member_name))));
}
body->append(create<ast::ReturnStatement>(Source{}));
@ -581,14 +587,21 @@ class InspectorHelper {
body->append(create<ast::VariableDeclStatement>(call_result));
ast::ExpressionList call_params;
call_params.push_back(create<ast::IdentifierExpression>(texture_name));
call_params.push_back(create<ast::IdentifierExpression>(sampler_name));
call_params.push_back(create<ast::IdentifierExpression>(coords_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(texture_name), texture_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(sampler_name), sampler_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(coords_name), coords_name));
auto* call_expr = create<ast::CallExpression>(
create<ast::IdentifierExpression>("textureSample"), call_params);
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("textureSample"), "textureSample"),
call_params);
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("sampler_result"), call_expr));
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("sampler_result"), "sampler_result"),
call_expr));
body->append(create<ast::ReturnStatement>(Source{}));
return create<ast::Function>(Source{}, mod()->RegisterSymbol(func_name),
@ -628,15 +641,23 @@ class InspectorHelper {
body->append(create<ast::VariableDeclStatement>(call_result));
ast::ExpressionList call_params;
call_params.push_back(create<ast::IdentifierExpression>(texture_name));
call_params.push_back(create<ast::IdentifierExpression>(sampler_name));
call_params.push_back(create<ast::IdentifierExpression>(coords_name));
call_params.push_back(create<ast::IdentifierExpression>(array_index));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(texture_name), texture_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(sampler_name), sampler_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(coords_name), coords_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(array_index), array_index));
auto* call_expr = create<ast::CallExpression>(
create<ast::IdentifierExpression>("textureSample"), call_params);
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("textureSample"), "textureSample"),
call_params);
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("sampler_result"), call_expr));
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("sampler_result"), "sampler_result"),
call_expr));
body->append(create<ast::ReturnStatement>(Source{}));
return create<ast::Function>(Source{}, mod()->RegisterSymbol(func_name),
@ -677,15 +698,24 @@ class InspectorHelper {
body->append(create<ast::VariableDeclStatement>(call_result));
ast::ExpressionList call_params;
call_params.push_back(create<ast::IdentifierExpression>(texture_name));
call_params.push_back(create<ast::IdentifierExpression>(sampler_name));
call_params.push_back(create<ast::IdentifierExpression>(coords_name));
call_params.push_back(create<ast::IdentifierExpression>(depth_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(texture_name), texture_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(sampler_name), sampler_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(coords_name), coords_name));
call_params.push_back(create<ast::IdentifierExpression>(
mod()->RegisterSymbol(depth_name), depth_name));
auto* call_expr = create<ast::CallExpression>(
create<ast::IdentifierExpression>("textureSampleCompare"), call_params);
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("textureSampleCompare"),
"textureSampleCompare"),
call_params);
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("sampler_result"), call_expr));
create<ast::IdentifierExpression>(
mod()->RegisterSymbol("sampler_result"), "sampler_result"),
call_expr));
body->append(create<ast::ReturnStatement>(Source{}));
return create<ast::Function>(Source{}, mod()->RegisterSymbol(func_name),
@ -1507,7 +1537,8 @@ TEST_F(InspectorGetUniformBufferResourceBindingsTest, MultipleUniformBuffers) {
AddReferenceFunc("ub_baz_func", "ub_baz");
auto AddFuncCall = [&](ast::BlockStatement* body, const std::string& callee) {
auto* ident_expr = create<ast::IdentifierExpression>(callee);
auto* ident_expr = create<ast::IdentifierExpression>(
mod()->RegisterSymbol(callee), callee);
auto* call_expr =
create<ast::CallExpression>(ident_expr, ast::ExpressionList());
body->append(create<ast::CallStatement>(call_expr));
@ -1654,7 +1685,8 @@ TEST_F(InspectorGetStorageBufferResourceBindingsTest, MultipleStorageBuffers) {
AddReferenceFunc("sb_baz_func", "sb_baz");
auto AddFuncCall = [&](ast::BlockStatement* body, const std::string& callee) {
auto* ident_expr = create<ast::IdentifierExpression>(callee);
auto* ident_expr = create<ast::IdentifierExpression>(
mod()->RegisterSymbol(callee), callee);
auto* call_expr =
create<ast::CallExpression>(ident_expr, ast::ExpressionList());
body->append(create<ast::CallStatement>(call_expr));
@ -1828,7 +1860,8 @@ TEST_F(InspectorGetReadOnlyStorageBufferResourceBindingsTest,
AddReferenceFunc("sb_baz_func", "sb_baz");
auto AddFuncCall = [&](ast::BlockStatement* body, const std::string& callee) {
auto* ident_expr = create<ast::IdentifierExpression>(callee);
auto* ident_expr = create<ast::IdentifierExpression>(
mod()->RegisterSymbol(callee), callee);
auto* call_expr =
create<ast::CallExpression>(ident_expr, ast::ExpressionList());
body->append(create<ast::CallStatement>(call_expr));

99
src/reader/spirv/function.cc
View File

@ -689,7 +689,8 @@ void FunctionEmitter::PushGuard(const std::string& guard_name,
// as the statement block at the top of the stack.
const auto& top = statements_stack_.back();
auto* cond = create<ast::IdentifierExpression>(guard_name);
auto* cond = create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(guard_name), guard_name);
auto* body = create<ast::BlockStatement>();
AddStatement(
create<ast::IfStatement>(Source{}, cond, body, ast::ElseStatementList{}));
@ -1891,9 +1892,11 @@ TypedExpression FunctionEmitter::MakeExpression(uint32_t id) {
return {};
}
if (identifier_values_.count(id) || parser_impl_.IsScalarSpecConstant(id)) {
auto name = namer_.Name(id);
return TypedExpression{
parser_impl_.ConvertType(def_use_mgr_->GetDef(id)->type_id()),
create<ast::IdentifierExpression>(namer_.Name(id))};
create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name),
name)};
}
if (singly_used_values_.count(id)) {
auto expr = std::move(singly_used_values_[id]);
@ -1910,11 +1913,13 @@ TypedExpression FunctionEmitter::MakeExpression(uint32_t id) {
return {};
}
switch (inst->opcode()) {
case SpvOpVariable:
case SpvOpVariable: {
// This occurs for module-scope variables.
return TypedExpression{
parser_impl_.ConvertType(inst->type_id()),
create<ast::IdentifierExpression>(namer_.Name(inst->result_id()))};
auto name = namer_.Name(inst->result_id());
return TypedExpression{parser_impl_.ConvertType(inst->type_id()),
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(name), name)};
}
default:
break;
}
@ -2579,7 +2584,9 @@ ast::Statement* FunctionEmitter::MakeBranchDetailed(
}
// Signal an exit from the branch.
return create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(flow_guard), MakeFalse());
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(flow_guard), flow_guard),
MakeFalse());
}
// For an unconditional branch, the break out to an if-selection
@ -2733,7 +2740,9 @@ bool FunctionEmitter::EmitStatementsInBasicBlock(const BlockInfo& block_info,
const auto var_name = GetDefInfo(assignment.phi_id)->phi_var;
auto expr = MakeExpression(assignment.value);
AddStatement(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(var_name), expr.expr));
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(var_name), var_name),
expr.expr));
}
}
@ -2766,10 +2775,11 @@ bool FunctionEmitter::EmitConstDefOrWriteToHoistedVar(
const auto result_id = inst.result_id();
const auto* def_info = GetDefInfo(result_id);
if (def_info && def_info->requires_hoisted_def) {
auto name = namer_.Name(result_id);
// Emit an assignment of the expression to the hoisted variable.
AddStatementForInstruction(
create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(namer_.Name(result_id)),
AddStatementForInstruction(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(name), name),
ast_expr.expr),
inst);
return true;
@ -2861,9 +2871,10 @@ bool FunctionEmitter::EmitStatement(const spvtools::opt::Instruction& inst) {
}
case SpvOpPhi: {
// Emit a read from the associated state variable.
TypedExpression expr{
parser_impl_.ConvertType(inst.type_id()),
create<ast::IdentifierExpression>(def_info->phi_var)};
TypedExpression expr{parser_impl_.ConvertType(inst.type_id()),
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(def_info->phi_var),
def_info->phi_var)};
return EmitConstDefOrWriteToHoistedVar(inst, expr);
}
case SpvOpFunctionCall:
@ -2916,7 +2927,9 @@ TypedExpression FunctionEmitter::MaybeEmitCombinatorialValue(
ast::ExpressionList params;
params.emplace_back(MakeOperand(inst, 0).expr);
return {ast_type, create<ast::CallExpression>(
create<ast::IdentifierExpression>(unary_builtin_name),
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(unary_builtin_name),
unary_builtin_name),
std::move(params))};
}
@ -3017,7 +3030,8 @@ TypedExpression FunctionEmitter::EmitGlslStd450ExtInst(
return {};
}
auto* func = create<ast::IdentifierExpression>(name);
auto* func =
create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name), name);
ast::ExpressionList operands;
ast::type::Type* first_operand_type = nullptr;
// All parameters to GLSL.std.450 extended instructions are IDs.
@ -3042,17 +3056,21 @@ ast::IdentifierExpression* FunctionEmitter::Swizzle(uint32_t i) {
return nullptr;
}
const char* names[] = {"x", "y", "z", "w"};
return create<ast::IdentifierExpression>(names[i & 3]);
return create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(names[i & 3]), names[i & 3]);
}
ast::IdentifierExpression* FunctionEmitter::PrefixSwizzle(uint32_t n) {
switch (n) {
case 1:
return create<ast::IdentifierExpression>("x");
return create<ast::IdentifierExpression>(ast_module_.RegisterSymbol("x"),
"x");
case 2:
return create<ast::IdentifierExpression>("xy");
return create<ast::IdentifierExpression>(ast_module_.RegisterSymbol("xy"),
"xy");
case 3:
return create<ast::IdentifierExpression>("xyz");
return create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol("xyz"), "xyz");
default:
break;
}
@ -3121,8 +3139,10 @@ TypedExpression FunctionEmitter::MakeAccessChain(
first_index = first_index + 1;
// Replace the gl_PerVertex reference with the gl_Position reference
ptr_ty_id = builtin_position_info.member_pointer_type_id;
current_expr.expr =
create<ast::IdentifierExpression>(namer_.Name(base_id));
auto name = namer_.Name(base_id);
current_expr.expr = create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(name), name);
current_expr.type = parser_impl_.ConvertType(ptr_ty_id);
}
}
@ -3212,8 +3232,10 @@ TypedExpression FunctionEmitter::MakeAccessChain(
<< pointee_type_id << " having " << num_members << " members";
return {};
}
auto name =
namer_.GetMemberName(pointee_type_id, uint32_t(index_const_val));
auto* member_access = create<ast::IdentifierExpression>(
namer_.GetMemberName(pointee_type_id, uint32_t(index_const_val)));
ast_module_.RegisterSymbol(name), name);
next_expr = create<ast::MemberAccessorExpression>(current_expr.expr,
member_access);
@ -3331,8 +3353,9 @@ TypedExpression FunctionEmitter::MakeCompositeExtract(
<< current_type_id << " having " << num_members << " members";
return {};
}
auto name = namer_.GetMemberName(current_type_id, uint32_t(index_val));
auto* member_access = create<ast::IdentifierExpression>(
namer_.GetMemberName(current_type_id, uint32_t(index_val)));
ast_module_.RegisterSymbol(name), name);
next_expr = create<ast::MemberAccessorExpression>(current_expr.expr,
member_access);
@ -3712,8 +3735,9 @@ TypedExpression FunctionEmitter::MakeNumericConversion(
bool FunctionEmitter::EmitFunctionCall(const spvtools::opt::Instruction& inst) {
// We ignore function attributes such as Inline, DontInline, Pure, Const.
auto* function = create<ast::IdentifierExpression>(
namer_.Name(inst.GetSingleWordInOperand(0)));
auto name = namer_.Name(inst.GetSingleWordInOperand(0));
auto* function =
create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name), name);
ast::ExpressionList params;
for (uint32_t iarg = 1; iarg < inst.NumInOperands(); ++iarg) {
@ -3739,7 +3763,9 @@ TypedExpression FunctionEmitter::MakeIntrinsicCall(
const auto intrinsic = GetIntrinsic(inst.opcode());
std::ostringstream ss;
ss << intrinsic;
auto* ident = create<ast::IdentifierExpression>(ss.str());
auto name = ss.str();
auto* ident =
create<ast::IdentifierExpression>(ast_module_.RegisterSymbol(name), name);
ident->set_intrinsic(intrinsic);
ast::ExpressionList params;
@ -3781,8 +3807,10 @@ TypedExpression FunctionEmitter::MakeSimpleSelect(
params.push_back(operand2.expr);
// The condition goes last.
params.push_back(condition.expr);
return {operand1.type, create<ast::CallExpression>(
create<ast::IdentifierExpression>("select"),
return {operand1.type,
create<ast::CallExpression>(
create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol("select"), "select"),
std::move(params))};
}
return {};
@ -3813,8 +3841,9 @@ bool FunctionEmitter::EmitImageAccess(const spvtools::opt::Instruction& inst) {
return Fail() << "internal error: couldn't find image for "
<< inst.PrettyPrint();
}
params.push_back(
create<ast::IdentifierExpression>(namer_.Name(image->result_id())));
auto name = namer_.Name(image->result_id());
params.push_back(create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(name), name));
if (IsSampledImageAccess(inst.opcode())) {
// Form the sampler operand.
@ -3824,8 +3853,9 @@ bool FunctionEmitter::EmitImageAccess(const spvtools::opt::Instruction& inst) {
return Fail() << "internal error: couldn't find sampler for "
<< inst.PrettyPrint();
}
params.push_back(
create<ast::IdentifierExpression>(namer_.Name(sampler->result_id())));
auto param_name = namer_.Name(sampler->result_id());
params.push_back(create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(param_name), param_name));
}
ast::type::Pointer* texture_ptr_type =
@ -3964,7 +3994,8 @@ bool FunctionEmitter::EmitImageAccess(const spvtools::opt::Instruction& inst) {
<< "): " << inst.PrettyPrint();
}
auto* ident = create<ast::IdentifierExpression>(builtin_name);
auto* ident = create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(builtin_name), builtin_name);
auto* call_expr = create<ast::CallExpression>(ident, std::move(params));
if (inst.type_id() != 0) {

90
src/reader/spirv/function_arithmetic_test.cc
View File

@ -135,7 +135,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Int_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -147,7 +147,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Int_Int) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_Int_Uint) {
@ -162,7 +162,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Int_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -176,7 +176,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Int_Uint) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_Uint_Int) {
@ -191,7 +191,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Uint_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -205,7 +205,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Uint_Int) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_Uint_Uint) {
@ -220,7 +220,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Uint_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -236,7 +236,7 @@ TEST_F(SpvUnaryArithTest, SNegate_Uint_Uint) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_SignedVec_SignedVec) {
@ -251,7 +251,7 @@ TEST_F(SpvUnaryArithTest, SNegate_SignedVec_SignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -267,7 +267,7 @@ TEST_F(SpvUnaryArithTest, SNegate_SignedVec_SignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_SignedVec_UnsignedVec) {
@ -282,7 +282,7 @@ TEST_F(SpvUnaryArithTest, SNegate_SignedVec_UnsignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -300,7 +300,7 @@ TEST_F(SpvUnaryArithTest, SNegate_SignedVec_UnsignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_SignedVec) {
@ -315,7 +315,7 @@ TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_SignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -333,7 +333,7 @@ TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_SignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_UnsignedVec) {
@ -348,7 +348,7 @@ TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_UnsignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -368,7 +368,7 @@ TEST_F(SpvUnaryArithTest, SNegate_UnsignedVec_UnsignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, FNegate_Scalar) {
@ -383,7 +383,7 @@ TEST_F(SpvUnaryArithTest, FNegate_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -395,7 +395,7 @@ TEST_F(SpvUnaryArithTest, FNegate_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryArithTest, FNegate_Vector) {
@ -410,7 +410,7 @@ TEST_F(SpvUnaryArithTest, FNegate_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -426,7 +426,7 @@ TEST_F(SpvUnaryArithTest, FNegate_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
struct BinaryData {
@ -474,7 +474,8 @@ TEST_P(SpvBinaryArithTest, EmitExpression) {
<< GetParam().ast_type << "\n {\n Binary[not set]{"
<< "\n " << GetParam().ast_lhs << "\n " << GetParam().ast_op
<< "\n " << GetParam().ast_rhs;
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(ss.str())) << assembly;
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(ss.str()))
<< assembly;
}
INSTANTIATE_TEST_SUITE_P(
@ -696,7 +697,7 @@ TEST_F(SpvBinaryArithTestBasic, SDiv_Scalar_UnsignedResult) {
<< assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -731,7 +732,7 @@ TEST_F(SpvBinaryArithTestBasic, SDiv_Vector_UnsignedResult) {
<< assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -754,7 +755,7 @@ TEST_F(SpvBinaryArithTestBasic, SDiv_Vector_UnsignedResult) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
INSTANTIATE_TEST_SUITE_P(
@ -842,7 +843,7 @@ TEST_F(SpvBinaryArithTestBasic, SMod_Scalar_UnsignedResult) {
<< assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -877,7 +878,7 @@ TEST_F(SpvBinaryArithTestBasic, SMod_Vector_UnsignedResult) {
<< assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -900,7 +901,7 @@ TEST_F(SpvBinaryArithTestBasic, SMod_Vector_UnsignedResult) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
INSTANTIATE_TEST_SUITE_P(
@ -930,7 +931,8 @@ TEST_F(SpvBinaryArithTestBasic, VectorTimesScalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__vec_2__f32
@ -942,7 +944,7 @@ TEST_F(SpvBinaryArithTestBasic, VectorTimesScalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvBinaryArithTestBasic, MatrixTimesScalar) {
@ -959,7 +961,8 @@ TEST_F(SpvBinaryArithTestBasic, MatrixTimesScalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__mat_2_2__f32
@ -971,7 +974,7 @@ TEST_F(SpvBinaryArithTestBasic, MatrixTimesScalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvBinaryArithTestBasic, VectorTimesMatrix) {
@ -988,7 +991,8 @@ TEST_F(SpvBinaryArithTestBasic, VectorTimesMatrix) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__mat_2_2__f32
@ -1000,7 +1004,7 @@ TEST_F(SpvBinaryArithTestBasic, VectorTimesMatrix) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvBinaryArithTestBasic, MatrixTimesVector) {
@ -1017,7 +1021,8 @@ TEST_F(SpvBinaryArithTestBasic, MatrixTimesVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__mat_2_2__f32
@ -1029,7 +1034,7 @@ TEST_F(SpvBinaryArithTestBasic, MatrixTimesVector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvBinaryArithTestBasic, MatrixTimesMatrix) {
@ -1046,7 +1051,8 @@ TEST_F(SpvBinaryArithTestBasic, MatrixTimesMatrix) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__mat_2_2__f32
@ -1058,7 +1064,7 @@ TEST_F(SpvBinaryArithTestBasic, MatrixTimesMatrix) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvBinaryArithTestBasic, Dot) {
@ -1075,7 +1081,8 @@ TEST_F(SpvBinaryArithTestBasic, Dot) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_3
none
__f32
@ -1089,7 +1096,7 @@ TEST_F(SpvBinaryArithTestBasic, Dot) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvBinaryArithTestBasic, OuterProduct) {
@ -1106,7 +1113,8 @@ TEST_F(SpvBinaryArithTestBasic, OuterProduct) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_3
none
__mat_2_2__f32
@ -1120,7 +1128,7 @@ TEST_F(SpvBinaryArithTestBasic, OuterProduct) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
// TODO(dneto): OpSRem. Missing from WGSL

67
src/reader/spirv/function_bit_test.cc
View File

@ -163,7 +163,8 @@ TEST_P(SpvBinaryBitTest, EmitExpression) {
<< GetParam().ast_type << "\n {\n Binary[not set]{"
<< "\n " << GetParam().ast_lhs << "\n " << GetParam().ast_op
<< "\n " << GetParam().ast_rhs;
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(ss.str())) << assembly;
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(ss.str()))
<< assembly;
}
INSTANTIATE_TEST_SUITE_P(
@ -400,7 +401,7 @@ TEST_F(SpvUnaryBitTest, Not_Int_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -412,7 +413,7 @@ TEST_F(SpvUnaryBitTest, Not_Int_Int) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_Int_Uint) {
@ -427,7 +428,7 @@ TEST_F(SpvUnaryBitTest, Not_Int_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -441,7 +442,7 @@ TEST_F(SpvUnaryBitTest, Not_Int_Uint) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_Uint_Int) {
@ -456,7 +457,7 @@ TEST_F(SpvUnaryBitTest, Not_Uint_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -470,7 +471,7 @@ TEST_F(SpvUnaryBitTest, Not_Uint_Int) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_Uint_Uint) {
@ -485,7 +486,7 @@ TEST_F(SpvUnaryBitTest, Not_Uint_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -497,7 +498,7 @@ TEST_F(SpvUnaryBitTest, Not_Uint_Uint) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_SignedVec_SignedVec) {
@ -512,7 +513,7 @@ TEST_F(SpvUnaryBitTest, Not_SignedVec_SignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -528,7 +529,7 @@ TEST_F(SpvUnaryBitTest, Not_SignedVec_SignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_SignedVec_UnsignedVec) {
@ -543,7 +544,7 @@ TEST_F(SpvUnaryBitTest, Not_SignedVec_UnsignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -561,7 +562,7 @@ TEST_F(SpvUnaryBitTest, Not_SignedVec_UnsignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_UnsignedVec_SignedVec) {
@ -576,7 +577,7 @@ TEST_F(SpvUnaryBitTest, Not_UnsignedVec_SignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -594,7 +595,7 @@ TEST_F(SpvUnaryBitTest, Not_UnsignedVec_SignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryBitTest, Not_UnsignedVec_UnsignedVec) {
const auto assembly = CommonTypes() + R"(
@ -608,7 +609,7 @@ TEST_F(SpvUnaryBitTest, Not_UnsignedVec_UnsignedVec) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -624,7 +625,7 @@ TEST_F(SpvUnaryBitTest, Not_UnsignedVec_UnsignedVec) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
std::string BitTestPreamble() {
@ -663,7 +664,7 @@ TEST_F(SpvUnaryBitTest, BitCount_Uint_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -691,7 +692,7 @@ TEST_F(SpvUnaryBitTest, BitCount_Uint_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -721,7 +722,7 @@ TEST_F(SpvUnaryBitTest, BitCount_Int_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -751,7 +752,7 @@ TEST_F(SpvUnaryBitTest, BitCount_Int_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -779,7 +780,7 @@ TEST_F(SpvUnaryBitTest, BitCount_UintVector_UintVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -807,7 +808,7 @@ TEST_F(SpvUnaryBitTest, BitCount_UintVector_IntVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -837,7 +838,7 @@ TEST_F(SpvUnaryBitTest, BitCount_IntVector_UintVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -867,7 +868,7 @@ TEST_F(SpvUnaryBitTest, BitCount_IntVector_IntVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -895,7 +896,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_Uint_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -923,7 +924,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_Uint_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -953,7 +954,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_Int_Uint) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -983,7 +984,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_Int_Int) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1011,7 +1012,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_UintVector_UintVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1039,7 +1040,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_UintVector_IntVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1069,7 +1070,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_IntVector_UintVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1099,7 +1100,7 @@ TEST_F(SpvUnaryBitTest, BitReverse_IntVector_IntVector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
const auto body = ToString(fe.ast_body());
const auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1

35
src/reader/spirv/function_call_test.cc
View File

@ -48,18 +48,16 @@ TEST_F(SpvParserTest, EmitStatement_VoidCallNoParams) {
ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error();
const auto module_ast_str = p->get_module().to_str();
EXPECT_THAT(module_ast_str, Eq(R"(Module{
Function )" + p->get_module().GetSymbol("x_50").to_str() +
R"( -> __void
Function tint_symbol_1 -> __void
()
{
Return{}
}
Function )" + p->get_module().GetSymbol("x_100").to_str() +
R"( -> __void
Function tint_symbol_2 -> __void
()
{
Call[not set]{
Identifier[not set]{x_50}
Identifier[not set]{tint_symbol_1}
(
)
}
@ -92,7 +90,8 @@ TEST_F(SpvParserTest, EmitStatement_ScalarCallNoParams) {
{
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -107,17 +106,17 @@ TEST_F(SpvParserTest, EmitStatement_ScalarCallNoParams) {
}
}
Return{})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
{
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 50));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Return{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Return{
{
ScalarConstructor[not set]{42}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
}
@ -148,7 +147,8 @@ TEST_F(SpvParserTest, EmitStatement_ScalarCallNoParamsUsedTwice) {
{
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_10
function
@ -178,16 +178,16 @@ Assignment{
Identifier[not set]{x_1}
}
Return{})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
{
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 50));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Return{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Return{
{
ScalarConstructor[not set]{42}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
}
@ -218,8 +218,7 @@ TEST_F(SpvParserTest, EmitStatement_CallWithParams) {
EXPECT_TRUE(p->error().empty());
const auto module_ast_str = p->get_module().to_str();
EXPECT_THAT(module_ast_str, HasSubstr(R"(Module{
Function )" + p->get_module().GetSymbol("x_50").to_str() +
R"( -> __u32
Function tint_symbol_3 -> __u32
(
VariableConst{
x_51
@ -236,9 +235,9 @@ TEST_F(SpvParserTest, EmitStatement_CallWithParams) {
Return{
{
Binary[not set]{
Identifier[not set]{x_51}
Identifier[not set]{tint_symbol_1}
add
Identifier[not set]{x_52}
Identifier[not set]{tint_symbol_2}
}
}
}
@ -254,7 +253,7 @@ TEST_F(SpvParserTest, EmitStatement_CallWithParams) {
__u32
{
Call[not set]{
Identifier[not set]{x_50}
Identifier[not set]{tint_symbol_3}
(
ScalarConstructor[not set]{42}
ScalarConstructor[not set]{84}

194
src/reader/spirv/function_cfg_test.cc
View File

@ -7361,7 +7361,7 @@ TEST_F(SpvParserTest, EmitBody_IfBreak_FromThen_ForwardWithinThen) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -7473,7 +7473,7 @@ TEST_F(SpvParserTest, EmitBody_IfBreak_FromElse_ForwardWithinElse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -7600,7 +7600,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error() << assembly;
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -7791,7 +7791,7 @@ TEST_F(SpvParserTest, EmitBody_If_Empty) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -7827,7 +7827,7 @@ TEST_F(SpvParserTest, EmitBody_If_Then_NoElse) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -7875,7 +7875,7 @@ TEST_F(SpvParserTest, EmitBody_If_NoThen_Else) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -7931,7 +7931,7 @@ TEST_F(SpvParserTest, EmitBody_If_Then_Else) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -7998,7 +7998,7 @@ TEST_F(SpvParserTest, EmitBody_If_Then_Else_Premerge) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8070,7 +8070,7 @@ TEST_F(SpvParserTest, EmitBody_If_Then_Premerge) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8134,7 +8134,7 @@ TEST_F(SpvParserTest, EmitBody_If_Else_Premerge) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8219,7 +8219,7 @@ TEST_F(SpvParserTest, EmitBody_If_Nest_If) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8309,7 +8309,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_TrueBackedge) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8364,7 +8364,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_FalseBackedge) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8415,7 +8415,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_BothBackedge) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8458,7 +8458,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_UnconditionalBackege) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8509,7 +8509,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_Unconditional_Body_SingleBlockContinue) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8574,7 +8574,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_Unconditional_Body_MultiBlockContinue) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8648,7 +8648,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_Unconditional_Body_ContinueNestIf) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8720,7 +8720,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_MultiBlockContinueIsEntireLoop) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -8778,7 +8778,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_Never) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -8838,7 +8838,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_TrueToBody_FalseBreaks) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -8905,7 +8905,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_FalseToBody_TrueBreaks) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -8979,7 +8979,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_NestedIfContinue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
If{
(
@ -9037,7 +9037,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_BodyAlwaysBreaks) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -9086,7 +9086,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_BodyConditionallyBreaks_FromTrue) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -9142,7 +9142,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_BodyConditionallyBreaks_FromFalse) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -9204,7 +9204,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_BodyConditionallyBreaks_FromTrue_Early) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -9266,7 +9266,7 @@ TEST_F(SpvParserTest, EmitBody_Loop_BodyConditionallyBreaks_FromFalse_Early) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -9319,7 +9319,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_DefaultIsMerge_NoCases) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9364,7 +9364,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_DefaultIsMerge_OneCase) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9418,7 +9418,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_DefaultIsMerge_TwoCases) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9478,7 +9478,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_DefaultIsMerge_CasesWithDup) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9544,7 +9544,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_DefaultIsCase_NoDupCases) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9615,7 +9615,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_DefaultIsCase_WithDupCase) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9687,7 +9687,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_Case_SintValue) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9757,7 +9757,7 @@ TEST_F(SpvParserTest, EmitBody_Switch_Case_UintValue) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -9809,7 +9809,7 @@ TEST_F(SpvParserTest, EmitBody_Return_TopLevel) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Return{}
)";
ASSERT_EQ(expect, got);
@ -9835,7 +9835,7 @@ TEST_F(SpvParserTest, EmitBody_Return_InsideIf) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -9875,7 +9875,7 @@ TEST_F(SpvParserTest, EmitBody_Return_InsideLoop) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Return{}
}
@ -9905,7 +9905,7 @@ TEST_F(SpvParserTest, EmitBody_ReturnValue_TopLevel) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Return{
{
ScalarConstructor[not set]{2}
@ -9944,7 +9944,7 @@ TEST_F(SpvParserTest, EmitBody_ReturnValue_InsideIf) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -10001,7 +10001,7 @@ TEST_F(SpvParserTest, EmitBody_ReturnValue_Loop) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Return{
{
@ -10031,7 +10031,7 @@ TEST_F(SpvParserTest, EmitBody_Kill_TopLevel) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Discard{}
)";
ASSERT_EQ(expect, got);
@ -10057,7 +10057,7 @@ TEST_F(SpvParserTest, EmitBody_Kill_InsideIf) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -10097,7 +10097,7 @@ TEST_F(SpvParserTest, EmitBody_Kill_InsideLoop) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Discard{}
}
@ -10119,7 +10119,7 @@ TEST_F(SpvParserTest, EmitBody_Unreachable_TopLevel) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Return{}
)";
ASSERT_EQ(expect, got);
@ -10145,7 +10145,7 @@ TEST_F(SpvParserTest, EmitBody_Unreachable_InsideIf) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -10185,7 +10185,7 @@ TEST_F(SpvParserTest, EmitBody_Unreachable_InsideLoop) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Return{}
}
@ -10215,7 +10215,7 @@ TEST_F(SpvParserTest, EmitBody_Unreachable_InNonVoidFunction) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 200));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Return{
{
ScalarConstructor[not set]{0}
@ -10249,7 +10249,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_BackEdge_MultiBlockLoop) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
continuing {
Assignment{
@ -10284,7 +10284,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_BackEdge_SingleBlockLoop) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -10321,7 +10321,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_SwitchBreak_LastInCase) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -10381,7 +10381,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_SwitchBreak_NotLastInCase) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -10452,7 +10452,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_LoopBreak_MultiBlockLoop_FromBody) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -10534,7 +10534,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
continuing {
Assignment{
@ -10576,7 +10576,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_LoopContinue_LastInLoopConstruct) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
Assignment{
Identifier[not set]{var_1}
@ -10630,7 +10630,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_LoopContinue_BeforeLast) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Loop{
If{
(
@ -10699,7 +10699,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_LoopContinue_FromSwitch) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -10769,7 +10769,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_IfBreak_FromThen) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -10812,7 +10812,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_IfBreak_FromElse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(If{
(
ScalarConstructor[not set]{false}
@ -10864,7 +10864,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_Fallthrough) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -10915,7 +10915,7 @@ TEST_F(SpvParserTest, EmitBody_Branch_Forward) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11019,7 +11019,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Back_SingleBlock_Back) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -11062,7 +11062,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -11113,7 +11113,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -11171,7 +11171,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -11227,7 +11227,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -11287,7 +11287,7 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11348,7 +11348,7 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11431,7 +11431,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_SwitchBreak_Continue_OnTrue) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11526,7 +11526,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_SwitchBreak_Continue_OnFalse) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11611,7 +11611,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_SwitchBreak_Forward_OnTrue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11680,7 +11680,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_SwitchBreak_Forward_OnFalse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11747,7 +11747,7 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11821,7 +11821,7 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -11890,7 +11890,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -11948,7 +11948,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12021,7 +12021,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_LoopBreak_Continue_OnTrue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12117,7 +12117,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_LoopBreak_Continue_OnFalse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12256,7 +12256,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_LoopBreak_Forward_OnTrue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12337,7 +12337,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_LoopBreak_Forward_OnFalse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12405,7 +12405,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_Continue_FromHeader) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12462,7 +12462,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12534,7 +12534,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12622,7 +12622,7 @@ TEST_F(
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12701,7 +12701,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_LoopContinue_FromSwitch) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -12789,7 +12789,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_IfBreak_OnTrue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12886,7 +12886,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_IfBreak_OnFalse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -12982,7 +12982,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_Fallthrough_OnTrue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -13091,7 +13091,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_Fallthrough_OnFalse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -13188,7 +13188,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_Forward_OnTrue) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -13269,7 +13269,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Continue_Forward_OnFalse) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -13333,7 +13333,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_IfBreak_IfBreak_Same) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{0}
@ -13418,7 +13418,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Fallthrough_Fallthrough_Same) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -13509,7 +13509,7 @@ TEST_F(SpvParserTest, EmitBody_BranchConditional_Forward_Forward_Same) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = R"(Assignment{
Identifier[not set]{var_1}
ScalarConstructor[not set]{1}
@ -13578,7 +13578,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = "unhandled case";
ASSERT_EQ(expect, got);
}
@ -13613,7 +13613,7 @@ TEST_F(SpvParserTest,
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto got = ToString(fe.ast_body());
auto got = ToString(p->get_module(), fe.ast_body());
auto* expect = "unhandled case";
ASSERT_EQ(expect, got);
}

74
src/reader/spirv/function_composite_test.cc
View File

@ -86,7 +86,8 @@ TEST_F(SpvParserTest_Composite_Construct, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -127,7 +128,7 @@ VariableDeclStatement{
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_Composite_Construct, Matrix) {
@ -142,7 +143,7 @@ TEST_F(SpvParserTest_Composite_Construct, Matrix) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -168,7 +169,7 @@ TEST_F(SpvParserTest_Composite_Construct, Matrix) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_Composite_Construct, Array) {
@ -183,7 +184,7 @@ TEST_F(SpvParserTest_Composite_Construct, Array) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -199,7 +200,7 @@ TEST_F(SpvParserTest_Composite_Construct, Array) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_Composite_Construct, Struct) {
@ -214,7 +215,7 @@ TEST_F(SpvParserTest_Composite_Construct, Struct) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -232,7 +233,7 @@ TEST_F(SpvParserTest_Composite_Construct, Struct) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
using SpvParserTest_CompositeExtract = SpvParserTest;
@ -249,7 +250,7 @@ TEST_F(SpvParserTest_CompositeExtract, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -265,7 +266,7 @@ TEST_F(SpvParserTest_CompositeExtract, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CompositeExtract, Vector_IndexTooBigError) {
@ -300,7 +301,7 @@ TEST_F(SpvParserTest_CompositeExtract, Matrix) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -312,7 +313,7 @@ TEST_F(SpvParserTest_CompositeExtract, Matrix) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CompositeExtract, Matrix_IndexTooBigError) {
@ -351,7 +352,7 @@ TEST_F(SpvParserTest_CompositeExtract, Matrix_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -366,7 +367,7 @@ TEST_F(SpvParserTest_CompositeExtract, Matrix_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CompositeExtract, Array) {
@ -385,7 +386,7 @@ TEST_F(SpvParserTest_CompositeExtract, Array) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -397,7 +398,7 @@ TEST_F(SpvParserTest_CompositeExtract, Array) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CompositeExtract, RuntimeArray_IsError) {
@ -436,7 +437,7 @@ TEST_F(SpvParserTest_CompositeExtract, Struct) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -448,7 +449,7 @@ TEST_F(SpvParserTest_CompositeExtract, Struct) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CompositeExtract, Struct_DifferOnlyInMemberName) {
@ -478,7 +479,7 @@ TEST_F(SpvParserTest_CompositeExtract, Struct_DifferOnlyInMemberName) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -490,8 +491,8 @@ TEST_F(SpvParserTest_CompositeExtract, Struct_DifferOnlyInMemberName) {
}
}
})"))
<< ToString(fe.ast_body());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
<< ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_4
none
@ -503,7 +504,7 @@ TEST_F(SpvParserTest_CompositeExtract, Struct_DifferOnlyInMemberName) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CompositeExtract, Struct_IndexTooBigError) {
@ -544,7 +545,7 @@ TEST_F(SpvParserTest_CompositeExtract, Struct_Array_Matrix_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -565,7 +566,7 @@ TEST_F(SpvParserTest_CompositeExtract, Struct_Array_Matrix_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
using SpvParserTest_CopyObject = SpvParserTest;
@ -583,7 +584,8 @@ TEST_F(SpvParserTest_CopyObject, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -602,7 +604,7 @@ VariableDeclStatement{
Identifier[not set]{x_1}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_CopyObject, Pointer) {
@ -621,7 +623,8 @@ TEST_F(SpvParserTest_CopyObject, Pointer) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -640,7 +643,7 @@ VariableDeclStatement{
Identifier[not set]{x_1}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
using SpvParserTest_VectorShuffle = SpvParserTest;
@ -661,7 +664,8 @@ TEST_F(SpvParserTest_VectorShuffle, FunctionScopeOperands_UseBoth) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__vec_4__u32
@ -687,7 +691,7 @@ TEST_F(SpvParserTest_VectorShuffle, FunctionScopeOperands_UseBoth) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_UseBoth) {
@ -703,7 +707,8 @@ TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_UseBoth) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__vec_4__u32
@ -745,7 +750,7 @@ TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_UseBoth) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_AllOnesMapToNull) {
@ -762,7 +767,8 @@ TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_AllOnesMapToNull) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_10
none
__vec_2__u32
@ -777,7 +783,7 @@ TEST_F(SpvParserTest_VectorShuffle, ConstantOperands_AllOnesMapToNull) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest_VectorShuffle, IndexTooBig_IsError) {

88
src/reader/spirv/function_conversion_test.cc
View File

@ -82,7 +82,7 @@ TEST_F(SpvUnaryConversionTest, Bitcast_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -93,7 +93,7 @@ TEST_F(SpvUnaryConversionTest, Bitcast_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, Bitcast_Vector) {
@ -108,7 +108,7 @@ TEST_F(SpvUnaryConversionTest, Bitcast_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -123,7 +123,7 @@ TEST_F(SpvUnaryConversionTest, Bitcast_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertSToF_BadArg) {
@ -238,7 +238,8 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Scalar_FromSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__f32
@ -249,7 +250,7 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Scalar_FromSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertSToF_Scalar_FromUnsigned) {
@ -265,7 +266,8 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Scalar_FromUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__f32
@ -278,7 +280,7 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Scalar_FromUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromSigned) {
@ -294,7 +296,8 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__f32
@ -305,7 +308,7 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromUnsigned) {
@ -321,7 +324,8 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__f32
@ -334,7 +338,7 @@ TEST_F(SpvUnaryConversionTest, ConvertSToF_Vector_FromUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_BadArgType) {
@ -383,7 +387,8 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_FromSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__f32
@ -396,7 +401,7 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_FromSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_FromUnsigned) {
@ -412,7 +417,8 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_FromUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__f32
@ -423,7 +429,7 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Scalar_FromUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromSigned) {
@ -439,7 +445,8 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__f32
@ -452,7 +459,7 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromUnsigned) {
@ -468,7 +475,8 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__f32
@ -479,7 +487,7 @@ TEST_F(SpvUnaryConversionTest, ConvertUToF_Vector_FromUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_BadArgType) {
@ -529,7 +537,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_ToSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__i32
@ -540,7 +549,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_ToSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_ToUnsigned) {
@ -556,7 +565,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_ToUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__u32
@ -569,7 +579,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Scalar_ToUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToSigned) {
@ -585,7 +595,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__i32
@ -596,7 +607,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToUnsigned) {
@ -612,7 +623,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__u32
@ -625,7 +637,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToS_Vector_ToUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_BadArgType) {
@ -675,7 +687,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_ToSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__i32
@ -688,7 +701,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_ToSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_ToUnsigned) {
@ -704,7 +717,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_ToUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__u32
@ -715,7 +729,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Scalar_ToUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToSigned) {
@ -731,7 +745,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToSigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__i32
@ -744,7 +759,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToSigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToUnsigned) {
@ -760,7 +775,8 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToUnsigned) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableConst{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableConst{
x_1
none
__vec_2__u32
@ -771,7 +787,7 @@ TEST_F(SpvUnaryConversionTest, ConvertFToU_Vector_ToUnsigned) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
// TODO(dneto): OpSConvert // only if multiple widths

114
src/reader/spirv/function_glsl_std_450_test.cc
View File

@ -183,7 +183,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_Floating, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -198,7 +198,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_Floating, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Float_Floating, Vector) {
@ -212,7 +212,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_Floating, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -227,7 +227,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_Floating, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Scalar) {
@ -241,7 +241,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -257,7 +257,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Vector) {
@ -271,7 +271,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -287,7 +287,7 @@ TEST_P(SpvParserTest_GlslStd450_Float_FloatingFloating, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Scalar) {
@ -301,7 +301,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -316,7 +316,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Vector) {
@ -330,7 +330,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -345,7 +345,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_Floating, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Scalar) {
@ -359,7 +359,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -375,7 +375,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Vector) {
@ -389,7 +389,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -405,7 +405,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloating, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Scalar) {
@ -419,7 +419,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -436,7 +436,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Vector) {
@ -451,7 +451,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -468,7 +468,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Scalar) {
@ -482,7 +482,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -498,7 +498,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Vector) {
@ -513,7 +513,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -529,7 +529,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingUinting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Scalar) {
@ -543,7 +543,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -559,7 +559,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Vector) {
@ -574,7 +574,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -590,7 +590,7 @@ TEST_P(SpvParserTest_GlslStd450_Floating_FloatingInting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Float3_Float3Float3, Samples) {
@ -605,7 +605,7 @@ TEST_P(SpvParserTest_GlslStd450_Float3_Float3Float3, Samples) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -621,7 +621,7 @@ TEST_P(SpvParserTest_GlslStd450_Float3_Float3Float3, Samples) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
INSTANTIATE_TEST_SUITE_P(Samples,
@ -709,7 +709,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_Inting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -724,7 +724,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_Inting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Inting_Inting, Vector) {
@ -739,7 +739,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_Inting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -754,7 +754,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_Inting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Scalar) {
@ -769,7 +769,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -785,7 +785,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Vector) {
@ -800,7 +800,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -816,7 +816,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingInting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Scalar) {
@ -831,7 +831,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -848,7 +848,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Vector) {
@ -863,7 +863,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -880,7 +880,7 @@ TEST_P(SpvParserTest_GlslStd450_Inting_IntingIntingInting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
INSTANTIATE_TEST_SUITE_P(Samples,
@ -907,7 +907,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -923,7 +923,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Vector) {
@ -938,7 +938,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -954,7 +954,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUinting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Scalar) {
@ -968,7 +968,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -985,7 +985,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Vector) {
@ -1000,7 +1000,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -1017,7 +1017,7 @@ TEST_P(SpvParserTest_GlslStd450_Uinting_UintingUintingUinting, Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
INSTANTIATE_TEST_SUITE_P(Samples,
@ -1043,7 +1043,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_SAbs) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1095,7 +1095,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_SMax) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1153,7 +1153,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_SMin) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1211,7 +1211,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_SClamp) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1271,7 +1271,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_UMax) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1329,7 +1329,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_UMin) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1
@ -1387,7 +1387,7 @@ TEST_F(SpvParserTest, RectifyOperandsAndResult_UClamp) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto body = ToString(fe.ast_body());
auto body = ToString(p->get_module(), fe.ast_body());
EXPECT_THAT(body, HasSubstr(R"(
VariableConst{
x_1

114
src/reader/spirv/function_logical_test.cc
View File

@ -206,7 +206,7 @@ TEST_F(SpvUnaryLogicalTest, LogicalNot_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -218,7 +218,7 @@ TEST_F(SpvUnaryLogicalTest, LogicalNot_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvUnaryLogicalTest, LogicalNot_Vector) {
@ -233,7 +233,7 @@ TEST_F(SpvUnaryLogicalTest, LogicalNot_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -249,7 +249,7 @@ TEST_F(SpvUnaryLogicalTest, LogicalNot_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
struct BinaryData {
@ -296,7 +296,8 @@ TEST_P(SpvBinaryLogicalTest, EmitExpression) {
<< GetParam().ast_type << "\n {\n Binary[not set]{"
<< "\n " << GetParam().ast_lhs << "\n " << GetParam().ast_op
<< "\n " << GetParam().ast_rhs;
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(ss.str())) << assembly;
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(ss.str()))
<< assembly;
}
INSTANTIATE_TEST_SUITE_P(
@ -701,7 +702,7 @@ TEST_F(SpvFUnordTest, FUnordEqual_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -717,7 +718,7 @@ TEST_F(SpvFUnordTest, FUnordEqual_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordEqual_Vector) {
@ -732,7 +733,7 @@ TEST_F(SpvFUnordTest, FUnordEqual_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -756,7 +757,7 @@ TEST_F(SpvFUnordTest, FUnordEqual_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordNotEqual_Scalar) {
@ -771,7 +772,7 @@ TEST_F(SpvFUnordTest, FUnordNotEqual_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -787,7 +788,7 @@ TEST_F(SpvFUnordTest, FUnordNotEqual_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordNotEqual_Vector) {
@ -802,7 +803,7 @@ TEST_F(SpvFUnordTest, FUnordNotEqual_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -826,7 +827,7 @@ TEST_F(SpvFUnordTest, FUnordNotEqual_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordLessThan_Scalar) {
@ -841,7 +842,7 @@ TEST_F(SpvFUnordTest, FUnordLessThan_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -857,7 +858,7 @@ TEST_F(SpvFUnordTest, FUnordLessThan_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordLessThan_Vector) {
@ -872,7 +873,7 @@ TEST_F(SpvFUnordTest, FUnordLessThan_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -896,7 +897,7 @@ TEST_F(SpvFUnordTest, FUnordLessThan_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordLessThanEqual_Scalar) {
@ -911,7 +912,7 @@ TEST_F(SpvFUnordTest, FUnordLessThanEqual_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -927,7 +928,7 @@ TEST_F(SpvFUnordTest, FUnordLessThanEqual_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordLessThanEqual_Vector) {
@ -942,7 +943,7 @@ TEST_F(SpvFUnordTest, FUnordLessThanEqual_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -966,7 +967,7 @@ TEST_F(SpvFUnordTest, FUnordLessThanEqual_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordGreaterThan_Scalar) {
@ -981,7 +982,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThan_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -997,7 +998,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThan_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordGreaterThan_Vector) {
@ -1012,7 +1013,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThan_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -1036,7 +1037,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThan_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Scalar) {
@ -1051,7 +1052,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -1067,7 +1068,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Scalar) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Vector) {
@ -1082,7 +1083,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -1106,7 +1107,7 @@ TEST_F(SpvFUnordTest, FUnordGreaterThanEqual_Vector) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, Select_BoolCond_BoolParams) {
@ -1121,7 +1122,8 @@ TEST_F(SpvFUnordTest, Select_BoolCond_BoolParams) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1137,7 +1139,7 @@ TEST_F(SpvFUnordTest, Select_BoolCond_BoolParams) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, Select_BoolCond_IntScalarParams) {
@ -1152,7 +1154,8 @@ TEST_F(SpvFUnordTest, Select_BoolCond_IntScalarParams) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1168,7 +1171,7 @@ TEST_F(SpvFUnordTest, Select_BoolCond_IntScalarParams) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, Select_BoolCond_FloatScalarParams) {
@ -1183,7 +1186,8 @@ TEST_F(SpvFUnordTest, Select_BoolCond_FloatScalarParams) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1199,7 +1203,7 @@ TEST_F(SpvFUnordTest, Select_BoolCond_FloatScalarParams) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, Select_BoolCond_VectorParams) {
@ -1214,7 +1218,8 @@ TEST_F(SpvFUnordTest, Select_BoolCond_VectorParams) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1238,7 +1243,7 @@ TEST_F(SpvFUnordTest, Select_BoolCond_VectorParams) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvFUnordTest, Select_VecBoolCond_VectorParams) {
@ -1253,7 +1258,8 @@ TEST_F(SpvFUnordTest, Select_VecBoolCond_VectorParams) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1281,7 +1287,7 @@ TEST_F(SpvFUnordTest, Select_VecBoolCond_VectorParams) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
using SpvLogicalTest = SpvParserTestBase<::testing::Test>;
@ -1298,7 +1304,8 @@ TEST_F(SpvLogicalTest, Any) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1316,7 +1323,7 @@ TEST_F(SpvLogicalTest, Any) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvLogicalTest, All) {
@ -1331,7 +1338,8 @@ TEST_F(SpvLogicalTest, All) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1349,7 +1357,7 @@ TEST_F(SpvLogicalTest, All) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvLogicalTest, IsNan_Scalar) {
@ -1364,7 +1372,8 @@ TEST_F(SpvLogicalTest, IsNan_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1378,7 +1387,7 @@ TEST_F(SpvLogicalTest, IsNan_Scalar) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvLogicalTest, IsNan_Vector) {
@ -1393,7 +1402,8 @@ TEST_F(SpvLogicalTest, IsNan_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1411,7 +1421,7 @@ TEST_F(SpvLogicalTest, IsNan_Vector) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvLogicalTest, IsInf_Scalar) {
@ -1426,7 +1436,8 @@ TEST_F(SpvLogicalTest, IsInf_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1440,7 +1451,7 @@ TEST_F(SpvLogicalTest, IsInf_Scalar) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvLogicalTest, IsInf_Vector) {
@ -1455,7 +1466,8 @@ TEST_F(SpvLogicalTest, IsInf_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1473,7 +1485,7 @@ TEST_F(SpvLogicalTest, IsInf_Vector) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
// TODO(dneto): Kernel-guarded instructions.

56
src/reader/spirv/function_memory_test.cc
View File

@ -50,7 +50,7 @@ TEST_F(SpvParserTest, EmitStatement_StoreBoolConst) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
Identifier[not set]{x_1}
ScalarConstructor[not set]{true}
}
@ -82,7 +82,7 @@ TEST_F(SpvParserTest, EmitStatement_StoreUintConst) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
Identifier[not set]{x_1}
ScalarConstructor[not set]{42}
}
@ -110,7 +110,7 @@ TEST_F(SpvParserTest, EmitStatement_StoreIntConst) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
Identifier[not set]{x_1}
ScalarConstructor[not set]{42}
}
@ -138,7 +138,7 @@ TEST_F(SpvParserTest, EmitStatement_StoreFloatConst) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
Identifier[not set]{x_1}
ScalarConstructor[not set]{42.000000}
}
@ -167,7 +167,7 @@ TEST_F(SpvParserTest, EmitStatement_LoadBool) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_2
none
@ -196,7 +196,8 @@ TEST_F(SpvParserTest, EmitStatement_LoadScalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_2
none
@ -237,7 +238,8 @@ TEST_F(SpvParserTest, EmitStatement_UseLoadedScalarTwice) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_2
none
@ -274,7 +276,7 @@ TEST_F(SpvParserTest, EmitStatement_StoreToModuleScopeVar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
Identifier[not set]{x_1}
ScalarConstructor[not set]{42}
})"));
@ -341,13 +343,13 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_VectorSwizzle) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
MemberAccessor[not set]{
Identifier[not set]{myvar}
Identifier[not set]{z}
}
ScalarConstructor[not set]{42}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_AccessChain_VectorConstOutOfBounds) {
@ -404,7 +406,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_VectorNonConstIndex) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
ArrayAccessor[not set]{
Identifier[not set]{myvar}
Identifier[not set]{x_11}
@ -441,7 +443,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_Matrix) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
ArrayAccessor[not set]{
Identifier[not set]{myvar}
ScalarConstructor[not set]{2}
@ -484,7 +486,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_Array) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
ArrayAccessor[not set]{
Identifier[not set]{myvar}
ScalarConstructor[not set]{2}
@ -526,7 +528,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_Struct) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
MemberAccessor[not set]{
Identifier[not set]{myvar}
Identifier[not set]{age}
@ -574,7 +576,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_Struct_DifferOnlyMemberName) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
MemberAccessor[not set]{
Identifier[not set]{myvar}
Identifier[not set]{age}
@ -587,7 +589,7 @@ Assignment{
Identifier[not set]{ancientness}
}
ScalarConstructor[not set]{420.000000}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_AccessChain_StructNonConstIndex) {
@ -684,7 +686,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_Struct_RuntimeArray) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
ArrayAccessor[not set]{
MemberAccessor[not set]{
Identifier[not set]{myvar}
@ -724,7 +726,7 @@ TEST_F(SpvParserTest, EmitStatement_AccessChain_Compound_Matrix_Vector) {
<< assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
MemberAccessor[not set]{
ArrayAccessor[not set]{
Identifier[not set]{myvar}
@ -832,7 +834,7 @@ TEST_F(SpvParserTest, RemapStorageBuffer_ThroughAccessChain_NonCascaded) {
ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
MemberAccessor[not set]{
Identifier[not set]{myvar}
Identifier[not set]{field0}
@ -848,7 +850,7 @@ Assignment{
ScalarConstructor[not set]{1}
}
ScalarConstructor[not set]{0}
})")) << ToString(fe.ast_body())
})")) << ToString(p->get_module(), fe.ast_body())
<< p->error();
}
@ -871,7 +873,7 @@ TEST_F(SpvParserTest, RemapStorageBuffer_ThroughAccessChain_Cascaded) {
ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(Assignment{
ArrayAccessor[not set]{
MemberAccessor[not set]{
Identifier[not set]{myvar}
@ -880,7 +882,7 @@ TEST_F(SpvParserTest, RemapStorageBuffer_ThroughAccessChain_Cascaded) {
ScalarConstructor[not set]{1}
}
ScalarConstructor[not set]{0}
})")) << ToString(fe.ast_body())
})")) << ToString(p->get_module(), fe.ast_body())
<< p->error();
}
@ -904,7 +906,8 @@ TEST_F(SpvParserTest, RemapStorageBuffer_ThroughCopyObject_WithoutHoisting) {
ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_2
none
@ -923,7 +926,7 @@ TEST_F(SpvParserTest, RemapStorageBuffer_ThroughCopyObject_WithoutHoisting) {
Assignment{
Identifier[not set]{x_2}
ScalarConstructor[not set]{0}
})")) << ToString(fe.ast_body())
})")) << ToString(p->get_module(), fe.ast_body())
<< p->error();
}
@ -959,7 +962,8 @@ TEST_F(SpvParserTest, RemapStorageBuffer_ThroughCopyObject_WithHoisting) {
ASSERT_TRUE(p->BuildAndParseInternalModule()) << assembly << p->error();
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
Variable{
x_2
function
@ -993,7 +997,7 @@ Assignment{
ScalarConstructor[not set]{0}
}
Return{}
)")) << ToString(fe.ast_body())
)")) << ToString(p->get_module(), fe.ast_body())
<< p->error();
}

32
src/reader/spirv/function_misc_test.cc
View File

@ -68,7 +68,8 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Scalar) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_11
none
@ -107,7 +108,7 @@ VariableDeclStatement{
ScalarConstructor[not set]{0.000000}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Vector) {
@ -128,7 +129,8 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Vector) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_11
none
@ -169,7 +171,7 @@ VariableDeclStatement{
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Matrix) {
@ -188,7 +190,8 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Matrix) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_11
none
@ -209,7 +212,7 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Matrix) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Array) {
@ -229,7 +232,8 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Array) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_11
none
@ -242,7 +246,7 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Array) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Struct) {
@ -261,7 +265,8 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Struct) {
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
VariableConst{
x_11
none
@ -276,7 +281,7 @@ TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Struct) {
}
}
}
})")) << ToString(fe.ast_body());
})")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTestMiscInstruction, OpNop) {
@ -292,8 +297,8 @@ TEST_F(SpvParserTestMiscInstruction, OpNop) {
<< p->error() << assembly;
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Return{}
)")) << ToString(fe.ast_body());
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Return{}
)")) << ToString(p->get_module(), fe.ast_body());
}
// Test swizzle generation.
@ -324,7 +329,8 @@ TEST_P(SpvParserSwizzleTest, Sample) {
ASSERT_NE(result, nullptr);
std::ostringstream ss;
result->to_str(ss, 0);
EXPECT_THAT(ss.str(), Eq(GetParam().expected_expr));
auto str = Demangler().Demangle(p->get_module(), ss.str());
EXPECT_THAT(str, Eq(GetParam().expected_expr));
} else {
EXPECT_EQ(result, nullptr);
EXPECT_FALSE(fe.success());

118
src/reader/spirv/function_var_test.cc
View File

@ -91,7 +91,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_AnonymousVars) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_1
function
@ -129,7 +130,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_NamedVars) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
a
function
@ -167,7 +169,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_MixedTypes) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
a
function
@ -208,7 +211,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ScalarInitializers) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
a
function
@ -281,7 +285,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ScalarNullInitializers) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
a
function
@ -340,7 +345,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_VectorInitializer) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -354,7 +360,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_VectorInitializer) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitFunctionVariables_MatrixInitializer) {
@ -378,7 +384,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_MatrixInitializer) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -424,7 +431,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -438,7 +446,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias) {
@ -458,7 +466,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -472,7 +481,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Null) {
@ -491,7 +500,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Null) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -505,7 +515,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Null) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias_Null) {
@ -525,7 +535,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias_Null) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -539,7 +550,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer_Alias_Null) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer) {
@ -559,7 +570,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -578,7 +590,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer_Null) {
@ -598,7 +610,8 @@ TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer_Null) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitFunctionVariables());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
HasSubstr(R"(VariableDeclStatement{
Variable{
x_200
function
@ -617,7 +630,7 @@ TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer_Null) {
}
}
}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest,
@ -642,7 +655,8 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
Variable{
x_25
function
@ -662,7 +676,7 @@ Assignment{
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_CombinatorialValue_Immediate_UsedTwice) {
@ -687,7 +701,8 @@ TEST_F(SpvParserTest, EmitStatement_CombinatorialValue_Immediate_UsedTwice) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
Variable{
x_25
function
@ -721,7 +736,7 @@ Assignment{
Identifier[not set]{x_2}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest,
@ -757,7 +772,8 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
Variable{
x_25
function
@ -795,7 +811,7 @@ Assignment{
ScalarConstructor[not set]{2}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(
@ -854,7 +870,7 @@ TEST_F(
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Assignment{
Identifier[not set]{x_1}
ScalarConstructor[not set]{0}
}
@ -926,7 +942,7 @@ Assignment{
ScalarConstructor[not set]{5}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(
@ -970,7 +986,8 @@ TEST_F(
// We don't hoist x_1 into its own mutable variable. It is emitted as
// a const definition.
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1002,7 +1019,7 @@ Assignment{
Identifier[not set]{x_3}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest,
@ -1053,7 +1070,7 @@ TEST_F(SpvParserTest,
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(If{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(If{
(
ScalarConstructor[not set]{true}
)
@ -1092,7 +1109,7 @@ TEST_F(SpvParserTest,
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(
@ -1138,7 +1155,7 @@ TEST_F(
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(If{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(If{
(
ScalarConstructor[not set]{true}
)
@ -1179,7 +1196,7 @@ TEST_F(
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest,
@ -1219,7 +1236,8 @@ TEST_F(SpvParserTest,
// We don't hoist x_1 into its own mutable variable. It is emitted as
// a const definition.
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
VariableConst{
x_1
none
@ -1247,7 +1265,7 @@ If{
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_Phi_SingleBlockLoopIndex) {
@ -1291,7 +1309,7 @@ TEST_F(SpvParserTest, EmitStatement_Phi_SingleBlockLoopIndex) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Loop{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Loop{
VariableDeclStatement{
Variable{
x_2_phi
@ -1386,7 +1404,7 @@ TEST_F(SpvParserTest, EmitStatement_Phi_SingleBlockLoopIndex) {
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_Phi_MultiBlockLoopIndex) {
@ -1433,7 +1451,7 @@ TEST_F(SpvParserTest, EmitStatement_Phi_MultiBlockLoopIndex) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Loop{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), Eq(R"(Loop{
VariableDeclStatement{
Variable{
x_2_phi
@ -1541,7 +1559,7 @@ TEST_F(SpvParserTest, EmitStatement_Phi_MultiBlockLoopIndex) {
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_Phi_ValueFromLoopBodyAndContinuing) {
@ -1589,7 +1607,8 @@ TEST_F(SpvParserTest, EmitStatement_Phi_ValueFromLoopBodyAndContinuing) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
VariableConst{
x_101
none
@ -1707,7 +1726,7 @@ Loop{
}
}
Return{}
)")) << ToString(fe.ast_body())
)")) << ToString(p->get_module(), fe.ast_body())
<< assembly;
}
@ -1757,7 +1776,8 @@ TEST_F(SpvParserTest, EmitStatement_Phi_FromElseAndThen) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
VariableConst{
x_101
none
@ -1831,7 +1851,7 @@ Loop{
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_Phi_FromHeaderAndThen) {
@ -1877,7 +1897,8 @@ TEST_F(SpvParserTest, EmitStatement_Phi_FromHeaderAndThen) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
VariableConst{
x_101
none
@ -1946,7 +1967,7 @@ Loop{
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
TEST_F(SpvParserTest, EmitStatement_UseInPhiCountsAsUse) {
@ -1983,7 +2004,8 @@ TEST_F(SpvParserTest, EmitStatement_UseInPhiCountsAsUse) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(VariableDeclStatement{
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()),
Eq(R"(VariableDeclStatement{
Variable{
x_101_phi
function
@ -2043,7 +2065,7 @@ VariableDeclStatement{
}
}
Return{}
)")) << ToString(fe.ast_body());
)")) << ToString(p->get_module(), fe.ast_body());
}
} // namespace

12
src/reader/spirv/parser_impl_function_decl_test.cc
View File

@ -199,10 +199,10 @@ TEST_F(SpvParserTest, EmitFunctions_CalleePrecedesCaller) {
)"));
EXPECT_TRUE(p->BuildAndParseInternalModule());
EXPECT_TRUE(p->error().empty());
const auto module_ast = p->get_module().to_str();
const auto module_ast =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module_ast, HasSubstr(R"(
Function )" + p->get_module().GetSymbol("leaf").to_str() +
R"( -> __u32
Function leaf -> __u32
()
{
Return{
@ -211,8 +211,7 @@ TEST_F(SpvParserTest, EmitFunctions_CalleePrecedesCaller) {
}
}
}
Function )" + p->get_module().GetSymbol("branch").to_str() +
R"( -> __u32
Function branch -> __u32
()
{
VariableDeclStatement{
@ -235,8 +234,7 @@ TEST_F(SpvParserTest, EmitFunctions_CalleePrecedesCaller) {
}
}
}
Function )" + p->get_module().GetSymbol("root").to_str() +
R"( -> __void
Function root -> __void
()
{
VariableDeclStatement{

13
src/reader/spirv/parser_impl_handle_test.cc
View File

@ -16,6 +16,7 @@
#include <vector>
#include "gmock/gmock.h"
#include "src/demangler.h"
#include "src/reader/spirv/function.h"
#include "src/reader/spirv/parser_impl.h"
#include "src/reader/spirv/parser_impl_test_helper.h"
@ -1128,7 +1129,8 @@ TEST_P(SpvParserTest_DeclUnderspecifiedHandle, Variable) {
auto p = parser(test::Assemble(assembly));
ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly;
EXPECT_TRUE(p->error().empty()) << p->error();
const auto module = p->module().to_str();
const auto module =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module, HasSubstr(GetParam().var_decl)) << module;
}
@ -1300,7 +1302,8 @@ TEST_P(SpvParserTest_SampledImageAccessTest, Variable) {
auto p = parser(test::Assemble(assembly));
ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly;
EXPECT_TRUE(p->error().empty()) << p->error();
const auto module = p->module().to_str();
const auto module =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module, HasSubstr(GetParam().var_decl))
<< "DECLARATIONS ARE BAD " << module;
EXPECT_THAT(module, HasSubstr(GetParam().texture_builtin))
@ -2373,7 +2376,8 @@ TEST_P(SpvParserTest_ImageAccessTest, Variable) {
auto p = parser(test::Assemble(assembly));
ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly;
EXPECT_TRUE(p->error().empty()) << p->error();
const auto module = p->module().to_str();
const auto module =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module, HasSubstr(GetParam().var_decl))
<< "DECLARATIONS ARE BAD " << module;
EXPECT_THAT(module, HasSubstr(GetParam().texture_builtin))
@ -3670,7 +3674,8 @@ TEST_P(SpvParserTest_ImageCoordsTest, MakeCoordinateOperandsForImageAccess) {
std::vector<std::string> result_strings;
for (auto* expr : result) {
ASSERT_NE(expr, nullptr);
result_strings.push_back(expr->str());
result_strings.push_back(
Demangler().Demangle(p->get_module(), expr->str()));
}
EXPECT_THAT(result_strings,
::testing::ContainerEq(GetParam().expected_expressions));

14
src/reader/spirv/parser_impl_module_var_test.cc
View File

@ -15,6 +15,7 @@
#include <string>
#include "gmock/gmock.h"
#include "src/demangler.h"
#include "src/reader/spirv/function.h"
#include "src/reader/spirv/parser_impl.h"
#include "src/reader/spirv/parser_impl_test_helper.h"
@ -326,7 +327,8 @@ TEST_F(SpvParserTest, ModuleScopeVar_BuiltinPosition_StorePosition) {
auto p = parser(test::Assemble(assembly));
EXPECT_TRUE(p->BuildAndParseInternalModule());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
const auto module_str =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module_str, HasSubstr(R"(
Assignment{
Identifier[not set]{gl_Position}
@ -357,7 +359,8 @@ TEST_F(SpvParserTest,
auto p = parser(test::Assemble(assembly));
EXPECT_TRUE(p->BuildAndParseInternalModule());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
const auto module_str =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module_str, HasSubstr(R"(
Assignment{
MemberAccessor[not set]{
@ -388,7 +391,8 @@ TEST_F(SpvParserTest,
auto p = parser(test::Assemble(assembly));
EXPECT_TRUE(p->BuildAndParseInternalModule());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
const auto module_str =
Demangler().Demangle(p->get_module(), p->get_module().to_str());
EXPECT_THAT(module_str, HasSubstr(R"(
{
Assignment{
@ -1654,7 +1658,7 @@ TEST_F(SpvParserTest, ModuleScopeVar_ScalarSpecConstant_UsedInFunction) {
FunctionEmitter fe(p.get(), *spirv_function(p.get(), 100));
EXPECT_TRUE(fe.EmitBody()) << p->error();
EXPECT_TRUE(p->error().empty());
EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(
EXPECT_THAT(ToString(p->get_module(), fe.ast_body()), HasSubstr(R"(
VariableConst{
x_1
none
@ -1667,7 +1671,7 @@ TEST_F(SpvParserTest, ModuleScopeVar_ScalarSpecConstant_UsedInFunction) {
}
}
})"))
<< ToString(fe.ast_body());
<< ToString(p->get_module(), fe.ast_body());
}
} // namespace

6
src/reader/spirv/parser_impl_test_helper.h
View File

@ -22,6 +22,7 @@
#include "gtest/gtest.h"
#include "source/opt/ir_context.h"
#include "src/demangler.h"
#include "src/reader/spirv/parser_impl.h"
namespace tint {
@ -59,12 +60,13 @@ using SpvParserTest = SpvParserTestBase<::testing::Test>;
/// Returns the string dump of a function body.
/// @param body the statement in the body
/// @returnss the string dump of a function body.
inline std::string ToString(const ast::BlockStatement* body) {
inline std::string ToString(const ast::Module& mod,
const ast::BlockStatement* body) {
std::ostringstream outs;
for (const auto* stmt : *body) {
stmt->to_str(outs, 0);
}
return outs.str();
return Demangler().Demangle(mod, outs.str());
}
} // namespace spirv

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

@ -2026,7 +2026,9 @@ Maybe<ast::CallStatement*> ParserImpl::func_call_stmt() {
return Failure::kErrored;
return create<ast::CallStatement>(create<ast::CallExpression>(
source, create<ast::IdentifierExpression>(name), std::move(params)));
source,
create<ast::IdentifierExpression>(module_.RegisterSymbol(name), name),
std::move(params)));
}
// break_stmt
@ -2097,7 +2099,8 @@ Maybe<ast::Expression*> ParserImpl::primary_expression() {
}
if (match(Token::Type::kIdentifier))
return create<ast::IdentifierExpression>(t.source(), t.to_str());
return create<ast::IdentifierExpression>(
t.source(), module_.RegisterSymbol(t.to_str()), t.to_str());
auto type = type_decl();
if (type.errored)
@ -2172,7 +2175,8 @@ Maybe<ast::Expression*> ParserImpl::postfix_expr(ast::Expression* prefix) {
return postfix_expr(create<ast::MemberAccessorExpression>(
ident.source, prefix,
create<ast::IdentifierExpression>(ident.source, ident.value)));
create<ast::IdentifierExpression>(
ident.source, module_.RegisterSymbol(ident.value), ident.value)));
}
return prefix;

4
src/transform/bound_array_accessors.cc
View File

@ -135,7 +135,9 @@ ast::ArrayAccessorExpression* BoundArrayAccessors::Transform(
ctx->mod->create<ast::UintLiteral>(u32, size - 1)));
auto* call_expr = ctx->mod->create<ast::CallExpression>(
ctx->mod->create<ast::IdentifierExpression>("min"), std::move(params));
ctx->mod->create<ast::IdentifierExpression>(
ctx->mod->RegisterSymbol("min"), "min"),
std::move(params));
call_expr->set_result_type(u32);
idx_expr = call_expr;

4
src/transform/emit_vertex_point_size.cc
View File

@ -67,8 +67,8 @@ Transform::Output EmitVertexPointSize::Run(ast::Module* in) {
// Build the AST expression & statement for assigning pointsize one.
auto* one = mod->create<ast::ScalarConstructorExpression>(
mod->create<ast::FloatLiteral>(f32, 1.0f));
auto* pointsize_ident =
mod->create<ast::IdentifierExpression>(Source{}, kPointSizeVar);
auto* pointsize_ident = mod->create<ast::IdentifierExpression>(
Source{}, mod->RegisterSymbol(kPointSizeVar), kPointSizeVar);
auto* pointsize_assign =
mod->create<ast::AssignmentStatement>(pointsize_ident, one);

40
src/transform/emit_vertex_point_size_test.cc
View File

@ -21,6 +21,7 @@
#include "src/ast/builder.h"
#include "src/ast/stage_decoration.h"
#include "src/ast/variable_decl_statement.h"
#include "src/demangler.h"
#include "src/diagnostic/formatter.h"
#include "src/transform/manager.h"
@ -85,7 +86,7 @@ TEST_F(EmitVertexPointSizeTest, VertexStageBasic) {
ASSERT_FALSE(result.diagnostics.contains_errors())
<< diag::Formatter().format(result.diagnostics);
auto expected = R"(Module{
auto* expected = R"(Module{
Variable{
Decorations{
BuiltinDecoration{pointsize}
@ -94,13 +95,11 @@ TEST_F(EmitVertexPointSizeTest, VertexStageBasic) {
out
__f32
}
Function )" + result.module.RegisterSymbol("non_entry_a").to_str() +
R"( -> __void
Function non_entry_a -> __void
()
{
}
Function )" + result.module.RegisterSymbol("entry").to_str() +
R"( -> __void
Function entry -> __void
StageDecoration{vertex}
()
{
@ -116,14 +115,14 @@ TEST_F(EmitVertexPointSizeTest, VertexStageBasic) {
}
}
}
Function )" + result.module.RegisterSymbol("non_entry_b").to_str() +
R"( -> __void
Function non_entry_b -> __void
()
{
}
}
)";
EXPECT_EQ(expected, result.module.to_str());
EXPECT_EQ(expected,
Demangler().Demangle(result.module, result.module.to_str()));
}
TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) {
@ -156,7 +155,7 @@ TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) {
ASSERT_FALSE(result.diagnostics.contains_errors())
<< diag::Formatter().format(result.diagnostics);
auto expected = R"(Module{
auto* expected = R"(Module{
Variable{
Decorations{
BuiltinDecoration{pointsize}
@ -165,13 +164,11 @@ TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) {
out
__f32
}
Function )" + result.module.RegisterSymbol("non_entry_a").to_str() +
R"( -> __void
Function non_entry_a -> __void
()
{
}
Function )" + result.module.RegisterSymbol("entry").to_str() +
R"( -> __void
Function entry -> __void
StageDecoration{vertex}
()
{
@ -180,14 +177,14 @@ TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) {
ScalarConstructor[__f32]{1.000000}
}
}
Function )" + result.module.RegisterSymbol("non_entry_b").to_str() +
R"( -> __void
Function non_entry_b -> __void
()
{
}
}
)";
EXPECT_EQ(expected, result.module.to_str());
EXPECT_EQ(expected,
Demangler().Demangle(result.module, result.module.to_str()));
}
TEST_F(EmitVertexPointSizeTest, NonVertexStage) {
@ -219,22 +216,21 @@ TEST_F(EmitVertexPointSizeTest, NonVertexStage) {
ASSERT_FALSE(result.diagnostics.contains_errors())
<< diag::Formatter().format(result.diagnostics);
auto expected = R"(Module{
Function )" + result.module.RegisterSymbol("fragment_entry").to_str() +
R"( -> __void
auto* expected = R"(Module{
Function fragment_entry -> __void
StageDecoration{fragment}
()
{
}
Function )" + result.module.RegisterSymbol("compute_entry").to_str() +
R"( -> __void
Function compute_entry -> __void
StageDecoration{compute}
()
{
}
}
)";
EXPECT_EQ(expected, result.module.to_str());
EXPECT_EQ(expected,
Demangler().Demangle(result.module, result.module.to_str()));
}
} // namespace

11
src/transform/first_index_offset.cc
View File

@ -251,13 +251,16 @@ ast::VariableDeclStatement* FirstIndexOffset::CreateFirstIndexOffset(
const std::string& field_name,
ast::Variable* buffer_var,
ast::Module* mod) {
auto* buffer = mod->create<ast::IdentifierExpression>(buffer_var->name());
auto* buffer = mod->create<ast::IdentifierExpression>(
mod->RegisterSymbol(buffer_var->name()), buffer_var->name());
auto* constructor = mod->create<ast::BinaryExpression>(
ast::BinaryOp::kAdd,
mod->create<ast::IdentifierExpression>(kIndexOffsetPrefix +
original_name),
mod->create<ast::IdentifierExpression>(
mod->RegisterSymbol(kIndexOffsetPrefix + original_name),
kIndexOffsetPrefix + original_name),
mod->create<ast::MemberAccessorExpression>(
buffer, mod->create<ast::IdentifierExpression>(field_name)));
buffer, mod->create<ast::IdentifierExpression>(
mod->RegisterSymbol(field_name), field_name)));
auto* var =
mod->create<ast::Variable>(Source{}, // source
original_name, // name

15
src/transform/first_index_offset_test.cc
View File

@ -74,7 +74,8 @@ TEST_F(FirstIndexOffsetTest, Error_AlreadyTransformed) {
void Build() override {
AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
AddFunction("test")->body()->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("vert_idx")));
Source{}, create<ast::IdentifierExpression>(
mod->RegisterSymbol("vert_idx"), "vert_idx")));
}
};
@ -115,7 +116,8 @@ TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex) {
void Build() override {
AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
AddFunction("test")->body()->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("vert_idx")));
Source{}, create<ast::IdentifierExpression>(
mod->RegisterSymbol("vert_idx"), "vert_idx")));
}
};
@ -191,7 +193,8 @@ TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex) {
void Build() override {
AddBuiltinInput("inst_idx", ast::Builtin::kInstanceIdx);
AddFunction("test")->body()->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("inst_idx")));
Source{}, create<ast::IdentifierExpression>(
mod->RegisterSymbol("inst_idx"), "inst_idx")));
}
};
@ -344,11 +347,13 @@ TEST_F(FirstIndexOffsetTest, NestedCalls) {
AddBuiltinInput("vert_idx", ast::Builtin::kVertexIdx);
ast::Function* func1 = AddFunction("func1");
func1->body()->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("vert_idx")));
Source{}, create<ast::IdentifierExpression>(
mod->RegisterSymbol("vert_idx"), "vert_idx")));
ast::Function* func2 = AddFunction("func2");
func2->body()->append(create<ast::ReturnStatement>(
Source{}, create<ast::CallExpression>(
create<ast::IdentifierExpression>("func1"),
create<ast::IdentifierExpression>(
mod->RegisterSymbol("func1"), "func1"),
ast::ExpressionList{})));
}
};

20
src/transform/vertex_pulling.cc
View File

@ -321,11 +321,12 @@ void VertexPulling::State::AddVertexPullingPreamble(
}
auto* v = it->second;
auto name = buffer_layout.step_mode == InputStepMode::kVertex
? vertex_index_name
: instance_index_name;
// Identifier to index by
auto* index_identifier = mod->create<ast::IdentifierExpression>(
buffer_layout.step_mode == InputStepMode::kVertex
? vertex_index_name
: instance_index_name);
mod->RegisterSymbol(name), name);
// An expression for the start of the read in the buffer in bytes
auto* pos_value = mod->create<ast::BinaryExpression>(
@ -341,7 +342,8 @@ void VertexPulling::State::AddVertexPullingPreamble(
block->append(set_pos_expr);
block->append(mod->create<ast::AssignmentStatement>(
mod->create<ast::IdentifierExpression>(v->name()),
mod->create<ast::IdentifierExpression>(mod->RegisterSymbol(v->name()),
v->name()),
AccessByFormat(i, attribute_desc.format)));
}
}
@ -355,7 +357,8 @@ ast::Expression* VertexPulling::State::GenUint(uint32_t value) {
}
ast::Expression* VertexPulling::State::CreatePullingPositionIdent() {
return mod->create<ast::IdentifierExpression>(kPullingPosVarName);
return mod->create<ast::IdentifierExpression>(
mod->RegisterSymbol(kPullingPosVarName), kPullingPosVarName);
}
ast::Expression* VertexPulling::State::AccessByFormat(uint32_t buffer,
@ -392,10 +395,13 @@ ast::Expression* VertexPulling::State::AccessU32(uint32_t buffer,
// by dividing. Then, that element is going to be read, and if needed,
// unpacked into an appropriate variable. All reads should end up here as a
// base case.
auto vbuf_name = GetVertexBufferName(buffer);
return mod->create<ast::ArrayAccessorExpression>(
mod->create<ast::MemberAccessorExpression>(
mod->create<ast::IdentifierExpression>(GetVertexBufferName(buffer)),
mod->create<ast::IdentifierExpression>(kStructBufferName)),
mod->create<ast::IdentifierExpression>(mod->RegisterSymbol(vbuf_name),
vbuf_name),
mod->create<ast::IdentifierExpression>(
mod->RegisterSymbol(kStructBufferName), kStructBufferName)),
mod->create<ast::BinaryExpression>(ast::BinaryOp::kDivide, pos,
GenUint(4)));
}

32
src/transform/vertex_pulling_test.cc
View File

@ -24,7 +24,7 @@
#include "src/ast/type/f32_type.h"
#include "src/ast/type/i32_type.h"
#include "src/ast/type/void_type.h"
#include "src/ast/variable.h"
#include "src/demangler.h"
#include "src/diagnostic/formatter.h"
#include "src/transform/manager.h"
#include "src/type_determiner.h"
@ -195,8 +195,7 @@ TEST_F(VertexPullingTest, OneAttribute) {
storage_buffer
__struct_TintVertexData
}
Function )" + result.module.GetSymbol("main").to_str() +
R"( -> __void
Function main -> __void
StageDecoration{vertex}
()
{
@ -240,7 +239,7 @@ TEST_F(VertexPullingTest, OneAttribute) {
}
}
)",
result.module.to_str());
Demangler().Demangle(result.module, result.module.to_str()));
}
TEST_F(VertexPullingTest, OneInstancedAttribute) {
@ -283,8 +282,7 @@ TEST_F(VertexPullingTest, OneInstancedAttribute) {
storage_buffer
__struct_TintVertexData
}
Function )" + result.module.GetSymbol("main").to_str() +
R"( -> __void
Function main -> __void
StageDecoration{vertex}
()
{
@ -328,7 +326,7 @@ TEST_F(VertexPullingTest, OneInstancedAttribute) {
}
}
)",
result.module.to_str());
Demangler().Demangle(result.module, result.module.to_str()));
}
TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) {
@ -371,8 +369,7 @@ TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) {
storage_buffer
__struct_TintVertexData
}
Function )" + result.module.GetSymbol("main").to_str() +
R"( -> __void
Function main -> __void
StageDecoration{vertex}
()
{
@ -416,7 +413,7 @@ TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) {
}
}
)",
result.module.to_str());
Demangler().Demangle(result.module, result.module.to_str()));
}
// We expect the transform to use an existing builtin variables if it finds them
@ -510,8 +507,7 @@ TEST_F(VertexPullingTest, ExistingVertexIndexAndInstanceIndex) {
storage_buffer
__struct_TintVertexData
}
Function )" + result.module.GetSymbol("main").to_str() +
R"( -> __void
Function main -> __void
StageDecoration{vertex}
()
{
@ -583,7 +579,7 @@ TEST_F(VertexPullingTest, ExistingVertexIndexAndInstanceIndex) {
}
}
)",
result.module.to_str());
Demangler().Demangle(result.module, result.module.to_str()));
}
TEST_F(VertexPullingTest, TwoAttributesSameBuffer) {
@ -636,8 +632,7 @@ TEST_F(VertexPullingTest, TwoAttributesSameBuffer) {
storage_buffer
__struct_TintVertexData
}
Function )" + result.module.GetSymbol("main").to_str() +
R"( -> __void
Function main -> __void
StageDecoration{vertex}
()
{
@ -767,7 +762,7 @@ TEST_F(VertexPullingTest, TwoAttributesSameBuffer) {
}
}
)",
result.module.to_str());
Demangler().Demangle(result.module, result.module.to_str()));
}
TEST_F(VertexPullingTest, FloatVectorAttributes) {
@ -847,8 +842,7 @@ TEST_F(VertexPullingTest, FloatVectorAttributes) {
storage_buffer
__struct_TintVertexData
}
Function )" + result.module.GetSymbol("main").to_str() +
R"( -> __void
Function main -> __void
StageDecoration{vertex}
()
{
@ -1071,7 +1065,7 @@ TEST_F(VertexPullingTest, FloatVectorAttributes) {
}
}
)",
result.module.to_str());
Demangler().Demangle(result.module, result.module.to_str()));
}
} // namespace

688
src/type_determiner_test.cc
View File

File diff suppressed because it is too large Load Diff

31
src/validator/validator_control_block_test.cc
View File

@ -53,8 +53,8 @@ TEST_F(ValidateControlBlockTest, SwitchSelectorExpressionNoneIntegerType_Fail) {
create<ast::SintLiteral>(&f32, 3.14f)), // constructor
ast::VariableDecorationList{}); // decorations
auto* cond =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
auto* cond = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList default_csl;
auto* block_default = create<ast::BlockStatement>();
ast::CaseStatementList body;
@ -87,7 +87,8 @@ TEST_F(ValidateControlBlockTest, SwitchWithoutDefault_Fail) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl;
csl.push_back(create<ast::SintLiteral>(&i32, 1));
ast::CaseStatementList body;
@ -125,7 +126,8 @@ TEST_F(ValidateControlBlockTest, SwitchWithTwoDefault_Fail) {
ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body;
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList default_csl_1;
auto* block_default_1 = create<ast::BlockStatement>();
@ -174,7 +176,8 @@ TEST_F(ValidateControlBlockTest,
ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body;
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl;
csl.push_back(create<ast::UintLiteral>(&u32, 1));
@ -216,7 +219,8 @@ TEST_F(ValidateControlBlockTest,
ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body;
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl;
csl.push_back(create<ast::SintLiteral>(&i32, -1));
@ -257,7 +261,8 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueUint_Fail) {
ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body;
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl_1;
csl_1.push_back(create<ast::UintLiteral>(&u32, 0));
@ -304,7 +309,8 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueSint_Fail) {
ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body;
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl_1;
csl_1.push_back(create<ast::SintLiteral>(&i32, 10));
@ -350,7 +356,8 @@ TEST_F(ValidateControlBlockTest, LastClauseLastStatementIsFallthrough_Fail) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList default_csl;
auto* block_default = create<ast::BlockStatement>();
block_default->append(
@ -386,7 +393,8 @@ TEST_F(ValidateControlBlockTest, SwitchCase_Pass) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList default_csl;
auto* block_default = create<ast::BlockStatement>();
ast::CaseStatementList body;
@ -425,7 +433,8 @@ TEST_F(ValidateControlBlockTest, SwitchCaseAlias_Pass) {
create<ast::SintLiteral>(&u32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* cond = create<ast::IdentifierExpression>("a");
auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList default_csl;
auto* block_default = create<ast::BlockStatement>();
ast::CaseStatementList body;

7
src/validator/validator_function_test.cc
View File

@ -237,7 +237,8 @@ TEST_F(ValidateFunctionTest, RecursionIsNotAllowed_Fail) {
ast::ExpressionList call_params;
auto* call_expr = create<ast::CallExpression>(
Source{Source::Location{12, 34}},
create<ast::IdentifierExpression>("func"), call_params);
create<ast::IdentifierExpression>(mod()->RegisterSymbol("func"), "func"),
call_params);
ast::VariableList params0;
auto* body0 = create<ast::BlockStatement>();
body0->append(create<ast::CallStatement>(call_expr));
@ -258,7 +259,8 @@ TEST_F(ValidateFunctionTest, RecursionIsNotAllowedExpr_Fail) {
ast::ExpressionList call_params;
auto* call_expr = create<ast::CallExpression>(
Source{Source::Location{12, 34}},
create<ast::IdentifierExpression>("func"), call_params);
create<ast::IdentifierExpression>(mod()->RegisterSymbol("func"), "func"),
call_params);
auto* var =
create<ast::Variable>(Source{}, // source
"a", // name
@ -267,6 +269,7 @@ TEST_F(ValidateFunctionTest, RecursionIsNotAllowedExpr_Fail) {
false, // is_const
call_expr, // constructor
ast::VariableDecorationList{}); // decorations
ast::VariableList params0;
auto* body0 = create<ast::BlockStatement>();
body0->append(create<ast::VariableDeclStatement>(var));

43
src/validator/validator_test.cc
View File

@ -66,7 +66,8 @@ TEST_F(ValidatorTest, DISABLED_AssignToScalar_Fail) {
auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1));
auto* rhs = create<ast::IdentifierExpression>("my_var");
auto* rhs = create<ast::IdentifierExpression>(mod()->RegisterSymbol("my_var"),
"my_var");
ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs);
// TODO(sarahM0): Invalidate assignment to scalar.
@ -79,8 +80,8 @@ TEST_F(ValidatorTest, UsingUndefinedVariable_Fail) {
// b = 2;
ast::type::I32 i32;
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "b");
auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto* assign = create<ast::AssignmentStatement>(
@ -97,8 +98,8 @@ TEST_F(ValidatorTest, UsingUndefinedVariableInBlockStatement_Fail) {
// }
ast::type::I32 i32;
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "b");
auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
@ -125,7 +126,8 @@ TEST_F(ValidatorTest, AssignCompatibleTypes_Pass) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
@ -155,7 +157,8 @@ TEST_F(ValidatorTest, AssignIncompatibleTypes_Fail) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.3f));
@ -188,7 +191,8 @@ TEST_F(ValidatorTest, AssignCompatibleTypesInBlockStatement_Pass) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
@ -221,7 +225,8 @@ TEST_F(ValidatorTest, AssignIncompatibleTypesInBlockStatement_Fail) {
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.3f));
@ -323,7 +328,8 @@ TEST_F(ValidatorTest, UsingUndefinedVariableGlobalVariable_Fail) {
ast::VariableDecorationList{})); // decorations
auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, "not_global_var");
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("not_global_var"),
"not_global_var");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
@ -360,7 +366,8 @@ TEST_F(ValidatorTest, UsingUndefinedVariableGlobalVariable_Pass) {
create<ast::FloatLiteral>(&f32, 2.1)), // constructor
ast::VariableDecorationList{})); // decorations
auto* lhs = create<ast::IdentifierExpression>("global_var");
auto* lhs = create<ast::IdentifierExpression>(
mod()->RegisterSymbol("global_var"), "global_var");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
@ -404,8 +411,8 @@ TEST_F(ValidatorTest, UsingUndefinedVariableInnerScope_Fail) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var));
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
@ -438,8 +445,8 @@ TEST_F(ValidatorTest, UsingUndefinedVariableOuterScope_Pass) {
create<ast::FloatLiteral>(&f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
@ -539,7 +546,8 @@ TEST_F(ValidatorTest, AssignToConstant_Fail) {
create<ast::SintLiteral>(&i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
@ -802,7 +810,8 @@ TEST_F(ValidatorTest, VariableDeclNoConstructor_Pass) {
ast::VariableDecorationList{}); // decorations
td()->RegisterVariableForTesting(var);
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));

9
src/writer/hlsl/generator_impl_array_accessor_test.cc
View File

@ -33,7 +33,8 @@ TEST_F(HlslGeneratorImplTest_Expression, EmitExpression_ArrayAccessor) {
ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, 5);
auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* ary = create<ast::IdentifierExpression>("ary");
auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
ast::ArrayAccessorExpression expr(ary, idx);
@ -42,8 +43,10 @@ TEST_F(HlslGeneratorImplTest_Expression, EmitExpression_ArrayAccessor) {
}
TEST_F(HlslGeneratorImplTest_Expression, EmitArrayAccessor) {
auto* ary = create<ast::IdentifierExpression>("ary");
auto* idx = create<ast::IdentifierExpression>("idx");
auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx =
create<ast::IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ast::ArrayAccessorExpression expr(ary, idx);

6
src/writer/hlsl/generator_impl_assign_test.cc
View File

@ -28,8 +28,10 @@ namespace {
using HlslGeneratorImplTest_Assign = TestHelper;
TEST_F(HlslGeneratorImplTest_Assign, Emit_Assign) {
auto* lhs = create<ast::IdentifierExpression>("lhs");
auto* rhs = create<ast::IdentifierExpression>("rhs");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
ast::AssignmentStatement assign(lhs, rhs);
gen.increment_indent();

123
src/writer/hlsl/generator_impl_binary_test.cc
View File

@ -79,8 +79,10 @@ TEST_P(HlslBinaryTest, Emit_f32) {
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* left = create<ast::IdentifierExpression>("left");
auto* right = create<ast::IdentifierExpression>("right");
auto* left =
create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
auto* right =
create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
td.RegisterVariableForTesting(left_var);
td.RegisterVariableForTesting(right_var);
@ -113,8 +115,10 @@ TEST_P(HlslBinaryTest, Emit_u32) {
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* left = create<ast::IdentifierExpression>("left");
auto* right = create<ast::IdentifierExpression>("right");
auto* left =
create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
auto* right =
create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
td.RegisterVariableForTesting(left_var);
td.RegisterVariableForTesting(right_var);
@ -147,8 +151,10 @@ TEST_P(HlslBinaryTest, Emit_i32) {
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* left = create<ast::IdentifierExpression>("left");
auto* right = create<ast::IdentifierExpression>("right");
auto* left =
create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
auto* right =
create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
td.RegisterVariableForTesting(left_var);
td.RegisterVariableForTesting(right_var);
@ -243,7 +249,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar) {
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("mat");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f));
@ -270,7 +277,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f));
auto* rhs = create<ast::IdentifierExpression>("mat");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
td.RegisterVariableForTesting(var);
@ -294,7 +302,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("mat");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>(
@ -337,7 +346,8 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
create<ast::FloatLiteral>(&f32, 1.f)));
auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals);
auto* rhs = create<ast::IdentifierExpression>("mat");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
td.RegisterVariableForTesting(var);
@ -361,8 +371,10 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("mat");
auto* rhs = create<ast::IdentifierExpression>("mat");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
td.RegisterVariableForTesting(var);
@ -374,8 +386,10 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
auto* left = create<ast::IdentifierExpression>("left");
auto* right = create<ast::IdentifierExpression>("right");
auto* left =
create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
auto* right =
create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, left, right);
@ -390,10 +404,10 @@ if (_tint_tmp) {
TEST_F(HlslGeneratorImplTest_Binary, Logical_Multi) {
// (a && b) || (c || d)
auto* a = create<ast::IdentifierExpression>("a");
auto* b = create<ast::IdentifierExpression>("b");
auto* c = create<ast::IdentifierExpression>("c");
auto* d = create<ast::IdentifierExpression>("d");
auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
auto* d = create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d");
ast::BinaryExpression expr(
ast::BinaryOp::kLogicalOr,
@ -418,8 +432,10 @@ if (!_tint_tmp_0) {
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_Or) {
auto* left = create<ast::IdentifierExpression>("left");
auto* right = create<ast::IdentifierExpression>("right");
auto* left =
create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
auto* right =
create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, left, right);
@ -454,9 +470,10 @@ TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) {
Source{}, create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* else_if_stmt = create<ast::ElseStatement>(
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>("b"),
create<ast::IdentifierExpression>("c")),
create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
body);
body = create<ast::BlockStatement>();
@ -466,9 +483,10 @@ TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) {
ast::IfStatement expr(
Source{},
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
create<ast::IdentifierExpression>("a"),
create<ast::IdentifierExpression>("b")),
create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd,
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
body,
{
else_if_stmt,
@ -498,9 +516,9 @@ if ((_tint_tmp)) {
TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) {
// return (a && b) || c;
auto* a = create<ast::IdentifierExpression>("a");
auto* b = create<ast::IdentifierExpression>("b");
auto* c = create<ast::IdentifierExpression>("c");
auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
ast::ReturnStatement expr(
Source{},
@ -523,10 +541,10 @@ return (_tint_tmp_0);
TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) {
// a = (b || c) && d;
auto* a = create<ast::IdentifierExpression>("a");
auto* b = create<ast::IdentifierExpression>("b");
auto* c = create<ast::IdentifierExpression>("c");
auto* d = create<ast::IdentifierExpression>("d");
auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
auto* d = create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d");
ast::AssignmentStatement expr(
a,
@ -551,9 +569,9 @@ TEST_F(HlslGeneratorImplTest_Binary, Decl_WithLogical) {
// var a : bool = (b && c) || d;
ast::type::Bool bool_type;
auto* b = create<ast::IdentifierExpression>("b");
auto* c = create<ast::IdentifierExpression>("c");
auto* d = create<ast::IdentifierExpression>("d");
auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
auto* d = create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d");
auto* var = create<ast::Variable>(
Source{}, // source
@ -586,9 +604,9 @@ TEST_F(HlslGeneratorImplTest_Binary, Bitcast_WithLogical) {
// as<i32>(a && (b || c))
ast::type::I32 i32;
auto* a = create<ast::IdentifierExpression>("a");
auto* b = create<ast::IdentifierExpression>("b");
auto* c = create<ast::IdentifierExpression>("c");
auto* a = create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a");
auto* b = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
auto* c = create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c");
ast::BitcastExpression expr(&i32, create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd, a,
@ -620,22 +638,27 @@ TEST_F(HlslGeneratorImplTest_Binary, Call_WithLogical) {
ast::ExpressionList params;
params.push_back(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd, create<ast::IdentifierExpression>("a"),
create<ast::IdentifierExpression>("b")));
ast::BinaryOp::kLogicalAnd,
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")));
params.push_back(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr, create<ast::IdentifierExpression>("c"),
create<ast::IdentifierExpression>("d")));
ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d")));
params.push_back(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>("a"),
create<ast::IdentifierExpression>("c")),
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>("b"),
create<ast::IdentifierExpression>("d"))));
create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("d"), "d"))));
ast::CallStatement expr(create<ast::CallExpression>(
create<ast::IdentifierExpression>("foo"), params));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
params));
ASSERT_TRUE(gen.EmitStatement(out, &expr)) << gen.error();
EXPECT_EQ(result(), R"(bool _tint_tmp = a;

6
src/writer/hlsl/generator_impl_bitcast_test.cc
View File

@ -31,7 +31,7 @@ using HlslGeneratorImplTest_Bitcast = TestHelper;
TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Float) {
ast::type::F32 f32;
auto* id = create<ast::IdentifierExpression>("id");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
ast::BitcastExpression bitcast(&f32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
@ -40,7 +40,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Float) {
TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
ast::type::I32 i32;
auto* id = create<ast::IdentifierExpression>("id");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
ast::BitcastExpression bitcast(&i32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();
@ -49,7 +49,7 @@ TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
TEST_F(HlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
ast::type::U32 u32;
auto* id = create<ast::IdentifierExpression>("id");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
ast::BitcastExpression bitcast(&u32, id);
ASSERT_TRUE(gen.EmitExpression(pre, out, &bitcast)) << gen.error();

21
src/writer/hlsl/generator_impl_call_test.cc
View File

@ -32,7 +32,8 @@ using HlslGeneratorImplTest_Call = TestHelper;
TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithoutParams) {
ast::type::Void void_type;
auto* id = create<ast::IdentifierExpression>("my_func");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
"my_func");
ast::CallExpression call(id, {});
auto* func = create<ast::Function>(
@ -47,10 +48,13 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithoutParams) {
TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
ast::type::Void void_type;
auto* id = create<ast::IdentifierExpression>("my_func");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
"my_func");
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("param1"));
params.push_back(create<ast::IdentifierExpression>("param2"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param2"), "param2"));
ast::CallExpression call(id, params);
auto* func = create<ast::Function>(
@ -65,10 +69,13 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
TEST_F(HlslGeneratorImplTest_Call, EmitStatement_Call) {
ast::type::Void void_type;
auto* id = create<ast::IdentifierExpression>("my_func");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
"my_func");
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("param1"));
params.push_back(create<ast::IdentifierExpression>("param2"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param2"), "param2"));
ast::CallStatement call(create<ast::CallExpression>(id, params));
auto* func = create<ast::Function>(

6
src/writer/hlsl/generator_impl_cast_test.cc
View File

@ -32,7 +32,8 @@ TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Scalar) {
ast::type::F32 f32;
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("id"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
ast::TypeConstructorExpression cast(&f32, params);
@ -45,7 +46,8 @@ TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Vector) {
ast::type::Vector vec3(&f32, 3);
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("id"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
ast::TypeConstructorExpression cast(&vec3, params);

55
src/writer/hlsl/generator_impl_function_entry_point_data_test.cc
View File

@ -84,11 +84,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@ -157,11 +157,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@ -230,11 +230,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -302,11 +302,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -371,11 +371,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -435,11 +435,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -506,10 +506,11 @@ TEST_F(HlslGeneratorImplTest_EntryPoint,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &void_type, body,

131
src/writer/hlsl/generator_impl_function_test.cc
View File

@ -171,8 +171,8 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("frag_main"), "frag_main", params,
@ -241,10 +241,11 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("frag_main"), "frag_main", params,
@ -304,8 +305,10 @@ TEST_F(HlslGeneratorImplTest_Function,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"),
"x")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -375,9 +378,12 @@ TEST_F(HlslGeneratorImplTest_Function,
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("uniforms"),
create<ast::IdentifierExpression>("coord")),
create<ast::IdentifierExpression>("x")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("uniforms"),
"uniforms"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"),
"x")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -452,8 +458,10 @@ TEST_F(HlslGeneratorImplTest_Function,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
"b")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -524,8 +532,10 @@ TEST_F(HlslGeneratorImplTest_Function,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
"b")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -592,8 +602,9 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::VariableList params;
auto* assign = create<ast::AssignmentStatement>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f)));
@ -683,13 +694,14 @@ TEST_F(
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("val"),
create<ast::IdentifierExpression>("param")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("val"), "val"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("foo")));
Source{},
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -702,8 +714,10 @@ TEST_F(
body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
"sub_func"),
expr)));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func_1 = create<ast::Function>(
@ -774,7 +788,8 @@ TEST_F(HlslGeneratorImplTest_Function,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("param")));
Source{},
create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -787,8 +802,10 @@ TEST_F(HlslGeneratorImplTest_Function,
body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
"sub_func"),
expr)));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func_1 = create<ast::Function>(
@ -867,12 +884,14 @@ TEST_F(
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("param")));
Source{},
create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -885,8 +904,10 @@ TEST_F(
body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
"sub_func"),
expr)));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func_1 = create<ast::Function>(
@ -956,9 +977,11 @@ TEST_F(HlslGeneratorImplTest_Function,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
Source{},
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -969,13 +992,15 @@ TEST_F(HlslGeneratorImplTest_Function,
expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)));
auto* var = create<ast::Variable>(
Source{}, // source
auto* var =
create<ast::Variable>(Source{}, // source
"v", // name
ast::StorageClass::kFunction, // storage_class
&f32, // type
false, // is_const
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(
mod.RegisterSymbol("sub_func"), "sub_func"),
expr), // constructor
ast::VariableDecorationList{}); // decorations
@ -1044,9 +1069,11 @@ TEST_F(HlslGeneratorImplTest_Function,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
Source{},
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -1057,13 +1084,15 @@ TEST_F(HlslGeneratorImplTest_Function,
expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)));
auto* var = create<ast::Variable>(
Source{}, // source
auto* var =
create<ast::Variable>(Source{}, // source
"v", // name
ast::StorageClass::kFunction, // storage_class
&f32, // type
false, // is_const
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(
mod.RegisterSymbol("sub_func"), "sub_func"),
expr), // constructor
ast::VariableDecorationList{}); // decorations
@ -1119,7 +1148,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))));
@ -1326,8 +1355,10 @@ TEST_F(HlslGeneratorImplTest_Function,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("d")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -1352,8 +1383,10 @@ TEST_F(HlslGeneratorImplTest_Function,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("d")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();

4
src/writer/hlsl/generator_impl_identifier_test.cc
View File

@ -24,14 +24,14 @@ namespace {
using HlslGeneratorImplTest_Identifier = TestHelper;
TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
ast::IdentifierExpression i("foo");
ast::IdentifierExpression i(mod.RegisterSymbol("foo"), "foo");
ASSERT_TRUE(gen.EmitExpression(pre, out, &i)) << gen.error();
EXPECT_EQ(result(), "foo");
}
TEST_F(HlslGeneratorImplTest_Identifier,
EmitIdentifierExpression_Single_WithCollision) {
ast::IdentifierExpression i("virtual");
ast::IdentifierExpression i(mod.RegisterSymbol("virtual"), "virtual");
ASSERT_TRUE(gen.EmitExpression(pre, out, &i)) << gen.error();
EXPECT_EQ(result(), "virtual_tint_0");
}

18
src/writer/hlsl/generator_impl_if_test.cc
View File

@ -27,7 +27,8 @@ namespace {
using HlslGeneratorImplTest_If = TestHelper;
TEST_F(HlslGeneratorImplTest_If, Emit_If) {
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));
@ -42,11 +43,13 @@ TEST_F(HlslGeneratorImplTest_If, Emit_If) {
}
TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElseIf) {
auto* else_cond = create<ast::IdentifierExpression>("else_cond");
auto* else_cond = create<ast::IdentifierExpression>(
mod.RegisterSymbol("else_cond"), "else_cond");
auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ReturnStatement>(Source{}));
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));
@ -70,7 +73,8 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) {
auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ReturnStatement>(Source{}));
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));
@ -89,7 +93,8 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithElse) {
}
TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) {
auto* else_cond = create<ast::IdentifierExpression>("else_cond");
auto* else_cond = create<ast::IdentifierExpression>(
mod.RegisterSymbol("else_cond"), "else_cond");
auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ReturnStatement>(Source{}));
@ -97,7 +102,8 @@ TEST_F(HlslGeneratorImplTest_If, Emit_IfWithMultiple) {
auto* else_body_2 = create<ast::BlockStatement>();
else_body_2->append(create<ast::ReturnStatement>(Source{}));
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));

28
src/writer/hlsl/generator_impl_import_test.cc
View File

@ -56,7 +56,8 @@ TEST_P(HlslImportData_SingleParamTest, FloatScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)));
auto* ident = create<ast::IdentifierExpression>(param.name);
auto* ident = create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name);
ast::CallExpression expr(ident, params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -101,7 +102,8 @@ TEST_P(HlslImportData_SingleIntParamTest, IntScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -124,7 +126,8 @@ TEST_P(HlslImportData_DualParamTest, FloatScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -169,7 +172,8 @@ TEST_P(HlslImportData_DualParam_VectorTest, FloatVector) {
create<ast::FloatLiteral>(&f32, 6.f)),
}));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -194,7 +198,8 @@ TEST_P(HlslImportData_DualParam_Int_Test, IntScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -220,7 +225,8 @@ TEST_P(HlslImportData_TripleParamTest, FloatScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -253,7 +259,8 @@ TEST_P(HlslImportData_TripleParam_Int_Test, IntScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -278,9 +285,12 @@ TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) {
ast::VariableDecorationList{}); // decorations
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("var"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("var"), "var"));
ast::CallExpression expr(create<ast::IdentifierExpression>("determinant"),
ast::CallExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("determinant"),
"determinant"),
params);
mod.AddGlobalVariable(var);

20
src/writer/hlsl/generator_impl_intrinsic_test.cc
View File

@ -93,10 +93,14 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, DISABLED_Intrinsic_OuterProduct) {
ast::VariableDecorationList{}); // decorations
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("a"));
params.push_back(create<ast::IdentifierExpression>("b"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
ast::CallExpression call(create<ast::IdentifierExpression>("outer_product"),
ast::CallExpression call(
create<ast::IdentifierExpression>(mod.RegisterSymbol("outer_product"),
"outer_product"),
params);
td.RegisterVariableForTesting(a);
@ -122,10 +126,14 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
ast::type::Vector vec(&f32, 3);
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("param1"));
params.push_back(create<ast::IdentifierExpression>("param2"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param2"), "param2"));
ast::CallExpression call(create<ast::IdentifierExpression>("dot"), params);
ast::CallExpression call(
create<ast::IdentifierExpression>(mod.RegisterSymbol("dot"), "dot"),
params);
ast::Variable v1(Source{}, "param1", ast::StorageClass::kFunction, &vec,
false, nullptr, ast::VariableDecorationList{});

12
src/writer/hlsl/generator_impl_loop_test.cc
View File

@ -86,8 +86,10 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopNestedWithContinuing) {
body = create<ast::BlockStatement>();
body->append(inner);
auto* lhs = create<ast::IdentifierExpression>("lhs");
auto* rhs = create<ast::IdentifierExpression>("rhs");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
continuing = create<ast::BlockStatement>();
continuing->append(create<ast::AssignmentStatement>(lhs, rhs));
@ -165,8 +167,10 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) {
nullptr, // constructor
ast::VariableDecorationList{}))); // decorations
auto* lhs = create<ast::IdentifierExpression>("lhs");
auto* rhs = create<ast::IdentifierExpression>("rhs");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
auto* continuing = create<ast::BlockStatement>();
continuing->append(create<ast::AssignmentStatement>(lhs, rhs));

127
src/writer/hlsl/generator_impl_member_accessor_test.cc
View File

@ -66,8 +66,10 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* str = create<ast::IdentifierExpression>("str");
auto* mem = create<ast::IdentifierExpression>("mem");
auto* str =
create<ast::IdentifierExpression>(mod.RegisterSymbol("str"), "str");
auto* mem =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mem"), "mem");
ast::MemberAccessorExpression expr(str, mem);
@ -115,8 +117,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("b"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var);
@ -164,8 +167,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var);
@ -226,9 +230,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
auto* rhs = create<ast::IdentifierExpression>("b");
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
auto* rhs = create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b");
ast::AssignmentStatement assign(lhs, rhs);
@ -289,8 +293,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
auto* rhs =
create<ast::TypeConstructorExpression>(&mat, ast::ExpressionList{});
@ -349,8 +353,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var);
@ -405,8 +410,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var);
@ -453,8 +459,9 @@ TEST_F(
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var);
@ -508,8 +515,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ast::ArrayAccessorExpression expr(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::ScalarConstructorExpression>(
@ -562,8 +570,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ast::ArrayAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
@ -614,8 +622,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ast::ArrayAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::BinaryExpression>(
ast::BinaryOp::kSubtract,
create<ast::BinaryExpression>(
@ -681,8 +689,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.Determine()) << td.error();
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("b"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f));
ast::AssignmentStatement assign(lhs, rhs);
@ -736,8 +744,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto* lhs = create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto* rhs = create<ast::ScalarConstructorExpression>(
@ -793,8 +801,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.Determine()) << td.error();
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("a"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
ast::AssignmentStatement assign(lhs, rhs);
@ -849,8 +857,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.Determine()) << td.error();
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("b"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
ASSERT_TRUE(td.DetermineResultType(&expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@ -910,8 +919,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
values.push_back(create<ast::ScalarConstructorExpression>(lit3));
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("b"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
auto* rhs = create<ast::TypeConstructorExpression>(&fvec3, values);
ast::AssignmentStatement assign(lhs, rhs);
@ -988,11 +997,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ast::MemberAccessorExpression expr(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("c")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("b"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
ASSERT_TRUE(td.DetermineResultType(&expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@ -1066,12 +1076,14 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::MemberAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("c")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("b")),
create<ast::IdentifierExpression>("xy"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("xy"), "xy"));
ASSERT_TRUE(td.DetermineResultType(&expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@ -1144,12 +1156,14 @@ TEST_F(
create<ast::MemberAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("c")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("b")),
create<ast::IdentifierExpression>("g"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("g"), "g"));
ASSERT_TRUE(td.DetermineResultType(&expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@ -1221,11 +1235,13 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::MemberAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("c")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)));
@ -1298,11 +1314,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("c")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("b"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f);
auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f);
@ -1388,12 +1405,14 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::MemberAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("c")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("b")),
create<ast::IdentifierExpression>("y"));
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("y"), "y"));
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&i32, 1.f));

3
src/writer/hlsl/generator_impl_return_test.cc
View File

@ -36,7 +36,8 @@ TEST_F(HlslGeneratorImplTest_Return, Emit_Return) {
}
TEST_F(HlslGeneratorImplTest_Return, Emit_ReturnWithValue) {
auto* expr = create<ast::IdentifierExpression>("expr");
auto* expr =
create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ast::ReturnStatement r(Source{}, expr);
gen.increment_indent();

3
src/writer/hlsl/generator_impl_switch_test.cc
View File

@ -48,7 +48,8 @@ TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) {
body.push_back(case_stmt);
body.push_back(def);
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
ast::SwitchStatement s(cond, body);
gen.increment_indent();

3
src/writer/hlsl/generator_impl_test.cc
View File

@ -56,7 +56,8 @@ TEST_F(HlslGeneratorImplTest, InputStructName_ConflictWithExisting) {
TEST_F(HlslGeneratorImplTest, NameConflictWith_InputStructName) {
ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
ast::IdentifierExpression ident("func_main_in");
ast::IdentifierExpression ident(mod.RegisterSymbol("func_main_in"),
"func_main_in");
ASSERT_TRUE(gen.EmitIdentifier(pre, out, &ident));
EXPECT_EQ(result(), "func_main_in_0");
}

3
src/writer/hlsl/generator_impl_unary_op_test.cc
View File

@ -37,7 +37,8 @@ using HlslUnaryOpTest = TestParamHelper<UnaryOpData>;
TEST_P(HlslUnaryOpTest, Emit) {
auto params = GetParam();
auto* expr = create<ast::IdentifierExpression>("expr");
auto* expr =
create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ast::UnaryOpExpression op(params.op, expr);
ASSERT_TRUE(gen.EmitExpression(pre, out, &op)) << gen.error();

3
src/writer/hlsl/generator_impl_variable_decl_statement_test.cc
View File

@ -127,7 +127,8 @@ TEST_F(HlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) {
TEST_F(HlslGeneratorImplTest_VariableDecl,
Emit_VariableDeclStatement_Initializer_Private) {
auto* ident = create<ast::IdentifierExpression>("initializer");
auto* ident = create<ast::IdentifierExpression>(
mod.RegisterSymbol("initializer"), "initializer");
ast::type::F32 f32;
auto* var =

9
src/writer/msl/generator_impl_array_accessor_test.cc
View File

@ -35,7 +35,8 @@ TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, 5);
auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* ary = create<ast::IdentifierExpression>("ary");
auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
ast::ArrayAccessorExpression expr(ary, idx);
@ -44,8 +45,10 @@ TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
}
TEST_F(MslGeneratorImplTest, EmitArrayAccessor) {
auto* ary = create<ast::IdentifierExpression>("ary");
auto* idx = create<ast::IdentifierExpression>("idx");
auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx =
create<ast::IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ast::ArrayAccessorExpression expr(ary, idx);

6
src/writer/msl/generator_impl_assign_test.cc
View File

@ -30,8 +30,10 @@ namespace {
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Assign) {
auto* lhs = create<ast::IdentifierExpression>("lhs");
auto* rhs = create<ast::IdentifierExpression>("rhs");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
ast::AssignmentStatement assign(lhs, rhs);
gen.increment_indent();

6
src/writer/msl/generator_impl_binary_test.cc
View File

@ -38,8 +38,10 @@ using MslBinaryTest = TestParamHelper<BinaryData>;
TEST_P(MslBinaryTest, Emit) {
auto params = GetParam();
auto* left = create<ast::IdentifierExpression>("left");
auto* right = create<ast::IdentifierExpression>("right");
auto* left =
create<ast::IdentifierExpression>(mod.RegisterSymbol("left"), "left");
auto* right =
create<ast::IdentifierExpression>(mod.RegisterSymbol("right"), "right");
ast::BinaryExpression expr(params.op, left, right);

2
src/writer/msl/generator_impl_bitcast_test.cc
View File

@ -31,7 +31,7 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) {
ast::type::F32 f32;
auto* id = create<ast::IdentifierExpression>("id");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id");
ast::BitcastExpression bitcast(&f32, id);
ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();

21
src/writer/msl/generator_impl_call_test.cc
View File

@ -34,7 +34,8 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
ast::type::Void void_type;
auto* id = create<ast::IdentifierExpression>("my_func");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
"my_func");
ast::CallExpression call(id, {});
auto* func = create<ast::Function>(
@ -49,10 +50,13 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
ast::type::Void void_type;
auto* id = create<ast::IdentifierExpression>("my_func");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
"my_func");
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("param1"));
params.push_back(create<ast::IdentifierExpression>("param2"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param2"), "param2"));
ast::CallExpression call(id, params);
auto* func = create<ast::Function>(
@ -67,10 +71,13 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
TEST_F(MslGeneratorImplTest, EmitStatement_Call) {
ast::type::Void void_type;
auto* id = create<ast::IdentifierExpression>("my_func");
auto* id = create<ast::IdentifierExpression>(mod.RegisterSymbol("my_func"),
"my_func");
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("param1"));
params.push_back(create<ast::IdentifierExpression>("param2"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param2"), "param2"));
ast::CallStatement call(create<ast::CallExpression>(id, params));
auto* func = create<ast::Function>(

6
src/writer/msl/generator_impl_cast_test.cc
View File

@ -34,7 +34,8 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Scalar) {
ast::type::F32 f32;
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("id"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
ast::TypeConstructorExpression cast(&f32, params);
@ -47,7 +48,8 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Vector) {
ast::type::Vector vec3(&f32, 3);
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("id"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("id"), "id"));
ast::TypeConstructorExpression cast(&vec3, params);

55
src/writer/msl/generator_impl_function_entry_point_data_test.cc
View File

@ -83,11 +83,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Input) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@ -153,11 +153,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Output) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("vtx_main"), "vtx_main", params, &f32, body,
@ -223,11 +223,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Input) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
ast::FunctionDecorationList{
@ -292,11 +292,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Output) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -359,11 +359,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Input) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -421,11 +421,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Output) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("foo"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("bar")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar")));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &f32, body,
@ -490,10 +490,11 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Builtins) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("main"), "main", params, &void_type, body,

133
src/writer/msl/generator_impl_function_test.cc
View File

@ -179,8 +179,8 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionDecoration_EntryPoint_WithInOutVars) {
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func = create<ast::Function>(
@ -252,10 +252,11 @@ TEST_F(MslGeneratorImplTest,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func = create<ast::Function>(
@ -315,8 +316,10 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionDecoration_EntryPoint_With_Uniform) {
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"),
"x")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -392,8 +395,10 @@ TEST_F(MslGeneratorImplTest,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
"b")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -474,8 +479,10 @@ TEST_F(MslGeneratorImplTest,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"),
"b")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -571,13 +578,14 @@ TEST_F(
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>("foo")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("val"),
create<ast::IdentifierExpression>("param")));
create<ast::IdentifierExpression>(mod.RegisterSymbol("val"), "val"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("foo")));
Source{},
create<ast::IdentifierExpression>(mod.RegisterSymbol("foo"), "foo")));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -590,8 +598,10 @@ TEST_F(
body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
"sub_func"),
expr)));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func_1 = create<ast::Function>(
@ -665,7 +675,8 @@ TEST_F(MslGeneratorImplTest,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("param")));
Source{},
create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -678,8 +689,10 @@ TEST_F(MslGeneratorImplTest,
body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
"sub_func"),
expr)));
body->append(create<ast::ReturnStatement>(Source{}));
@ -762,12 +775,14 @@ TEST_F(
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("param")));
Source{},
create<ast::IdentifierExpression>(mod.RegisterSymbol("param"), "param")));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -780,8 +795,10 @@ TEST_F(
body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("depth"),
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("depth"), "depth"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("sub_func"),
"sub_func"),
expr)));
body->append(create<ast::ReturnStatement>(Source{}));
auto* func_1 = create<ast::Function>(
@ -849,9 +866,11 @@ TEST_F(MslGeneratorImplTest,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("x"))));
Source{},
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("x"), "x"))));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -862,13 +881,15 @@ TEST_F(MslGeneratorImplTest,
expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)));
auto* var = create<ast::Variable>(
Source{}, // source
auto* var =
create<ast::Variable>(Source{}, // source
"v", // name
ast::StorageClass::kFunction, // storage_class
&f32, // type
false, // is_const
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(
mod.RegisterSymbol("sub_func"), "sub_func"),
expr), // constructor
ast::VariableDecorationList{}); // decorations
@ -951,9 +972,11 @@ TEST_F(MslGeneratorImplTest,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b"))));
Source{},
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"))));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -964,13 +987,15 @@ TEST_F(MslGeneratorImplTest,
expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)));
auto* var = create<ast::Variable>(
Source{}, // source
auto* var =
create<ast::Variable>(Source{}, // source
"v", // name
ast::StorageClass::kFunction, // storage_class
&f32, // type
false, // is_const
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(
mod.RegisterSymbol("sub_func"), "sub_func"),
expr), // constructor
ast::VariableDecorationList{}); // decorations
@ -1059,9 +1084,11 @@ TEST_F(MslGeneratorImplTest,
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("coord"),
create<ast::IdentifierExpression>("b"))));
Source{},
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("coord"),
"coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"))));
auto* sub_func = create<ast::Function>(
Source{}, mod.RegisterSymbol("sub_func"), "sub_func", params, &f32, body,
ast::FunctionDecorationList{});
@ -1072,13 +1099,15 @@ TEST_F(MslGeneratorImplTest,
expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)));
auto* var = create<ast::Variable>(
Source{}, // source
auto* var =
create<ast::Variable>(Source{}, // source
"v", // name
ast::StorageClass::kFunction, // storage_class
&f32, // type
false, // is_const
create<ast::CallExpression>(create<ast::IdentifierExpression>("sub_func"),
create<ast::CallExpression>(
create<ast::IdentifierExpression>(
mod.RegisterSymbol("sub_func"), "sub_func"),
expr), // constructor
ast::VariableDecorationList{}); // decorations
@ -1141,7 +1170,7 @@ TEST_F(MslGeneratorImplTest,
ast::VariableList params;
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("bar"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))));
@ -1306,8 +1335,10 @@ TEST_F(MslGeneratorImplTest,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("d")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -1333,8 +1364,10 @@ TEST_F(MslGeneratorImplTest,
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("d")), // constructor
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();

4
src/writer/msl/generator_impl_identifier_test.cc
View File

@ -26,14 +26,14 @@ namespace {
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitIdentifierExpression) {
ast::IdentifierExpression i("foo");
ast::IdentifierExpression i(mod.RegisterSymbol("foo"), "foo");
ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
EXPECT_EQ(gen.result(), "foo");
}
TEST_F(MslGeneratorImplTest, EmitIdentifierExpression_Single_WithCollision) {
ast::IdentifierExpression i("virtual");
ast::IdentifierExpression i(mod.RegisterSymbol("virtual"), "virtual");
ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error();
EXPECT_EQ(gen.result(), "virtual_tint_0");

18
src/writer/msl/generator_impl_if_test.cc
View File

@ -29,7 +29,8 @@ namespace {
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_If) {
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));
@ -45,11 +46,13 @@ TEST_F(MslGeneratorImplTest, Emit_If) {
}
TEST_F(MslGeneratorImplTest, Emit_IfWithElseIf) {
auto* else_cond = create<ast::IdentifierExpression>("else_cond");
auto* else_cond = create<ast::IdentifierExpression>(
mod.RegisterSymbol("else_cond"), "else_cond");
auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ReturnStatement>(Source{}));
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));
@ -71,7 +74,8 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithElse) {
auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ReturnStatement>(Source{}));
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));
@ -90,7 +94,8 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithElse) {
}
TEST_F(MslGeneratorImplTest, Emit_IfWithMultiple) {
auto* else_cond = create<ast::IdentifierExpression>("else_cond");
auto* else_cond = create<ast::IdentifierExpression>(
mod.RegisterSymbol("else_cond"), "else_cond");
auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ReturnStatement>(Source{}));
@ -98,7 +103,8 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithMultiple) {
auto* else_body_2 = create<ast::BlockStatement>();
else_body_2->append(create<ast::ReturnStatement>(Source{}));
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}));

29
src/writer/msl/generator_impl_import_test.cc
View File

@ -57,7 +57,8 @@ TEST_P(MslImportData_SingleParamTest, FloatScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)));
auto* ident = create<ast::IdentifierExpression>(param.name);
auto* ident = create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name);
ast::CallExpression call(ident, params);
@ -100,7 +101,9 @@ TEST_F(MslGeneratorImplTest, MslImportData_SingleParamTest_IntScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)));
ast::CallExpression expr(create<ast::IdentifierExpression>("abs"), params);
ast::CallExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("abs"), "abs"),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -120,7 +123,8 @@ TEST_P(MslImportData_DualParamTest, FloatScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -168,7 +172,8 @@ TEST_P(MslImportData_DualParam_VectorTest, FloatVector) {
create<ast::FloatLiteral>(&f32, 6.f)),
}));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -193,7 +198,8 @@ TEST_P(MslImportData_DualParam_Int_Test, IntScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -219,7 +225,8 @@ TEST_P(MslImportData_TripleParamTest, FloatScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -250,7 +257,8 @@ TEST_P(MslImportData_TripleParam_Int_Test, IntScalar) {
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)));
ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name),
params);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -277,9 +285,12 @@ TEST_F(MslGeneratorImplTest, MslImportData_Determinant) {
ast::VariableDecorationList{}); // decorations
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("var"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("var"), "var"));
ast::CallExpression expr(create<ast::IdentifierExpression>("determinant"),
ast::CallExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("determinant"),
"determinant"),
params);
mod.AddGlobalVariable(var);

20
src/writer/msl/generator_impl_intrinsic_test.cc
View File

@ -88,10 +88,14 @@ TEST_F(MslGeneratorImplTest, DISABLED_Intrinsic_OuterProduct) {
ast::VariableDecorationList{}); // decorations
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("a"));
params.push_back(create<ast::IdentifierExpression>("b"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
params.push_back(
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
ast::CallExpression call(create<ast::IdentifierExpression>("outer_product"),
ast::CallExpression call(
create<ast::IdentifierExpression>(mod.RegisterSymbol("outer_product"),
"outer_product"),
params);
td.RegisterVariableForTesting(a);
@ -117,10 +121,14 @@ TEST_F(MslGeneratorImplTest, Intrinsic_Call) {
ast::type::Vector vec(&f32, 3);
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>("param1"));
params.push_back(create<ast::IdentifierExpression>("param2"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
mod.RegisterSymbol("param2"), "param2"));
ast::CallExpression call(create<ast::IdentifierExpression>("dot"), params);
ast::CallExpression call(
create<ast::IdentifierExpression>(mod.RegisterSymbol("dot"), "dot"),
params);
ast::Variable v1(Source{}, "param1", ast::StorageClass::kFunction, &vec,
false, nullptr, ast::VariableDecorationList{});

12
src/writer/msl/generator_impl_loop_test.cc
View File

@ -90,8 +90,10 @@ TEST_F(MslGeneratorImplTest, Emit_LoopNestedWithContinuing) {
body = create<ast::BlockStatement>();
body->append(inner);
auto* lhs = create<ast::IdentifierExpression>("lhs");
auto* rhs = create<ast::IdentifierExpression>("rhs");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
continuing = create<ast::BlockStatement>();
continuing->append(create<ast::AssignmentStatement>(lhs, rhs));
@ -170,8 +172,10 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithVarUsedInContinuing) {
nullptr, // constructor
ast::VariableDecorationList{}))); // decorations
auto* lhs = create<ast::IdentifierExpression>("lhs");
auto* rhs = create<ast::IdentifierExpression>("rhs");
auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("lhs"), "lhs");
auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("rhs"), "rhs");
auto* continuing = create<ast::BlockStatement>();
continuing->append(create<ast::AssignmentStatement>(lhs, rhs));

6
src/writer/msl/generator_impl_member_accessor_test.cc
View File

@ -29,8 +29,10 @@ namespace {
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) {
auto* str = create<ast::IdentifierExpression>("str");
auto* mem = create<ast::IdentifierExpression>("mem");
auto* str =
create<ast::IdentifierExpression>(mod.RegisterSymbol("str"), "str");
auto* mem =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mem"), "mem");
ast::MemberAccessorExpression expr(str, mem);

3
src/writer/msl/generator_impl_return_test.cc
View File

@ -39,7 +39,8 @@ TEST_F(MslGeneratorImplTest, Emit_Return) {
}
TEST_F(MslGeneratorImplTest, Emit_ReturnWithValue) {
auto* expr = create<ast::IdentifierExpression>("expr");
auto* expr =
create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ast::ReturnStatement r(Source{}, expr);
gen.increment_indent();

3
src/writer/msl/generator_impl_switch_test.cc
View File

@ -50,7 +50,8 @@ TEST_F(MslGeneratorImplTest, Emit_Switch) {
body.push_back(case_stmt);
body.push_back(def);
auto* cond = create<ast::IdentifierExpression>("cond");
auto* cond =
create<ast::IdentifierExpression>(mod.RegisterSymbol("cond"), "cond");
ast::SwitchStatement s(cond, body);
gen.increment_indent();

3
src/writer/msl/generator_impl_test.cc
View File

@ -79,7 +79,8 @@ TEST_F(MslGeneratorImplTest, InputStructName_ConflictWithExisting) {
TEST_F(MslGeneratorImplTest, NameConflictWith_InputStructName) {
ASSERT_EQ(gen.generate_name("func_main_in"), "func_main_in");
ast::IdentifierExpression ident("func_main_in");
ast::IdentifierExpression ident(mod.RegisterSymbol("func_main_in"),
"func_main_in");
ASSERT_TRUE(gen.EmitIdentifier(&ident));
EXPECT_EQ(gen.result(), "func_main_in_0");
}

3
src/writer/msl/generator_impl_unary_op_test.cc
View File

@ -39,7 +39,8 @@ using MslUnaryOpTest = TestParamHelper<UnaryOpData>;
TEST_P(MslUnaryOpTest, Emit) {
auto params = GetParam();
auto* expr = create<ast::IdentifierExpression>("expr");
auto* expr =
create<ast::IdentifierExpression>(mod.RegisterSymbol("expr"), "expr");
ast::UnaryOpExpression op(params.op, expr);
ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();

3
src/writer/msl/generator_impl_variable_decl_statement_test.cc
View File

@ -193,7 +193,8 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
auto* ident = create<ast::IdentifierExpression>("initializer");
auto* ident = create<ast::IdentifierExpression>(
mod.RegisterSymbol("initializer"), "initializer");
ast::type::F32 f32;
auto* var =

106
src/writer/spirv/builder_accessor_expression_test.cc
View File

@ -56,7 +56,8 @@ TEST_F(BuilderTest, ArrayAccessor) {
ast::Variable var(Source{}, "ary", ast::StorageClass::kFunction, &vec3, false,
nullptr, ast::VariableDecorationList{});
auto* ary = create<ast::IdentifierExpression>("ary");
auto* ary =
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
auto* idx_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1));
@ -100,8 +101,10 @@ TEST_F(BuilderTest, Accessor_Array_LoadIndex) {
ast::Variable idx(Source{}, "idx", ast::StorageClass::kFunction, &i32, false,
nullptr, ast::VariableDecorationList{});
auto* ary = create<ast::IdentifierExpression>("ary");
auto* idx_expr = create<ast::IdentifierExpression>("idx");
auto* ary =
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
auto* idx_expr =
create<ast::IdentifierExpression>(mod->RegisterSymbol("idx"), "idx");
ast::ArrayAccessorExpression expr(ary, idx_expr);
@ -145,7 +148,8 @@ TEST_F(BuilderTest, ArrayAccessor_Dynamic) {
ast::Variable var(Source{}, "ary", ast::StorageClass::kFunction, &vec3, false,
nullptr, ast::VariableDecorationList{});
auto* ary = create<ast::IdentifierExpression>("ary");
auto* ary =
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
ast::ArrayAccessorExpression expr(
ary,
@ -195,7 +199,7 @@ TEST_F(BuilderTest, ArrayAccessor_MultiLevel) {
ast::ArrayAccessorExpression expr(
create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("ary"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))),
create<ast::ScalarConstructorExpression>(
@ -243,10 +247,10 @@ TEST_F(BuilderTest, Accessor_ArrayWithSwizzle) {
ast::MemberAccessorExpression expr(
create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("ary"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("xy"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("xy"), "xy"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -298,8 +302,9 @@ TEST_F(BuilderTest, MemberAccessor) {
ast::Variable var(Source{}, "ident", ast::StorageClass::kFunction, &s_type,
false, nullptr, ast::VariableDecorationList{});
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("b"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -355,9 +360,11 @@ TEST_F(BuilderTest, MemberAccessor_Nested) {
ast::MemberAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("inner")),
create<ast::IdentifierExpression>("a"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
"inner")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -416,9 +423,11 @@ TEST_F(BuilderTest, MemberAccessor_Nested_WithAlias) {
ast::MemberAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("inner")),
create<ast::IdentifierExpression>("a"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
"inner")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -476,9 +485,11 @@ TEST_F(BuilderTest, MemberAccessor_Nested_Assignment_LHS) {
auto* lhs = create<ast::MemberAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("inner")),
create<ast::IdentifierExpression>("a"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
"inner")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f));
@ -543,13 +554,16 @@ TEST_F(BuilderTest, MemberAccessor_Nested_Assignment_RHS) {
ast::Variable store(Source{}, "store", ast::StorageClass::kFunction, &f32,
false, nullptr, ast::VariableDecorationList{});
auto* lhs = create<ast::IdentifierExpression>("store");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("store"), "store");
auto* rhs = create<ast::MemberAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("inner")),
create<ast::IdentifierExpression>("a"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("inner"),
"inner")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
ast::AssignmentStatement expr(lhs, rhs);
@ -593,8 +607,9 @@ TEST_F(BuilderTest, MemberAccessor_Swizzle_Single) {
ast::Variable var(Source{}, "ident", ast::StorageClass::kFunction, &vec3,
false, nullptr, ast::VariableDecorationList{});
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("y"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("y"), "y"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -629,8 +644,9 @@ TEST_F(BuilderTest, MemberAccessor_Swizzle_MultipleNames) {
ast::Variable var(Source{}, "ident", ast::StorageClass::kFunction, &vec3,
false, nullptr, ast::VariableDecorationList{});
ast::MemberAccessorExpression expr(create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("yx"));
ast::MemberAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("yx"), "yx"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -666,9 +682,10 @@ TEST_F(BuilderTest, MemberAccessor_Swizzle_of_Swizzle) {
ast::MemberAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("yxz")),
create<ast::IdentifierExpression>("xz"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("xz"), "xz"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -705,9 +722,10 @@ TEST_F(BuilderTest, MemberAccessor_Member_of_Swizzle) {
ast::MemberAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("yxz")),
create<ast::IdentifierExpression>("x"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("x"), "x"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -744,8 +762,9 @@ TEST_F(BuilderTest, MemberAccessor_Array_of_Swizzle) {
ast::ArrayAccessorExpression expr(
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("yxz")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"),
"ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)));
@ -818,15 +837,18 @@ TEST_F(BuilderTest, Accessor_Mixed_ArrayAndMember) {
create<ast::ArrayAccessorExpression>(
create<ast::MemberAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("index"),
create<ast::IdentifierExpression>(
mod->RegisterSymbol("index"), "index"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 0))),
create<ast::IdentifierExpression>("foo")),
create<ast::IdentifierExpression>(
mod->RegisterSymbol("foo"), "foo")),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))),
create<ast::IdentifierExpression>("bar")),
create<ast::IdentifierExpression>("baz")),
create<ast::IdentifierExpression>("yx"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("bar"),
"bar")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("baz"), "baz")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("yx"), "yx"));
td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -906,7 +928,8 @@ TEST_F(BuilderTest, Accessor_Array_Of_Vec) {
create<ast::TypeConstructorExpression>(&arr, ary_params),
ast::VariableDecorationList{});
ast::ArrayAccessorExpression expr(create<ast::IdentifierExpression>("pos"),
ast::ArrayAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)));
@ -963,7 +986,8 @@ TEST_F(BuilderTest, Accessor_Const_Vec) {
create<ast::TypeConstructorExpression>(&vec, std::move(vec_params)),
ast::VariableDecorationList{});
ast::ArrayAccessorExpression expr(create<ast::IdentifierExpression>("pos"),
ast::ArrayAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)));

25
src/writer/spirv/builder_assign_test.cc
View File

@ -47,7 +47,8 @@ TEST_F(BuilderTest, Assign_Var) {
ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &f32, false,
nullptr, ast::VariableDecorationList{});
auto* ident = create<ast::IdentifierExpression>("var");
auto* ident =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f));
@ -82,7 +83,8 @@ TEST_F(BuilderTest, Assign_Var_ZeroConstructor) {
ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec, false,
nullptr, ast::VariableDecorationList{});
auto* ident = create<ast::IdentifierExpression>("var");
auto* ident =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
ast::ExpressionList vals;
auto* val = create<ast::TypeConstructorExpression>(&vec, vals);
@ -133,7 +135,8 @@ TEST_F(BuilderTest, Assign_Var_Complex_ConstructorWithExtract) {
ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
nullptr, ast::VariableDecorationList{});
ast::AssignmentStatement assign(create<ast::IdentifierExpression>("var"),
ast::AssignmentStatement assign(
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
init);
td.RegisterVariableForTesting(&v);
@ -182,7 +185,8 @@ TEST_F(BuilderTest, Assign_Var_Complex_Constructor) {
ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
nullptr, ast::VariableDecorationList{});
ast::AssignmentStatement assign(create<ast::IdentifierExpression>("var"),
ast::AssignmentStatement assign(
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
init);
td.RegisterVariableForTesting(&v);
@ -231,8 +235,8 @@ TEST_F(BuilderTest, Assign_StructMember) {
false, nullptr, ast::VariableDecorationList{});
auto* ident = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("ident"),
create<ast::IdentifierExpression>("b"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("ident"), "ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"));
auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 4.0f));
@ -273,7 +277,8 @@ TEST_F(BuilderTest, Assign_Vector) {
ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
nullptr, ast::VariableDecorationList{});
auto* ident = create<ast::IdentifierExpression>("var");
auto* ident =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>(
@ -322,8 +327,8 @@ TEST_F(BuilderTest, Assign_Vector_MemberByName) {
nullptr, ast::VariableDecorationList{});
auto* ident = create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("var"),
create<ast::IdentifierExpression>("y"));
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("y"), "y"));
auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f));
@ -368,7 +373,7 @@ TEST_F(BuilderTest, Assign_Vector_MemberByIndex) {
nullptr, ast::VariableDecorationList{});
auto* ident = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("var"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)));
auto* val = create<ast::ScalarConstructorExpression>(

32
src/writer/spirv/builder_binary_expression_test.cc
View File

@ -124,8 +124,10 @@ TEST_P(BinaryArithSignedIntegerTest, Scalar_Loads) {
ast::Variable var(Source{}, "param", ast::StorageClass::kFunction, &i32,
false, nullptr, ast::VariableDecorationList{});
auto* lhs = create<ast::IdentifierExpression>("param");
auto* rhs = create<ast::IdentifierExpression>("param");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param");
auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param");
ast::BinaryExpression expr(param.op, lhs, rhs);
@ -642,7 +644,8 @@ TEST_F(BuilderTest, Binary_Multiply_MatrixScalar) {
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("mat");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f));
@ -683,7 +686,8 @@ TEST_F(BuilderTest, Binary_Multiply_ScalarMatrix) {
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f));
auto* rhs = create<ast::IdentifierExpression>("mat");
auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
td.RegisterVariableForTesting(var);
@ -721,7 +725,8 @@ TEST_F(BuilderTest, Binary_Multiply_MatrixVector) {
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("mat");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>(
@ -779,7 +784,8 @@ TEST_F(BuilderTest, Binary_Multiply_VectorMatrix) {
create<ast::FloatLiteral>(&f32, 1.f)));
auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals);
auto* rhs = create<ast::IdentifierExpression>("mat");
auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
td.RegisterVariableForTesting(var);
@ -818,8 +824,10 @@ TEST_F(BuilderTest, Binary_Multiply_MatrixMatrix) {
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("mat");
auto* rhs = create<ast::IdentifierExpression>("mat");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
td.RegisterVariableForTesting(var);
@ -911,8 +919,8 @@ TEST_F(BuilderTest, Binary_LogicalAnd_WithLoads) {
create<ast::BoolLiteral>(&bool_type, false)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* rhs = create<ast::IdentifierExpression>("b");
auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a");
auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b");
td.RegisterVariableForTesting(a_var);
td.RegisterVariableForTesting(b_var);
@ -1107,8 +1115,8 @@ TEST_F(BuilderTest, Binary_LogicalOr_WithLoads) {
create<ast::BoolLiteral>(&bool_type, false)), // constructor
ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>("a");
auto* rhs = create<ast::IdentifierExpression>("b");
auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a");
auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b");
td.RegisterVariableForTesting(a_var);
td.RegisterVariableForTesting(b_var);

6
src/writer/spirv/builder_block_test.cc
View File

@ -50,7 +50,7 @@ TEST_F(BuilderTest, Block) {
nullptr, // constructor
ast::VariableDecorationList{}))); // decorations
outer.append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("var"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))));
@ -64,13 +64,13 @@ TEST_F(BuilderTest, Block) {
nullptr, // constructor
ast::VariableDecorationList{}))); // decorations
inner->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("var"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f))));
outer.append(inner);
outer.append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("var"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))));

26
src/writer/spirv/builder_call_test.cc
View File

@ -1,3 +1,4 @@
// Copyright 2020 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@ -62,9 +63,11 @@ TEST_F(BuilderTest, Expression_Call) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::BinaryExpression>(
ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("a"),
create<ast::IdentifierExpression>("b"))));
Source{},
create<ast::BinaryExpression>(
ast::BinaryOp::kAdd,
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"))));
ast::Function a_func(Source{}, mod->RegisterSymbol("a_func"), "a_func",
func_params, &f32, body, ast::FunctionDecorationList{});
@ -78,7 +81,8 @@ TEST_F(BuilderTest, Expression_Call) {
call_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>("a_func"),
ast::CallExpression expr(create<ast::IdentifierExpression>(
mod->RegisterSymbol("a_func"), "a_func"),
call_params);
ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
@ -139,9 +143,11 @@ TEST_F(BuilderTest, Statement_Call) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::BinaryExpression>(
ast::BinaryOp::kAdd, create<ast::IdentifierExpression>("a"),
create<ast::IdentifierExpression>("b"))));
Source{},
create<ast::BinaryExpression>(
ast::BinaryOp::kAdd,
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"))));
ast::Function a_func(Source{}, mod->RegisterSymbol("a_func"), "a_func",
func_params, &void_type, body,
@ -157,8 +163,10 @@ TEST_F(BuilderTest, Statement_Call) {
call_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)));
ast::CallStatement expr(create<ast::CallExpression>(
create<ast::IdentifierExpression>("a_func"), call_params));
ast::CallStatement expr(
create<ast::CallExpression>(create<ast::IdentifierExpression>(
mod->RegisterSymbol("a_func"), "a_func"),
call_params));
ASSERT_TRUE(td.DetermineFunction(&func)) << td.error();
ASSERT_TRUE(td.DetermineFunction(&a_func)) << td.error();

17
src/writer/spirv/builder_function_decoration_test.cc
View File

@ -165,15 +165,20 @@ TEST_F(BuilderTest, FunctionDecoration_Stage_WithUsedInterfaceIds) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("my_out"),
create<ast::IdentifierExpression>("my_in")));
create<ast::IdentifierExpression>(mod->RegisterSymbol("my_out"),
"my_out"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("my_in"),
"my_in")));
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("my_wg"),
create<ast::IdentifierExpression>("my_wg")));
create<ast::IdentifierExpression>(mod->RegisterSymbol("my_wg"), "my_wg"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("my_wg"),
"my_wg")));
// Add duplicate usages so we show they don't get output multiple times.
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>("my_out"),
create<ast::IdentifierExpression>("my_in")));
create<ast::IdentifierExpression>(mod->RegisterSymbol("my_out"),
"my_out"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("my_in"),
"my_in")));
ast::Function func(
Source{}, mod->RegisterSymbol("main"), "main", {}, &void_type, body,

18
src/writer/spirv/builder_function_test.cc
View File

@ -98,7 +98,8 @@ TEST_F(BuilderTest, Function_Terminator_ReturnValue) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("a")));
Source{},
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a")));
ASSERT_TRUE(td.DetermineResultType(body)) << td.error();
ast::Function func(Source{}, mod->RegisterSymbol("a_func"), "a_func", {},
@ -167,7 +168,8 @@ TEST_F(BuilderTest, Function_WithParams) {
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(
Source{}, create<ast::IdentifierExpression>("a")));
Source{},
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a")));
ast::Function func(Source{}, mod->RegisterSymbol("a_func"), "a_func", params,
&f32, body, ast::FunctionDecorationList{});
@ -299,8 +301,10 @@ TEST_F(BuilderTest, Emit_Multiple_EntryPoint_With_Same_ModuleVar) {
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("d")), // constructor
create<ast::IdentifierExpression>(mod->RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
@ -326,8 +330,10 @@ TEST_F(BuilderTest, Emit_Multiple_EntryPoint_With_Same_ModuleVar) {
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>("data"),
create<ast::IdentifierExpression>("d")), // constructor
create<ast::IdentifierExpression>(mod->RegisterSymbol("data"),
"data"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();

10
src/writer/spirv/builder_function_variable_test.cc
View File

@ -168,8 +168,9 @@ TEST_F(BuilderTest, FunctionVar_WithNonConstantConstructorLoadedFromVar) {
init, ast::VariableDecorationList{});
td.RegisterVariableForTesting(&v);
ast::Variable v2(Source{}, "v2", ast::StorageClass::kFunction, &f32, false,
create<ast::IdentifierExpression>("v"),
ast::Variable v2(
Source{}, "v2", ast::StorageClass::kFunction, &f32, false,
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
ast::VariableDecorationList{});
td.RegisterVariableForTesting(&v2);
@ -214,8 +215,9 @@ TEST_F(BuilderTest, FunctionVar_ConstWithVarInitializer) {
init, ast::VariableDecorationList{});
td.RegisterVariableForTesting(&v);
ast::Variable v2(Source{}, "v2", ast::StorageClass::kFunction, &f32, true,
create<ast::IdentifierExpression>("v"),
ast::Variable v2(
Source{}, "v2", ast::StorageClass::kFunction, &f32, true,
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
ast::VariableDecorationList{});
td.RegisterVariableForTesting(&v2);

20
src/writer/spirv/builder_ident_expression_test.cc
View File

@ -68,7 +68,7 @@ TEST_F(BuilderTest, IdentifierExpression_GlobalConst) {
%5 = OpConstantComposite %1 %3 %3 %4
)");
ast::IdentifierExpression expr("var");
ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
ASSERT_TRUE(td.DetermineResultType(&expr));
EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5u);
@ -91,7 +91,7 @@ TEST_F(BuilderTest, IdentifierExpression_GlobalVar) {
%1 = OpVariable %2 Output %4
)");
ast::IdentifierExpression expr("var");
ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
ASSERT_TRUE(td.DetermineResultType(&expr));
EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1u);
}
@ -126,7 +126,7 @@ TEST_F(BuilderTest, IdentifierExpression_FunctionConst) {
%5 = OpConstantComposite %1 %3 %3 %4
)");
ast::IdentifierExpression expr("var");
ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
ASSERT_TRUE(td.DetermineResultType(&expr));
EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5u);
}
@ -152,7 +152,7 @@ TEST_F(BuilderTest, IdentifierExpression_FunctionVar) {
R"(%1 = OpVariable %2 Function %4
)");
ast::IdentifierExpression expr("var");
ast::IdentifierExpression expr(mod->RegisterSymbol("var"), "var");
ASSERT_TRUE(td.DetermineResultType(&expr));
EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1u);
}
@ -165,8 +165,10 @@ TEST_F(BuilderTest, IdentifierExpression_Load) {
td.RegisterVariableForTesting(&var);
auto* lhs = create<ast::IdentifierExpression>("var");
auto* rhs = create<ast::IdentifierExpression>("var");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
ast::BinaryExpression expr(ast::BinaryOp::kAdd, lhs, rhs);
@ -198,8 +200,10 @@ TEST_F(BuilderTest, IdentifierExpression_NoLoadConst) {
td.RegisterVariableForTesting(&var);
auto* lhs = create<ast::IdentifierExpression>("var");
auto* rhs = create<ast::IdentifierExpression>("var");
auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
ast::BinaryExpression expr(ast::BinaryOp::kAdd, lhs, rhs);

43
src/writer/spirv/builder_if_test.cc
View File

@ -85,8 +85,8 @@ TEST_F(BuilderTest, If_WithStatements) {
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
@ -139,14 +139,14 @@ TEST_F(BuilderTest, If_WithElse) {
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* else_body = create<ast::BlockStatement>();
else_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
else_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))));
@ -205,14 +205,14 @@ TEST_F(BuilderTest, If_WithElseIf) {
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* else_body = create<ast::BlockStatement>();
else_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
else_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))));
@ -283,23 +283,23 @@ TEST_F(BuilderTest, If_WithMultiple) {
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* elseif_1_body = create<ast::BlockStatement>();
elseif_1_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
elseif_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))));
auto* elseif_2_body = create<ast::BlockStatement>();
elseif_2_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
elseif_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4))));
auto* else_body = create<ast::BlockStatement>();
else_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
else_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 5))));
@ -643,9 +643,10 @@ TEST_F(BuilderTest, If_WithLoad_Bug327) {
ast::VariableDecorationList{}); // decorations
td.RegisterVariableForTesting(var);
ast::IfStatement expr(Source{}, create<ast::IdentifierExpression>("a"),
create<ast::BlockStatement>(),
ast::ElseStatementList{});
ast::IfStatement expr(
Source{},
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"),
create<ast::BlockStatement>(), ast::ElseStatementList{});
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();

12
src/writer/spirv/builder_loop_test.cc
View File

@ -75,8 +75,8 @@ TEST_F(BuilderTest, Loop_WithoutContinuing) {
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
@ -128,14 +128,14 @@ TEST_F(BuilderTest, Loop_WithContinuing) {
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>();
body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* continuing = create<ast::BlockStatement>();
continuing->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
continuing->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))));
ast::LoopStatement expr(body, continuing);

5
src/writer/spirv/builder_return_test.cc
View File

@ -84,8 +84,9 @@ TEST_F(BuilderTest, Return_WithValue_GeneratesLoad) {
ast::Variable var(Source{}, "param", ast::StorageClass::kFunction, &f32,
false, nullptr, ast::VariableDecorationList{});
ast::ReturnStatement ret(Source{},
create<ast::IdentifierExpression>("param"));
ast::ReturnStatement ret(
Source{},
create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param"));
td.RegisterVariableForTesting(&var);
EXPECT_TRUE(td.DetermineResultType(&ret)) << td.error();

62
src/writer/spirv/builder_switch_test.cc
View File

@ -94,14 +94,14 @@ TEST_F(BuilderTest, Switch_WithCase) {
ast::VariableDecorationList{}); // decorations
auto* case_1_body = create<ast::BlockStatement>();
case_1_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))));
auto* case_2_body = create<ast::BlockStatement>();
case_2_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
@ -115,7 +115,8 @@ TEST_F(BuilderTest, Switch_WithCase) {
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
ast::SwitchStatement expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
@ -187,15 +188,16 @@ TEST_F(BuilderTest, Switch_WithDefault) {
ast::VariableDecorationList{}); // decorations
auto* default_body = create<ast::BlockStatement>();
default_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
default_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))));
ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(default_body));
ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
ast::SwitchStatement expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
@ -265,20 +267,20 @@ TEST_F(BuilderTest, Switch_WithCaseAndDefault) {
ast::VariableDecorationList{}); // decorations
auto* case_1_body = create<ast::BlockStatement>();
case_1_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))));
auto* case_2_body = create<ast::BlockStatement>();
case_2_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* default_body = create<ast::BlockStatement>();
default_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
default_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))));
@ -294,7 +296,8 @@ TEST_F(BuilderTest, Switch_WithCaseAndDefault) {
cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
cases.push_back(create<ast::CaseStatement>(default_body));
ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
ast::SwitchStatement expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
@ -373,21 +376,21 @@ TEST_F(BuilderTest, Switch_CaseWithFallthrough) {
ast::VariableDecorationList{}); // decorations
auto* case_1_body = create<ast::BlockStatement>();
case_1_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))));
case_1_body->append(create<ast::FallthroughStatement>());
auto* case_2_body = create<ast::BlockStatement>();
case_2_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))));
auto* default_body = create<ast::BlockStatement>();
default_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
default_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))));
@ -402,7 +405,8 @@ TEST_F(BuilderTest, Switch_CaseWithFallthrough) {
cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
cases.push_back(create<ast::CaseStatement>(default_body));
ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
ast::SwitchStatement expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
@ -477,8 +481,8 @@ TEST_F(BuilderTest, Switch_CaseFallthroughLastStatement) {
ast::VariableDecorationList{}); // decorations
auto* case_1_body = create<ast::BlockStatement>();
case_1_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))));
case_1_body->append(create<ast::FallthroughStatement>());
@ -489,7 +493,8 @@ TEST_F(BuilderTest, Switch_CaseFallthroughLastStatement) {
ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
ast::SwitchStatement expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
@ -546,8 +551,8 @@ TEST_F(BuilderTest, Switch_WithNestedBreak) {
create<ast::BoolLiteral>(&bool_type, true)),
if_body, ast::ElseStatementList{}));
case_1_body->append(
create<ast::AssignmentStatement>(create<ast::IdentifierExpression>("v"),
case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))));
@ -557,7 +562,8 @@ TEST_F(BuilderTest, Switch_WithNestedBreak) {
ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
ast::SwitchStatement expr(create<ast::IdentifierExpression>("a"), cases);
ast::SwitchStatement expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);

5
src/writer/spirv/builder_unary_op_expression_test.cc
View File

@ -101,8 +101,9 @@ TEST_F(BuilderTest, UnaryOp_LoadRequired) {
ast::Variable var(Source{}, "param", ast::StorageClass::kFunction, &vec,
false, nullptr, ast::VariableDecorationList{});
ast::UnaryOpExpression expr(ast::UnaryOp::kNegation,
create<ast::IdentifierExpression>("param"));
ast::UnaryOpExpression expr(
ast::UnaryOp::kNegation,
create<ast::IdentifierExpression>(mod->RegisterSymbol("param"), "param"));
td.RegisterVariableForTesting(&var);
EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error();

9
src/writer/wgsl/generator_impl_array_accessor_test.cc
View File

@ -34,7 +34,8 @@ TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) {
ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, 5);
auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* ary = create<ast::IdentifierExpression>("ary");
auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
ast::ArrayAccessorExpression expr(ary, idx);
@ -43,8 +44,10 @@ TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) {
}
TEST_F(WgslGeneratorImplTest, EmitArrayAccessor) {
auto* ary = create<ast::IdentifierExpression>("ary");
auto* idx = create<ast::IdentifierExpression>("idx");
auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");
auto* idx =
create<ast::IdentifierExpression>(mod.RegisterSymbol("idx"), "idx");
ast::ArrayAccessorExpression expr(ary, idx);

Some files were not shown because too many files have changed in this diff Show More