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

Use a test namer in the MSL generator. 

This CL updates the MSL generator to use a test namer, the various
places where the incorrect name was emitted have been fixed.

Change-Id: I20c990bdddc4f0580b09269920abe8376fa3ca07
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/36900
Reviewed-by: Ryan Harrison <rharrison@chromium.org>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
dan sinclair 2021-01-11 16:24:32 +00:00 committed by dan sinclair
parent c8c31560de
commit f74b90b3dd
36 changed files with 479 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD.gn
View File

@ -834,6 +834,8 @@ source_set("tint_unittests_core_src") {
"src/validator/validator_function_test.cc", "src/validator/validator_function_test.cc",
"src/validator/validator_test.cc", "src/validator/validator_test.cc",
"src/writer/float_to_string_test.cc", "src/writer/float_to_string_test.cc",
"src/writer/test_namer.cc",
"src/writer/test_namer.h",
] ]
configs += [ configs += [

2
src/CMakeLists.txt
View File

@ -467,6 +467,8 @@ if(${TINT_BUILD_TESTS})
validator/validator_test.cc validator/validator_test.cc
validator/validator_type_test.cc validator/validator_type_test.cc
writer/float_to_string_test.cc writer/float_to_string_test.cc
writer/test_namer.cc
writer/test_namer.h
) )
if(${TINT_BUILD_SPV_READER}) if(${TINT_BUILD_SPV_READER})

8
src/ast/identifier_expression.h
View File

@ -58,6 +58,12 @@ class IdentifierExpression : public Castable<IdentifierExpression, Expression> {
/// @returns true if this identifier is for an intrinsic /// @returns true if this identifier is for an intrinsic
bool IsIntrinsic() const { return intrinsic_ != Intrinsic::kNone; } bool IsIntrinsic() const { return intrinsic_ != Intrinsic::kNone; }
/// Sets the identifier as a swizzle
void SetIsSwizzle() { is_swizzle_ = true; }
/// @returns true if this is a swizzle identifier
bool IsSwizzle() const { return is_swizzle_; }
/// Clones this node and all transitive child nodes using the `CloneContext` /// Clones this node and all transitive child nodes using the `CloneContext`
/// `ctx`. /// `ctx`.
/// @note Semantic information such as resolved expression type and intrinsic /// @note Semantic information such as resolved expression type and intrinsic
@ -78,9 +84,9 @@ class IdentifierExpression : public Castable<IdentifierExpression, Expression> {
IdentifierExpression(const IdentifierExpression&) = delete; IdentifierExpression(const IdentifierExpression&) = delete;
Symbol const sym_; Symbol const sym_;
Intrinsic intrinsic_ = Intrinsic::kNone; // Semantic info Intrinsic intrinsic_ = Intrinsic::kNone; // Semantic info
std::unique_ptr<intrinsic::Signature> intrinsic_sig_; // Semantic info std::unique_ptr<intrinsic::Signature> intrinsic_sig_; // Semantic info
bool is_swizzle_ = false; // Semantic info
}; };
} // namespace ast } // namespace ast

4
src/namer.cc
View File

