encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-08-11 22:49:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

[hlsl-writer] Update all expressions to take a pre stream.

Browse Source 
This Cl updates all of the expression methods to accept a pre stream.
The prestream is used to output code _before_ the statement which is
executing the expression. This will allow for unwrapping logical and and
or expressions and emitting them prior to their expression.

Bug: tint:192
Change-Id: Ifb24e7b8964948a3893185710f17177aaec2a2c9
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/27780
Commit-Queue: David Neto <dneto@google.com>
Reviewed-by: David Neto <dneto@google.com>
This commit is contained in:
dan sinclair 2020-09-02 14:19:45 +00:00 committed by Commit Bot service account
parent 4beff41b7d
commit ddb05a3679
15 changed files with 230 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
src/writer/hlsl/generator_impl.cc
View File

@ -210,19 +210,20 @@ bool GeneratorImpl::EmitAliasType(std::ostream& out,
return true; return true;
} }
bool GeneratorImpl::EmitArrayAccessor(std::ostream& out, bool GeneratorImpl::EmitArrayAccessor(std::ostream& pre,
std::ostream& out,
ast::ArrayAccessorExpression* expr) { ast::ArrayAccessorExpression* expr) {
// Handle writing into a storage buffer array // Handle writing into a storage buffer array
if (is_storage_buffer_access(expr)) { if (is_storage_buffer_access(expr)) {
return EmitStorageBufferAccessor(out, expr, nullptr); return EmitStorageBufferAccessor(pre, out, expr, nullptr);
} }
if (!EmitExpression(out, expr->array())) { if (!EmitExpression(pre, out, expr->array())) {
return false; return false;
} }
out << "["; out << "[";
if (!EmitExpression(out, expr->idx_expr())) { if (!EmitExpression(pre, out, expr->idx_expr())) {
return false; return false;
} }
out << "]"; out << "]";
@ -230,7 +231,9 @@ bool GeneratorImpl::EmitArrayAccessor(std::ostream& out,
return true; return true;
} }
bool GeneratorImpl::EmitAs(std::ostream& out, ast::AsExpression* expr) { bool GeneratorImpl::EmitAs(std::ostream& pre,
std::ostream& out,
ast::AsExpression* expr) {
if (!expr->type()->IsF32() && !expr->type()->IsI32() && if (!expr->type()->IsF32() && !expr->type()->IsI32() &&
!expr->type()->IsU32()) { !expr->type()->IsU32()) {
error_ = "Unable to do as cast to type " + expr->type()->type_name(); error_ = "Unable to do as cast to type " + expr->type()->type_name();
@ -242,7 +245,7 @@ bool GeneratorImpl::EmitAs(std::ostream& out, ast::AsExpression* expr) {
return false; return false;
} }
out << "("; out << "(";
if (!EmitExpression(out, expr->expr())) { if (!EmitExpression(pre, out, expr->expr())) {
return false; return false;
} }
out << ")"; out << ")";
@ -253,12 +256,14 @@ bool GeneratorImpl::EmitAssign(std::ostream& out,
ast::AssignmentStatement* stmt) { ast::AssignmentStatement* stmt) {
make_indent(out); make_indent(out);
std::ostringstream pre;
// If the LHS is an accessor into a storage buffer then we have to // If the LHS is an accessor into a storage buffer then we have to
// emit a Store operation instead of an ='s. // emit a Store operation instead of an ='s.
if (stmt->lhs()->IsMemberAccessor()) { if (stmt->lhs()->IsMemberAccessor()) {
auto* mem = stmt->lhs()->AsMemberAccessor(); auto* mem = stmt->lhs()->AsMemberAccessor();
if (is_storage_buffer_access(mem)) { if (is_storage_buffer_access(mem)) {
if (!EmitStorageBufferAccessor(out, mem, stmt->rhs())) { if (!EmitStorageBufferAccessor(pre, out, mem, stmt->rhs())) {
return false; return false;
} }
out << ";" << std::endl; out << ";" << std::endl;
@ -267,7 +272,7 @@ bool GeneratorImpl::EmitAssign(std::ostream& out,
} else if (stmt->lhs()->IsArrayAccessor()) { } else if (stmt->lhs()->IsArrayAccessor()) {
auto* ary = stmt->lhs()->AsArrayAccessor(); auto* ary = stmt->lhs()->AsArrayAccessor();
if (is_storage_buffer_access(ary)) { if (is_storage_buffer_access(ary)) {
if (!EmitStorageBufferAccessor(out, ary, stmt->rhs())) { if (!EmitStorageBufferAccessor(pre, out, ary, stmt->rhs())) {
return false; return false;
} }
out << ";" << std::endl; out << ";" << std::endl;
@ -275,13 +280,13 @@ bool GeneratorImpl::EmitAssign(std::ostream& out,
} }
} }
if (!EmitExpression(out, stmt->lhs())) { if (!EmitExpression(pre, out, stmt->lhs())) {
return false; return false;
} }
out << " = "; out << " = ";
if (!EmitExpression(out, stmt->rhs())) { if (!EmitExpression(pre, out, stmt->rhs())) {
return false; return false;
} }
@ -290,10 +295,12 @@ bool GeneratorImpl::EmitAssign(std::ostream& out,
return true; return true;
} }
bool GeneratorImpl::EmitBinary(std::ostream& out, ast::BinaryExpression* expr) { bool GeneratorImpl::EmitBinary(std::ostream& pre,
std::ostream& out,
ast::BinaryExpression* expr) {
out << "("; out << "(";
if (!EmitExpression(out, expr->lhs())) { if (!EmitExpression(pre, out, expr->lhs())) {
return false; return false;
} }
out << " "; out << " ";
@ -366,7 +373,7 @@ bool GeneratorImpl::EmitBinary(std::ostream& out, ast::BinaryExpression* expr) {
} }
out << " "; out << " ";
if (!EmitExpression(out, expr->rhs())) { if (!EmitExpression(pre, out, expr->rhs())) {
return false; return false;
} }
@ -460,7 +467,9 @@ std::string GeneratorImpl::generate_intrinsic_name(const std::string& name) {
return ""; return "";
} }
bool GeneratorImpl::EmitCall(std::ostream& out, ast::CallExpression* expr) { bool GeneratorImpl::EmitCall(std::ostream& pre,
std::ostream& out,
ast::CallExpression* expr) {
if (!expr->func()->IsIdentifier()) { if (!expr->func()->IsIdentifier()) {
error_ = "invalid function name"; error_ = "invalid function name";
return 0; return 0;
@ -515,12 +524,12 @@ bool GeneratorImpl::EmitCall(std::ostream& out, ast::CallExpression* expr) {
// out << ", "; // out << ", ";
// } // }
// if (!EmitExpression(out, params[0].get())) { // if (!EmitExpression(pre, out, params[0].get())) {
// return false; // return false;
// } // }
// out << " * "; // out << " * ";
// if (!EmitExpression(out, params[1].get())) { // if (!EmitExpression(pre, out, params[1].get())) {
// return false; // return false;
// } // }
// out << "[" << i << "]"; // out << "[" << i << "]";
@ -545,7 +554,7 @@ bool GeneratorImpl::EmitCall(std::ostream& out, ast::CallExpression* expr) {
} }
first = false; first = false;
if (!EmitExpression(out, param.get())) { if (!EmitExpression(pre, out, param.get())) {
return false; return false;
} }
} }
@ -596,19 +605,20 @@ bool GeneratorImpl::EmitCall(std::ostream& out, ast::CallExpression* expr) {
} }
first = false; first = false;
if (!EmitExpression(out, param.get())) { if (!EmitExpression(pre, out, param.get())) {
return false; return false;
} }
} }
out << ")"; out << ")";
} else { } else {
return EmitImportFunction(out, expr); return EmitImportFunction(pre, out, expr);
} }
return true; return true;
} }
bool GeneratorImpl::EmitImportFunction(std::ostream& out, bool GeneratorImpl::EmitImportFunction(std::ostream& pre,
std::ostream& out,
ast::CallExpression* expr) { ast::CallExpression* expr) {
auto* ident = expr->func()->AsIdentifier(); auto* ident = expr->func()->AsIdentifier();
@ -717,7 +727,7 @@ bool GeneratorImpl::EmitImportFunction(std::ostream& out,
} }
first = false; first = false;
if (!EmitExpression(out, param.get())) { if (!EmitExpression(pre, out, param.get())) {
return false; return false;
} }
} }
@ -726,13 +736,15 @@ bool GeneratorImpl::EmitImportFunction(std::ostream& out,
return true; return true;
} }
bool GeneratorImpl::EmitCast(std::ostream& out, ast::CastExpression* expr) { bool GeneratorImpl::EmitCast(std::ostream& pre,
std::ostream& out,
ast::CastExpression* expr) {
if (!EmitType(out, expr->type(), "")) { if (!EmitType(out, expr->type(), "")) {
return false; return false;
} }
out << "("; out << "(";
if (!EmitExpression(out, expr->expr())) { if (!EmitExpression(pre, out, expr->expr())) {
return false; return false;
} }
out << ")"; out << ")";
@ -783,21 +795,24 @@ bool GeneratorImpl::EmitCase(std::ostream& out, ast::CaseStatement* stmt) {
return true; return true;
} }
bool GeneratorImpl::EmitConstructor(std::ostream& out, bool GeneratorImpl::EmitConstructor(std::ostream& pre,
std::ostream& out,
ast::ConstructorExpression* expr) { ast::ConstructorExpression* expr) {
if (expr->IsScalarConstructor()) { if (expr->IsScalarConstructor()) {
return EmitScalarConstructor(out, expr->AsScalarConstructor()); return EmitScalarConstructor(pre, out, expr->AsScalarConstructor());
} }
return EmitTypeConstructor(out, expr->AsTypeConstructor()); return EmitTypeConstructor(pre, out, expr->AsTypeConstructor());
} }
bool GeneratorImpl::EmitScalarConstructor( bool GeneratorImpl::EmitScalarConstructor(
std::ostream&,
std::ostream& out, std::ostream& out,
ast::ScalarConstructorExpression* expr) { ast::ScalarConstructorExpression* expr) {
return EmitLiteral(out, expr->literal()); return EmitLiteral(out, expr->literal());
} }
bool GeneratorImpl::EmitTypeConstructor(std::ostream& out, bool GeneratorImpl::EmitTypeConstructor(std::ostream& pre,
std::ostream& out,
ast::TypeConstructorExpression* expr) { ast::TypeConstructorExpression* expr) {
if (expr->type()->IsArray()) { if (expr->type()->IsArray()) {
out << "{"; out << "{";
@ -822,7 +837,7 @@ bool GeneratorImpl::EmitTypeConstructor(std::ostream& out,
} }
first = false; first = false;
if (!EmitExpression(out, e.get())) { if (!EmitExpression(pre, out, e.get())) {
return false; return false;
} }
} }
@ -850,33 +865,35 @@ bool GeneratorImpl::EmitDiscard(std::ostream& out, ast::DiscardStatement*) {
return true; return true;
} }
bool GeneratorImpl::EmitExpression(std::ostream& out, ast::Expression* expr) { bool GeneratorImpl::EmitExpression(std::ostream& pre,
std::ostream& out,
ast::Expression* expr) {
if (expr->IsAs()) { if (expr->IsAs()) {
return EmitAs(out, expr->AsAs()); return EmitAs(pre, out, expr->AsAs());
} }
if (expr->IsArrayAccessor()) { if (expr->IsArrayAccessor()) {
return EmitArrayAccessor(out, expr->AsArrayAccessor()); return EmitArrayAccessor(pre, out, expr->AsArrayAccessor());
} }
if (expr->IsBinary()) { if (expr->IsBinary()) {
return EmitBinary(out, expr->AsBinary()); return EmitBinary(pre, out, expr->AsBinary());
} }
if (expr->IsCall()) { if (expr->IsCall()) {
return EmitCall(out, expr->AsCall()); return EmitCall(pre, out, expr->AsCall());
} }
if (expr->IsCast()) { if (expr->IsCast()) {
return EmitCast(out, expr->AsCast()); return EmitCast(pre, out, expr->AsCast());
} }
if (expr->IsConstructor()) { if (expr->IsConstructor()) {
return EmitConstructor(out, expr->AsConstructor()); return EmitConstructor(pre, out, expr->AsConstructor());
} }
if (expr->IsIdentifier()) { if (expr->IsIdentifier()) {
return EmitIdentifier(out, expr->AsIdentifier()); return EmitIdentifier(pre, out, expr->AsIdentifier());
} }
if (expr->IsMemberAccessor()) { if (expr->IsMemberAccessor()) {
return EmitMemberAccessor(out, expr->AsMemberAccessor()); return EmitMemberAccessor(pre, out, expr->AsMemberAccessor());
} }
if (expr->IsUnaryOp()) { if (expr->IsUnaryOp()) {
return EmitUnaryOp(out, expr->AsUnaryOp()); return EmitUnaryOp(pre, out, expr->AsUnaryOp());
} }
error_ = "unknown expression type: " + expr->str(); error_ = "unknown expression type: " + expr->str();
@ -891,7 +908,8 @@ bool GeneratorImpl::global_is_in_struct(ast::Variable* var) const {
var->storage_class() == ast::StorageClass::kOutput); var->storage_class() == ast::StorageClass::kOutput);
} }
bool GeneratorImpl::EmitIdentifier(std::ostream& out, bool GeneratorImpl::EmitIdentifier(std::ostream&,
std::ostream& out,
ast::IdentifierExpression* expr) { ast::IdentifierExpression* expr) {
auto* ident = expr->AsIdentifier(); auto* ident = expr->AsIdentifier();
if (ident->has_path()) { if (ident->has_path()) {
@ -922,8 +940,9 @@ bool GeneratorImpl::EmitIdentifier(std::ostream& out,
bool GeneratorImpl::EmitIf(std::ostream& out, ast::IfStatement* stmt) { bool GeneratorImpl::EmitIf(std::ostream& out, ast::IfStatement* stmt) {
make_indent(out); make_indent(out);
std::ostringstream pre;
out << "if ("; out << "if (";
if (!EmitExpression(out, stmt->condition())) { if (!EmitExpression(pre, out, stmt->condition())) {
return false; return false;
} }
out << ") "; out << ") ";
@ -943,9 +962,10 @@ bool GeneratorImpl::EmitIf(std::ostream& out, ast::IfStatement* stmt) {
} }
bool GeneratorImpl::EmitElse(std::ostream& out, ast::ElseStatement* stmt) { bool GeneratorImpl::EmitElse(std::ostream& out, ast::ElseStatement* stmt) {
std::ostringstream pre;
if (stmt->HasCondition()) { if (stmt->HasCondition()) {
out << " else if ("; out << " else if (";
if (!EmitExpression(out, stmt->condition())) { if (!EmitExpression(pre, out, stmt->condition())) {
return false; return false;
} }
out << ") "; out << ") ";
@ -1511,7 +1531,8 @@ bool GeneratorImpl::EmitLoop(std::ostream& out, ast::LoopStatement* stmt) {
auto* var = s->AsVariableDecl()->variable(); auto* var = s->AsVariableDecl()->variable();
out << var->name() << " = "; out << var->name() << " = ";
if (var->constructor() != nullptr) { if (var->constructor() != nullptr) {
if (!EmitExpression(out, var->constructor())) { std::ostringstream pre;
if (!EmitExpression(pre, out, var->constructor())) {
return false; return false;
} }
} else { } else {
@ -1614,7 +1635,8 @@ std::string GeneratorImpl::generate_storage_buffer_index_expression(
return ""; return "";
} }
out << " * "; out << " * ";
if (!EmitExpression(out, ary->idx_expr())) { std::ostringstream pre;
if (!EmitExpression(pre, out, ary->idx_expr())) {
return ""; return "";
} }
out << ")"; out << ")";
@ -1636,7 +1658,8 @@ std::string GeneratorImpl::generate_storage_buffer_index_expression(
// TODO(dsinclair): Need to support loading through a pointer. The pointer is // TODO(dsinclair): Need to support loading through a pointer. The pointer is
// just a memory address in the storage buffer, so need to do the correct // just a memory address in the storage buffer, so need to do the correct
// calculation. // calculation.
bool GeneratorImpl::EmitStorageBufferAccessor(std::ostream& out, bool GeneratorImpl::EmitStorageBufferAccessor(std::ostream& pre,
std::ostream& out,
ast::Expression* expr, ast::Expression* expr,
ast::Expression* rhs) { ast::Expression* rhs) {
auto* result_type = expr->result_type()->UnwrapAliasPtrAlias(); auto* result_type = expr->result_type()->UnwrapAliasPtrAlias();
@ -1685,7 +1708,7 @@ bool GeneratorImpl::EmitStorageBufferAccessor(std::ostream& out,
auto name = generate_name(kTempNamePrefix); auto name = generate_name(kTempNamePrefix);
out << " " << name << " = "; out << " " << name << " = ";
if (!EmitExpression(out, rhs)) { if (!EmitExpression(pre, out, rhs)) {
return false; return false;
} }
out << ";" << std::endl; out << ";" << std::endl;
@ -1723,7 +1746,7 @@ bool GeneratorImpl::EmitStorageBufferAccessor(std::ostream& out,
out << buffer_name << "." << access_method << "(" << idx; out << buffer_name << "." << access_method << "(" << idx;
if (is_store) { if (is_store) {
out << ", asuint("; out << ", asuint(";
if (!EmitExpression(out, rhs)) { if (!EmitExpression(pre, out, rhs)) {
return false; return false;
} }
out << ")"; out << ")";
@ -1786,20 +1809,21 @@ bool GeneratorImpl::is_storage_buffer_access(
return false; return false;
} }
bool GeneratorImpl::EmitMemberAccessor(std::ostream& out, bool GeneratorImpl::EmitMemberAccessor(std::ostream& pre,
std::ostream& out,
ast::MemberAccessorExpression* expr) { ast::MemberAccessorExpression* expr) {
// Look for storage buffer accesses as we have to convert them into Load // Look for storage buffer accesses as we have to convert them into Load
// expressions. Stores will be identified in the assignment emission and a // expressions. Stores will be identified in the assignment emission and a
// member accessor store of a storage buffer will not get here. // member accessor store of a storage buffer will not get here.
if (is_storage_buffer_access(expr)) { if (is_storage_buffer_access(expr)) {
return EmitStorageBufferAccessor(out, expr, nullptr); return EmitStorageBufferAccessor(pre, out, expr, nullptr);
} }
if (!EmitExpression(out, expr->structure())) { if (!EmitExpression(pre, out, expr->structure())) {
return false; return false;
} }
out << "."; out << ".";
return EmitExpression(out, expr->member()); return EmitExpression(pre, out, expr->member());
} }
bool GeneratorImpl::EmitReturn(std::ostream& out, ast::ReturnStatement* stmt) { bool GeneratorImpl::EmitReturn(std::ostream& out, ast::ReturnStatement* stmt) {
@ -1814,7 +1838,8 @@ bool GeneratorImpl::EmitReturn(std::ostream& out, ast::ReturnStatement* stmt) {
} }
} else if (stmt->has_value()) { } else if (stmt->has_value()) {
out << " "; out << " ";
if (!EmitExpression(out, stmt->value())) { std::ostringstream pre;
if (!EmitExpression(pre, out, stmt->value())) {
return false; return false;
} }
} }
@ -1834,7 +1859,8 @@ bool GeneratorImpl::EmitStatement(std::ostream& out, ast::Statement* stmt) {
} }
if (stmt->IsCall()) { if (stmt->IsCall()) {
make_indent(out); make_indent(out);
if (!EmitCall(out, stmt->AsCall()->expr())) { std::ostringstream pre;
if (!EmitCall(pre, out, stmt->AsCall()->expr())) {
return false; return false;
} }
out << ";" << std::endl; out << ";" << std::endl;
@ -1874,8 +1900,9 @@ bool GeneratorImpl::EmitStatement(std::ostream& out, ast::Statement* stmt) {
bool GeneratorImpl::EmitSwitch(std::ostream& out, ast::SwitchStatement* stmt) { bool GeneratorImpl::EmitSwitch(std::ostream& out, ast::SwitchStatement* stmt) {
make_indent(out); make_indent(out);
std::ostringstream pre;
out << "switch("; out << "switch(";
if (!EmitExpression(out, stmt->condition())) { if (!EmitExpression(pre, out, stmt->condition())) {
return false; return false;
} }
out << ") {" << std::endl; out << ") {" << std::endl;
@ -1994,7 +2021,8 @@ bool GeneratorImpl::EmitType(std::ostream& out,
return true; return true;
} }
bool GeneratorImpl::EmitUnaryOp(std::ostream& out, bool GeneratorImpl::EmitUnaryOp(std::ostream& pre,
std::ostream& out,
ast::UnaryOpExpression* expr) { ast::UnaryOpExpression* expr) {
switch (expr->op()) { switch (expr->op()) {
case ast::UnaryOp::kNot: case ast::UnaryOp::kNot:
@ -2006,7 +2034,7 @@ bool GeneratorImpl::EmitUnaryOp(std::ostream& out,
} }
out << "("; out << "(";
if (!EmitExpression(out, expr->expr())) { if (!EmitExpression(pre, out, expr->expr())) {
return false; return false;
} }
@ -2038,7 +2066,9 @@ bool GeneratorImpl::EmitVariable(std::ostream& out,
if (!skip_constructor && var->constructor() != nullptr) { if (!skip_constructor && var->constructor() != nullptr) {
out << " = "; out << " = ";
if (!EmitExpression(out, var->constructor())) {
std::ostringstream pre;
if (!EmitExpression(pre, out, var->constructor())) {
return false; return false;
} }
} }
@ -2070,7 +2100,9 @@ bool GeneratorImpl::EmitProgramConstVariable(std::ostream& out,
if (var->constructor() != nullptr) { if (var->constructor() != nullptr) {
out << " = "; out << " = ";
if (!EmitExpression(out, var->constructor())) {
std::ostringstream pre;
if (!EmitExpression(pre, out, var->constructor())) {
return false; return false;
} }
} }

92
src/writer/hlsl/generator_impl.h
View File

@ -62,25 +62,32 @@ class GeneratorImpl {
/// @returns true if the alias was emitted /// @returns true if the alias was emitted
bool EmitAliasType(std::ostream& out, const ast::type::AliasType* alias); bool EmitAliasType(std::ostream& out, const ast::type::AliasType* alias);
/// Handles an array accessor expression /// Handles an array accessor expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the expression to emit /// @param expr the expression to emit
/// @returns true if the array accessor was emitted /// @returns true if the array accessor was emitted
bool EmitArrayAccessor(std::ostream& out, ast::ArrayAccessorExpression* expr); bool EmitArrayAccessor(std::ostream& pre,
std::ostream& out,
ast::ArrayAccessorExpression* expr);
/// Handles generating an as expression /// Handles generating an as expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the as expression /// @param expr the as expression
/// @returns true if the as was emitted /// @returns true if the as was emitted
bool EmitAs(std::ostream& out, ast::AsExpression* expr); bool EmitAs(std::ostream& pre, std::ostream& out, ast::AsExpression* expr);
/// Handles an assignment statement /// Handles an assignment statement
/// @param out the output stream /// @param out the output stream
/// @param stmt the statement to emit /// @param stmt the statement to emit
/// @returns true if the statement was emitted successfully /// @returns true if the statement was emitted successfully
bool EmitAssign(std::ostream& out, ast::AssignmentStatement* stmt); bool EmitAssign(std::ostream& out, ast::AssignmentStatement* stmt);
/// Handles generating a binary expression /// Handles generating a binary expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the binary expression /// @param expr the binary expression
/// @returns true if the expression was emitted, false otherwise /// @returns true if the expression was emitted, false otherwise
bool EmitBinary(std::ostream& out, ast::BinaryExpression* expr); bool EmitBinary(std::ostream& pre,
std::ostream& out,
ast::BinaryExpression* expr);
/// Handles a block statement /// Handles a block statement
/// @param out the output stream /// @param out the output stream
/// @param stmt the statement to emit /// @param stmt the statement to emit
@ -103,41 +110,54 @@ class GeneratorImpl {
/// @returns true if the statement was emitted successfully /// @returns true if the statement was emitted successfully
bool EmitBreak(std::ostream& out, ast::BreakStatement* stmt); bool EmitBreak(std::ostream& out, ast::BreakStatement* stmt);
/// Handles generating a call expression /// Handles generating a call expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the call expression /// @param expr the call expression
/// @returns true if the call expression is emitted /// @returns true if the call expression is emitted
bool EmitCall(std::ostream& out, ast::CallExpression* expr); bool EmitCall(std::ostream& pre,
std::ostream& out,
ast::CallExpression* expr);
/// Handles a case statement /// Handles a case statement
/// @param out the output stream /// @param out the output stream
/// @param stmt the statement /// @param stmt the statement
/// @returns true if the statment was emitted successfully /// @returns true if the statment was emitted successfully
bool EmitCase(std::ostream& out, ast::CaseStatement* stmt); bool EmitCase(std::ostream& out, ast::CaseStatement* stmt);
/// Handles generating a cast expression /// Handles generating a cast expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the cast expression /// @param expr the cast expression
/// @returns true if the cast was emitted /// @returns true if the cast was emitted
bool EmitCast(std::ostream& out, ast::CastExpression* expr); bool EmitCast(std::ostream& pre,
std::ostream& out,
ast::CastExpression* expr);
/// Handles generating constructor expressions /// Handles generating constructor expressions
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the constructor expression /// @param expr the constructor expression
/// @returns true if the expression was emitted /// @returns true if the expression was emitted
bool EmitConstructor(std::ostream& out, ast::ConstructorExpression* expr); bool EmitConstructor(std::ostream& pre,
std::ostream& out,
ast::ConstructorExpression* expr);
/// Handles generating a discard statement /// Handles generating a discard statement
/// @param out the output stream /// @param out the output stream
/// @param stmt the discard statement /// @param stmt the discard statement
/// @returns true if the statement was successfully emitted /// @returns true if the statement was successfully emitted
bool EmitDiscard(std::ostream& out, ast::DiscardStatement* stmt); bool EmitDiscard(std::ostream& out, ast::DiscardStatement* stmt);
/// Handles generating a scalar constructor /// Handles generating a scalar constructor
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the scalar constructor expression /// @param expr the scalar constructor expression
/// @returns true if the scalar constructor is emitted /// @returns true if the scalar constructor is emitted
bool EmitScalarConstructor(std::ostream& out, bool EmitScalarConstructor(std::ostream& pre,
std::ostream& out,
ast::ScalarConstructorExpression* expr); ast::ScalarConstructorExpression* expr);
/// Handles emitting a type constructor /// Handles emitting a type constructor
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the type constructor expression /// @param expr the type constructor expression
/// @returns true if the constructor is emitted /// @returns true if the constructor is emitted
bool EmitTypeConstructor(std::ostream& out, bool EmitTypeConstructor(std::ostream& pre,
std::ostream& out,
ast::TypeConstructorExpression* expr); ast::TypeConstructorExpression* expr);
/// Handles a continue statement /// Handles a continue statement
/// @param out the output stream /// @param out the output stream
@ -150,10 +170,13 @@ class GeneratorImpl {
/// @returns true if the statement was emitted /// @returns true if the statement was emitted
bool EmitElse(std::ostream& out, ast::ElseStatement* stmt); bool EmitElse(std::ostream& out, ast::ElseStatement* stmt);
/// Handles generate an Expression /// Handles generate an Expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the expression /// @param expr the expression
/// @returns true if the expression was emitted /// @returns true if the expression was emitted
bool EmitExpression(std::ostream& out, ast::Expression* expr); bool EmitExpression(std::ostream& pre,
std::ostream& out,
ast::Expression* expr);
/// Handles generating a function /// Handles generating a function
/// @param out the output stream /// @param out the output stream
/// @param func the function to generate /// @param func the function to generate
@ -186,10 +209,13 @@ class GeneratorImpl {
/// @returns true if the statement was successfully emitted /// @returns true if the statement was successfully emitted
bool EmitIf(std::ostream& out, ast::IfStatement* stmt); bool EmitIf(std::ostream& out, ast::IfStatement* stmt);
/// Handles genreating an import expression /// Handles genreating an import expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the expression /// @param expr the expression
/// @returns true if the expression was successfully emitted. /// @returns true if the expression was successfully emitted.
bool EmitImportFunction(std::ostream& out, ast::CallExpression* expr); bool EmitImportFunction(std::ostream& pre,
std::ostream& out,
ast::CallExpression* expr);
/// Handles a literal /// Handles a literal
/// @param out the output stream /// @param out the output stream
/// @param lit the literal to emit /// @param lit the literal to emit
@ -201,22 +227,29 @@ class GeneratorImpl {
/// @returns true if the statement was emitted /// @returns true if the statement was emitted
bool EmitLoop(std::ostream& out, ast::LoopStatement* stmt); bool EmitLoop(std::ostream& out, ast::LoopStatement* stmt);
/// Handles generating an identifier expression /// Handles generating an identifier expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the identifier expression /// @param expr the identifier expression
/// @returns true if the identifeir was emitted /// @returns true if the identifeir was emitted
bool EmitIdentifier(std::ostream& out, ast::IdentifierExpression* expr); bool EmitIdentifier(std::ostream& pre,
std::ostream& out,
ast::IdentifierExpression* expr);
/// Handles a member accessor expression /// Handles a member accessor expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the member accessor expression /// @param expr the member accessor expression
/// @returns true if the member accessor was emitted /// @returns true if the member accessor was emitted
bool EmitMemberAccessor(std::ostream& out, bool EmitMemberAccessor(std::ostream& pre,
std::ostream& out,
ast::MemberAccessorExpression* expr); ast::MemberAccessorExpression* expr);
/// Handles a storage buffer accessor expression /// Handles a storage buffer accessor expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the storage buffer accessor expression /// @param expr the storage buffer accessor expression
/// @param rhs the right side of a store expression. Set to nullptr for a load /// @param rhs the right side of a store expression. Set to nullptr for a load
/// @returns true if the storage buffer accessor was emitted /// @returns true if the storage buffer accessor was emitted
bool EmitStorageBufferAccessor(std::ostream& out, bool EmitStorageBufferAccessor(std::ostream& pre,
std::ostream& out,
ast::Expression* expr, ast::Expression* expr,
ast::Expression* rhs); ast::Expression* rhs);
/// Handles return statements /// Handles return statements
@ -243,10 +276,13 @@ class GeneratorImpl {
ast::type::Type* type, ast::type::Type* type,
const std::string& name); const std::string& name);
/// Handles a unary op expression /// Handles a unary op expression
/// @param out the output stream /// @param pre the preamble for the expression stream
/// @param out the output of the expression stream
/// @param expr the expression to emit /// @param expr the expression to emit
/// @returns true if the expression was emitted /// @returns true if the expression was emitted
bool EmitUnaryOp(std::ostream& out, ast::UnaryOpExpression* expr); bool EmitUnaryOp(std::ostream& pre,
std::ostream& out,
ast::UnaryOpExpression* expr);
/// Emits the zero value for the given type /// Emits the zero value for the given type
/// @param out the output stream /// @param out the output stream
/// @param type the type to emit the value for /// @param type the type to emit the value for

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

@ -37,7 +37,7 @@ TEST_F(HlslGeneratorImplTest_Expression, EmitExpression_ArrayAccessor) {
ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx)); ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "ary[5]"); EXPECT_EQ(result(), "ary[5]");
} }
@ -47,7 +47,7 @@ TEST_F(HlslGeneratorImplTest_Expression, EmitArrayAccessor) {
ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx)); ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "ary[idx]"); EXPECT_EQ(result(), "ary[idx]");
} }

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

@ -34,7 +34,7 @@ TEST_F(HlslGeneratorImplTest_As, EmitExpression_As_Float) {
auto id = std::make_unique<ast::IdentifierExpression>("id"); auto id = std::make_unique<ast::IdentifierExpression>("id");
ast::AsExpression as(&f32, std::move(id)); ast::AsExpression as(&f32, std::move(id));
ASSERT_TRUE(gen().EmitExpression(out(), &as)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &as)) << gen().error();
EXPECT_EQ(result(), "asfloat(id)"); EXPECT_EQ(result(), "asfloat(id)");
} }
@ -43,7 +43,7 @@ TEST_F(HlslGeneratorImplTest_As, EmitExpression_As_Int) {
auto id = std::make_unique<ast::IdentifierExpression>("id"); auto id = std::make_unique<ast::IdentifierExpression>("id");
ast::AsExpression as(&i32, std::move(id)); ast::AsExpression as(&i32, std::move(id));
ASSERT_TRUE(gen().EmitExpression(out(), &as)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &as)) << gen().error();
EXPECT_EQ(result(), "asint(id)"); EXPECT_EQ(result(), "asint(id)");
} }
@ -52,7 +52,7 @@ TEST_F(HlslGeneratorImplTest_As, EmitExpression_As_Uint) {
auto id = std::make_unique<ast::IdentifierExpression>("id"); auto id = std::make_unique<ast::IdentifierExpression>("id");
ast::AsExpression as(&u32, std::move(id)); ast::AsExpression as(&u32, std::move(id));
ASSERT_TRUE(gen().EmitExpression(out(), &as)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &as)) << gen().error();
EXPECT_EQ(result(), "asuint(id)"); EXPECT_EQ(result(), "asuint(id)");
} }

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

@ -42,7 +42,7 @@ TEST_P(HlslBinaryTest, Emit) {
ast::BinaryExpression expr(params.op, std::move(left), std::move(right)); ast::BinaryExpression expr(params.op, std::move(left), std::move(right));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), params.result); EXPECT_EQ(result(), params.result);
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(

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

@ -39,7 +39,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithoutParams) {
&void_type); &void_type);
mod()->AddFunction(std::move(func)); mod()->AddFunction(std::move(func));
ASSERT_TRUE(gen().EmitExpression(out(), &call)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
EXPECT_EQ(result(), "my_func()"); EXPECT_EQ(result(), "my_func()");
} }
@ -56,7 +56,7 @@ TEST_F(HlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
&void_type); &void_type);
mod()->AddFunction(std::move(func)); mod()->AddFunction(std::move(func));
ASSERT_TRUE(gen().EmitExpression(out(), &call)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
EXPECT_EQ(result(), "my_func(param1, param2)"); EXPECT_EQ(result(), "my_func(param1, param2)");
} }

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

@ -33,7 +33,7 @@ TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Scalar) {
auto id = std::make_unique<ast::IdentifierExpression>("id"); auto id = std::make_unique<ast::IdentifierExpression>("id");
ast::CastExpression cast(&f32, std::move(id)); ast::CastExpression cast(&f32, std::move(id));
ASSERT_TRUE(gen().EmitExpression(out(), &cast)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &cast)) << gen().error();
EXPECT_EQ(result(), "float(id)"); EXPECT_EQ(result(), "float(id)");
} }
@ -44,7 +44,7 @@ TEST_F(HlslGeneratorImplTest_Cast, EmitExpression_Cast_Vector) {
auto id = std::make_unique<ast::IdentifierExpression>("id"); auto id = std::make_unique<ast::IdentifierExpression>("id");
ast::CastExpression cast(&vec3, std::move(id)); ast::CastExpression cast(&vec3, std::move(id));
ASSERT_TRUE(gen().EmitExpression(out(), &cast)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &cast)) << gen().error();
EXPECT_EQ(result(), "vector<float, 3>(id)"); EXPECT_EQ(result(), "vector<float, 3>(id)");
} }

24
src/writer/hlsl/generator_impl_constructor_test.cc
View File

@ -40,7 +40,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Bool) {
auto lit = std::make_unique<ast::BoolLiteral>(&bool_type, false); auto lit = std::make_unique<ast::BoolLiteral>(&bool_type, false);
ast::ScalarConstructorExpression expr(std::move(lit)); ast::ScalarConstructorExpression expr(std::move(lit));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "false"); EXPECT_EQ(result(), "false");
} }
@ -49,7 +49,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Int) {
auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345); auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345);
ast::ScalarConstructorExpression expr(std::move(lit)); ast::ScalarConstructorExpression expr(std::move(lit));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "-12345"); EXPECT_EQ(result(), "-12345");
} }
@ -58,7 +58,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_UInt) {
auto lit = std::make_unique<ast::UintLiteral>(&u32, 56779); auto lit = std::make_unique<ast::UintLiteral>(&u32, 56779);
ast::ScalarConstructorExpression expr(std::move(lit)); ast::ScalarConstructorExpression expr(std::move(lit));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "56779u"); EXPECT_EQ(result(), "56779u");
} }
@ -68,7 +68,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Float) {
auto lit = std::make_unique<ast::FloatLiteral>(&f32, float((1 << 30) - 4)); auto lit = std::make_unique<ast::FloatLiteral>(&f32, float((1 << 30) - 4));
ast::ScalarConstructorExpression expr(std::move(lit)); ast::ScalarConstructorExpression expr(std::move(lit));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "1.07374182e+09f"); EXPECT_EQ(result(), "1.07374182e+09f");
} }
@ -82,7 +82,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Float) {
ast::TypeConstructorExpression expr(&f32, std::move(values)); ast::TypeConstructorExpression expr(&f32, std::move(values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "float(-1.20000004e-05f)"); EXPECT_EQ(result(), "float(-1.20000004e-05f)");
} }
@ -96,7 +96,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Bool) {
ast::TypeConstructorExpression expr(&b, std::move(values)); ast::TypeConstructorExpression expr(&b, std::move(values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "bool(true)"); EXPECT_EQ(result(), "bool(true)");
} }
@ -110,7 +110,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Int) {
ast::TypeConstructorExpression expr(&i32, std::move(values)); ast::TypeConstructorExpression expr(&i32, std::move(values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "int(-12345)"); EXPECT_EQ(result(), "int(-12345)");
} }
@ -124,7 +124,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Uint) {
ast::TypeConstructorExpression expr(&u32, std::move(values)); ast::TypeConstructorExpression expr(&u32, std::move(values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "uint(12345u)"); EXPECT_EQ(result(), "uint(12345u)");
} }
@ -145,7 +145,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Vec) {
ast::TypeConstructorExpression expr(&vec, std::move(values)); ast::TypeConstructorExpression expr(&vec, std::move(values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
"vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f)"); "vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f)");
} }
@ -157,7 +157,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Vec_Empty) {
ast::ExpressionList values; ast::ExpressionList values;
ast::TypeConstructorExpression expr(&vec, std::move(values)); ast::TypeConstructorExpression expr(&vec, std::move(values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "vector<float, 3>(0.0f)"); EXPECT_EQ(result(), "vector<float, 3>(0.0f)");
} }
@ -193,7 +193,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Mat) {
ast::TypeConstructorExpression expr(&mat, std::move(mat_values)); ast::TypeConstructorExpression expr(&mat, std::move(mat_values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
// A matrix of type T with n columns and m rows can also be constructed from // A matrix of type T with n columns and m rows can also be constructed from
// n vectors of type T with m components. // n vectors of type T with m components.
@ -232,7 +232,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Array) {
ast::TypeConstructorExpression expr(&ary, std::move(ary_values)); ast::TypeConstructorExpression expr(&ary, std::move(ary_values));
ASSERT_TRUE(gen().EmitConstructor(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitConstructor(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
std::string("{") + std::string("{") +
"vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), " + "vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), " +

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

@ -25,20 +25,20 @@ using HlslGeneratorImplTest_Identifier = TestHelper;
TEST_F(HlslGeneratorImplTest_Identifier, DISABLED_EmitExpression_Identifier) { TEST_F(HlslGeneratorImplTest_Identifier, DISABLED_EmitExpression_Identifier) {
ast::IdentifierExpression i(std::vector<std::string>{"std", "glsl"}); ast::IdentifierExpression i(std::vector<std::string>{"std", "glsl"});
ASSERT_TRUE(gen().EmitExpression(out(), &i)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
EXPECT_EQ(result(), "std::glsl"); EXPECT_EQ(result(), "std::glsl");
} }
TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression_Single) { TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression_Single) {
ast::IdentifierExpression i("foo"); ast::IdentifierExpression i("foo");
ASSERT_TRUE(gen().EmitExpression(out(), &i)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
EXPECT_EQ(result(), "foo"); EXPECT_EQ(result(), "foo");
} }
TEST_F(HlslGeneratorImplTest_Identifier, TEST_F(HlslGeneratorImplTest_Identifier,
EmitIdentifierExpression_Single_WithCollision) { EmitIdentifierExpression_Single_WithCollision) {
ast::IdentifierExpression i("virtual"); ast::IdentifierExpression i("virtual");
ASSERT_TRUE(gen().EmitExpression(out(), &i)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
EXPECT_EQ(result(), "virtual_tint_0"); EXPECT_EQ(result(), "virtual_tint_0");
} }
@ -46,7 +46,7 @@ TEST_F(HlslGeneratorImplTest_Identifier,
TEST_F(HlslGeneratorImplTest_Identifier, TEST_F(HlslGeneratorImplTest_Identifier,
DISABLED_EmitIdentifierExpression_MultipleNames) { DISABLED_EmitIdentifierExpression_MultipleNames) {
ast::IdentifierExpression i({"std", "glsl", "init"}); ast::IdentifierExpression i({"std", "glsl", "init"});
ASSERT_TRUE(gen().EmitExpression(out(), &i)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
EXPECT_EQ(result(), "std::glsl::init"); EXPECT_EQ(result(), "std::glsl::init");
} }

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

@ -65,7 +65,7 @@ TEST_P(HlslImportData_SingleParamTest, FloatScalar) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1.00000000f)"); EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1.00000000f)");
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
@ -130,7 +130,7 @@ TEST_P(HlslImportData_SingleIntParamTest, IntScalar) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1)"); EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1)");
} }
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import, INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
@ -158,7 +158,7 @@ TEST_P(HlslImportData_DualParamTest, FloatScalar) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
std::string(param.hlsl_name) + "(1.00000000f, 2.00000000f)"); std::string(param.hlsl_name) + "(1.00000000f, 2.00000000f)");
} }
@ -210,7 +210,7 @@ TEST_P(HlslImportData_DualParam_VectorTest, FloatVector) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
std::string(param.hlsl_name) + std::string(param.hlsl_name) +
"(vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), " "(vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), "
@ -240,7 +240,7 @@ TEST_P(HlslImportData_DualParam_Int_Test, IntScalar) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2)"); EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2)");
} }
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import, INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
@ -272,7 +272,7 @@ TEST_P(HlslImportData_TripleParamTest, FloatScalar) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), std::string(param.hlsl_name) + EXPECT_EQ(result(), std::string(param.hlsl_name) +
"(1.00000000f, 2.00000000f, 3.00000000f)"); "(1.00000000f, 2.00000000f, 3.00000000f)");
} }
@ -311,7 +311,7 @@ TEST_P(HlslImportData_TripleParam_Int_Test, IntScalar) {
mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std")); mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2, 3)"); EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2, 3)");
} }
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import, INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
@ -339,7 +339,7 @@ TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) {
// Register the global // Register the global
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitImportFunction(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), std::string("determinant(var)")); EXPECT_EQ(result(), std::string("determinant(var)"));
} }

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