@ -26,6 +26,10 @@ Namer::Namer(ast::Module* mod) : module_(mod) {}
Namer::~Namer() = default; Namer::~Namer() = default;
void Namer::Reset() {
used_.clear();
}
bool Namer::IsUsed(const std::string& name) { bool Namer::IsUsed(const std::string& name) {
auto it = used_.find(name); auto it = used_.find(name);
return it != used_.end(); return it != used_.end();

3
src/namer.h
View File

@ -42,6 +42,9 @@ class Namer {
/// @returns the unique name string /// @returns the unique name string
std::string GenerateName(const std::string& prefix); std::string GenerateName(const std::string& prefix);
/// Resets the namer, removing all known symbols.
void Reset();
protected: protected:
/// Checks if `name` has been used /// Checks if `name` has been used
/// @param name the name to check /// @param name the name to check

2
src/type_determiner.cc
View File

@ -1079,7 +1079,7 @@ bool TypeDeterminer::DetermineMemberAccessor(
ret = mod_->create<ast::type::Pointer>(ret, ptr->storage_class()); ret = mod_->create<ast::type::Pointer>(ret, ptr->storage_class());
} }
} else if (auto* vec = data_type->As<ast::type::Vector>()) { } else if (auto* vec = data_type->As<ast::type::Vector>()) {
// TODO(dsinclair): Swizzle, record into the identifier experesion expr->member()->SetIsSwizzle();
auto size = mod_->SymbolToName(expr->member()->symbol()).size(); auto size = mod_->SymbolToName(expr->member()->symbol()).size();
if (size == 1) { if (size == 1) {

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

@ -22,13 +22,15 @@ namespace msl {
Generator::Generator(ast::Module module) Generator::Generator(ast::Module module)
: Text(std::move(module)), : Text(std::move(module)),
impl_(std::make_unique<GeneratorImpl>(&module_)) {} namer_(std::make_unique<UnsafeNamer>(&module_)),
impl_(std::make_unique<GeneratorImpl>(&module_, namer_.get())) {}
Generator::~Generator() = default; Generator::~Generator() = default;
void Generator::Reset() { void Generator::Reset() {
set_error(""); set_error("");
impl_ = std::make_unique<GeneratorImpl>(&module_); namer_->Reset();
impl_ = std::make_unique<GeneratorImpl>(&module_, namer_.get());
} }
bool Generator::Generate() { bool Generator::Generate() {

2
src/writer/msl/generator.h
View File

@ -18,6 +18,7 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include "src/namer.h"
#include "src/writer/msl/generator_impl.h" #include "src/writer/msl/generator_impl.h"
#include "src/writer/text.h" #include "src/writer/text.h"
@ -54,6 +55,7 @@ class Generator : public Text {
std::string error() const; std::string error() const;
private: private:
std::unique_ptr<Namer> namer_;
std::unique_ptr<GeneratorImpl> impl_; std::unique_ptr<GeneratorImpl> impl_;
}; };

109
src/writer/msl/generator_impl.cc
View File

@ -96,10 +96,8 @@ uint32_t adjust_for_alignment(uint32_t count, uint32_t alignment) {
} // namespace } // namespace
GeneratorImpl::GeneratorImpl(ast::Module* module) GeneratorImpl::GeneratorImpl(ast::Module* module, Namer* namer)
: TextGenerator(), : TextGenerator(), module_(module), namer_(namer) {}
module_(module),
namer_(std::make_unique<UnsafeNamer>(module)) {}
GeneratorImpl::~GeneratorImpl() = default; GeneratorImpl::~GeneratorImpl() = default;
@ -398,25 +396,25 @@ bool GeneratorImpl::EmitBreak(ast::BreakStatement*) {
return true; return true;
} }
std::string GeneratorImpl::current_ep_var_name(VarType type) { Symbol GeneratorImpl::current_ep_var_symbol(VarType type) {
std::string name = ""; Symbol sym;
switch (type) { switch (type) {
case VarType::kIn: { case VarType::kIn: {
auto in_it = ep_sym_to_in_data_.find(current_ep_sym_.value()); auto in_it = ep_sym_to_in_data_.find(current_ep_sym_.value());
if (in_it != ep_sym_to_in_data_.end()) { if (in_it != ep_sym_to_in_data_.end()) {
name = in_it->second.var_name; sym = in_it->second.var_symbol;
} }
break; break;
} }
case VarType::kOut: { case VarType::kOut: {
auto out_it = ep_sym_to_out_data_.find(current_ep_sym_.value()); auto out_it = ep_sym_to_out_data_.find(current_ep_sym_.value());
if (out_it != ep_sym_to_out_data_.end()) { if (out_it != ep_sym_to_out_data_.end()) {
name = out_it->second.var_name; sym = out_it->second.var_symbol;
} }
break; break;
} }
} }
return name; return sym;
} }
std::string GeneratorImpl::generate_intrinsic_name(ast::Intrinsic intrinsic) { std::string GeneratorImpl::generate_intrinsic_name(ast::Intrinsic intrinsic) {
@ -563,12 +561,11 @@ bool GeneratorImpl::EmitCall(ast::CallExpression* expr) {
return true; return true;
} }
auto name = namer_->NameFor(ident->symbol()); auto name_sym = ident->symbol();
auto caller_sym = ident->symbol(); auto it = ep_func_name_remapped_.find(module_->SymbolToName(current_ep_sym_) +
auto it = ep_func_name_remapped_.find(current_ep_sym_.to_str() + "_" + "_" + module_->SymbolToName(name_sym));
caller_sym.to_str());
if (it != ep_func_name_remapped_.end()) { if (it != ep_func_name_remapped_.end()) {
name = it->second; name_sym = it->second;
} }
auto* func = module_->FindFunctionBySymbol(ident->symbol()); auto* func = module_->FindFunctionBySymbol(ident->symbol());
@ -578,24 +575,24 @@ bool GeneratorImpl::EmitCall(ast::CallExpression* expr) {
return false; return false;
} }
out_ << name << "("; out_ << namer_->NameFor(name_sym) << "(";
bool first = true; bool first = true;
if (has_referenced_in_var_needing_struct(func)) { if (has_referenced_in_var_needing_struct(func)) {
auto var_name = current_ep_var_name(VarType::kIn); auto var_sym = current_ep_var_symbol(VarType::kIn);
if (!var_name.empty()) { if (var_sym.IsValid()) {
out_ << var_name; out_ << namer_->NameFor(var_sym);
first = false; first = false;
} }
} }
if (has_referenced_out_var_needing_struct(func)) { if (has_referenced_out_var_needing_struct(func)) {
auto var_name = current_ep_var_name(VarType::kOut); auto var_sym = current_ep_var_symbol(VarType::kOut);
if (!var_name.empty()) { if (var_sym.IsValid()) {
if (!first) { if (!first) {
out_ << ", "; out_ << ", ";
} }
first = false; first = false;
out_ << var_name; out_ << namer_->NameFor(var_sym);
} }
} }
@ -1018,13 +1015,14 @@ bool GeneratorImpl::EmitEntryPointData(ast::Function* func) {
} }
if (!in_locations.empty()) { if (!in_locations.empty()) {
auto in_struct_name = namer_->GenerateName(namer_->NameFor(func->symbol()) + auto in_struct_sym = module_->RegisterSymbol(namer_->GenerateName(
"_" + kInStructNameSuffix); module_->SymbolToName(func->symbol()) + "_" + kInStructNameSuffix));
auto in_var_name = namer_->GenerateName(kTintStructInVarPrefix); auto in_var_name = namer_->GenerateName(kTintStructInVarPrefix);
ep_sym_to_in_data_[func->symbol().value()] = {in_struct_name, in_var_name}; ep_sym_to_in_data_[func->symbol().value()] = {
in_struct_sym, module_->RegisterSymbol(in_var_name)};
make_indent(); make_indent();
out_ << "struct " << in_struct_name << " {" << std::endl; out_ << "struct " << namer_->NameFor(in_struct_sym) << " {" << std::endl;
increment_indent(); increment_indent();
@ -1055,14 +1053,14 @@ bool GeneratorImpl::EmitEntryPointData(ast::Function* func) {
} }
if (!out_variables.empty()) { if (!out_variables.empty()) {
auto out_struct_name = namer_->GenerateName( auto out_struct_sym = module_->RegisterSymbol(namer_->GenerateName(
namer_->NameFor(func->symbol()) + "_" + kOutStructNameSuffix); module_->SymbolToName(func->symbol()) + "_" + kOutStructNameSuffix));
auto out_var_name = namer_->GenerateName(kTintStructOutVarPrefix); auto out_var_name = namer_->GenerateName(kTintStructOutVarPrefix);
ep_sym_to_out_data_[func->symbol().value()] = {out_struct_name, ep_sym_to_out_data_[func->symbol().value()] = {
out_var_name}; out_struct_sym, module_->RegisterSymbol(out_var_name)};
make_indent(); make_indent();
out_ << "struct " << out_struct_name << " {" << std::endl; out_ << "struct " << namer_->NameFor(out_struct_sym) << " {" << std::endl;
increment_indent(); increment_indent();
for (auto& data : out_variables) { for (auto& data : out_variables) {
@ -1221,22 +1219,20 @@ bool GeneratorImpl::EmitFunction(ast::Function* func) {
bool GeneratorImpl::EmitFunctionInternal(ast::Function* func, bool GeneratorImpl::EmitFunctionInternal(ast::Function* func,
bool emit_duplicate_functions, bool emit_duplicate_functions,
Symbol ep_sym) { Symbol ep_sym) {
auto name = func->symbol().to_str();
if (!EmitType(func->return_type(), Symbol())) { if (!EmitType(func->return_type(), Symbol())) {
return false; return false;
} }
out_ << " "; out_ << " ";
auto func_name_sym = func->symbol();
if (emit_duplicate_functions) { if (emit_duplicate_functions) {
auto func_name = name; auto func_name = module_->SymbolToName(func_name_sym);
auto ep_name = ep_sym.to_str(); auto ep_name = module_->SymbolToName(ep_sym);
name = namer_->GenerateName(namer_->NameFor(func->symbol()) + "_" + func_name_sym = module_->RegisterSymbol(
namer_->NameFor(ep_sym)); namer_->GenerateName(func_name + "_" + ep_name));
ep_func_name_remapped_[ep_name + "_" + func_name] = name; ep_func_name_remapped_[ep_name + "_" + func_name] = func_name_sym;
} else {
name = namer_->NameFor(func->symbol());
} }
out_ << name << "("; out_ << namer_->NameFor(func_name_sym) << "(";
bool first = true; bool first = true;
@ -1247,8 +1243,8 @@ bool GeneratorImpl::EmitFunctionInternal(ast::Function* func,
if (emit_duplicate_functions) { if (emit_duplicate_functions) {
auto in_it = ep_sym_to_in_data_.find(ep_sym.value()); auto in_it = ep_sym_to_in_data_.find(ep_sym.value());
if (in_it != ep_sym_to_in_data_.end()) { if (in_it != ep_sym_to_in_data_.end()) {
out_ << "thread " << in_it->second.struct_name << "& " out_ << "thread " << namer_->NameFor(in_it->second.struct_symbol) << "& "
<< in_it->second.var_name; << namer_->NameFor(in_it->second.var_symbol);
first = false; first = false;
} }
@ -1257,8 +1253,8 @@ bool GeneratorImpl::EmitFunctionInternal(ast::Function* func,
if (!first) { if (!first) {
out_ << ", "; out_ << ", ";
} }
out_ << "thread " << out_it->second.struct_name << "& " out_ << "thread " << namer_->NameFor(out_it->second.struct_symbol) << "& "
<< out_it->second.var_name; << namer_->NameFor(out_it->second.var_symbol);
first = false; first = false;
} }
} }
@ -1385,7 +1381,7 @@ bool GeneratorImpl::EmitEntryPointFunction(ast::Function* func) {
auto out_data = ep_sym_to_out_data_.find(current_ep_sym_.value()); auto out_data = ep_sym_to_out_data_.find(current_ep_sym_.value());
bool has_out_data = out_data != ep_sym_to_out_data_.end(); bool has_out_data = out_data != ep_sym_to_out_data_.end();
if (has_out_data) { if (has_out_data) {
out_ << out_data->second.struct_name; out_ << namer_->NameFor(out_data->second.struct_symbol);
} else { } else {
out_ << "void"; out_ << "void";
} }
@ -1394,8 +1390,8 @@ bool GeneratorImpl::EmitEntryPointFunction(ast::Function* func) {
bool first = true; bool first = true;
auto in_data = ep_sym_to_in_data_.find(current_ep_sym_.value()); auto in_data = ep_sym_to_in_data_.find(current_ep_sym_.value());
if (in_data != ep_sym_to_in_data_.end()) { if (in_data != ep_sym_to_in_data_.end()) {
out_ << in_data->second.struct_name << " " << in_data->second.var_name out_ << namer_->NameFor(in_data->second.struct_symbol) << " "
<< " [[stage_in]]"; << namer_->NameFor(in_data->second.var_symbol) << " [[stage_in]]";
first = false; first = false;
} }
@ -1488,8 +1484,9 @@ bool GeneratorImpl::EmitEntryPointFunction(ast::Function* func) {
if (has_out_data) { if (has_out_data) {
make_indent(); make_indent();
out_ << out_data->second.struct_name << " " << out_data->second.var_name out_ << namer_->NameFor(out_data->second.struct_symbol) << " "
<< " = {};" << std::endl; << namer_->NameFor(out_data->second.var_symbol) << " = {};"
<< std::endl;
} }
generating_entry_point_ = true; generating_entry_point_ = true;
@ -1527,15 +1524,21 @@ bool GeneratorImpl::EmitIdentifier(ast::IdentifierExpression* expr) {
auto var_type = var->storage_class() == ast::StorageClass::kInput auto var_type = var->storage_class() == ast::StorageClass::kInput
? VarType::kIn ? VarType::kIn
: VarType::kOut; : VarType::kOut;
auto name = current_ep_var_name(var_type); auto sym = current_ep_var_symbol(var_type);
if (name.empty()) { if (!sym.IsValid()) {
error_ = "unable to find entry point data for variable"; error_ = "unable to find entry point data for variable";
return false; return false;
} }
out_ << name << "."; out_ << namer_->NameFor(sym) << ".";
} }
} }
out_ << namer_->NameFor(ident->symbol());
// Swizzles get written out directly
if (ident->IsSwizzle()) {
out_ << module_->SymbolToName(ident->symbol());
} else {
out_ << namer_->NameFor(ident->symbol());
}
return true; return true;
} }
@ -1690,7 +1693,7 @@ bool GeneratorImpl::EmitReturn(ast::ReturnStatement* stmt) {
if (generating_entry_point_) { if (generating_entry_point_) {
auto out_data = ep_sym_to_out_data_.find(current_ep_sym_.value()); auto out_data = ep_sym_to_out_data_.find(current_ep_sym_.value());
if (out_data != ep_sym_to_out_data_.end()) { if (out_data != ep_sym_to_out_data_.end()) {
out_ << " " << out_data->second.var_name; out_ << " " << namer_->NameFor(out_data->second.var_symbol);
} }
} else if (stmt->has_value()) { } else if (stmt->has_value()) {
out_ << " "; out_ << " ";

16
src/writer/msl/generator_impl.h
View File

@ -15,7 +15,6 @@
#ifndef SRC_WRITER_MSL_GENERATOR_IMPL_H_ #ifndef SRC_WRITER_MSL_GENERATOR_IMPL_H_
#define SRC_WRITER_MSL_GENERATOR_IMPL_H_ #define SRC_WRITER_MSL_GENERATOR_IMPL_H_
#include <memory>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
@ -56,7 +55,8 @@ class GeneratorImpl : public TextGenerator {
public: public:
/// Constructor /// Constructor
/// @param module the module to generate /// @param module the module to generate
explicit GeneratorImpl(ast::Module* module); /// @param namer the namer to use for generation
GeneratorImpl(ast::Module* module, Namer* namer);
~GeneratorImpl(); ~GeneratorImpl();
/// @returns true on successful generation; false otherwise /// @returns true on successful generation; false otherwise
@ -268,18 +268,18 @@ class GeneratorImpl : public TextGenerator {
enum class VarType { kIn, kOut }; enum class VarType { kIn, kOut };
struct EntryPointData { struct EntryPointData {
std::string struct_name; Symbol struct_symbol;
std::string var_name; Symbol var_symbol;
}; };
std::string current_ep_var_name(VarType type); Symbol current_ep_var_symbol(VarType type);
ScopeStack<ast::Variable*> global_variables_; ScopeStack<ast::Variable*> global_variables_;
Symbol current_ep_sym_; Symbol current_ep_sym_;
bool generating_entry_point_ = false; bool generating_entry_point_ = false;
const ast::Module* module_ = nullptr; ast::Module* module_ = nullptr;
uint32_t loop_emission_counter_ = 0; uint32_t loop_emission_counter_ = 0;
std::unique_ptr<Namer> namer_; Namer* namer_;
std::unordered_map<uint32_t, EntryPointData> ep_sym_to_in_data_; std::unordered_map<uint32_t, EntryPointData> ep_sym_to_in_data_;
std::unordered_map<uint32_t, EntryPointData> ep_sym_to_out_data_; std::unordered_map<uint32_t, EntryPointData> ep_sym_to_out_data_;
@ -287,7 +287,7 @@ class GeneratorImpl : public TextGenerator {
// This maps an input of "<entry_point_name>_<function_name>" to a remapped // This maps an input of "<entry_point_name>_<function_name>" to a remapped
// function name. If there is no entry for a given key then function did // function name. If there is no entry for a given key then function did
// not need to be remapped for the entry point and can be emitted directly. // not need to be remapped for the entry point and can be emitted directly.
std::unordered_map<std::string, std::string> ep_func_name_remapped_; std::unordered_map<std::string, Symbol> ep_func_name_remapped_;
}; };
} // namespace msl } // namespace msl

10
src/writer/msl/generator_impl_alias_type_test.cc
View File

@ -31,7 +31,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_F32) {
auto* alias = ty.alias("a", ty.f32); auto* alias = ty.alias("a", ty.f32);
ASSERT_TRUE(gen.EmitConstructedType(alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(alias)) << gen.error();
EXPECT_EQ(gen.result(), R"(typedef float a; EXPECT_EQ(gen.result(), R"(typedef float test_a;
)"); )");
} }
@ -43,9 +43,9 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_Struct) {
auto* s = ty.struct_("a", str); auto* s = ty.struct_("a", str);
ASSERT_TRUE(gen.EmitConstructedType(s)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(s)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct a { EXPECT_EQ(gen.result(), R"(struct test_a {
float a; float test_a;
int b; int test_b;
}; };
)"); )");
} }
@ -60,7 +60,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_AliasStructIdent) {
auto* alias = ty.alias("a", s); auto* alias = ty.alias("a", s);
ASSERT_TRUE(gen.EmitConstructedType(alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(alias)) << gen.error();
EXPECT_EQ(gen.result(), R"(typedef b a; EXPECT_EQ(gen.result(), R"(typedef test_b test_a;
)"); )");
} }

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

@ -35,7 +35,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
auto* expr = IndexAccessor(Expr("ary"), 5); auto* expr = IndexAccessor(Expr("ary"), 5);
ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), "ary[5]"); EXPECT_EQ(gen.result(), "test_ary[5]");
} }
TEST_F(MslGeneratorImplTest, EmitArrayAccessor) { TEST_F(MslGeneratorImplTest, EmitArrayAccessor) {
@ -43,7 +43,7 @@ TEST_F(MslGeneratorImplTest, EmitArrayAccessor) {
ASSERT_TRUE(gen.EmitArrayAccessor(expr->As<ast::ArrayAccessorExpression>())) ASSERT_TRUE(gen.EmitArrayAccessor(expr->As<ast::ArrayAccessorExpression>()))
<< gen.error(); << gen.error();
EXPECT_EQ(gen.result(), "ary[idx]"); EXPECT_EQ(gen.result(), "test_ary[test_idx]");
} }
} // namespace } // namespace

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

@ -34,7 +34,7 @@ TEST_F(MslGeneratorImplTest, Emit_Assign) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(assign)) << gen.error();
EXPECT_EQ(gen.result(), " lhs = rhs;\n"); EXPECT_EQ(gen.result(), " test_lhs = test_rhs;\n");
} }
} // namespace } // namespace

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

@ -47,24 +47,25 @@ INSTANTIATE_TEST_SUITE_P(
MslGeneratorImplTest, MslGeneratorImplTest,
MslBinaryTest, MslBinaryTest,
testing::Values( testing::Values(
BinaryData{"(left & right)", ast::BinaryOp::kAnd}, BinaryData{"(test_left & test_right)", ast::BinaryOp::kAnd},
BinaryData{"(left | right)", ast::BinaryOp::kOr}, BinaryData{"(test_left | test_right)", ast::BinaryOp::kOr},
BinaryData{"(left ^ right)", ast::BinaryOp::kXor}, BinaryData{"(test_left ^ test_right)", ast::BinaryOp::kXor},
BinaryData{"(left && right)", ast::BinaryOp::kLogicalAnd}, BinaryData{"(test_left && test_right)", ast::BinaryOp::kLogicalAnd},
BinaryData{"(left || right)", ast::BinaryOp::kLogicalOr}, BinaryData{"(test_left || test_right)", ast::BinaryOp::kLogicalOr},
BinaryData{"(left == right)", ast::BinaryOp::kEqual}, BinaryData{"(test_left == test_right)", ast::BinaryOp::kEqual},
BinaryData{"(left != right)", ast::BinaryOp::kNotEqual}, BinaryData{"(test_left != test_right)", ast::BinaryOp::kNotEqual},
BinaryData{"(left < right)", ast::BinaryOp::kLessThan}, BinaryData{"(test_left < test_right)", ast::BinaryOp::kLessThan},
BinaryData{"(left > right)", ast::BinaryOp::kGreaterThan}, BinaryData{"(test_left > test_right)", ast::BinaryOp::kGreaterThan},
BinaryData{"(left <= right)", ast::BinaryOp::kLessThanEqual}, BinaryData{"(test_left <= test_right)", ast::BinaryOp::kLessThanEqual},
BinaryData{"(left >= right)", ast::BinaryOp::kGreaterThanEqual}, BinaryData{"(test_left >= test_right)",
BinaryData{"(left << right)", ast::BinaryOp::kShiftLeft}, ast::BinaryOp::kGreaterThanEqual},
BinaryData{"(left >> right)", ast::BinaryOp::kShiftRight}, BinaryData{"(test_left << test_right)", ast::BinaryOp::kShiftLeft},
BinaryData{"(left + right)", ast::BinaryOp::kAdd}, BinaryData{"(test_left >> test_right)", ast::BinaryOp::kShiftRight},
BinaryData{"(left - right)", ast::BinaryOp::kSubtract}, BinaryData{"(test_left + test_right)", ast::BinaryOp::kAdd},
BinaryData{"(left * right)", ast::BinaryOp::kMultiply}, BinaryData{"(test_left - test_right)", ast::BinaryOp::kSubtract},
BinaryData{"(left / right)", ast::BinaryOp::kDivide}, BinaryData{"(test_left * test_right)", ast::BinaryOp::kMultiply},
BinaryData{"(left % right)", ast::BinaryOp::kModulo})); BinaryData{"(test_left / test_right)", ast::BinaryOp::kDivide},
BinaryData{"(test_left % test_right)", ast::BinaryOp::kModulo}));
} // namespace } // namespace
} // namespace msl } // namespace msl

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

@ -32,7 +32,7 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) { TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) {
auto* bitcast = create<ast::BitcastExpression>(ty.f32, Expr("id")); auto* bitcast = create<ast::BitcastExpression>(ty.f32, Expr("id"));
ASSERT_TRUE(gen.EmitExpression(bitcast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(bitcast)) << gen.error();
EXPECT_EQ(gen.result(), "as_type<float>(id)"); EXPECT_EQ(gen.result(), "as_type<float>(test_id)");
} }
} // namespace } // namespace

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

@ -38,7 +38,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
mod->AddFunction(func); mod->AddFunction(func);
ASSERT_TRUE(gen.EmitExpression(call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(call)) << gen.error();
EXPECT_EQ(gen.result(), "my_func()"); EXPECT_EQ(gen.result(), "test_my_func()");
} }
TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) { TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
@ -48,7 +48,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
mod->AddFunction(func); mod->AddFunction(func);
ASSERT_TRUE(gen.EmitExpression(call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(call)) << gen.error();
EXPECT_EQ(gen.result(), "my_func(param1, param2)"); EXPECT_EQ(gen.result(), "test_my_func(test_param1, test_param2)");
} }
TEST_F(MslGeneratorImplTest, EmitStatement_Call) { TEST_F(MslGeneratorImplTest, EmitStatement_Call) {
@ -61,7 +61,7 @@ TEST_F(MslGeneratorImplTest, EmitStatement_Call) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
EXPECT_EQ(gen.result(), " my_func(param1, param2);\n"); EXPECT_EQ(gen.result(), " test_my_func(test_param1, test_param2);\n");
} }
} // namespace } // namespace

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