@ -96,7 +96,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, DISABLED_Intrinsic_OuterProduct) {
ASSERT_TRUE(td().DetermineResultType(&call)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&call)) << td().error();
gen().increment_indent(); gen().increment_indent();
ASSERT_TRUE(gen().EmitExpression(out(), &call)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
EXPECT_EQ(result(), " float3x2(a * b[0], a * b[1], a * b[2])"); EXPECT_EQ(result(), " float3x2(a * b[0], a * b[1], a * b[2])");
} }
@ -113,7 +113,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
std::move(params)); std::move(params));
gen().increment_indent(); gen().increment_indent();
ASSERT_TRUE(gen().EmitExpression(out(), &call)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
EXPECT_EQ(result(), " dot(param1, param2)"); EXPECT_EQ(result(), " dot(param1, param2)");
} }

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

@ -73,7 +73,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
mod()->AddGlobalVariable(std::move(str_var)); mod()->AddGlobalVariable(std::move(str_var));
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "str.mem"); EXPECT_EQ(result(), "str.mem");
} }
@ -122,7 +122,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load(4))"); EXPECT_EQ(result(), "asfloat(data.Load(4))");
} }
@ -171,7 +171,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asint(data.Load(0))"); EXPECT_EQ(result(), "asint(data.Load(0))");
} }
TEST_F(HlslGeneratorImplTest_MemberAccessor, TEST_F(HlslGeneratorImplTest_MemberAccessor,
@ -347,7 +347,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
"asfloat(matrix<uint, 2, 3>(data.Load2(4 + 0), data.Load2(4 + 8), " "asfloat(matrix<uint, 2, 3>(data.Load2(4 + 0), data.Load2(4 + 8), "
"data.Load2(4 + 16)))"); "data.Load2(4 + 16)))");
@ -403,7 +403,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ( EXPECT_EQ(
result(), result(),
"asfloat(matrix<uint, 3, 2>(data.Load3(4 + 0), data.Load3(4 + 16)))"); "asfloat(matrix<uint, 3, 2>(data.Load3(4 + 0), data.Load3(4 + 16)))");
@ -451,7 +451,7 @@ TEST_F(
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), EXPECT_EQ(result(),
"asfloat(matrix<uint, 3, 3>(data.Load3(0 + 0), data.Load3(0 + 16), " "asfloat(matrix<uint, 3, 3>(data.Load3(0 + 0), data.Load3(0 + 16), "
"data.Load3(0 + 32)))"); "data.Load3(0 + 32)))");
@ -509,7 +509,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + (16 * 2) + 16))"); EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + (16 * 2) + 16))");
} }
@ -557,7 +557,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asint(data.Load((4 * 2) + 0))"); EXPECT_EQ(result(), "asint(data.Load((4 * 2) + 0))");
} }
@ -613,7 +613,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td().Determine()) << td().error(); ASSERT_TRUE(td().Determine()) << td().error();
ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error(); ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asint(data.Load((4 * ((2 + 4) - 3)) + 0))"); EXPECT_EQ(result(), "asint(data.Load((4 * ((2 + 4) - 3)) + 0))");
} }
@ -826,7 +826,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
std::make_unique<ast::IdentifierExpression>("b")); std::make_unique<ast::IdentifierExpression>("b"));
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load3(16))"); EXPECT_EQ(result(), "asfloat(data.Load3(16))");
} }
@ -946,12 +946,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto pre_str = std::make_unique<ast::Struct>(); auto pre_str = std::make_unique<ast::Struct>();
pre_str->set_members(std::move(members)); pre_str->set_members(std::move(members));
ast::type::StructType pre(std::move(pre_str)); ast::type::StructType pre_struct(std::move(pre_str));
pre.set_name("Pre"); pre_struct.set_name("Pre");
auto coord_var = auto coord_var =
std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>( std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
"data", ast::StorageClass::kStorageBuffer, &pre)); "data", ast::StorageClass::kStorageBuffer, &pre_struct));
td().RegisterVariableForTesting(coord_var.get()); td().RegisterVariableForTesting(coord_var.get());
gen().register_global(coord_var.get()); gen().register_global(coord_var.get());
@ -969,7 +969,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
std::make_unique<ast::IdentifierExpression>("b")); std::make_unique<ast::IdentifierExpression>("b"));
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0))"); EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0))");
} }
@ -1019,12 +1019,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto pre_str = std::make_unique<ast::Struct>(); auto pre_str = std::make_unique<ast::Struct>();
pre_str->set_members(std::move(members)); pre_str->set_members(std::move(members));
ast::type::StructType pre(std::move(pre_str)); ast::type::StructType pre_struct(std::move(pre_str));
pre.set_name("Pre"); pre_struct.set_name("Pre");
auto coord_var = auto coord_var =
std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>( std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
"data", ast::StorageClass::kStorageBuffer, &pre)); "data", ast::StorageClass::kStorageBuffer, &pre_struct));
td().RegisterVariableForTesting(coord_var.get()); td().RegisterVariableForTesting(coord_var.get());
gen().register_global(coord_var.get()); gen().register_global(coord_var.get());
@ -1044,7 +1044,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
std::make_unique<ast::IdentifierExpression>("xy")); std::make_unique<ast::IdentifierExpression>("xy"));
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0)).xy"); EXPECT_EQ(result(), "asfloat(data.Load3(16 + (32 * 2) + 0)).xy");
} }
@ -1095,12 +1095,12 @@ TEST_F(
auto pre_str = std::make_unique<ast::Struct>(); auto pre_str = std::make_unique<ast::Struct>();
pre_str->set_members(std::move(members)); pre_str->set_members(std::move(members));
ast::type::StructType pre(std::move(pre_str)); ast::type::StructType pre_struct(std::move(pre_str));
pre.set_name("Pre"); pre_struct.set_name("Pre");
auto coord_var = auto coord_var =
std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>( std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
"data", ast::StorageClass::kStorageBuffer, &pre)); "data", ast::StorageClass::kStorageBuffer, &pre_struct));
td().RegisterVariableForTesting(coord_var.get()); td().RegisterVariableForTesting(coord_var.get());
gen().register_global(coord_var.get()); gen().register_global(coord_var.get());
@ -1120,7 +1120,7 @@ TEST_F(
std::make_unique<ast::IdentifierExpression>("g")); std::make_unique<ast::IdentifierExpression>("g"));
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))"); EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))");
} }
@ -1170,12 +1170,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto pre_str = std::make_unique<ast::Struct>(); auto pre_str = std::make_unique<ast::Struct>();
pre_str->set_members(std::move(members)); pre_str->set_members(std::move(members));
ast::type::StructType pre(std::move(pre_str)); ast::type::StructType pre_struct(std::move(pre_str));
pre.set_name("Pre"); pre_struct.set_name("Pre");
auto coord_var = auto coord_var =
std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>( std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
"data", ast::StorageClass::kStorageBuffer, &pre)); "data", ast::StorageClass::kStorageBuffer, &pre_struct));
td().RegisterVariableForTesting(coord_var.get()); td().RegisterVariableForTesting(coord_var.get());
gen().register_global(coord_var.get()); gen().register_global(coord_var.get());
@ -1196,7 +1196,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
std::make_unique<ast::SintLiteral>(&i32, 1))); std::make_unique<ast::SintLiteral>(&i32, 1)));
ASSERT_TRUE(td().DetermineResultType(&expr)); ASSERT_TRUE(td().DetermineResultType(&expr));
ASSERT_TRUE(gen().EmitExpression(out(), &expr)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &expr)) << gen().error();
EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))"); EXPECT_EQ(result(), "asfloat(data.Load((4 * 1) + 16 + (32 * 2) + 0))");
} }
@ -1246,12 +1246,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto pre_str = std::make_unique<ast::Struct>(); auto pre_str = std::make_unique<ast::Struct>();
pre_str->set_members(std::move(members)); pre_str->set_members(std::move(members));
ast::type::StructType pre(std::move(pre_str)); ast::type::StructType pre_struct(std::move(pre_str));
pre.set_name("Pre"); pre_struct.set_name("Pre");
auto coord_var = auto coord_var =
std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>( std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
"data", ast::StorageClass::kStorageBuffer, &pre)); "data", ast::StorageClass::kStorageBuffer, &pre_struct));
td().RegisterVariableForTesting(coord_var.get()); td().RegisterVariableForTesting(coord_var.get());
gen().register_global(coord_var.get()); gen().register_global(coord_var.get());
@ -1338,12 +1338,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
auto pre_str = std::make_unique<ast::Struct>(); auto pre_str = std::make_unique<ast::Struct>();
pre_str->set_members(std::move(members)); pre_str->set_members(std::move(members));
ast::type::StructType pre(std::move(pre_str)); ast::type::StructType pre_struct(std::move(pre_str));
pre.set_name("Pre"); pre_struct.set_name("Pre");
auto coord_var = auto coord_var =
std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>( std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
"data", ast::StorageClass::kStorageBuffer, &pre)); "data", ast::StorageClass::kStorageBuffer, &pre_struct));
td().RegisterVariableForTesting(coord_var.get()); td().RegisterVariableForTesting(coord_var.get());
gen().register_global(coord_var.get()); gen().register_global(coord_var.get());

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

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

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