@ -34,14 +34,14 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Scalar) {
auto* cast = Construct<f32>("id"); auto* cast = Construct<f32>("id");
ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error();
EXPECT_EQ(gen.result(), "float(id)"); EXPECT_EQ(gen.result(), "float(test_id)");
} }
TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Vector) { TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Vector) {
auto* cast = vec3<f32>("id"); auto* cast = vec3<f32>("id");
ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error();
EXPECT_EQ(gen.result(), "float3(id)"); EXPECT_EQ(gen.result(), "float3(test_id)");
} }
} // namespace } // namespace

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

@ -76,9 +76,9 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Input) {
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct vtx_main_in { EXPECT_EQ(gen.result(), R"(struct test_vtx_main_in {
float foo [[attribute(0)]]; float test_foo [[attribute(0)]];
int bar [[attribute(1)]]; int test_bar [[attribute(1)]];
}; };
)"); )");
@ -122,9 +122,9 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Output) {
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct vtx_main_out { EXPECT_EQ(gen.result(), R"(struct test_vtx_main_out {
float foo [[user(locn0)]]; float test_foo [[user(locn0)]];
int bar [[user(locn1)]]; int test_bar [[user(locn1)]];
}; };
)"); )");
@ -168,9 +168,9 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Input) {
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct main_in { EXPECT_EQ(gen.result(), R"(struct test_main_in {
float foo [[user(locn0)]]; float test_foo [[user(locn0)]];
int bar [[user(locn1)]]; int test_bar [[user(locn1)]];
}; };
)"); )");
@ -214,9 +214,9 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Output) {
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct main_out { EXPECT_EQ(gen.result(), R"(struct test_main_out {
float foo [[color(0)]]; float test_foo [[color(0)]];
int bar [[color(1)]]; int test_bar [[color(1)]];
}; };
)"); )");
@ -338,8 +338,8 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Builtins) {
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error(); ASSERT_TRUE(gen.EmitEntryPointData(func)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct main_out { EXPECT_EQ(gen.result(), R"(struct test_main_out {
float depth [[depth(any)]]; float test_depth [[depth(any)]];
}; };
)"); )");

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

@ -68,27 +68,7 @@ TEST_F(MslGeneratorImplTest, Emit_Function) {
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
void my_func() { void test_my_func() {
return;
}
)");
}
TEST_F(MslGeneratorImplTest, Emit_Function_Name_Collision) {
auto* func = Func("main", ast::VariableList{}, ty.void_,
ast::StatementList{
create<ast::ReturnStatement>(),
},
ast::FunctionDecorationList{});
mod->AddFunction(func);
gen.increment_indent();
ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
void main() {
return; return;
} }
@ -112,7 +92,7 @@ TEST_F(MslGeneratorImplTest, Emit_Function_WithParams) {
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
void my_func(float a, int b) { void test_my_func(float test_a, int test_b) {
return; return;
} }
@ -149,18 +129,18 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionDecoration_EntryPoint_WithInOutVars) {
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct frag_main_in { struct test_frag_main_in {
float foo [[user(locn0)]]; float test_foo [[user(locn0)]];
}; };
struct frag_main_out { struct test_frag_main_out {
float bar [[color(1)]]; float test_bar [[color(1)]];
}; };
fragment frag_main_out frag_main(frag_main_in tint_in [[stage_in]]) { fragment test_frag_main_out test_frag_main(test_frag_main_in test_tint_in [[stage_in]]) {
frag_main_out tint_out = {}; test_frag_main_out test_tint_out = {};
tint_out.bar = tint_in.foo; test_tint_out.test_bar = test_tint_in.test_foo;
return tint_out; return test_tint_out;
} }
)"); )");
@ -202,14 +182,14 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct frag_main_out { struct test_frag_main_out {
float depth [[depth(any)]]; float test_depth [[depth(any)]];
}; };
fragment frag_main_out frag_main(float4 coord [[position]]) { fragment test_frag_main_out test_frag_main(float4 test_coord [[position]]) {
frag_main_out tint_out = {}; test_frag_main_out test_tint_out = {};
tint_out.depth = coord.x; test_tint_out.test_depth = test_coord.x;
return tint_out; return test_tint_out;
} }
)"); )");
@ -245,8 +225,8 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionDecoration_EntryPoint_With_Uniform) {
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
fragment void frag_main(constant float4& coord [[buffer(0)]]) { fragment void test_frag_main(constant float4& test_coord [[buffer(0)]]) {
float v = coord.x; float test_v = test_coord.x;
return; return;
} }
@ -293,13 +273,13 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct Data { struct test_Data {
int a; int test_a;
float b; float test_b;
}; };
fragment void frag_main(device Data& coord [[buffer(0)]]) { fragment void test_frag_main(device test_Data& test_coord [[buffer(0)]]) {
float v = coord.b; float test_v = test_coord.test_b;
return; return;
} }
@ -310,7 +290,7 @@ TEST_F(MslGeneratorImplTest,
Emit_FunctionDecoration_EntryPoint_With_RO_StorageBuffer) { Emit_FunctionDecoration_EntryPoint_With_RO_StorageBuffer) {
auto* str = create<ast::Struct>( auto* str = create<ast::Struct>(
ast::StructMemberList{Member("a", ty.i32, {MemberOffset(0)}), ast::StructMemberList{Member("a", ty.i32, {MemberOffset(0)}),
Member("b", ty.f32, {MemberOffset(4)})}, Member("x", ty.f32, {MemberOffset(4)})},
ast::StructDecorationList{}); ast::StructDecorationList{});
auto* s = ty.struct_("Data", str); auto* s = ty.struct_("Data", str);
@ -326,7 +306,7 @@ TEST_F(MslGeneratorImplTest,
mod->AddGlobalVariable(coord_var); mod->AddGlobalVariable(coord_var);
auto* var = Var("v", ast::StorageClass::kFunction, ty.f32, auto* var = Var("v", ast::StorageClass::kFunction, ty.f32,
MemberAccessor("coord", "b"), ast::VariableDecorationList{}); MemberAccessor("coord", "x"), ast::VariableDecorationList{});
auto* func = auto* func =
Func("frag_main", ast::VariableList{}, ty.void_, Func("frag_main", ast::VariableList{}, ty.void_,
@ -345,13 +325,13 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct Data { struct test_Data {
int a; int test_a;
float b; float test_x;
}; };
fragment void frag_main(const device Data& coord [[buffer(0)]]) { fragment void test_frag_main(const device test_Data& test_coord [[buffer(0)]]) {
float v = coord.b; float test_v = test_coord.test_x;
return; return;
} }
@ -410,25 +390,25 @@ TEST_F(
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct ep_1_in { struct test_ep_1_in {
float foo [[user(locn0)]]; float test_foo [[user(locn0)]];
}; };
struct ep_1_out { struct test_ep_1_out {
float bar [[color(1)]]; float test_bar [[color(1)]];
float val [[color(0)]]; float test_val [[color(0)]];
}; };
float sub_func_ep_1(thread ep_1_in& tint_in, thread ep_1_out& tint_out, float param) { float test_sub_func_ep_1(thread test_ep_1_in& test_tint_in, thread test_ep_1_out& test_tint_out, float test_param) {
tint_out.bar = tint_in.foo; test_tint_out.test_bar = test_tint_in.test_foo;
tint_out.val = param; test_tint_out.test_val = test_param;
return tint_in.foo; return test_tint_in.test_foo;
} }
fragment ep_1_out ep_1(ep_1_in tint_in [[stage_in]]) { fragment test_ep_1_out test_ep_1(test_ep_1_in test_tint_in [[stage_in]]) {
ep_1_out tint_out = {}; test_ep_1_out test_tint_out = {};
tint_out.bar = sub_func_ep_1(tint_in, tint_out, 1.0f); test_tint_out.test_bar = test_sub_func_ep_1(test_tint_in, test_tint_out, 1.0f);
return tint_out; return test_tint_out;
} }
)"); )");
@ -473,18 +453,18 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct ep_1_out { struct test_ep_1_out {
float depth [[depth(any)]]; float test_depth [[depth(any)]];
}; };
float sub_func(float param) { float test_sub_func(float test_param) {
return param; return test_param;
} }
fragment ep_1_out ep_1() { fragment test_ep_1_out test_ep_1() {
ep_1_out tint_out = {}; test_ep_1_out test_tint_out = {};
tint_out.depth = sub_func(1.0f); test_tint_out.test_depth = test_sub_func(1.0f);
return tint_out; return test_tint_out;
} }
)"); )");
@ -538,19 +518,19 @@ TEST_F(
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct ep_1_out { struct test_ep_1_out {
float depth [[depth(any)]]; float test_depth [[depth(any)]];
}; };
float sub_func_ep_1(thread ep_1_out& tint_out, thread float4& coord, float param) { float test_sub_func_ep_1(thread test_ep_1_out& test_tint_out, thread float4& test_coord, float test_param) {
tint_out.depth = coord.x; test_tint_out.test_depth = test_coord.x;
return param; return test_param;
} }
fragment ep_1_out ep_1(float4 coord [[position]]) { fragment test_ep_1_out test_ep_1(float4 test_coord [[position]]) {
ep_1_out tint_out = {}; test_ep_1_out test_tint_out = {};
tint_out.depth = sub_func_ep_1(tint_out, coord, 1.0f); test_tint_out.test_depth = test_sub_func_ep_1(test_tint_out, test_coord, 1.0f);
return tint_out; return test_tint_out;
} }
)"); )");
@ -599,12 +579,12 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
float sub_func(constant float4& coord, float param) { float test_sub_func(constant float4& test_coord, float test_param) {
return coord.x; return test_coord.x;
} }
fragment void frag_main(constant float4& coord [[buffer(0)]]) { fragment void test_frag_main(constant float4& test_coord [[buffer(0)]]) {
float v = sub_func(coord, 1.0f); float test_v = test_sub_func(test_coord, 1.0f);
return; return;
} }
@ -661,17 +641,17 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct Data { struct test_Data {
int a; int test_a;
float b; float test_b;
}; };
float sub_func(device Data& coord, float param) { float test_sub_func(device test_Data& test_coord, float test_param) {
return coord.b; return test_coord.test_b;
} }
fragment void frag_main(device Data& coord [[buffer(0)]]) { fragment void test_frag_main(device test_Data& test_coord [[buffer(0)]]) {
float v = sub_func(coord, 1.0f); float test_v = test_sub_func(test_coord, 1.0f);
return; return;
} }
@ -731,17 +711,17 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct Data { struct test_Data {
int a; int test_a;
float b; float test_b;
}; };
float sub_func(const device Data& coord, float param) { float test_sub_func(const device test_Data& test_coord, float test_param) {
return coord.b; return test_coord.test_b;
} }
fragment void frag_main(const device Data& coord [[buffer(0)]]) { fragment void test_frag_main(const device test_Data& test_coord [[buffer(0)]]) {
float v = sub_func(coord, 1.0f); float test_v = test_sub_func(test_coord, 1.0f);
return; return;
} }
@ -781,17 +761,17 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct ep_1_out { struct test_ep_1_out {
float bar [[color(1)]]; float test_bar [[color(1)]];
}; };
fragment ep_1_out ep_1() { fragment test_ep_1_out test_ep_1() {
ep_1_out tint_out = {}; test_ep_1_out test_tint_out = {};
tint_out.bar = 1.0f; test_tint_out.test_bar = 1.0f;
if ((1 == 1)) { if ((1 == 1)) {
return tint_out; return test_tint_out;
} }
return tint_out; return test_tint_out;
} }
)"); )");
@ -813,7 +793,7 @@ TEST_F(MslGeneratorImplTest, Emit_Function_WithArrayParams) {
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
void my_func(float a[5]) { void test_my_func(float test_a[5]) {
return; return;
} }
@ -892,17 +872,17 @@ TEST_F(MslGeneratorImplTest,
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
struct Data { struct test_Data {
float d; float test_d;
}; };
kernel void a(device Data& data [[buffer(0)]]) { kernel void test_a(device test_Data& test_data [[buffer(0)]]) {
float v = data.d; float test_v = test_data.test_d;
return; return;
} }
kernel void b(device Data& data [[buffer(0)]]) { kernel void test_b(device test_Data& test_data [[buffer(0)]]) {
float v = data.d; float test_v = test_data.test_d;
return; return;
} }

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

@ -28,13 +28,7 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitIdentifierExpression) { TEST_F(MslGeneratorImplTest, EmitIdentifierExpression) {
auto* i = Expr("foo"); auto* i = Expr("foo");
ASSERT_TRUE(gen.EmitExpression(i)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(i)) << gen.error();
EXPECT_EQ(gen.result(), "foo"); EXPECT_EQ(gen.result(), "test_foo");
}
TEST_F(MslGeneratorImplTest, EmitIdentifierExpression_Single_WithCollision) {
auto* i = Expr("virtual");
ASSERT_TRUE(gen.EmitExpression(i)) << gen.error();
EXPECT_EQ(gen.result(), "virtual");
} }
} // namespace } // namespace

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

@ -38,7 +38,7 @@ TEST_F(MslGeneratorImplTest, Emit_If) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (test_cond) {
return; return;
} }
)"); )");
@ -63,9 +63,9 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithElseIf) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (test_cond) {
return; return;
} else if (else_cond) { } else if (test_else_cond) {
return; return;
} }
)"); )");
@ -89,7 +89,7 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithElse) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (test_cond) {
return; return;
} else { } else {
return; return;
@ -122,9 +122,9 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithMultiple) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (test_cond) {
return; return;
} else if (else_cond) { } else if (test_else_cond) {
return; return;
} else { } else {
return; return;

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

@ -187,7 +187,7 @@ TEST_F(MslGeneratorImplTest, MslImportData_Determinant) {
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.EmitCall(expr)) << gen.error(); ASSERT_TRUE(gen.EmitCall(expr)) << gen.error();
EXPECT_EQ(gen.result(), std::string("metal::determinant(var)")); EXPECT_EQ(gen.result(), std::string("metal::determinant(test_var)"));
} }
} // namespace } // namespace

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

@ -69,7 +69,7 @@ TEST_F(MslGeneratorImplTest, DISABLED_Intrinsic_OuterProduct) {
auto* a = Var("a", ast::StorageClass::kNone, ty.vec2<f32>()); auto* a = Var("a", ast::StorageClass::kNone, ty.vec2<f32>());
auto* b = Var("b", ast::StorageClass::kNone, ty.vec3<f32>()); auto* b = Var("b", ast::StorageClass::kNone, ty.vec3<f32>());
auto* call = Call("outer_product", "a", "b"); auto* call = Call("outerProduct", "a", "b");
td.RegisterVariableForTesting(a); td.RegisterVariableForTesting(a);
td.RegisterVariableForTesting(b); td.RegisterVariableForTesting(b);
@ -81,7 +81,9 @@ TEST_F(MslGeneratorImplTest, DISABLED_Intrinsic_OuterProduct) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitExpression(call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(call)) << gen.error();
EXPECT_EQ(gen.result(), " float3x2(a * b[0], a * b[1], a * b[2])"); EXPECT_EQ(
gen.result(),
" float3x2(test_a * test_b[0], test_a * test_b[1], test_a * test_b[2])");
} }
TEST_F(MslGeneratorImplTest, Intrinsic_Bad_Name) { TEST_F(MslGeneratorImplTest, Intrinsic_Bad_Name) {
@ -101,7 +103,7 @@ TEST_F(MslGeneratorImplTest, Intrinsic_Call) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitExpression(call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(call)) << gen.error();
EXPECT_EQ(gen.result(), " dot(param1, param2)"); EXPECT_EQ(gen.result(), " dot(test_param1, test_param2)");
} }
} // namespace } // namespace

197
src/writer/msl/generator_impl_intrinsic_texture_test.cc
View File