@ -40,7 +40,7 @@ TEST_P(HlslUnaryOpTest, Emit) {
auto expr = std::make_unique<ast::IdentifierExpression>("expr"); auto expr = std::make_unique<ast::IdentifierExpression>("expr");
ast::UnaryOpExpression op(params.op, std::move(expr)); ast::UnaryOpExpression op(params.op, std::move(expr));
ASSERT_TRUE(gen().EmitExpression(out(), &op)) << gen().error(); ASSERT_TRUE(gen().EmitExpression(pre(), out(), &op)) << gen().error();
EXPECT_EQ(result(), std::string(params.name) + "(expr)"); EXPECT_EQ(result(), std::string(params.name) + "(expr)");
} }
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_UnaryOp, INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_UnaryOp,

7
src/writer/hlsl/test_helper.h
View File

@ -46,15 +46,22 @@ class TestHelperBase : public T {
/// @returns the output stream /// @returns the output stream
std::ostream& out() { return out_; } std::ostream& out() { return out_; }
/// @returns the pre stream
std::ostream& pre() { return pre_; }
/// @returns the result string /// @returns the result string
std::string result() const { return out_.str(); } std::string result() const { return out_.str(); }
/// @returns the pre result string
std::string pre_result() const { return pre_.str(); }
private: private:
Context ctx_; Context ctx_;
ast::Module mod_; ast::Module mod_;
TypeDeterminer td_; TypeDeterminer td_;
GeneratorImpl impl_; GeneratorImpl impl_;
std::ostringstream out_; std::ostringstream out_;
std::ostringstream pre_;
}; };
using TestHelper = TestHelperBase<testing::Test>; using TestHelper = TestHelperBase<testing::Test>;