@ -22,6 +22,7 @@
#include "src/ast/type/sampled_texture_type.h" #include "src/ast/type/sampled_texture_type.h"
#include "src/type_determiner.h" #include "src/type_determiner.h"
#include "src/writer/msl/generator_impl.h" #include "src/writer/msl/generator_impl.h"
#include "src/writer/test_namer.h"
namespace tint { namespace tint {
namespace writer { namespace writer {
@ -33,181 +34,181 @@ std::string expected_texture_overload(
using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload; using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload;
switch (overload) { switch (overload) {
case ValidTextureOverload::kSample1dF32: case ValidTextureOverload::kSample1dF32:
return R"(texture.sample(sampler, 1.0f))"; return R"(test_texture.sample(test_sampler, 1.0f))";
case ValidTextureOverload::kSample1dArrayF32: case ValidTextureOverload::kSample1dArrayF32:
return R"(texture.sample(sampler, 1.0f, 2))"; return R"(test_texture.sample(test_sampler, 1.0f, 2))";
case ValidTextureOverload::kSample2dF32: case ValidTextureOverload::kSample2dF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f)))";
case ValidTextureOverload::kSample2dOffsetF32: case ValidTextureOverload::kSample2dOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), int2(3, 4)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), int2(3, 4)))";
case ValidTextureOverload::kSample2dArrayF32: case ValidTextureOverload::kSample2dArrayF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3))";
case ValidTextureOverload::kSample2dArrayOffsetF32: case ValidTextureOverload::kSample2dArrayOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
case ValidTextureOverload::kSample3dF32: case ValidTextureOverload::kSample3dF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSample3dOffsetF32: case ValidTextureOverload::kSample3dOffsetF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))";
case ValidTextureOverload::kSampleCubeF32: case ValidTextureOverload::kSampleCubeF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSampleCubeArrayF32: case ValidTextureOverload::kSampleCubeArrayF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), 4))";
case ValidTextureOverload::kSampleDepth2dF32: case ValidTextureOverload::kSampleDepth2dF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f)))";
case ValidTextureOverload::kSampleDepth2dOffsetF32: case ValidTextureOverload::kSampleDepth2dOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), int2(3, 4)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), int2(3, 4)))";
case ValidTextureOverload::kSampleDepth2dArrayF32: case ValidTextureOverload::kSampleDepth2dArrayF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3))";
case ValidTextureOverload::kSampleDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleDepth2dArrayOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
case ValidTextureOverload::kSampleDepthCubeF32: case ValidTextureOverload::kSampleDepthCubeF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSampleDepthCubeArrayF32: case ValidTextureOverload::kSampleDepthCubeArrayF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), 4))";
case ValidTextureOverload::kSampleBias2dF32: case ValidTextureOverload::kSampleBias2dF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), bias(3.0f)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), bias(3.0f)))";
case ValidTextureOverload::kSampleBias2dOffsetF32: case ValidTextureOverload::kSampleBias2dOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), bias(3.0f), int2(4, 5)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), bias(3.0f), int2(4, 5)))";
case ValidTextureOverload::kSampleBias2dArrayF32: case ValidTextureOverload::kSampleBias2dArrayF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 4, bias(3.0f)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 4, bias(3.0f)))";
case ValidTextureOverload::kSampleBias2dArrayOffsetF32: case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, bias(4.0f), int2(5, 6)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, bias(4.0f), int2(5, 6)))";
case ValidTextureOverload::kSampleBias3dF32: case ValidTextureOverload::kSampleBias3dF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), bias(4.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), bias(4.0f)))";
case ValidTextureOverload::kSampleBias3dOffsetF32: case ValidTextureOverload::kSampleBias3dOffsetF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), bias(4.0f), int3(5, 6, 7)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), bias(4.0f), int3(5, 6, 7)))";
case ValidTextureOverload::kSampleBiasCubeF32: case ValidTextureOverload::kSampleBiasCubeF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), bias(4.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), bias(4.0f)))";
case ValidTextureOverload::kSampleBiasCubeArrayF32: case ValidTextureOverload::kSampleBiasCubeArrayF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 3, bias(4.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), 3, bias(4.0f)))";
case ValidTextureOverload::kSampleLevel2dF32: case ValidTextureOverload::kSampleLevel2dF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3.0f)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), level(3.0f)))";
case ValidTextureOverload::kSampleLevel2dOffsetF32: case ValidTextureOverload::kSampleLevel2dOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3.0f), int2(4, 5)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), level(3.0f), int2(4, 5)))";
case ValidTextureOverload::kSampleLevel2dArrayF32: case ValidTextureOverload::kSampleLevel2dArrayF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, level(4.0f)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, level(4.0f)))";
case ValidTextureOverload::kSampleLevel2dArrayOffsetF32: case ValidTextureOverload::kSampleLevel2dArrayOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, level(4.0f), int2(5, 6)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, level(4.0f), int2(5, 6)))";
case ValidTextureOverload::kSampleLevel3dF32: case ValidTextureOverload::kSampleLevel3dF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), level(4.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), level(4.0f)))";
case ValidTextureOverload::kSampleLevel3dOffsetF32: case ValidTextureOverload::kSampleLevel3dOffsetF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), level(4.0f), int3(5, 6, 7)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), level(4.0f), int3(5, 6, 7)))";
case ValidTextureOverload::kSampleLevelCubeF32: case ValidTextureOverload::kSampleLevelCubeF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), level(4.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), level(4.0f)))";
case ValidTextureOverload::kSampleLevelCubeArrayF32: case ValidTextureOverload::kSampleLevelCubeArrayF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4, level(5.0f)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), 4, level(5.0f)))";
case ValidTextureOverload::kSampleLevelDepth2dF32: case ValidTextureOverload::kSampleLevelDepth2dF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), level(3)))";
case ValidTextureOverload::kSampleLevelDepth2dOffsetF32: case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3), int2(4, 5)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), level(3), int2(4, 5)))";
case ValidTextureOverload::kSampleLevelDepth2dArrayF32: case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, level(4)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, level(4)))";
case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, level(4), int2(5, 6)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, level(4), int2(5, 6)))";
case ValidTextureOverload::kSampleLevelDepthCubeF32: case ValidTextureOverload::kSampleLevelDepthCubeF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), level(4)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), level(4)))";
case ValidTextureOverload::kSampleLevelDepthCubeArrayF32: case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4, level(5)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), 4, level(5)))";
case ValidTextureOverload::kSampleGrad2dF32: case ValidTextureOverload::kSampleGrad2dF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), gradient2d(float2(3.0f, 4.0f), float2(5.0f, 6.0f))))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), gradient2d(float2(3.0f, 4.0f), float2(5.0f, 6.0f))))";
case ValidTextureOverload::kSampleGrad2dOffsetF32: case ValidTextureOverload::kSampleGrad2dOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), gradient2d(float2(3.0f, 4.0f), float2(5.0f, 6.0f)), int2(7, 8)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), gradient2d(float2(3.0f, 4.0f), float2(5.0f, 6.0f)), int2(7, 8)))";
case ValidTextureOverload::kSampleGrad2dArrayF32: case ValidTextureOverload::kSampleGrad2dArrayF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f))))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f))))";
case ValidTextureOverload::kSampleGrad2dArrayOffsetF32: case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f)), int2(8, 9)))"; return R"(test_texture.sample(test_sampler, float2(1.0f, 2.0f), 3, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f)), int2(8, 9)))";
case ValidTextureOverload::kSampleGrad3dF32: case ValidTextureOverload::kSampleGrad3dF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), gradient3d(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f))))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), gradient3d(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f))))";
case ValidTextureOverload::kSampleGrad3dOffsetF32: case ValidTextureOverload::kSampleGrad3dOffsetF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), gradient3d(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)), int3(10, 11, 12)))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), gradient3d(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)), int3(10, 11, 12)))";
case ValidTextureOverload::kSampleGradCubeF32: case ValidTextureOverload::kSampleGradCubeF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), gradientcube(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f))))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), gradientcube(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f))))";
case ValidTextureOverload::kSampleGradCubeArrayF32: case ValidTextureOverload::kSampleGradCubeArrayF32:
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4, gradientcube(float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f))))"; return R"(test_texture.sample(test_sampler, float3(1.0f, 2.0f, 3.0f), 4, gradientcube(float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f))))";
case ValidTextureOverload::kSampleGradDepth2dF32: case ValidTextureOverload::kSampleGradDepth2dF32:
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(test_texture.sample_compare(test_sampler, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleGradDepth2dOffsetF32: case ValidTextureOverload::kSampleGradDepth2dOffsetF32:
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(test_texture.sample_compare(test_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleGradDepth2dArrayF32: case ValidTextureOverload::kSampleGradDepth2dArrayF32:
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 4, 3.0f))"; return R"(test_texture.sample_compare(test_sampler, float2(1.0f, 2.0f), 4, 3.0f))";
case ValidTextureOverload::kSampleGradDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleGradDepth2dArrayOffsetF32:
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 4, 3.0f, int2(5, 6)))"; return R"(test_texture.sample_compare(test_sampler, float2(1.0f, 2.0f), 4, 3.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleGradDepthCubeF32: case ValidTextureOverload::kSampleGradDepthCubeF32:
return R"(texture.sample_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(test_texture.sample_compare(test_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleGradDepthCubeArrayF32: case ValidTextureOverload::kSampleGradDepthCubeArrayF32:
return R"(texture.sample_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4, 5.0f))"; return R"(test_texture.sample_compare(test_sampler, float3(1.0f, 2.0f, 3.0f), 4, 5.0f))";
case ValidTextureOverload::kLoad1dF32: case ValidTextureOverload::kLoad1dF32:
return R"(texture.read(1))"; return R"(test_texture.read(1))";
case ValidTextureOverload::kLoad1dU32: case ValidTextureOverload::kLoad1dU32:
return R"(texture.read(1))"; return R"(test_texture.read(1))";
case ValidTextureOverload::kLoad1dI32: case ValidTextureOverload::kLoad1dI32:
return R"(texture.read(1))"; return R"(test_texture.read(1))";
case ValidTextureOverload::kLoad1dArrayF32: case ValidTextureOverload::kLoad1dArrayF32:
return R"(texture.read(1, 2))"; return R"(test_texture.read(1, 2))";
case ValidTextureOverload::kLoad1dArrayU32: case ValidTextureOverload::kLoad1dArrayU32:
return R"(texture.read(1, 2))"; return R"(test_texture.read(1, 2))";
case ValidTextureOverload::kLoad1dArrayI32: case ValidTextureOverload::kLoad1dArrayI32:
return R"(texture.read(1, 2))"; return R"(test_texture.read(1, 2))";
case ValidTextureOverload::kLoad2dF32: case ValidTextureOverload::kLoad2dF32:
return R"(texture.read(int2(1, 2)))"; return R"(test_texture.read(int2(1, 2)))";
case ValidTextureOverload::kLoad2dU32: case ValidTextureOverload::kLoad2dU32:
return R"(texture.read(int2(1, 2)))"; return R"(test_texture.read(int2(1, 2)))";
case ValidTextureOverload::kLoad2dI32: case ValidTextureOverload::kLoad2dI32:
return R"(texture.read(int2(1, 2)))"; return R"(test_texture.read(int2(1, 2)))";
case ValidTextureOverload::kLoad2dLevelF32: case ValidTextureOverload::kLoad2dLevelF32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoad2dLevelU32: case ValidTextureOverload::kLoad2dLevelU32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoad2dLevelI32: case ValidTextureOverload::kLoad2dLevelI32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoad2dArrayF32: case ValidTextureOverload::kLoad2dArrayF32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoad2dArrayU32: case ValidTextureOverload::kLoad2dArrayU32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoad2dArrayI32: case ValidTextureOverload::kLoad2dArrayI32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoad2dArrayLevelF32: case ValidTextureOverload::kLoad2dArrayLevelF32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoad2dArrayLevelU32: case ValidTextureOverload::kLoad2dArrayLevelU32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoad2dArrayLevelI32: case ValidTextureOverload::kLoad2dArrayLevelI32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoad3dF32: case ValidTextureOverload::kLoad3dF32:
return R"(texture.read(int3(1, 2, 3)))"; return R"(test_texture.read(int3(1, 2, 3)))";
case ValidTextureOverload::kLoad3dU32: case ValidTextureOverload::kLoad3dU32:
return R"(texture.read(int3(1, 2, 3)))"; return R"(test_texture.read(int3(1, 2, 3)))";
case ValidTextureOverload::kLoad3dI32: case ValidTextureOverload::kLoad3dI32:
return R"(texture.read(int3(1, 2, 3)))"; return R"(test_texture.read(int3(1, 2, 3)))";
case ValidTextureOverload::kLoad3dLevelF32: case ValidTextureOverload::kLoad3dLevelF32:
return R"(texture.read(int3(1, 2, 3), 4))"; return R"(test_texture.read(int3(1, 2, 3), 4))";
case ValidTextureOverload::kLoad3dLevelU32: case ValidTextureOverload::kLoad3dLevelU32:
return R"(texture.read(int3(1, 2, 3), 4))"; return R"(test_texture.read(int3(1, 2, 3), 4))";
case ValidTextureOverload::kLoad3dLevelI32: case ValidTextureOverload::kLoad3dLevelI32:
return R"(texture.read(int3(1, 2, 3), 4))"; return R"(test_texture.read(int3(1, 2, 3), 4))";
case ValidTextureOverload::kLoadMultisampled2dF32: case ValidTextureOverload::kLoadMultisampled2dF32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoadMultisampled2dU32: case ValidTextureOverload::kLoadMultisampled2dU32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoadMultisampled2dI32: case ValidTextureOverload::kLoadMultisampled2dI32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoadMultisampled2dArrayF32: case ValidTextureOverload::kLoadMultisampled2dArrayF32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoadMultisampled2dArrayU32: case ValidTextureOverload::kLoadMultisampled2dArrayU32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoadMultisampled2dArrayI32: case ValidTextureOverload::kLoadMultisampled2dArrayI32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoadDepth2dF32: case ValidTextureOverload::kLoadDepth2dF32:
return R"(texture.read(int2(1, 2)))"; return R"(test_texture.read(int2(1, 2)))";
case ValidTextureOverload::kLoadDepth2dLevelF32: case ValidTextureOverload::kLoadDepth2dLevelF32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoadDepth2dArrayF32: case ValidTextureOverload::kLoadDepth2dArrayF32:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoadDepth2dArrayLevelF32: case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
return R"(texture.read(int2(1, 2), 3, 4))"; return R"(test_texture.read(int2(1, 2), 3, 4))";
case ValidTextureOverload::kLoadStorageRO1dRgba32float: case ValidTextureOverload::kLoadStorageRO1dRgba32float:
return R"(texture.read(1))"; return R"(test_texture.read(1))";
case ValidTextureOverload::kLoadStorageRO1dArrayRgba32float: case ValidTextureOverload::kLoadStorageRO1dArrayRgba32float:
return R"(texture.read(1, 2))"; return R"(test_texture.read(1, 2))";
case ValidTextureOverload::kLoadStorageRO2dRgba8unorm: case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8snorm: case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8uint: case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
@ -224,21 +225,21 @@ std::string expected_texture_overload(
case ValidTextureOverload::kLoadStorageRO2dRgba32uint: case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
case ValidTextureOverload::kLoadStorageRO2dRgba32sint: case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
case ValidTextureOverload::kLoadStorageRO2dRgba32float: case ValidTextureOverload::kLoadStorageRO2dRgba32float:
return R"(texture.read(int2(1, 2)))"; return R"(test_texture.read(int2(1, 2)))";
case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float: case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
return R"(texture.read(int2(1, 2), 3))"; return R"(test_texture.read(int2(1, 2), 3))";
case ValidTextureOverload::kLoadStorageRO3dRgba32float: case ValidTextureOverload::kLoadStorageRO3dRgba32float:
return R"(texture.read(int3(1, 2, 3)))"; return R"(test_texture.read(int3(1, 2, 3)))";
case ValidTextureOverload::kStoreWO1dRgba32float: case ValidTextureOverload::kStoreWO1dRgba32float:
return R"(texture.write(float4(2.0f, 3.0f, 4.0f, 5.0f), 1))"; return R"(test_texture.write(float4(2.0f, 3.0f, 4.0f, 5.0f), 1))";
case ValidTextureOverload::kStoreWO1dArrayRgba32float: case ValidTextureOverload::kStoreWO1dArrayRgba32float:
return R"(texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), 1, 2))"; return R"(test_texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), 1, 2))";
case ValidTextureOverload::kStoreWO2dRgba32float: case ValidTextureOverload::kStoreWO2dRgba32float:
return R"(texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), int2(1, 2)))"; return R"(test_texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), int2(1, 2)))";
case ValidTextureOverload::kStoreWO2dArrayRgba32float: case ValidTextureOverload::kStoreWO2dArrayRgba32float:
return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), int2(1, 2), 3))"; return R"(test_texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), int2(1, 2), 3))";
case ValidTextureOverload::kStoreWO3dRgba32float: case ValidTextureOverload::kStoreWO3dRgba32float:
return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), int3(1, 2, 3)))"; return R"(test_texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), int3(1, 2, 3)))";
} }
return "<unmatched texture overload>"; return "<unmatched texture overload>";
} // NOLINT - Ignore the length of this function } // NOLINT - Ignore the length of this function
@ -253,8 +254,10 @@ class MslGeneratorIntrinsicTextureTest
/// The type determiner /// The type determiner
TypeDeterminer td{mod}; TypeDeterminer td{mod};
/// The namer
TestNamer namer{mod};
/// The generator /// The generator
GeneratorImpl gen{mod}; GeneratorImpl gen{mod, &namer};
}; };
TEST_P(MslGeneratorIntrinsicTextureTest, Call) { TEST_P(MslGeneratorIntrinsicTextureTest, Call) {

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

@ -102,7 +102,7 @@ TEST_F(MslGeneratorImplTest, Emit_LoopNestedWithContinuing) {
bool tint_msl_is_first_1 = true; bool tint_msl_is_first_1 = true;
for(;;) { for(;;) {
if (!tint_msl_is_first_1) { if (!tint_msl_is_first_1) {
lhs = rhs; test_lhs = test_rhs;
} }
tint_msl_is_first_1 = false; tint_msl_is_first_1 = false;
@ -162,16 +162,16 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithVarUsedInContinuing) {
ASSERT_TRUE(gen.EmitStatement(outer)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(outer)) << gen.error();
EXPECT_EQ(gen.result(), R"( { EXPECT_EQ(gen.result(), R"( {
bool tint_msl_is_first_1 = true; bool tint_msl_is_first_1 = true;
float lhs; float test_lhs;
float other; float test_other;
for(;;) { for(;;) {
if (!tint_msl_is_first_1) { if (!tint_msl_is_first_1) {
lhs = rhs; test_lhs = test_rhs;
} }
tint_msl_is_first_1 = false; tint_msl_is_first_1 = false;
lhs = 2.400000095f; test_lhs = 2.400000095f;
other = 0.0f; test_other = 0.0f;
} }
} }
)"); )");

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

@ -32,7 +32,29 @@ TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) {
auto* expr = MemberAccessor("str", "mem"); auto* expr = MemberAccessor("str", "mem");
ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), "str.mem"); EXPECT_EQ(gen.result(), "test_str.test_mem");
}
TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_xyz) {
auto* vec = Var("my_vec", ast::StorageClass::kPrivate, ty.vec4<f32>());
td.RegisterVariableForTesting(vec);
mod->AddGlobalVariable(vec);
auto* expr = MemberAccessor("my_vec", "xyz");
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), "test_my_vec.xyz");
}
TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor_Swizzle_gbr) {
auto* vec = Var("my_vec", ast::StorageClass::kPrivate, ty.vec4<f32>());
td.RegisterVariableForTesting(vec);
mod->AddGlobalVariable(vec);
auto* expr = MemberAccessor("my_vec", "gbr");
ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), "test_my_vec.gbr");
} }
} // namespace } // namespace

5
src/writer/msl/generator_impl_module_constant_test.cc
View File

@ -40,7 +40,7 @@ TEST_F(MslGeneratorImplTest, Emit_ModuleConstant) {
array<f32, 3>(1.f, 2.f, 3.f), ast::VariableDecorationList{}); array<f32, 3>(1.f, 2.f, 3.f), ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error(); ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
EXPECT_EQ(gen.result(), "constant float pos[3] = {1.0f, 2.0f, 3.0f};\n"); EXPECT_EQ(gen.result(), "constant float test_pos[3] = {1.0f, 2.0f, 3.0f};\n");
} }
TEST_F(MslGeneratorImplTest, Emit_SpecConstant) { TEST_F(MslGeneratorImplTest, Emit_SpecConstant) {
@ -50,7 +50,8 @@ TEST_F(MslGeneratorImplTest, Emit_SpecConstant) {
}); });
ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error(); ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
EXPECT_EQ(gen.result(), "constant float pos [[function_constant(23)]];\n"); EXPECT_EQ(gen.result(),
"constant float test_pos [[function_constant(23)]];\n");
} }
} // namespace } // namespace

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

@ -42,7 +42,7 @@ TEST_F(MslGeneratorImplTest, Emit_ReturnWithValue) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(r)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
EXPECT_EQ(gen.result(), " return expr;\n"); EXPECT_EQ(gen.result(), " return test_expr;\n");
} }
} // namespace } // namespace

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

@ -55,7 +55,7 @@ TEST_F(MslGeneratorImplTest, Emit_Switch) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(s)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(s)) << gen.error();
EXPECT_EQ(gen.result(), R"( switch(cond) { EXPECT_EQ(gen.result(), R"( switch(test_cond) {
case 5: { case 5: {
break; break;
} }

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

@ -57,7 +57,7 @@ TEST_F(MslGeneratorImplTest, Generate) {
ASSERT_TRUE(gen.Generate()) << gen.error(); ASSERT_TRUE(gen.Generate()) << gen.error();
EXPECT_EQ(gen.result(), R"(#include <metal_stdlib> EXPECT_EQ(gen.result(), R"(#include <metal_stdlib>
kernel void my_func() { kernel void test_my_func() {
} }
)"); )");

34
src/writer/msl/generator_impl_type_test.cc
View File

@ -49,13 +49,13 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitType_Alias) { TEST_F(MslGeneratorImplTest, EmitType_Alias) {
auto* alias = ty.alias("alias", ty.f32); auto* alias = ty.alias("alias", ty.f32);
ASSERT_TRUE(gen.EmitType(alias, Symbol())) << gen.error(); ASSERT_TRUE(gen.EmitType(alias, Symbol())) << gen.error();
EXPECT_EQ(gen.result(), "alias"); EXPECT_EQ(gen.result(), "test_alias");
} }
TEST_F(MslGeneratorImplTest, EmitType_Array) { TEST_F(MslGeneratorImplTest, EmitType_Array) {
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(ty.array<bool, 4>(), sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(ty.array<bool, 4>(), sym)) << gen.error();
EXPECT_EQ(gen.result(), "bool ary[4]"); EXPECT_EQ(gen.result(), "bool test_ary[4]");
} }
TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) { TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) {
@ -63,7 +63,7 @@ TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArray) {
auto* b = ty.array(a, 5); auto* b = ty.array(a, 5);
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(b, sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(b, sym)) << gen.error();
EXPECT_EQ(gen.result(), "bool ary[5][4]"); EXPECT_EQ(gen.result(), "bool test_ary[5][4]");
} }
// TODO(dsinclair): Is this possible? What order should it output in? // TODO(dsinclair): Is this possible? What order should it output in?
@ -73,7 +73,7 @@ TEST_F(MslGeneratorImplTest, DISABLED_EmitType_ArrayOfArrayOfRuntimeArray) {
auto* c = ty.array(b, 0); auto* c = ty.array(b, 0);
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(c, sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(c, sym)) << gen.error();
EXPECT_EQ(gen.result(), "bool ary[5][4][1]"); EXPECT_EQ(gen.result(), "bool test_ary[5][4][1]");
} }
TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) { TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) {
@ -82,7 +82,7 @@ TEST_F(MslGeneratorImplTest, EmitType_ArrayOfArrayOfArray) {
auto* c = ty.array(b, 6); auto* c = ty.array(b, 6);
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(c, sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(c, sym)) << gen.error();
EXPECT_EQ(gen.result(), "bool ary[6][5][4]"); EXPECT_EQ(gen.result(), "bool test_ary[6][5][4]");
} }
TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) { TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) {
@ -93,7 +93,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Array_WithoutName) {
TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray) { TEST_F(MslGeneratorImplTest, EmitType_RuntimeArray) {
auto sym = mod->RegisterSymbol("ary"); auto sym = mod->RegisterSymbol("ary");
ASSERT_TRUE(gen.EmitType(ty.array<bool, 1>(), sym)) << gen.error(); ASSERT_TRUE(gen.EmitType(ty.array<bool, 1>(), sym)) << gen.error();
EXPECT_EQ(gen.result(), "bool ary[1]"); EXPECT_EQ(gen.result(), "bool test_ary[1]");
} }
TEST_F(MslGeneratorImplTest, EmitType_Bool) { TEST_F(MslGeneratorImplTest, EmitType_Bool) {
@ -132,7 +132,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct) {
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitType(s, Symbol())) << gen.error(); ASSERT_TRUE(gen.EmitType(s, Symbol())) << gen.error();
EXPECT_EQ(gen.result(), "S"); EXPECT_EQ(gen.result(), "test_S");
} }
TEST_F(MslGeneratorImplTest, EmitType_StructDecl) { TEST_F(MslGeneratorImplTest, EmitType_StructDecl) {
@ -144,9 +144,9 @@ TEST_F(MslGeneratorImplTest, EmitType_StructDecl) {
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(s)) << gen.error(); ASSERT_TRUE(gen.EmitStructType(s)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct S { EXPECT_EQ(gen.result(), R"(struct test_S {
int a; int test_a;
float b; float test_b;
}; };
)"); )");
} }
@ -162,13 +162,13 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_InjectPadding) {
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitStructType(s)) << gen.error(); ASSERT_TRUE(gen.EmitStructType(s)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct S { EXPECT_EQ(gen.result(), R"(struct test_S {
int8_t pad_0[4]; int8_t pad_0[4];
int a; int test_a;
int8_t pad_1[24]; int8_t pad_1[24];
float b; float test_b;
int8_t pad_2[92]; int8_t pad_2[92];
float c; float test_c;
}; };
)"); )");
} }
@ -184,9 +184,9 @@ TEST_F(MslGeneratorImplTest, DISABLED_EmitType_Struct_WithDecoration) {
auto* s = ty.struct_("S", str); auto* s = ty.struct_("S", str);
ASSERT_TRUE(gen.EmitType(s, Symbol())) << gen.error(); ASSERT_TRUE(gen.EmitType(s, Symbol())) << gen.error();
EXPECT_EQ(gen.result(), R"(struct { EXPECT_EQ(gen.result(), R"(struct test_S {
int a; int test_a;
float b; float test_b;
})"); })");
} }

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

@ -40,7 +40,7 @@ TEST_P(MslUnaryOpTest, Emit) {
auto params = GetParam(); auto params = GetParam();
auto* op = create<ast::UnaryOpExpression>(params.op, Expr("expr")); auto* op = create<ast::UnaryOpExpression>(params.op, Expr("expr"));
ASSERT_TRUE(gen.EmitExpression(op)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)"); EXPECT_EQ(gen.result(), std::string(params.name) + "(test_expr)");
} }
INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest, INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
MslUnaryOpTest, MslUnaryOpTest,

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

@ -47,7 +47,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float a = 0.0f;\n"); EXPECT_EQ(gen.result(), " float test_a = 0.0f;\n");
} }
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) { TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) {
@ -57,7 +57,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " const float a = 0.0f;\n"); EXPECT_EQ(gen.result(), " const float test_a = 0.0f;\n");
} }
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Array) { TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Array) {
@ -69,7 +69,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Array) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float a[5] = {0.0f};\n"); EXPECT_EQ(gen.result(), " float test_a[5] = {0.0f};\n");
} }
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) { TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
@ -85,7 +85,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), R"( S a = {}; EXPECT_EQ(gen.result(), R"( test_S test_a = {};
)"); )");
} }
@ -96,7 +96,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Vector) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float2 a = 0.0f;\n"); EXPECT_EQ(gen.result(), " float2 test_a = 0.0f;\n");
} }
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) { TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
@ -107,7 +107,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float3x2 a = 0.0f;\n"); EXPECT_EQ(gen.result(), " float3x2 test_a = 0.0f;\n");
} }
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) { TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
@ -117,7 +117,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float a = 0.0f;\n"); EXPECT_EQ(gen.result(), " float test_a = 0.0f;\n");
} }
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) { TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
@ -126,7 +126,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
auto* stmt = create<ast::VariableDeclStatement>(var); auto* stmt = create<ast::VariableDeclStatement>(var);
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), R"(float a = initializer; EXPECT_EQ(gen.result(), R"(float test_a = test_initializer;
)"); )");
} }
@ -138,7 +138,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_ZeroVec) {
auto* stmt = create<ast::VariableDeclStatement>(var); auto* stmt = create<ast::VariableDeclStatement>(var);
ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), R"(float3 a = float3(0.0f); EXPECT_EQ(gen.result(), R"(float3 test_a = float3(0.0f);
)"); )");
} }

5
src/writer/msl/test_helper.h
View File

@ -23,6 +23,7 @@
#include "src/ast/module.h" #include "src/ast/module.h"
#include "src/type_determiner.h" #include "src/type_determiner.h"
#include "src/writer/msl/generator_impl.h" #include "src/writer/msl/generator_impl.h"
#include "src/writer/test_namer.h"
namespace tint { namespace tint {
namespace writer { namespace writer {
@ -32,11 +33,13 @@ namespace msl {
template <typename BASE> template <typename BASE>
class TestHelperBase : public BASE, public ast::BuilderWithModule { class TestHelperBase : public BASE, public ast::BuilderWithModule {
public: public:
TestHelperBase() : td(mod), gen(mod) {} TestHelperBase() : td(mod), namer_(mod), gen(mod, &namer_) {}
~TestHelperBase() = default; ~TestHelperBase() = default;
/// The type determiner /// The type determiner
TypeDeterminer td; TypeDeterminer td;
/// The namer
TestNamer namer_;
/// The generator /// The generator
GeneratorImpl gen; GeneratorImpl gen;
}; };

29
src/writer/test_namer.cc Normal file
View File

@ -0,0 +1,29 @@
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/writer/test_namer.h"
namespace tint {
namespace writer {
TestNamer::TestNamer(ast::Module* mod) : Namer(mod) {}
TestNamer::~TestNamer() = default;
std::string TestNamer::NameFor(const Symbol& sym) {
return "test_" + module_->SymbolToName(sym);
}
} // namespace writer
} // namespace tint

43
src/writer/test_namer.h Normal file
View File

@ -0,0 +1,43 @@
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef SRC_WRITER_TEST_NAMER_H_
#define SRC_WRITER_TEST_NAMER_H_
#include <string>
#include "src/namer.h"
namespace tint {
namespace writer {
/// A namer which returns the provided name prefixed with `test_`.
class TestNamer : public Namer {
public:
/// Constructor
/// @param mod the module to retrieve names from
explicit TestNamer(ast::Module* mod);
/// Destructor
~TestNamer() override;
/// Returns `name`
/// @param sym the symbol
/// @returns `name` or "" if not found
std::string NameFor(const Symbol& sym) override;
};
} // namespace writer
} // namespace tint
#endif // SRC_WRITER_TEST_NAMER_H_