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

ast: Add Source argument to literals 

Bug: tint:396
Bug: tint:390
Change-Id: Ib78c19533dc65c85e2381bf1ce0d0966dd7babe9
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/35019
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>
This commit is contained in:
Ben Clayton 2020-12-12 01:35:43 +00:00 committed by Commit Bot service account
parent 604bc72dd9
commit 5ed161b2d9
78 changed files with 1038 additions and 1005 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/ast/bool_literal.cc
View File

@ -22,8 +22,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::BoolLiteral);
namespace tint { namespace tint {
namespace ast { namespace ast {
BoolLiteral::BoolLiteral(type::Type* type, bool value) BoolLiteral::BoolLiteral(const Source& source, type::Type* type, bool value)
: Base(type), value_(value) {} : Base(source, type), value_(value) {}
BoolLiteral::~BoolLiteral() = default; BoolLiteral::~BoolLiteral() = default;
@ -36,7 +36,8 @@ std::string BoolLiteral::name() const {
} }
BoolLiteral* BoolLiteral::Clone(CloneContext* ctx) const { BoolLiteral* BoolLiteral::Clone(CloneContext* ctx) const {
return ctx->mod->create<BoolLiteral>(ctx->Clone(type()), value_); return ctx->mod->create<BoolLiteral>(ctx->Clone(source()), ctx->Clone(type()),
value_);
} }
} // namespace ast } // namespace ast

3
src/ast/bool_literal.h
View File

@ -26,9 +26,10 @@ namespace ast {
class BoolLiteral : public Castable<BoolLiteral, Literal> { class BoolLiteral : public Castable<BoolLiteral, Literal> {
public: public:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type of the literal /// @param type the type of the literal
/// @param value the bool literals value /// @param value the bool literals value
BoolLiteral(type::Type* type, bool value); BoolLiteral(const Source& source, type::Type* type, bool value);
~BoolLiteral() override; ~BoolLiteral() override;
/// @returns true if the bool literal is true /// @returns true if the bool literal is true

10
src/ast/bool_literal_test.cc
View File

@ -29,7 +29,7 @@ using BoolLiteralTest = TestHelper;
TEST_F(BoolLiteralTest, True) { TEST_F(BoolLiteralTest, True) {
type::Bool bool_type; type::Bool bool_type;
BoolLiteral b{&bool_type, true}; BoolLiteral b{Source{}, &bool_type, true};
ASSERT_TRUE(b.Is<BoolLiteral>()); ASSERT_TRUE(b.Is<BoolLiteral>());
ASSERT_TRUE(b.IsTrue()); ASSERT_TRUE(b.IsTrue());
ASSERT_FALSE(b.IsFalse()); ASSERT_FALSE(b.IsFalse());
@ -37,7 +37,7 @@ TEST_F(BoolLiteralTest, True) {
TEST_F(BoolLiteralTest, False) { TEST_F(BoolLiteralTest, False) {
type::Bool bool_type; type::Bool bool_type;
BoolLiteral b{&bool_type, false}; BoolLiteral b{Source{}, &bool_type, false};
ASSERT_TRUE(b.Is<BoolLiteral>()); ASSERT_TRUE(b.Is<BoolLiteral>());
ASSERT_FALSE(b.IsTrue()); ASSERT_FALSE(b.IsTrue());
ASSERT_TRUE(b.IsFalse()); ASSERT_TRUE(b.IsFalse());
@ -45,7 +45,7 @@ TEST_F(BoolLiteralTest, False) {
TEST_F(BoolLiteralTest, Is) { TEST_F(BoolLiteralTest, Is) {
type::Bool bool_type; type::Bool bool_type;
BoolLiteral b{&bool_type, false}; BoolLiteral b{Source{}, &bool_type, false};
Literal* l = &b; Literal* l = &b;
EXPECT_TRUE(l->Is<BoolLiteral>()); EXPECT_TRUE(l->Is<BoolLiteral>());
EXPECT_FALSE(l->Is<SintLiteral>()); EXPECT_FALSE(l->Is<SintLiteral>());
@ -57,8 +57,8 @@ TEST_F(BoolLiteralTest, Is) {
TEST_F(BoolLiteralTest, ToStr) { TEST_F(BoolLiteralTest, ToStr) {
type::Bool bool_type; type::Bool bool_type;
BoolLiteral t{&bool_type, true}; BoolLiteral t{Source{}, &bool_type, true};
BoolLiteral f{&bool_type, false}; BoolLiteral f{Source{}, &bool_type, false};
EXPECT_EQ(t.to_str(), "true"); EXPECT_EQ(t.to_str(), "true");
EXPECT_EQ(f.to_str(), "false"); EXPECT_EQ(f.to_str(), "false");

16
src/ast/builder.h
View File

@ -275,19 +275,27 @@ class Builder {
/// @param val the boolan value /// @param val the boolan value
/// @return a boolean literal with the given value /// @return a boolean literal with the given value
BoolLiteral* Literal(bool val) { return create<BoolLiteral>(ty.bool_, val); } BoolLiteral* Literal(bool val) {
return create<BoolLiteral>(Source{}, ty.bool_, val);
}
/// @param val the float value /// @param val the float value
/// @return a float literal with the given value /// @return a float literal with the given value
FloatLiteral* Literal(f32 val) { return create<FloatLiteral>(ty.f32, val); } FloatLiteral* Literal(f32 val) {
return create<FloatLiteral>(Source{}, ty.f32, val);
}
/// @param val the unsigned int value /// @param val the unsigned int value
/// @return a UintLiteral with the given value /// @return a UintLiteral with the given value
UintLiteral* Literal(u32 val) { return create<UintLiteral>(ty.u32, val); } UintLiteral* Literal(u32 val) {
return create<UintLiteral>(Source{}, ty.u32, val);
}
/// @param val the integer value /// @param val the integer value
/// @return the SintLiteral with the given value /// @return the SintLiteral with the given value
SintLiteral* Literal(i32 val) { return create<SintLiteral>(ty.i32, val); } SintLiteral* Literal(i32 val) {
return create<SintLiteral>(Source{}, ty.i32, val);
}
/// @param args the arguments for the type constructor /// @param args the arguments for the type constructor
/// @return an `TypeConstructorExpression` of type `ty`, with the values /// @return an `TypeConstructorExpression` of type `ty`, with the values

20
src/ast/case_statement_test.cc
View File

@ -32,7 +32,7 @@ TEST_F(CaseStatementTest, Creation_i32) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
auto* selector = create<SintLiteral>(&i32, 2); auto* selector = create<SintLiteral>(Source{}, &i32, 2);
b.push_back(selector); b.push_back(selector);
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
@ -50,7 +50,7 @@ TEST_F(CaseStatementTest, Creation_u32) {
type::U32 u32; type::U32 u32;
CaseSelectorList b; CaseSelectorList b;
auto* selector = create<SintLiteral>(&u32, 2); auto* selector = create<SintLiteral>(Source{}, &u32, 2);
b.push_back(selector); b.push_back(selector);
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
@ -67,7 +67,7 @@ TEST_F(CaseStatementTest, Creation_u32) {
TEST_F(CaseStatementTest, Creation_WithSource) { TEST_F(CaseStatementTest, Creation_WithSource) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<SintLiteral>(&i32, 2)); b.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());
@ -89,7 +89,7 @@ TEST_F(CaseStatementTest, IsDefault_WithoutSelectors) {
TEST_F(CaseStatementTest, IsDefault_WithSelectors) { TEST_F(CaseStatementTest, IsDefault_WithSelectors) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<SintLiteral>(&i32, 2)); b.push_back(create<SintLiteral>(Source{}, &i32, 2));
CaseStatement c(b, create<BlockStatement>()); CaseStatement c(b, create<BlockStatement>());
EXPECT_FALSE(c.IsDefault()); EXPECT_FALSE(c.IsDefault());
@ -108,7 +108,7 @@ TEST_F(CaseStatementTest, IsValid) {
TEST_F(CaseStatementTest, IsValid_NullBodyStatement) { TEST_F(CaseStatementTest, IsValid_NullBodyStatement) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<SintLiteral>(&i32, 2)); b.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());
@ -121,7 +121,7 @@ TEST_F(CaseStatementTest, IsValid_NullBodyStatement) {
TEST_F(CaseStatementTest, IsValid_InvalidBodyStatement) { TEST_F(CaseStatementTest, IsValid_InvalidBodyStatement) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<SintLiteral>(&i32, 2)); b.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<IfStatement>(Source{}, nullptr, create<BlockStatement>(), body->append(create<IfStatement>(Source{}, nullptr, create<BlockStatement>(),
@ -134,7 +134,7 @@ TEST_F(CaseStatementTest, IsValid_InvalidBodyStatement) {
TEST_F(CaseStatementTest, ToStr_WithSelectors_i32) { TEST_F(CaseStatementTest, ToStr_WithSelectors_i32) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<SintLiteral>(&i32, -2)); b.push_back(create<SintLiteral>(Source{}, &i32, -2));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());
@ -151,7 +151,7 @@ TEST_F(CaseStatementTest, ToStr_WithSelectors_i32) {
TEST_F(CaseStatementTest, ToStr_WithSelectors_u32) { TEST_F(CaseStatementTest, ToStr_WithSelectors_u32) {
type::U32 u32; type::U32 u32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<UintLiteral>(&u32, 2)); b.push_back(create<UintLiteral>(Source{}, &u32, 2));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());
@ -169,8 +169,8 @@ TEST_F(CaseStatementTest, ToStr_WithMultipleSelectors) {
type::I32 i32; type::I32 i32;
CaseSelectorList b; CaseSelectorList b;
b.push_back(create<SintLiteral>(&i32, 1)); b.push_back(create<SintLiteral>(Source{}, &i32, 1));
b.push_back(create<SintLiteral>(&i32, 2)); b.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());

3
src/ast/clone_context.h
View File

@ -109,7 +109,8 @@ class CloneContext {
/// // Replace all ast::UintLiterals with the number 42 /// // Replace all ast::UintLiterals with the number 42
/// CloneCtx ctx(mod); /// CloneCtx ctx(mod);
/// ctx.ReplaceAll([&] (ast::UintLiteral* in) { /// ctx.ReplaceAll([&] (ast::UintLiteral* in) {
/// return ctx.mod->create<ast::UintLiteral>(ctx.Clone(in->type()), 42); /// return ctx.mod->create<ast::UintLiteral>(ctx.Clone(in->source()),
/// ctx.Clone(in->type()), 42);
/// }); /// });
/// auto* out = ctx.Clone(tree); /// auto* out = ctx.Clone(tree);
/// ``` /// ```

6
src/ast/else_statement_test.cc
View File

@ -30,7 +30,7 @@ using ElseStatementTest = TestHelper;
TEST_F(ElseStatementTest, Creation) { TEST_F(ElseStatementTest, Creation) {
type::Bool bool_type; type::Bool bool_type;
auto* cond = create<ScalarConstructorExpression>( auto* cond = create<ScalarConstructorExpression>(
create<BoolLiteral>(&bool_type, true)); create<BoolLiteral>(Source{}, &bool_type, true));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());
@ -57,7 +57,7 @@ TEST_F(ElseStatementTest, IsElse) {
TEST_F(ElseStatementTest, HasCondition) { TEST_F(ElseStatementTest, HasCondition) {
type::Bool bool_type; type::Bool bool_type;
auto* cond = create<ScalarConstructorExpression>( auto* cond = create<ScalarConstructorExpression>(
create<BoolLiteral>(&bool_type, true)); create<BoolLiteral>(Source{}, &bool_type, true));
ElseStatement e(cond, create<BlockStatement>()); ElseStatement e(cond, create<BlockStatement>());
EXPECT_TRUE(e.HasCondition()); EXPECT_TRUE(e.HasCondition());
} }
@ -107,7 +107,7 @@ TEST_F(ElseStatementTest, IsValid_InvalidBodyStatement) {
TEST_F(ElseStatementTest, ToStr) { TEST_F(ElseStatementTest, ToStr) {
type::Bool bool_type; type::Bool bool_type;
auto* cond = create<ScalarConstructorExpression>( auto* cond = create<ScalarConstructorExpression>(
create<BoolLiteral>(&bool_type, true)); create<BoolLiteral>(Source{}, &bool_type, true));
auto* body = create<BlockStatement>(); auto* body = create<BlockStatement>();
body->append(create<DiscardStatement>()); body->append(create<DiscardStatement>());

7
src/ast/float_literal.cc
View File

@ -25,8 +25,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::FloatLiteral);
namespace tint { namespace tint {
namespace ast { namespace ast {
FloatLiteral::FloatLiteral(type::Type* type, float value) FloatLiteral::FloatLiteral(const Source& source, type::Type* type, float value)
: Base(type), value_(value) {} : Base(source, type), value_(value) {}
FloatLiteral::~FloatLiteral() = default; FloatLiteral::~FloatLiteral() = default;
@ -43,7 +43,8 @@ std::string FloatLiteral::name() const {
} }
FloatLiteral* FloatLiteral::Clone(CloneContext* ctx) const { FloatLiteral* FloatLiteral::Clone(CloneContext* ctx) const {
return ctx->mod->create<FloatLiteral>(ctx->Clone(type()), value_); return ctx->mod->create<FloatLiteral>(ctx->Clone(source()),
ctx->Clone(type()), value_);
} }
} // namespace ast } // namespace ast

3
src/ast/float_literal.h
View File

@ -26,9 +26,10 @@ namespace ast {
class FloatLiteral : public Castable<FloatLiteral, Literal> { class FloatLiteral : public Castable<FloatLiteral, Literal> {
public: public:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type of the literal /// @param type the type of the literal
/// @param value the float literals value /// @param value the float literals value
FloatLiteral(type::Type* type, float value); FloatLiteral(const Source& source, type::Type* type, float value);
~FloatLiteral() override; ~FloatLiteral() override;
/// @returns the float literal value /// @returns the float literal value

8
src/ast/float_literal_test.cc
View File

@ -29,14 +29,14 @@ using FloatLiteralTest = TestHelper;
TEST_F(FloatLiteralTest, Value) { TEST_F(FloatLiteralTest, Value) {
type::F32 f32; type::F32 f32;
FloatLiteral f{&f32, 47.2f}; FloatLiteral f{Source{}, &f32, 47.2f};
ASSERT_TRUE(f.Is<FloatLiteral>()); ASSERT_TRUE(f.Is<FloatLiteral>());
EXPECT_EQ(f.value(), 47.2f); EXPECT_EQ(f.value(), 47.2f);
} }
TEST_F(FloatLiteralTest, Is) { TEST_F(FloatLiteralTest, Is) {
type::F32 f32; type::F32 f32;
FloatLiteral f{&f32, 42.f}; FloatLiteral f{Source{}, &f32, 42.f};
Literal* l = &f; Literal* l = &f;
EXPECT_FALSE(l->Is<BoolLiteral>()); EXPECT_FALSE(l->Is<BoolLiteral>());
EXPECT_FALSE(l->Is<SintLiteral>()); EXPECT_FALSE(l->Is<SintLiteral>());
@ -48,14 +48,14 @@ TEST_F(FloatLiteralTest, Is) {
TEST_F(FloatLiteralTest, ToStr) { TEST_F(FloatLiteralTest, ToStr) {
type::F32 f32; type::F32 f32;
FloatLiteral f{&f32, 42.1f}; FloatLiteral f{Source{}, &f32, 42.1f};
EXPECT_EQ(f.to_str(), "42.099998"); EXPECT_EQ(f.to_str(), "42.099998");
} }
TEST_F(FloatLiteralTest, ToName) { TEST_F(FloatLiteralTest, ToName) {
type::F32 f32; type::F32 f32;
FloatLiteral f{&f32, 42.1f}; FloatLiteral f{Source{}, &f32, 42.1f};
EXPECT_EQ(f.name(), "__float42.0999985"); EXPECT_EQ(f.name(), "__float42.0999985");
} }

3
src/ast/int_literal.cc
View File

@ -19,7 +19,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::IntLiteral);
namespace tint { namespace tint {
namespace ast { namespace ast {
IntLiteral::IntLiteral(type::Type* type) : Base(type) {} IntLiteral::IntLiteral(const Source& source, type::Type* type)
: Base(source, type) {}
IntLiteral::~IntLiteral() = default; IntLiteral::~IntLiteral() = default;

3
src/ast/int_literal.h
View File

@ -27,8 +27,9 @@ class IntLiteral : public Castable<IntLiteral, Literal> {
protected: protected:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type of the literal /// @param type the type of the literal
explicit IntLiteral(type::Type* type); IntLiteral(const Source& source, type::Type* type);
}; };
} // namespace ast } // namespace ast

4
src/ast/int_literal_test.cc
View File

@ -31,13 +31,13 @@ using IntLiteralTest = TestHelper;
TEST_F(IntLiteralTest, Sint_IsInt) { TEST_F(IntLiteralTest, Sint_IsInt) {
type::I32 i32; type::I32 i32;
SintLiteral i{&i32, 47}; SintLiteral i{Source{}, &i32, 47};
ASSERT_TRUE(i.Is<IntLiteral>()); ASSERT_TRUE(i.Is<IntLiteral>());
} }
TEST_F(IntLiteralTest, Uint_IsInt) { TEST_F(IntLiteralTest, Uint_IsInt) {
type::I32 i32; type::I32 i32;
UintLiteral i{&i32, 42}; UintLiteral i{Source{}, &i32, 42};
EXPECT_TRUE(i.Is<IntLiteral>()); EXPECT_TRUE(i.Is<IntLiteral>());
} }

3
src/ast/literal.cc
View File

@ -19,7 +19,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::Literal);
namespace tint { namespace tint {
namespace ast { namespace ast {
Literal::Literal(type::Type* type) : type_(type) {} Literal::Literal(const Source& source, type::Type* type)
: Base(source), type_(type) {}
Literal::~Literal() = default; Literal::~Literal() = default;

3
src/ast/literal.h
View File

@ -47,8 +47,9 @@ class Literal : public Castable<Literal, Node> {
protected: protected:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type of the literal /// @param type the type of the literal
explicit Literal(type::Type* type); explicit Literal(const Source& source, type::Type* type);
private: private:
type::Type* type_ = nullptr; type::Type* type_ = nullptr;

2
src/ast/node.h
View File

@ -64,7 +64,7 @@ class Node : public Castable<Node> {
/// Create a new node /// Create a new node
Node(); Node();
/// Create a new node /// Create a new node
/// @param source The input source for the node /// @param source the input source for the node
explicit Node(const Source& source); explicit Node(const Source& source);
/// Move constructor /// Move constructor
Node(Node&&); Node(Node&&);

6
src/ast/null_literal.cc
View File

@ -22,7 +22,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::NullLiteral);
namespace tint { namespace tint {
namespace ast { namespace ast {
NullLiteral::NullLiteral(type::Type* type) : Base(type) {} NullLiteral::NullLiteral(const Source& source, type::Type* type)
: Base(source, type) {}
NullLiteral::~NullLiteral() = default; NullLiteral::~NullLiteral() = default;
@ -35,7 +36,8 @@ std::string NullLiteral::name() const {
} }
NullLiteral* NullLiteral::Clone(CloneContext* ctx) const { NullLiteral* NullLiteral::Clone(CloneContext* ctx) const {
return ctx->mod->create<NullLiteral>(ctx->Clone(type())); return ctx->mod->create<NullLiteral>(ctx->Clone(source()),
ctx->Clone(type()));
} }
} // namespace ast } // namespace ast

3
src/ast/null_literal.h
View File

@ -26,8 +26,9 @@ namespace ast {
class NullLiteral : public Castable<NullLiteral, Literal> { class NullLiteral : public Castable<NullLiteral, Literal> {
public: public:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type /// @param type the type
explicit NullLiteral(type::Type* type); NullLiteral(const Source& source, type::Type* type);
~NullLiteral() override; ~NullLiteral() override;
/// @returns the name for this literal. This name is unique to this value. /// @returns the name for this literal. This name is unique to this value.

6
src/ast/null_literal_test.cc
View File

@ -29,7 +29,7 @@ using NullLiteralTest = TestHelper;
TEST_F(NullLiteralTest, Is) { TEST_F(NullLiteralTest, Is) {
type::I32 i32; type::I32 i32;
NullLiteral i{&i32}; NullLiteral i{Source{}, &i32};
Literal* l = &i; Literal* l = &i;
EXPECT_FALSE(l->Is<BoolLiteral>()); EXPECT_FALSE(l->Is<BoolLiteral>());
EXPECT_FALSE(l->Is<SintLiteral>()); EXPECT_FALSE(l->Is<SintLiteral>());
@ -41,14 +41,14 @@ TEST_F(NullLiteralTest, Is) {
TEST_F(NullLiteralTest, ToStr) { TEST_F(NullLiteralTest, ToStr) {
type::I32 i32; type::I32 i32;
NullLiteral i{&i32}; NullLiteral i{Source{}, &i32};
EXPECT_EQ(i.to_str(), "null __i32"); EXPECT_EQ(i.to_str(), "null __i32");
} }
TEST_F(NullLiteralTest, Name_I32) { TEST_F(NullLiteralTest, Name_I32) {
type::I32 i32; type::I32 i32;
NullLiteral i{&i32}; NullLiteral i{Source{}, &i32};
EXPECT_EQ("__null__i32", i.name()); EXPECT_EQ("__null__i32", i.name());
} }

8
src/ast/scalar_constructor_expression_test.cc
View File

@ -26,14 +26,14 @@ using ScalarConstructorExpressionTest = TestHelper;
TEST_F(ScalarConstructorExpressionTest, Creation) { TEST_F(ScalarConstructorExpressionTest, Creation) {
type::Bool bool_type; type::Bool bool_type;
auto* b = create<BoolLiteral>(&bool_type, true); auto* b = create<BoolLiteral>(Source{}, &bool_type, true);
ScalarConstructorExpression c(b); ScalarConstructorExpression c(b);
EXPECT_EQ(c.literal(), b); EXPECT_EQ(c.literal(), b);
} }
TEST_F(ScalarConstructorExpressionTest, Creation_WithSource) { TEST_F(ScalarConstructorExpressionTest, Creation_WithSource) {
type::Bool bool_type; type::Bool bool_type;
auto* b = create<BoolLiteral>(&bool_type, true); auto* b = create<BoolLiteral>(Source{}, &bool_type, true);
ScalarConstructorExpression c(Source{Source::Location{20, 2}}, b); ScalarConstructorExpression c(Source{Source::Location{20, 2}}, b);
auto src = c.source(); auto src = c.source();
EXPECT_EQ(src.range.begin.line, 20u); EXPECT_EQ(src.range.begin.line, 20u);
@ -42,7 +42,7 @@ TEST_F(ScalarConstructorExpressionTest, Creation_WithSource) {
TEST_F(ScalarConstructorExpressionTest, IsValid) { TEST_F(ScalarConstructorExpressionTest, IsValid) {
type::Bool bool_type; type::Bool bool_type;
auto* b = create<BoolLiteral>(&bool_type, true); auto* b = create<BoolLiteral>(Source{}, &bool_type, true);
ScalarConstructorExpression c(b); ScalarConstructorExpression c(b);
EXPECT_TRUE(c.IsValid()); EXPECT_TRUE(c.IsValid());
} }
@ -54,7 +54,7 @@ TEST_F(ScalarConstructorExpressionTest, IsValid_MissingLiteral) {
TEST_F(ScalarConstructorExpressionTest, ToStr) { TEST_F(ScalarConstructorExpressionTest, ToStr) {
type::Bool bool_type; type::Bool bool_type;
auto* b = create<BoolLiteral>(&bool_type, true); auto* b = create<BoolLiteral>(Source{}, &bool_type, true);
ScalarConstructorExpression c(b); ScalarConstructorExpression c(b);
std::ostringstream out; std::ostringstream out;
c.to_str(out, 2); c.to_str(out, 2);

7
src/ast/sint_literal.cc
View File

@ -22,8 +22,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::SintLiteral);
namespace tint { namespace tint {
namespace ast { namespace ast {
SintLiteral::SintLiteral(type::Type* type, int32_t value) SintLiteral::SintLiteral(const Source& source, type::Type* type, int32_t value)
: Base(type), value_(value) {} : Base(source, type), value_(value) {}
SintLiteral::~SintLiteral() = default; SintLiteral::~SintLiteral() = default;
@ -36,7 +36,8 @@ std::string SintLiteral::name() const {
} }
SintLiteral* SintLiteral::Clone(CloneContext* ctx) const { SintLiteral* SintLiteral::Clone(CloneContext* ctx) const {
return ctx->mod->create<SintLiteral>(ctx->Clone(type()), value_); return ctx->mod->create<SintLiteral>(ctx->Clone(source()), ctx->Clone(type()),
value_);
} }
} // namespace ast } // namespace ast

3
src/ast/sint_literal.h
View File

@ -26,9 +26,10 @@ namespace ast {
class SintLiteral : public Castable<SintLiteral, IntLiteral> { class SintLiteral : public Castable<SintLiteral, IntLiteral> {
public: public:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type /// @param type the type
/// @param value the signed int literals value /// @param value the signed int literals value
SintLiteral(type::Type* type, int32_t value); SintLiteral(const Source& source, type::Type* type, int32_t value);
~SintLiteral() override; ~SintLiteral() override;
/// @returns the int literal value /// @returns the int literal value

10
src/ast/sint_literal_test.cc
View File

@ -30,14 +30,14 @@ using SintLiteralTest = TestHelper;
TEST_F(SintLiteralTest, Value) { TEST_F(SintLiteralTest, Value) {
type::I32 i32; type::I32 i32;
SintLiteral i{&i32, 47}; SintLiteral i{Source{}, &i32, 47};
ASSERT_TRUE(i.Is<SintLiteral>()); ASSERT_TRUE(i.Is<SintLiteral>());
EXPECT_EQ(i.value(), 47); EXPECT_EQ(i.value(), 47);
} }
TEST_F(SintLiteralTest, Is) { TEST_F(SintLiteralTest, Is) {
type::I32 i32; type::I32 i32;
SintLiteral i{&i32, 42}; SintLiteral i{Source{}, &i32, 42};
Literal* l = &i; Literal* l = &i;
EXPECT_FALSE(l->Is<BoolLiteral>()); EXPECT_FALSE(l->Is<BoolLiteral>());
EXPECT_TRUE(l->Is<SintLiteral>()); EXPECT_TRUE(l->Is<SintLiteral>());
@ -48,20 +48,20 @@ TEST_F(SintLiteralTest, Is) {
TEST_F(SintLiteralTest, ToStr) { TEST_F(SintLiteralTest, ToStr) {
type::I32 i32; type::I32 i32;
SintLiteral i{&i32, -42}; SintLiteral i{Source{}, &i32, -42};
EXPECT_EQ(i.to_str(), "-42"); EXPECT_EQ(i.to_str(), "-42");
} }
TEST_F(SintLiteralTest, Name_I32) { TEST_F(SintLiteralTest, Name_I32) {
type::I32 i32; type::I32 i32;
SintLiteral i{&i32, 2}; SintLiteral i{Source{}, &i32, 2};
EXPECT_EQ("__sint__i32_2", i.name()); EXPECT_EQ("__sint__i32_2", i.name());
} }
TEST_F(SintLiteralTest, Name_U32) { TEST_F(SintLiteralTest, Name_U32) {
type::U32 u32; type::U32 u32;
SintLiteral i{&u32, 2}; SintLiteral i{Source{}, &u32, 2};
EXPECT_EQ("__sint__u32_2", i.name()); EXPECT_EQ("__sint__u32_2", i.name());
} }

14
src/ast/switch_statement_test.cc
View File

@ -32,7 +32,7 @@ TEST_F(SwitchStatementTest, Creation) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 1)); lit.push_back(create<SintLiteral>(Source{}, &i32, 1));
auto* ident = auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"); create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
@ -61,7 +61,7 @@ TEST_F(SwitchStatementTest, IsSwitch) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2)); lit.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* ident = auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"); create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
@ -76,7 +76,7 @@ TEST_F(SwitchStatementTest, IsValid) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2)); lit.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* ident = auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"); create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
@ -91,7 +91,7 @@ TEST_F(SwitchStatementTest, IsValid_Null_Condition) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2)); lit.push_back(create<SintLiteral>(Source{}, &i32, 2));
CaseStatementList body; CaseStatementList body;
body.push_back(create<CaseStatement>(lit, create<BlockStatement>())); body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
@ -104,7 +104,7 @@ TEST_F(SwitchStatementTest, IsValid_Invalid_Condition) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2)); lit.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* ident = create<IdentifierExpression>(mod.RegisterSymbol(""), ""); auto* ident = create<IdentifierExpression>(mod.RegisterSymbol(""), "");
CaseStatementList body; CaseStatementList body;
@ -118,7 +118,7 @@ TEST_F(SwitchStatementTest, IsValid_Null_BodyStatement) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2)); lit.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* ident = auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"); create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");
@ -163,7 +163,7 @@ TEST_F(SwitchStatementTest, ToStr) {
type::I32 i32; type::I32 i32;
CaseSelectorList lit; CaseSelectorList lit;
lit.push_back(create<SintLiteral>(&i32, 2)); lit.push_back(create<SintLiteral>(Source{}, &i32, 2));
auto* ident = auto* ident =
create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident"); create<IdentifierExpression>(mod.RegisterSymbol("ident"), "ident");

7
src/ast/uint_literal.cc
View File

@ -22,8 +22,8 @@ TINT_INSTANTIATE_CLASS_ID(tint::ast::UintLiteral);
namespace tint { namespace tint {
namespace ast { namespace ast {
UintLiteral::UintLiteral(type::Type* type, uint32_t value) UintLiteral::UintLiteral(const Source& source, type::Type* type, uint32_t value)
: Base(type), value_(value) {} : Base(source, type), value_(value) {}
UintLiteral::~UintLiteral() = default; UintLiteral::~UintLiteral() = default;
@ -36,7 +36,8 @@ std::string UintLiteral::name() const {
} }
UintLiteral* UintLiteral::Clone(CloneContext* ctx) const { UintLiteral* UintLiteral::Clone(CloneContext* ctx) const {
return ctx->mod->create<UintLiteral>(ctx->Clone(type()), value_); return ctx->mod->create<UintLiteral>(ctx->Clone(source()), ctx->Clone(type()),
value_);
} }
} // namespace ast } // namespace ast

3
src/ast/uint_literal.h
View File

@ -26,9 +26,10 @@ namespace ast {
class UintLiteral : public Castable<UintLiteral, IntLiteral> { class UintLiteral : public Castable<UintLiteral, IntLiteral> {
public: public:
/// Constructor /// Constructor
/// @param source the input source
/// @param type the type of the literal /// @param type the type of the literal
/// @param value the uint literals value /// @param value the uint literals value
UintLiteral(type::Type* type, uint32_t value); UintLiteral(const Source& source, type::Type* type, uint32_t value);
~UintLiteral() override; ~UintLiteral() override;
/// @returns the uint literal value /// @returns the uint literal value

9
src/ast/uint_literal_test.cc
View File

@ -29,14 +29,14 @@ using UintLiteralTest = TestHelper;
TEST_F(UintLiteralTest, Value) { TEST_F(UintLiteralTest, Value) {
type::U32 u32; type::U32 u32;
UintLiteral u{&u32, 47}; UintLiteral u{Source{}, &u32, 47};
ASSERT_TRUE(u.Is<UintLiteral>()); ASSERT_TRUE(u.Is<UintLiteral>());
EXPECT_EQ(u.value(), 47u); EXPECT_EQ(u.value(), 47u);
} }
TEST_F(UintLiteralTest, Is) { TEST_F(UintLiteralTest, Is) {
type::U32 u32; type::U32 u32;
UintLiteral u{&u32, 42}; UintLiteral u{Source{}, &u32, 42};
Literal* l = &u; Literal* l = &u;
EXPECT_FALSE(l->Is<BoolLiteral>()); EXPECT_FALSE(l->Is<BoolLiteral>());
EXPECT_FALSE(l->Is<SintLiteral>()); EXPECT_FALSE(l->Is<SintLiteral>());
@ -47,9 +47,8 @@ TEST_F(UintLiteralTest, Is) {
TEST_F(UintLiteralTest, ToStr) { TEST_F(UintLiteralTest, ToStr) {
type::U32 u32; type::U32 u32;
UintLiteral i{&u32, 42}; UintLiteral u{Source{}, &u32, 42};
EXPECT_EQ(u.to_str(), "42");
EXPECT_EQ(i.to_str(), "42");
} }
} // namespace } // namespace

8
src/inspector/inspector_test.cc
View File

@ -228,28 +228,28 @@ class InspectorHelper {
/// @param val scalar value for the literal to contain /// @param val scalar value for the literal to contain
/// @returns a Literal of the expected type and value /// @returns a Literal of the expected type and value
ast::Literal* MakeLiteral(ast::type::Type* type, bool* val) { ast::Literal* MakeLiteral(ast::type::Type* type, bool* val) {
return create<ast::BoolLiteral>(type, *val); return create<ast::BoolLiteral>(Source{}, type, *val);
} }
/// @param type AST type of the literal, must resolve to UIntLiteral /// @param type AST type of the literal, must resolve to UIntLiteral
/// @param val scalar value for the literal to contain /// @param val scalar value for the literal to contain
/// @returns a Literal of the expected type and value /// @returns a Literal of the expected type and value
ast::Literal* MakeLiteral(ast::type::Type* type, uint32_t* val) { ast::Literal* MakeLiteral(ast::type::Type* type, uint32_t* val) {
return create<ast::UintLiteral>(type, *val); return create<ast::UintLiteral>(Source{}, type, *val);
} }
/// @param type AST type of the literal, must resolve to IntLiteral /// @param type AST type of the literal, must resolve to IntLiteral
/// @param val scalar value for the literal to contain /// @param val scalar value for the literal to contain
/// @returns a Literal of the expected type and value /// @returns a Literal of the expected type and value
ast::Literal* MakeLiteral(ast::type::Type* type, int32_t* val) { ast::Literal* MakeLiteral(ast::type::Type* type, int32_t* val) {
return create<ast::SintLiteral>(type, *val); return create<ast::SintLiteral>(Source{}, type, *val);
} }
/// @param type AST type of the literal, must resolve to FloattLiteral /// @param type AST type of the literal, must resolve to FloattLiteral
/// @param val scalar value for the literal to contain /// @param val scalar value for the literal to contain
/// @returns a Literal of the expected type and value /// @returns a Literal of the expected type and value
ast::Literal* MakeLiteral(ast::type::Type* type, float* val) { ast::Literal* MakeLiteral(ast::type::Type* type, float* val) {
return create<ast::FloatLiteral>(type, *val); return create<ast::FloatLiteral>(Source{}, type, *val);
} }
/// @param vec Vector of strings to be searched /// @param vec Vector of strings to be searched

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

@ -695,7 +695,7 @@ void FunctionEmitter::PushTrueGuard(uint32_t end_id) {
assert(!statements_stack_.empty()); assert(!statements_stack_.empty());
const auto& top = statements_stack_.back(); const auto& top = statements_stack_.back();
auto* cond = MakeTrue(); auto* cond = MakeTrue(Source{});
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
AddStatement( AddStatement(
create<ast::IfStatement>(Source{}, cond, body, ast::ElseStatementList{})); create<ast::IfStatement>(Source{}, cond, body, ast::ElseStatementList{}));
@ -2142,7 +2142,7 @@ bool FunctionEmitter::EmitIfStart(const BlockInfo& block_info) {
ast::StorageClass::kFunction, // storage_class ast::StorageClass::kFunction, // storage_class
parser_impl_.Bool(), // type parser_impl_.Bool(), // type
false, // is_const false, // is_const
MakeTrue(), // constructor MakeTrue(Source{}), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* guard_decl = create<ast::VariableDeclStatement>(guard_var); auto* guard_decl = create<ast::VariableDeclStatement>(guard_var);
AddStatement(guard_decl); AddStatement(guard_decl);
@ -2354,10 +2354,10 @@ bool FunctionEmitter::EmitSwitchStart(const BlockInfo& block_info) {
const uint32_t value32 = uint32_t(value & 0xFFFFFFFF); const uint32_t value32 = uint32_t(value & 0xFFFFFFFF);
if (selector.type->is_unsigned_scalar_or_vector()) { if (selector.type->is_unsigned_scalar_or_vector()) {
selectors.emplace_back( selectors.emplace_back(
create<ast::UintLiteral>(selector.type, value32)); create<ast::UintLiteral>(Source{}, selector.type, value32));
} else { } else {
selectors.emplace_back( selectors.emplace_back(
create<ast::SintLiteral>(selector.type, value32)); create<ast::SintLiteral>(Source{}, selector.type, value32));
} }
} }
} }
@ -2572,7 +2572,7 @@ ast::Statement* FunctionEmitter::MakeBranchDetailed(
return create<ast::AssignmentStatement>( return create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>( create<ast::IdentifierExpression>(
ast_module_.RegisterSymbol(flow_guard), flow_guard), ast_module_.RegisterSymbol(flow_guard), flow_guard),
MakeFalse()); MakeFalse(Source{}));
} }
// For an unconditional branch, the break out to an if-selection // For an unconditional branch, the break out to an if-selection
@ -3256,7 +3256,7 @@ TypedExpression FunctionEmitter::MakeCompositeExtract(
auto make_index = [this](uint32_t literal) { auto make_index = [this](uint32_t literal) {
auto* type = create<ast::type::U32>(); auto* type = create<ast::type::U32>();
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(type, literal)); create<ast::UintLiteral>(Source{}, type, literal));
}; };
const auto composite = inst.GetSingleWordInOperand(0); const auto composite = inst.GetSingleWordInOperand(0);
@ -3356,15 +3356,15 @@ TypedExpression FunctionEmitter::MakeCompositeExtract(
return current_expr; return current_expr;
} }
ast::Expression* FunctionEmitter::MakeTrue() const { ast::Expression* FunctionEmitter::MakeTrue(const Source& source) const {
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(parser_impl_.Bool(), true)); create<ast::BoolLiteral>(source, parser_impl_.Bool(), true));
} }
ast::Expression* FunctionEmitter::MakeFalse() const { ast::Expression* FunctionEmitter::MakeFalse(const Source& source) const {
ast::type::Bool bool_type; ast::type::Bool bool_type;
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(parser_impl_.Bool(), false)); create<ast::BoolLiteral>(source, parser_impl_.Bool(), false));
} }
TypedExpression FunctionEmitter::MakeVectorShuffle( TypedExpression FunctionEmitter::MakeVectorShuffle(

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

@ -698,7 +698,7 @@ class FunctionEmitter {
/// return the given value. Otherwise, wrap the value in a TypeConstructor /// return the given value. Otherwise, wrap the value in a TypeConstructor
/// expression. /// expression.
/// @param value the value to pass through or convert /// @param value the value to pass through or convert
/// @reutrns the value as an I32 value. /// @returns the value as an I32 value.
TypedExpression ToI32(TypedExpression value); TypedExpression ToI32(TypedExpression value);
private: private:
@ -865,10 +865,10 @@ class FunctionEmitter {
void PushTrueGuard(uint32_t end_id); void PushTrueGuard(uint32_t end_id);
/// @returns a boolean true expression. /// @returns a boolean true expression.
ast::Expression* MakeTrue() const; ast::Expression* MakeTrue(const Source&) const;
/// @returns a boolean false expression. /// @returns a boolean false expression.
ast::Expression* MakeFalse() const; ast::Expression* MakeFalse(const Source&) const;
/// Creates a new `ast::Node` owned by the Module. When the Module is /// Creates a new `ast::Node` owned by the Module. When the Module is
/// destructed, the `ast::Node` will also be destructed. /// destructed, the `ast::Node` will also be destructed.

31
src/reader/spirv/parser_impl.cc
View File

@ -1033,7 +1033,7 @@ bool ParserImpl::EmitScalarSpecConstants() {
ast_type = ConvertType(inst.type_id()); ast_type = ConvertType(inst.type_id());
ast_expr = ast_expr =
create<ast::ScalarConstructorExpression>(create<ast::BoolLiteral>( create<ast::ScalarConstructorExpression>(create<ast::BoolLiteral>(
ast_type, inst.opcode() == SpvOpSpecConstantTrue)); Source{}, ast_type, inst.opcode() == SpvOpSpecConstantTrue));
break; break;
} }
case SpvOpSpecConstant: { case SpvOpSpecConstant: {
@ -1042,17 +1042,17 @@ bool ParserImpl::EmitScalarSpecConstants() {
if (ast_type->Is<ast::type::I32>()) { if (ast_type->Is<ast::type::I32>()) {
ast_expr = ast_expr =
create<ast::ScalarConstructorExpression>(create<ast::SintLiteral>( create<ast::ScalarConstructorExpression>(create<ast::SintLiteral>(
ast_type, static_cast<int32_t>(literal_value))); Source{}, ast_type, static_cast<int32_t>(literal_value)));
} else if (ast_type->Is<ast::type::U32>()) { } else if (ast_type->Is<ast::type::U32>()) {
ast_expr = ast_expr =
create<ast::ScalarConstructorExpression>(create<ast::UintLiteral>( create<ast::ScalarConstructorExpression>(create<ast::UintLiteral>(
ast_type, static_cast<uint32_t>(literal_value))); Source{}, ast_type, static_cast<uint32_t>(literal_value)));
} else if (ast_type->Is<ast::type::F32>()) { } else if (ast_type->Is<ast::type::F32>()) {
float float_value; float float_value;
// Copy the bits so we can read them as a float. // Copy the bits so we can read them as a float.
std::memcpy(&float_value, &literal_value, sizeof(float_value)); std::memcpy(&float_value, &literal_value, sizeof(float_value));
ast_expr = create<ast::ScalarConstructorExpression>( ast_expr = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(ast_type, float_value)); create<ast::FloatLiteral>(Source{}, ast_type, float_value));
} else { } else {
return Fail() << " invalid result type for OpSpecConstant " return Fail() << " invalid result type for OpSpecConstant "
<< inst.PrettyPrint(); << inst.PrettyPrint();
@ -1314,6 +1314,7 @@ TypedExpression ParserImpl::MakeConstantExpression(uint32_t id) {
return {}; return {};
} }
auto source = GetSourceForInst(inst);
auto* ast_type = original_ast_type->UnwrapIfNeeded(); auto* ast_type = original_ast_type->UnwrapIfNeeded();
// TODO(dneto): Note: NullConstant for int, uint, float map to a regular 0. // TODO(dneto): Note: NullConstant for int, uint, float map to a regular 0.
@ -1322,25 +1323,25 @@ TypedExpression ParserImpl::MakeConstantExpression(uint32_t id) {
// See https://bugs.chromium.org/p/tint/issues/detail?id=34 // See https://bugs.chromium.org/p/tint/issues/detail?id=34
if (ast_type->Is<ast::type::U32>()) { if (ast_type->Is<ast::type::U32>()) {
return {ast_type, return {ast_type,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(create<ast::UintLiteral>(
create<ast::UintLiteral>(ast_type, spirv_const->GetU32()))}; source, ast_type, spirv_const->GetU32()))};
} }
if (ast_type->Is<ast::type::I32>()) { if (ast_type->Is<ast::type::I32>()) {
return {ast_type, return {ast_type,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(create<ast::SintLiteral>(
create<ast::SintLiteral>(ast_type, spirv_const->GetS32()))}; source, ast_type, spirv_const->GetS32()))};
} }
if (ast_type->Is<ast::type::F32>()) { if (ast_type->Is<ast::type::F32>()) {
return {ast_type, return {ast_type,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(create<ast::FloatLiteral>(
create<ast::FloatLiteral>(ast_type, spirv_const->GetFloat()))}; source, ast_type, spirv_const->GetFloat()))};
} }
if (ast_type->Is<ast::type::Bool>()) { if (ast_type->Is<ast::type::Bool>()) {
const bool value = spirv_const->AsNullConstant() const bool value = spirv_const->AsNullConstant()
? false ? false
: spirv_const->AsBoolConstant()->value(); : spirv_const->AsBoolConstant()->value();
return {ast_type, create<ast::ScalarConstructorExpression>( return {ast_type, create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(ast_type, value))}; create<ast::BoolLiteral>(source, ast_type, value))};
} }
auto* spirv_composite_const = spirv_const->AsCompositeConstant(); auto* spirv_composite_const = spirv_const->AsCompositeConstant();
if (spirv_composite_const != nullptr) { if (spirv_composite_const != nullptr) {
@ -1394,19 +1395,19 @@ ast::Expression* ParserImpl::MakeNullValue(ast::type::Type* type) {
if (type->Is<ast::type::Bool>()) { if (type->Is<ast::type::Bool>()) {
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(type, false)); create<ast::BoolLiteral>(Source{}, type, false));
} }
if (type->Is<ast::type::U32>()) { if (type->Is<ast::type::U32>()) {
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(type, 0u)); create<ast::UintLiteral>(Source{}, type, 0u));
} }
if (type->Is<ast::type::I32>()) { if (type->Is<ast::type::I32>()) {
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(type, 0)); create<ast::SintLiteral>(Source{}, type, 0));
} }
if (type->Is<ast::type::F32>()) { if (type->Is<ast::type::F32>()) {
return create<ast::ScalarConstructorExpression>( return create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(type, 0.0f)); create<ast::FloatLiteral>(Source{}, type, 0.0f));
} }
if (const auto* vec_ty = type->As<ast::type::Vector>()) { if (const auto* vec_ty = type->As<ast::type::Vector>()) {
ast::ExpressionList ast_components; ast::ExpressionList ast_components;

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

@ -2678,19 +2678,19 @@ Maybe<ast::Literal*> ParserImpl::const_literal() {
auto t = peek(); auto t = peek();
if (match(Token::Type::kTrue)) { if (match(Token::Type::kTrue)) {
auto* type = module_.create<ast::type::Bool>(); auto* type = module_.create<ast::type::Bool>();
return create<ast::BoolLiteral>(type, true); return create<ast::BoolLiteral>(Source{}, type, true);
} }
if (match(Token::Type::kFalse)) { if (match(Token::Type::kFalse)) {
auto* type = module_.create<ast::type::Bool>(); auto* type = module_.create<ast::type::Bool>();
return create<ast::BoolLiteral>(type, false); return create<ast::BoolLiteral>(Source{}, type, false);
} }
if (match(Token::Type::kSintLiteral)) { if (match(Token::Type::kSintLiteral)) {
auto* type = module_.create<ast::type::I32>(); auto* type = module_.create<ast::type::I32>();
return create<ast::SintLiteral>(type, t.to_i32()); return create<ast::SintLiteral>(Source{}, type, t.to_i32());
} }
if (match(Token::Type::kUintLiteral)) { if (match(Token::Type::kUintLiteral)) {
auto* type = module_.create<ast::type::U32>(); auto* type = module_.create<ast::type::U32>();
return create<ast::UintLiteral>(type, t.to_u32()); return create<ast::UintLiteral>(Source{}, type, t.to_u32());
} }
if (match(Token::Type::kFloatLiteral)) { if (match(Token::Type::kFloatLiteral)) {
auto p = peek(); auto p = peek();
@ -2699,7 +2699,7 @@ Maybe<ast::Literal*> ParserImpl::const_literal() {
add_error(p.source(), "float literals must not be suffixed with 'f'"); add_error(p.source(), "float literals must not be suffixed with 'f'");
} }
auto* type = module_.create<ast::type::F32>(); auto* type = module_.create<ast::type::F32>();
return create<ast::FloatLiteral>(type, t.to_f32()); return create<ast::FloatLiteral>(Source{}, type, t.to_f32());
} }
return Failure::kNoMatch; return Failure::kNoMatch;
} }

8
src/transform/bound_array_accessors.cc
View File

@ -105,13 +105,15 @@ ast::ArrayAccessorExpression* BoundArrayAccessors::Transform(
} else if (val >= int32_t(size)) { } else if (val >= int32_t(size)) {
val = int32_t(size) - 1; val = int32_t(size) - 1;
} }
lit = ctx->mod->create<ast::SintLiteral>(ctx->Clone(sint->type()), val); lit = ctx->mod->create<ast::SintLiteral>(ctx->Clone(sint->source()),
ctx->Clone(sint->type()), val);
} else if (auto* uint = lit->As<ast::UintLiteral>()) { } else if (auto* uint = lit->As<ast::UintLiteral>()) {
uint32_t val = uint->value(); uint32_t val = uint->value();
if (val >= size - 1) { if (val >= size - 1) {
val = size - 1; val = size - 1;
} }
lit = ctx->mod->create<ast::UintLiteral>(ctx->Clone(uint->type()), val); lit = ctx->mod->create<ast::UintLiteral>(ctx->Clone(uint->source()),
ctx->Clone(uint->type()), val);
} else { } else {
diag::Diagnostic err; diag::Diagnostic err;
err.severity = diag::Severity::Error; err.severity = diag::Severity::Error;
@ -132,7 +134,7 @@ ast::ArrayAccessorExpression* BoundArrayAccessors::Transform(
params.push_back( params.push_back(
ctx->mod->create<ast::TypeConstructorExpression>(u32, cast_expr)); ctx->mod->create<ast::TypeConstructorExpression>(u32, cast_expr));
params.push_back(ctx->mod->create<ast::ScalarConstructorExpression>( params.push_back(ctx->mod->create<ast::ScalarConstructorExpression>(
ctx->mod->create<ast::UintLiteral>(u32, size - 1))); ctx->mod->create<ast::UintLiteral>(Source{}, u32, size - 1)));
auto* call_expr = ctx->mod->create<ast::CallExpression>( auto* call_expr = ctx->mod->create<ast::CallExpression>(
ctx->mod->create<ast::IdentifierExpression>( ctx->mod->create<ast::IdentifierExpression>(

2
src/transform/emit_vertex_point_size.cc
View File

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

2
src/transform/vertex_pulling.cc
View File

@ -353,7 +353,7 @@ void VertexPulling::State::AddVertexPullingPreamble(
ast::Expression* VertexPulling::State::GenUint(uint32_t value) { ast::Expression* VertexPulling::State::GenUint(uint32_t value) {
return mod->create<ast::ScalarConstructorExpression>( return mod->create<ast::ScalarConstructorExpression>(
mod->create<ast::UintLiteral>(GetU32Type(), value)); mod->create<ast::UintLiteral>(Source{}, GetU32Type(), value));
} }
ast::Expression* VertexPulling::State::CreatePullingPositionIdent() { ast::Expression* VertexPulling::State::CreatePullingPositionIdent() {

585
src/type_determiner_test.cc
View File

File diff suppressed because it is too large Load Diff

66
src/validator/validator_control_block_test.cc
View File

@ -50,8 +50,8 @@ TEST_F(ValidateControlBlockTest, SwitchSelectorExpressionNoneIntegerType_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&f32, 3.14f)), // constructor create<ast::SintLiteral>(Source{}, &f32, 3.14f)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* cond = create<ast::IdentifierExpression>( auto* cond = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a"); Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
@ -84,13 +84,13 @@ TEST_F(ValidateControlBlockTest, SwitchWithoutDefault_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl; ast::CaseSelectorList csl;
csl.push_back(create<ast::SintLiteral>(&i32, 1)); csl.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
ast::CaseStatementList body; ast::CaseStatementList body;
body.push_back( body.push_back(
create<ast::CaseStatement>(csl, create<ast::BlockStatement>())); create<ast::CaseStatement>(csl, create<ast::BlockStatement>()));
@ -122,8 +122,8 @@ TEST_F(ValidateControlBlockTest, SwitchWithTwoDefault_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body; ast::CaseStatementList switch_body;
auto* cond = auto* cond =
@ -135,7 +135,7 @@ TEST_F(ValidateControlBlockTest, SwitchWithTwoDefault_Fail) {
create<ast::CaseStatement>(default_csl_1, block_default_1)); create<ast::CaseStatement>(default_csl_1, block_default_1));
ast::CaseSelectorList csl_case_1; ast::CaseSelectorList csl_case_1;
csl_case_1.push_back(create<ast::SintLiteral>(&i32, 1)); csl_case_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
auto* block_case_1 = create<ast::BlockStatement>(); auto* block_case_1 = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(csl_case_1, block_case_1)); switch_body.push_back(create<ast::CaseStatement>(csl_case_1, block_case_1));
@ -172,15 +172,15 @@ TEST_F(ValidateControlBlockTest,
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body; ast::CaseStatementList switch_body;
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl; ast::CaseSelectorList csl;
csl.push_back(create<ast::UintLiteral>(&u32, 1)); csl.push_back(create<ast::UintLiteral>(Source{}, &u32, 1));
switch_body.push_back(create<ast::CaseStatement>( switch_body.push_back(create<ast::CaseStatement>(
Source{Source::Location{12, 34}}, csl, create<ast::BlockStatement>())); Source{Source::Location{12, 34}}, csl, create<ast::BlockStatement>()));
@ -215,15 +215,15 @@ TEST_F(ValidateControlBlockTest,
&u32, // type &u32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 2)), // constructor create<ast::UintLiteral>(Source{}, &u32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body; ast::CaseStatementList switch_body;
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl; ast::CaseSelectorList csl;
csl.push_back(create<ast::SintLiteral>(&i32, -1)); csl.push_back(create<ast::SintLiteral>(Source{}, &i32, -1));
switch_body.push_back(create<ast::CaseStatement>( switch_body.push_back(create<ast::CaseStatement>(
Source{Source::Location{12, 34}}, csl, create<ast::BlockStatement>())); Source{Source::Location{12, 34}}, csl, create<ast::BlockStatement>()));
@ -257,21 +257,21 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueUint_Fail) {
&u32, // type &u32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3)), // constructor create<ast::UintLiteral>(Source{}, &u32, 3)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body; ast::CaseStatementList switch_body;
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl_1; ast::CaseSelectorList csl_1;
csl_1.push_back(create<ast::UintLiteral>(&u32, 0)); csl_1.push_back(create<ast::UintLiteral>(Source{}, &u32, 0));
switch_body.push_back( switch_body.push_back(
create<ast::CaseStatement>(csl_1, create<ast::BlockStatement>())); create<ast::CaseStatement>(csl_1, create<ast::BlockStatement>()));
ast::CaseSelectorList csl_2; ast::CaseSelectorList csl_2;
csl_2.push_back(create<ast::UintLiteral>(&u32, 2)); csl_2.push_back(create<ast::UintLiteral>(Source{}, &u32, 2));
csl_2.push_back(create<ast::UintLiteral>(&u32, 2)); csl_2.push_back(create<ast::UintLiteral>(Source{}, &u32, 2));
switch_body.push_back(create<ast::CaseStatement>( switch_body.push_back(create<ast::CaseStatement>(
Source{Source::Location{12, 34}}, csl_2, create<ast::BlockStatement>())); Source{Source::Location{12, 34}}, csl_2, create<ast::BlockStatement>()));
@ -305,23 +305,23 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueSint_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::CaseStatementList switch_body; ast::CaseStatementList switch_body;
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
ast::CaseSelectorList csl_1; ast::CaseSelectorList csl_1;
csl_1.push_back(create<ast::SintLiteral>(&i32, 10)); csl_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 10));
switch_body.push_back( switch_body.push_back(
create<ast::CaseStatement>(csl_1, create<ast::BlockStatement>())); create<ast::CaseStatement>(csl_1, create<ast::BlockStatement>()));
ast::CaseSelectorList csl_2; ast::CaseSelectorList csl_2;
csl_2.push_back(create<ast::SintLiteral>(&i32, 0)); csl_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 0));
csl_2.push_back(create<ast::SintLiteral>(&i32, 1)); csl_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
csl_2.push_back(create<ast::SintLiteral>(&i32, 2)); csl_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 2));
csl_2.push_back(create<ast::SintLiteral>(&i32, 10)); csl_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 10));
switch_body.push_back(create<ast::CaseStatement>( switch_body.push_back(create<ast::CaseStatement>(
Source{Source::Location{12, 34}}, csl_2, create<ast::BlockStatement>())); Source{Source::Location{12, 34}}, csl_2, create<ast::BlockStatement>()));
@ -353,8 +353,8 @@ TEST_F(ValidateControlBlockTest, LastClauseLastStatementIsFallthrough_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
@ -390,8 +390,8 @@ TEST_F(ValidateControlBlockTest, SwitchCase_Pass) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
@ -401,7 +401,7 @@ TEST_F(ValidateControlBlockTest, SwitchCase_Pass) {
body.push_back(create<ast::CaseStatement>(Source{Source::Location{12, 34}}, body.push_back(create<ast::CaseStatement>(Source{Source::Location{12, 34}},
default_csl, block_default)); default_csl, block_default));
ast::CaseSelectorList case_csl; ast::CaseSelectorList case_csl;
case_csl.push_back(create<ast::SintLiteral>(&i32, 5)); case_csl.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
auto* block_case = create<ast::BlockStatement>(); auto* block_case = create<ast::BlockStatement>();
body.push_back(create<ast::CaseStatement>(case_csl, block_case)); body.push_back(create<ast::CaseStatement>(case_csl, block_case));
@ -430,8 +430,8 @@ TEST_F(ValidateControlBlockTest, SwitchCaseAlias_Pass) {
&my_int, // type &my_int, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&u32, 2)), // constructor create<ast::SintLiteral>(Source{}, &u32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* cond = auto* cond =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");

20
src/validator/validator_function_test.cc
View File

@ -46,8 +46,8 @@ TEST_F(ValidateFunctionTest, VoidFunctionEndWithoutReturnStatement_Pass) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::VariableList params; ast::VariableList params;
ast::type::Void void_type; ast::type::Void void_type;
@ -94,8 +94,8 @@ TEST_F(ValidateFunctionTest, FunctionEndWithoutReturnStatement_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::VariableList params; ast::VariableList params;
ast::type::Void void_type; ast::type::Void void_type;
@ -155,7 +155,7 @@ TEST_F(ValidateFunctionTest, FunctionTypeMustMatchReturnStatementType_fail) {
ast::VariableList params; ast::VariableList params;
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
auto* return_expr = create<ast::ScalarConstructorExpression>( auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
body->append(create<ast::ReturnStatement>(Source{Source::Location{12, 34}}, body->append(create<ast::ReturnStatement>(Source{Source::Location{12, 34}},
return_expr)); return_expr));
@ -179,7 +179,7 @@ TEST_F(ValidateFunctionTest, FunctionTypeMustMatchReturnStatementTypeF32_fail) {
ast::VariableList params; ast::VariableList params;
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
auto* return_expr = create<ast::ScalarConstructorExpression>( auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
body->append(create<ast::ReturnStatement>(Source{Source::Location{12, 34}}, body->append(create<ast::ReturnStatement>(Source{Source::Location{12, 34}},
return_expr)); return_expr));
@ -205,7 +205,7 @@ TEST_F(ValidateFunctionTest, FunctionNamesMustBeUnique_fail) {
ast::VariableList params; ast::VariableList params;
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
auto* return_expr = create<ast::ScalarConstructorExpression>( auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
body->append(create<ast::ReturnStatement>(Source{}, return_expr)); body->append(create<ast::ReturnStatement>(Source{}, return_expr));
auto* func = auto* func =
@ -215,7 +215,7 @@ TEST_F(ValidateFunctionTest, FunctionNamesMustBeUnique_fail) {
ast::VariableList params_copy; ast::VariableList params_copy;
auto* body_copy = create<ast::BlockStatement>(); auto* body_copy = create<ast::BlockStatement>();
auto* return_expr_copy = create<ast::ScalarConstructorExpression>( auto* return_expr_copy = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
body_copy->append(create<ast::ReturnStatement>(Source{}, return_expr_copy)); body_copy->append(create<ast::ReturnStatement>(Source{}, return_expr_copy));
auto* func_copy = create<ast::Function>( auto* func_copy = create<ast::Function>(
@ -274,7 +274,7 @@ TEST_F(ValidateFunctionTest, RecursionIsNotAllowedExpr_Fail) {
auto* body0 = create<ast::BlockStatement>(); auto* body0 = create<ast::BlockStatement>();
body0->append(create<ast::VariableDeclStatement>(var)); body0->append(create<ast::VariableDeclStatement>(var));
auto* return_expr = create<ast::ScalarConstructorExpression>( auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
body0->append(create<ast::ReturnStatement>(Source{}, return_expr)); body0->append(create<ast::ReturnStatement>(Source{}, return_expr));
auto* func0 = create<ast::Function>(Source{}, mod()->RegisterSymbol("func"), auto* func0 = create<ast::Function>(Source{}, mod()->RegisterSymbol("func"),
@ -293,7 +293,7 @@ TEST_F(ValidateFunctionTest, Function_WithPipelineStage_NotVoid_Fail) {
ast::type::I32 i32; ast::type::I32 i32;
ast::VariableList params; ast::VariableList params;
auto* return_expr = create<ast::ScalarConstructorExpression>( auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 0)); create<ast::SintLiteral>(Source{}, &i32, 0));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(Source{}, return_expr)); body->append(create<ast::ReturnStatement>(Source{}, return_expr));

126
src/validator/validator_test.cc
View File

@ -65,7 +65,7 @@ TEST_F(ValidatorTest, DISABLED_AssignToScalar_Fail) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)); create<ast::SintLiteral>(Source{}, &i32, 1));
auto* rhs = create<ast::IdentifierExpression>(mod()->RegisterSymbol("my_var"), auto* rhs = create<ast::IdentifierExpression>(mod()->RegisterSymbol("my_var"),
"my_var"); "my_var");
ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs); ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs);
@ -83,7 +83,7 @@ TEST_F(ValidatorTest, UsingUndefinedVariable_Fail) {
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b"); Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
auto* assign = create<ast::AssignmentStatement>( auto* assign = create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, lhs, rhs); Source{Source::Location{12, 34}}, lhs, rhs);
@ -101,7 +101,7 @@ TEST_F(ValidatorTest, UsingUndefinedVariableInBlockStatement_Fail) {
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b"); Source{Source::Location{12, 34}}, mod()->RegisterSymbol("b"), "b");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -123,13 +123,13 @@ TEST_F(ValidatorTest, AssignCompatibleTypes_Pass) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs); ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs);
td()->RegisterVariableForTesting(var); td()->RegisterVariableForTesting(var);
@ -154,13 +154,13 @@ TEST_F(ValidatorTest, AssignIncompatibleTypes_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.3f)); create<ast::FloatLiteral>(Source{}, &f32, 2.3f));
ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs); ast::AssignmentStatement assign(Source{Source::Location{12, 34}}, lhs, rhs);
td()->RegisterVariableForTesting(var); td()->RegisterVariableForTesting(var);
@ -188,13 +188,13 @@ TEST_F(ValidatorTest, AssignCompatibleTypesInBlockStatement_Pass) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));
@ -223,12 +223,12 @@ TEST_F(ValidatorTest, AssignIncompatibleTypesInBlockStatement_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.3f)); create<ast::FloatLiteral>(Source{}, &f32, 2.3f));
ast::BlockStatement block; ast::BlockStatement block;
block.append(create<ast::VariableDeclStatement>(var)); block.append(create<ast::VariableDeclStatement>(var));
@ -324,14 +324,14 @@ TEST_F(ValidatorTest, UsingUndefinedVariableGlobalVariable_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.1)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.1)), // constructor
ast::VariableDecorationList{})); // decorations ast::VariableDecorationList{})); // decorations
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("not_global_var"), Source{Source::Location{12, 34}}, mod()->RegisterSymbol("not_global_var"),
"not_global_var"); "not_global_var");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f)); create<ast::FloatLiteral>(Source{}, &f32, 3.14f));
ast::VariableList params; ast::VariableList params;
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
@ -363,13 +363,13 @@ TEST_F(ValidatorTest, UsingUndefinedVariableGlobalVariable_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.1)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.1)), // constructor
ast::VariableDecorationList{})); // decorations ast::VariableDecorationList{})); // decorations
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = create<ast::IdentifierExpression>(
mod()->RegisterSymbol("global_var"), "global_var"); mod()->RegisterSymbol("global_var"), "global_var");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f)); create<ast::FloatLiteral>(Source{}, &f32, 3.14f));
ast::VariableList params; ast::VariableList params;
@ -402,19 +402,19 @@ TEST_F(ValidatorTest, UsingUndefinedVariableInnerScope_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a"); Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f)); create<ast::FloatLiteral>(Source{}, &f32, 3.14f));
auto* outer_body = create<ast::BlockStatement>(); auto* outer_body = create<ast::BlockStatement>();
outer_body->append( outer_body->append(
@ -442,17 +442,17 @@ TEST_F(ValidatorTest, UsingUndefinedVariableOuterScope_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a"); Source{Source::Location{12, 34}}, mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f)); create<ast::FloatLiteral>(Source{}, &f32, 3.14f));
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, lhs, rhs)); Source{Source::Location{12, 34}}, lhs, rhs));
@ -479,8 +479,8 @@ TEST_F(ValidatorTest, GlobalVariableUnique_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.1)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 0.1)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
mod()->AddGlobalVariable(var0); mod()->AddGlobalVariable(var0);
auto* var1 = create<ast::Variable>( auto* var1 = create<ast::Variable>(
@ -490,8 +490,8 @@ TEST_F(ValidatorTest, GlobalVariableUnique_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 0)), // constructor create<ast::SintLiteral>(Source{}, &i32, 0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
mod()->AddGlobalVariable(var1); mod()->AddGlobalVariable(var1);
EXPECT_TRUE(v()->ValidateGlobalVariables(mod()->global_variables())) EXPECT_TRUE(v()->ValidateGlobalVariables(mod()->global_variables()))
@ -510,8 +510,8 @@ TEST_F(ValidatorTest, GlobalVariableNotUnique_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.1)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 0.1)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
mod()->AddGlobalVariable(var0); mod()->AddGlobalVariable(var0);
auto* var1 = create<ast::Variable>( auto* var1 = create<ast::Variable>(
@ -521,8 +521,8 @@ TEST_F(ValidatorTest, GlobalVariableNotUnique_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 0)), // constructor create<ast::SintLiteral>(Source{}, &i32, 0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
mod()->AddGlobalVariable(var1); mod()->AddGlobalVariable(var1);
EXPECT_FALSE(v()->ValidateGlobalVariables(mod()->global_variables())); EXPECT_FALSE(v()->ValidateGlobalVariables(mod()->global_variables()));
@ -543,13 +543,13 @@ TEST_F(ValidatorTest, AssignToConstant_Fail) {
&i32, // type &i32, // type
true, // is_const true, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));
@ -580,8 +580,8 @@ TEST_F(ValidatorTest, GlobalVariableFunctionVariableNotUnique_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.1)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.1)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
mod()->AddGlobalVariable(global_var); mod()->AddGlobalVariable(global_var);
auto* var = create<ast::Variable>( auto* var = create<ast::Variable>(
@ -591,8 +591,8 @@ TEST_F(ValidatorTest, GlobalVariableFunctionVariableNotUnique_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::VariableList params; ast::VariableList params;
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>( body->append(create<ast::VariableDeclStatement>(
@ -624,8 +624,8 @@ TEST_F(ValidatorTest, RedeclaredIndentifier_Fail) {
&i32, // type &i32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), // constructor create<ast::SintLiteral>(Source{}, &i32, 2)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* var_a_float = create<ast::Variable>( auto* var_a_float = create<ast::Variable>(
Source{}, // source Source{}, // source
@ -634,8 +634,8 @@ TEST_F(ValidatorTest, RedeclaredIndentifier_Fail) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.1)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 0.1)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::VariableList params; ast::VariableList params;
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
@ -667,12 +667,12 @@ TEST_F(ValidatorTest, RedeclaredIdentifierInnerScope_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));
@ -683,8 +683,8 @@ TEST_F(ValidatorTest, RedeclaredIdentifierInnerScope_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 3.14)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* outer_body = create<ast::BlockStatement>(); auto* outer_body = create<ast::BlockStatement>();
outer_body->append( outer_body->append(
@ -711,8 +711,8 @@ TEST_F(ValidatorTest, DISABLED_RedeclaredIdentifierInnerScope_False) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 3.14)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* var = create<ast::Variable>( auto* var = create<ast::Variable>(
Source{}, // source Source{}, // source
@ -721,12 +721,12 @@ TEST_F(ValidatorTest, DISABLED_RedeclaredIdentifierInnerScope_False) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>( body->append(create<ast::VariableDeclStatement>(
Source{Source::Location{12, 34}}, var)); Source{Source::Location{12, 34}}, var));
@ -753,8 +753,8 @@ TEST_F(ValidatorTest, RedeclaredIdentifierDifferentFunctions_Pass) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* var1 = create<ast::Variable>( auto* var1 = create<ast::Variable>(
Source{}, // source Source{}, // source
@ -763,8 +763,8 @@ TEST_F(ValidatorTest, RedeclaredIdentifierDifferentFunctions_Pass) {
&void_type, // type &void_type, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 1.0)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
ast::VariableList params0; ast::VariableList params0;
auto* body0 = create<ast::BlockStatement>(); auto* body0 = create<ast::BlockStatement>();
@ -813,7 +813,7 @@ TEST_F(ValidatorTest, VariableDeclNoConstructor_Pass) {
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a"); create<ast::IdentifierExpression>(mod()->RegisterSymbol("a"), "a");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));

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

@ -779,7 +779,7 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& pre,
auto emit_vector_appended_with_i32_zero = [&](tint::ast::Expression* vector) { auto emit_vector_appended_with_i32_zero = [&](tint::ast::Expression* vector) {
auto* i32 = module_->create<ast::type::I32>(); auto* i32 = module_->create<ast::type::I32>();
ast::SintLiteral zero_lit(i32, 0); ast::SintLiteral zero_lit(Source{}, i32, 0);
ast::ScalarConstructorExpression zero(&zero_lit); ast::ScalarConstructorExpression zero(&zero_lit);
zero.set_result_type(i32); zero.set_result_type(i32);
return AppendVector(vector, &zero, return AppendVector(vector, &zero,

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

@ -31,7 +31,7 @@ using HlslGeneratorImplTest_Expression = TestHelper;
TEST_F(HlslGeneratorImplTest_Expression, EmitExpression_ArrayAccessor) { TEST_F(HlslGeneratorImplTest_Expression, EmitExpression_ArrayAccessor) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, 5); auto* lit = create<ast::SintLiteral>(Source{}, &i32, 5);
auto* idx = create<ast::ScalarConstructorExpression>(lit); auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* ary = auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary"); create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");

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

@ -193,15 +193,15 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorScalar) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
}); });
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs); ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs);
@ -217,15 +217,15 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarVector) {
ast::type::Vector vec3(&f32, 3); ast::type::Vector vec3(&f32, 3);
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals); auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals);
ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs); ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs);
@ -252,7 +252,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar) {
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat"); create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
td.RegisterVariableForTesting(var); td.RegisterVariableForTesting(var);
@ -276,7 +276,7 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
nullptr, // constructor nullptr, // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
auto* rhs = auto* rhs =
create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat"); create<ast::IdentifierExpression>(mod.RegisterSymbol("mat"), "mat");
@ -307,11 +307,11 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals); auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals);
td.RegisterVariableForTesting(var); td.RegisterVariableForTesting(var);
@ -339,11 +339,11 @@ TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals); auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals);
auto* rhs = auto* rhs =
@ -462,13 +462,13 @@ TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) {
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>( body->append(create<ast::ReturnStatement>(
Source{}, create<ast::ScalarConstructorExpression>( Source{}, create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
auto* else_stmt = create<ast::ElseStatement>(body); auto* else_stmt = create<ast::ElseStatement>(body);
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>( body->append(create<ast::ReturnStatement>(
Source{}, create<ast::ScalarConstructorExpression>( Source{}, create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* else_if_stmt = create<ast::ElseStatement>( auto* else_if_stmt = create<ast::ElseStatement>(
create<ast::BinaryExpression>( create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr, ast::BinaryOp::kLogicalOr,
@ -479,7 +479,7 @@ TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) {
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>( body->append(create<ast::ReturnStatement>(
Source{}, create<ast::ScalarConstructorExpression>( Source{}, create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
ast::IfStatement expr( ast::IfStatement expr(
Source{}, Source{},

10
src/writer/hlsl/generator_impl_case_test.cc
View File

@ -37,7 +37,7 @@ TEST_F(HlslGeneratorImplTest_Case, Emit_Case) {
body->append(create<ast::BreakStatement>()); body->append(create<ast::BreakStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();
@ -53,7 +53,7 @@ TEST_F(HlslGeneratorImplTest_Case, Emit_Case_BreaksByDefault) {
ast::type::I32 i32; ast::type::I32 i32;
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, create<ast::BlockStatement>()); ast::CaseStatement c(lit, create<ast::BlockStatement>());
gen.increment_indent(); gen.increment_indent();
@ -72,7 +72,7 @@ TEST_F(HlslGeneratorImplTest_Case, Emit_Case_WithFallthrough) {
body->append(create<ast::FallthroughStatement>()); body->append(create<ast::FallthroughStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();
@ -91,8 +91,8 @@ TEST_F(HlslGeneratorImplTest_Case, Emit_Case_MultipleSelectors) {
body->append(create<ast::BreakStatement>()); body->append(create<ast::BreakStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
lit.push_back(create<ast::SintLiteral>(&i32, 6)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 6));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();

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

@ -37,7 +37,7 @@ using HlslGeneratorImplTest_Constructor = TestHelper;
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Bool) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Bool) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* lit = create<ast::BoolLiteral>(&bool_type, false); auto* lit = create<ast::BoolLiteral>(Source{}, &bool_type, false);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
@ -46,7 +46,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Bool) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Int) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Int) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, -12345); auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
@ -55,7 +55,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Int) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_UInt) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_UInt) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lit = create<ast::UintLiteral>(&u32, 56779); auto* lit = create<ast::UintLiteral>(Source{}, &u32, 56779);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
@ -65,8 +65,8 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_UInt) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Float) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Float) {
ast::type::F32 f32; ast::type::F32 f32;
// Use a number close to 1<<30 but whose decimal representation ends in 0. // Use a number close to 1<<30 but whose decimal representation ends in 0.
auto* lit = auto* lit = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>((1 << 30) - 4)); static_cast<float>((1 << 30) - 4));
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(pre, out, &expr)) << gen.error();
@ -76,7 +76,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Float) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Float) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Float) {
ast::type::F32 f32; ast::type::F32 f32;
auto* lit = create<ast::FloatLiteral>(&f32, -1.2e-5); auto* lit = create<ast::FloatLiteral>(Source{}, &f32, -1.2e-5);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -89,7 +89,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Float) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Bool) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Bool) {
ast::type::Bool b; ast::type::Bool b;
auto* lit = create<ast::BoolLiteral>(&b, true); auto* lit = create<ast::BoolLiteral>(Source{}, &b, true);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -102,7 +102,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Bool) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Int) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Int) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, -12345); auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -115,7 +115,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Int) {
TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Uint) { TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Uint) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lit = create<ast::UintLiteral>(&u32, 12345); auto* lit = create<ast::UintLiteral>(Source{}, &u32, 12345);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -129,9 +129,9 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Vec) {
ast::type::F32 f32; ast::type::F32 f32;
ast::type::Vector vec(&f32, 3); ast::type::Vector vec(&f32, 3);
auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f); auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32, 1.f);
auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f); auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32, 2.f);
auto* lit3 = create<ast::FloatLiteral>(&f32, 3.f); auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32, 3.f);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
values.push_back(create<ast::ScalarConstructorExpression>(lit2)); values.push_back(create<ast::ScalarConstructorExpression>(lit2));
@ -165,12 +165,12 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Mat) {
ast::ExpressionList mat_values; ast::ExpressionList mat_values;
for (size_t i = 0; i < 2; i++) { for (size_t i = 0; i < 2; i++) {
auto* lit1 = auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 2))); static_cast<float>(1 + (i * 2)));
auto* lit2 = auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 2))); static_cast<float>(2 + (i * 2)));
auto* lit3 = auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 2))); static_cast<float>(3 + (i * 2)));
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
@ -198,12 +198,12 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Array) {
ast::ExpressionList ary_values; ast::ExpressionList ary_values;
for (size_t i = 0; i < 3; i++) { for (size_t i = 0; i < 3; i++) {
auto* lit1 = auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 3))); static_cast<float>(1 + (i * 3)));
auto* lit2 = auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 3))); static_cast<float>(2 + (i * 3)));
auto* lit3 = auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 3))); static_cast<float>(3 + (i * 3)));
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));

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

@ -606,7 +606,7 @@ TEST_F(HlslGeneratorImplTest_Function,
"coord"), "coord"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")), create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f))); create<ast::FloatLiteral>(Source{}, &f32, 2.0f)));
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(assign); body->append(assign);
@ -710,7 +710,7 @@ TEST_F(
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -798,7 +798,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -900,7 +900,7 @@ TEST_F(
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -990,7 +990,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
auto* var = auto* var =
create<ast::Variable>(Source{}, // source create<ast::Variable>(Source{}, // source
@ -1082,7 +1082,7 @@ TEST_F(HlslGeneratorImplTest_Function,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
auto* var = auto* var =
create<ast::Variable>(Source{}, // source create<ast::Variable>(Source{}, // source
@ -1150,18 +1150,19 @@ TEST_F(HlslGeneratorImplTest_Function,
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"), create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f))));
auto* list = create<ast::BlockStatement>(); auto* list = create<ast::BlockStatement>();
list->append(create<ast::ReturnStatement>(Source{})); list->append(create<ast::ReturnStatement>(Source{}));
body->append(create<ast::IfStatement>( body->append(create<ast::IfStatement>(
Source{}, Source{},
create<ast::BinaryExpression>(ast::BinaryOp::kEqual, create<ast::BinaryExpression>(
create<ast::ScalarConstructorExpression>( ast::BinaryOp::kEqual,
create<ast::SintLiteral>(&i32, 1)), create<ast::ScalarConstructorExpression>(
create<ast::ScalarConstructorExpression>( create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::SintLiteral>(&i32, 1))), create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(Source{}, &i32, 1))),
list, ast::ElseStatementList{})); list, ast::ElseStatementList{}));
body->append(create<ast::ReturnStatement>(Source{})); body->append(create<ast::ReturnStatement>(Source{}));

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

@ -54,7 +54,7 @@ TEST_P(HlslImportData_SingleParamTest, FloatScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* ident = create<ast::IdentifierExpression>( auto* ident = create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name); mod.RegisterSymbol(param.name), param.name);
@ -100,7 +100,7 @@ TEST_P(HlslImportData_SingleIntParamTest, IntScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -122,9 +122,9 @@ TEST_P(HlslImportData_DualParamTest, FloatScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f))); create<ast::FloatLiteral>(Source{}, &f32, 2.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -155,21 +155,21 @@ TEST_P(HlslImportData_DualParam_VectorTest, FloatVector) {
params.push_back(create<ast::TypeConstructorExpression>( params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f)), create<ast::FloatLiteral>(Source{}, &f32, 2.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.f)), create<ast::FloatLiteral>(Source{}, &f32, 3.f)),
})); }));
params.push_back(create<ast::TypeConstructorExpression>( params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 4.f)), create<ast::FloatLiteral>(Source{}, &f32, 4.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 5.f)), create<ast::FloatLiteral>(Source{}, &f32, 5.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 6.f)), create<ast::FloatLiteral>(Source{}, &f32, 6.f)),
})); }));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
@ -194,9 +194,9 @@ TEST_P(HlslImportData_DualParam_Int_Test, IntScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -219,11 +219,11 @@ TEST_P(HlslImportData_TripleParamTest, FloatScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f))); create<ast::FloatLiteral>(Source{}, &f32, 2.f)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.f))); create<ast::FloatLiteral>(Source{}, &f32, 3.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -253,11 +253,11 @@ TEST_P(HlslImportData_TripleParam_Int_Test, IntScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))); create<ast::SintLiteral>(Source{}, &i32, 3)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),

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

@ -153,8 +153,8 @@ TEST_F(HlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.4)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.4)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));

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

@ -519,9 +519,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
"data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")), create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
td.RegisterVariableForTesting(coord_var); td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var); gen.register_global(coord_var);
@ -573,7 +573,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"), create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")), create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
td.RegisterVariableForTesting(coord_var); td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var); gen.register_global(coord_var);
@ -629,11 +629,11 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::BinaryExpression>( create<ast::BinaryExpression>(
ast::BinaryOp::kAdd, ast::BinaryOp::kAdd,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), create<ast::SintLiteral>(Source{}, &i32, 2)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4))), create<ast::SintLiteral>(Source{}, &i32, 4))),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
td.RegisterVariableForTesting(coord_var); td.RegisterVariableForTesting(coord_var);
gen.register_global(coord_var); gen.register_global(coord_var);
@ -692,7 +692,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"), create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")); create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f)); create<ast::FloatLiteral>(Source{}, &f32, 2.0f));
ast::AssignmentStatement assign(lhs, rhs); ast::AssignmentStatement assign(lhs, rhs);
ASSERT_TRUE(td.DetermineResultType(&assign)); ASSERT_TRUE(td.DetermineResultType(&assign));
@ -747,9 +747,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"), create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")), create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
ast::AssignmentStatement assign(lhs, rhs); ast::AssignmentStatement assign(lhs, rhs);
ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
@ -804,7 +804,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"), create<ast::IdentifierExpression>(mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a")); create<ast::IdentifierExpression>(mod.RegisterSymbol("a"), "a"));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)); create<ast::SintLiteral>(Source{}, &i32, 2));
ast::AssignmentStatement assign(lhs, rhs); ast::AssignmentStatement assign(lhs, rhs);
ASSERT_TRUE(td.DetermineResultType(&assign)); ASSERT_TRUE(td.DetermineResultType(&assign));
@ -910,9 +910,9 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f); auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32, 1.f);
auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f); auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32, 2.f);
auto* lit3 = create<ast::FloatLiteral>(&f32, 3.f); auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32, 3.f);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
values.push_back(create<ast::ScalarConstructorExpression>(lit2)); values.push_back(create<ast::ScalarConstructorExpression>(lit2));
@ -1001,7 +1001,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
"data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")), create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")); create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
ASSERT_TRUE(td.DetermineResultType(&expr)); ASSERT_TRUE(td.DetermineResultType(&expr));
@ -1081,7 +1081,7 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")), "c")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")), create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("xy"), "xy")); create<ast::IdentifierExpression>(mod.RegisterSymbol("xy"), "xy"));
@ -1161,7 +1161,7 @@ TEST_F(
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")), "c")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")), create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("g"), "g")); create<ast::IdentifierExpression>(mod.RegisterSymbol("g"), "g"));
@ -1240,10 +1240,10 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")), "c")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")), create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
ASSERT_TRUE(td.DetermineResultType(&expr)); ASSERT_TRUE(td.DetermineResultType(&expr));
ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(pre, out, &expr)) << gen.error();
@ -1318,12 +1318,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
"data"), "data"),
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")), create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), "c")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")); create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b"));
auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f); auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32, 1.f);
auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f); auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32, 2.f);
auto* lit3 = create<ast::FloatLiteral>(&f32, 3.f); auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32, 3.f);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
values.push_back(create<ast::ScalarConstructorExpression>(lit2)); values.push_back(create<ast::ScalarConstructorExpression>(lit2));
@ -1410,12 +1410,12 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
create<ast::IdentifierExpression>(mod.RegisterSymbol("c"), create<ast::IdentifierExpression>(mod.RegisterSymbol("c"),
"c")), "c")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")), create<ast::IdentifierExpression>(mod.RegisterSymbol("b"), "b")),
create<ast::IdentifierExpression>(mod.RegisterSymbol("y"), "y")); create<ast::IdentifierExpression>(mod.RegisterSymbol("y"), "y"));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&i32, 1.f)); create<ast::FloatLiteral>(Source{}, &i32, 1.f));
ast::AssignmentStatement assign(lhs, rhs); ast::AssignmentStatement assign(lhs, rhs);

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

@ -38,11 +38,11 @@ TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_ModuleConstant) {
ast::ExpressionList exprs; ast::ExpressionList exprs;
exprs.push_back(create<ast::ScalarConstructorExpression>( exprs.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
exprs.push_back(create<ast::ScalarConstructorExpression>( exprs.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f))); create<ast::FloatLiteral>(Source{}, &f32, 2.0f)));
exprs.push_back(create<ast::ScalarConstructorExpression>( exprs.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* var = create<ast::Variable>( auto* var = create<ast::Variable>(
Source{}, // source Source{}, // source
@ -67,7 +67,7 @@ TEST_F(HlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) {
&f32, // type &f32, // type
true, // is_const true, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 3.0f)), // constructor
ast::VariableDecorationList{ ast::VariableDecorationList{
// decorations // decorations
create<ast::ConstantIdDecoration>(23, Source{}), create<ast::ConstantIdDecoration>(23, Source{}),

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

@ -37,7 +37,7 @@ TEST_F(HlslGeneratorImplTest_Switch, Emit_Switch) {
ast::type::I32 i32; ast::type::I32 i32;
ast::CaseSelectorList case_val; ast::CaseSelectorList case_val;
case_val.push_back(create<ast::SintLiteral>(&i32, 5)); case_val.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
auto* case_body = create<ast::BlockStatement>(); auto* case_body = create<ast::BlockStatement>();
case_body->append(create<ast::BreakStatement>()); case_body->append(create<ast::BreakStatement>());

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

@ -33,7 +33,7 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) { TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, 5); auto* lit = create<ast::SintLiteral>(Source{}, &i32, 5);
auto* idx = create<ast::ScalarConstructorExpression>(lit); auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* ary = auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary"); create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");

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

@ -39,7 +39,7 @@ TEST_F(MslGeneratorImplTest, Emit_Case) {
body->append(create<ast::BreakStatement>()); body->append(create<ast::BreakStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();
@ -55,7 +55,7 @@ TEST_F(MslGeneratorImplTest, Emit_Case_BreaksByDefault) {
ast::type::I32 i32; ast::type::I32 i32;
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, create<ast::BlockStatement>()); ast::CaseStatement c(lit, create<ast::BlockStatement>());
gen.increment_indent(); gen.increment_indent();
@ -74,7 +74,7 @@ TEST_F(MslGeneratorImplTest, Emit_Case_WithFallthrough) {
body->append(create<ast::FallthroughStatement>()); body->append(create<ast::FallthroughStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();
@ -93,8 +93,8 @@ TEST_F(MslGeneratorImplTest, Emit_Case_MultipleSelectors) {
body->append(create<ast::BreakStatement>()); body->append(create<ast::BreakStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
lit.push_back(create<ast::SintLiteral>(&i32, 6)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 6));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();

48
src/writer/msl/generator_impl_constructor_test.cc
View File

@ -39,7 +39,7 @@ using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) { TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* lit = create<ast::BoolLiteral>(&bool_type, false); auto* lit = create<ast::BoolLiteral>(Source{}, &bool_type, false);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -48,7 +48,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) {
TEST_F(MslGeneratorImplTest, EmitConstructor_Int) { TEST_F(MslGeneratorImplTest, EmitConstructor_Int) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, -12345); auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -57,7 +57,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Int) {
TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) { TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lit = create<ast::UintLiteral>(&u32, 56779); auto* lit = create<ast::UintLiteral>(Source{}, &u32, 56779);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -67,8 +67,8 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) {
TEST_F(MslGeneratorImplTest, EmitConstructor_Float) { TEST_F(MslGeneratorImplTest, EmitConstructor_Float) {
ast::type::F32 f32; ast::type::F32 f32;
// Use a number close to 1<<30 but whose decimal representation ends in 0. // Use a number close to 1<<30 but whose decimal representation ends in 0.
auto* lit = auto* lit = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>((1 << 30) - 4)); static_cast<float>((1 << 30) - 4));
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -78,7 +78,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Float) {
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) { TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) {
ast::type::F32 f32; ast::type::F32 f32;
auto* lit = create<ast::FloatLiteral>(&f32, -1.2e-5); auto* lit = create<ast::FloatLiteral>(Source{}, &f32, -1.2e-5);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -91,7 +91,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) {
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) { TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) {
ast::type::Bool b; ast::type::Bool b;
auto* lit = create<ast::BoolLiteral>(&b, true); auto* lit = create<ast::BoolLiteral>(Source{}, &b, true);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -104,7 +104,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) {
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) { TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, -12345); auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -117,7 +117,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) {
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Uint) { TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Uint) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lit = create<ast::UintLiteral>(&u32, 12345); auto* lit = create<ast::UintLiteral>(Source{}, &u32, 12345);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -131,9 +131,9 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Vec) {
ast::type::F32 f32; ast::type::F32 f32;
ast::type::Vector vec(&f32, 3); ast::type::Vector vec(&f32, 3);
auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f); auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32, 1.f);
auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f); auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32, 2.f);
auto* lit3 = create<ast::FloatLiteral>(&f32, 3.f); auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32, 3.f);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
values.push_back(create<ast::ScalarConstructorExpression>(lit2)); values.push_back(create<ast::ScalarConstructorExpression>(lit2));
@ -167,12 +167,12 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Mat) {
ast::ExpressionList mat_values; ast::ExpressionList mat_values;
for (size_t i = 0; i < 2; i++) { for (size_t i = 0; i < 2; i++) {
auto* lit1 = auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 2))); static_cast<float>(1 + (i * 2)));
auto* lit2 = auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 2))); static_cast<float>(2 + (i * 2)));
auto* lit3 = auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 2))); static_cast<float>(3 + (i * 2)));
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
@ -199,12 +199,12 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Array) {
ast::ExpressionList ary_values; ast::ExpressionList ary_values;
for (size_t i = 0; i < 3; i++) { for (size_t i = 0; i < 3; i++) {
auto* lit1 = auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 3))); static_cast<float>(1 + (i * 3)));
auto* lit2 = auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 3))); static_cast<float>(2 + (i * 3)));
auto* lit3 = auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 3))); static_cast<float>(3 + (i * 3)));
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));

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

@ -594,7 +594,7 @@ TEST_F(
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -685,7 +685,7 @@ TEST_F(MslGeneratorImplTest,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -791,7 +791,7 @@ TEST_F(
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
body = create<ast::BlockStatement>(); body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
@ -879,7 +879,7 @@ TEST_F(MslGeneratorImplTest,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
auto* var = auto* var =
create<ast::Variable>(Source{}, // source create<ast::Variable>(Source{}, // source
@ -985,7 +985,7 @@ TEST_F(MslGeneratorImplTest,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
auto* var = auto* var =
create<ast::Variable>(Source{}, // source create<ast::Variable>(Source{}, // source
@ -1097,7 +1097,7 @@ TEST_F(MslGeneratorImplTest,
ast::ExpressionList expr; ast::ExpressionList expr;
expr.push_back(create<ast::ScalarConstructorExpression>( expr.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
auto* var = auto* var =
create<ast::Variable>(Source{}, // source create<ast::Variable>(Source{}, // source
@ -1172,18 +1172,19 @@ TEST_F(MslGeneratorImplTest,
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"), create<ast::IdentifierExpression>(mod.RegisterSymbol("bar"), "bar"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f))));
auto* list = create<ast::BlockStatement>(); auto* list = create<ast::BlockStatement>();
list->append(create<ast::ReturnStatement>(Source{})); list->append(create<ast::ReturnStatement>(Source{}));
body->append(create<ast::IfStatement>( body->append(create<ast::IfStatement>(
Source{}, Source{},
create<ast::BinaryExpression>(ast::BinaryOp::kEqual, create<ast::BinaryExpression>(
create<ast::ScalarConstructorExpression>( ast::BinaryOp::kEqual,
create<ast::SintLiteral>(&i32, 1)), create<ast::ScalarConstructorExpression>(
create<ast::ScalarConstructorExpression>( create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::SintLiteral>(&i32, 1))), create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(Source{}, &i32, 1))),
list, ast::ElseStatementList{})); list, ast::ElseStatementList{}));
body->append(create<ast::ReturnStatement>(Source{})); body->append(create<ast::ReturnStatement>(Source{}));

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

@ -55,7 +55,7 @@ TEST_P(MslImportData_SingleParamTest, FloatScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* ident = create<ast::IdentifierExpression>( auto* ident = create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name); mod.RegisterSymbol(param.name), param.name);
@ -99,7 +99,7 @@ TEST_F(MslGeneratorImplTest, MslImportData_SingleParamTest_IntScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
ast::CallExpression expr( ast::CallExpression expr(
create<ast::IdentifierExpression>(mod.RegisterSymbol("abs"), "abs"), create<ast::IdentifierExpression>(mod.RegisterSymbol("abs"), "abs"),
@ -119,9 +119,9 @@ TEST_P(MslImportData_DualParamTest, FloatScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f))); create<ast::FloatLiteral>(Source{}, &f32, 2.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -155,21 +155,21 @@ TEST_P(MslImportData_DualParam_VectorTest, FloatVector) {
params.push_back(create<ast::TypeConstructorExpression>( params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f)), create<ast::FloatLiteral>(Source{}, &f32, 2.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.f)), create<ast::FloatLiteral>(Source{}, &f32, 3.f)),
})); }));
params.push_back(create<ast::TypeConstructorExpression>( params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 4.f)), create<ast::FloatLiteral>(Source{}, &f32, 4.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 5.f)), create<ast::FloatLiteral>(Source{}, &f32, 5.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 6.f)), create<ast::FloatLiteral>(Source{}, &f32, 6.f)),
})); }));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
@ -194,9 +194,9 @@ TEST_P(MslImportData_DualParam_Int_Test, IntScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -219,11 +219,11 @@ TEST_P(MslImportData_TripleParamTest, FloatScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f))); create<ast::FloatLiteral>(Source{}, &f32, 2.f)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.f))); create<ast::FloatLiteral>(Source{}, &f32, 3.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),
@ -251,11 +251,11 @@ TEST_P(MslImportData_TripleParam_Int_Test, IntScalar) {
ast::ExpressionList params; ast::ExpressionList params;
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
params.push_back(create<ast::ScalarConstructorExpression>( params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))); create<ast::SintLiteral>(Source{}, &i32, 3)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod.RegisterSymbol(param.name), param.name), mod.RegisterSymbol(param.name), param.name),

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

@ -158,8 +158,8 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithVarUsedInContinuing) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.4)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.4)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>(); auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(var)); body->append(create<ast::VariableDeclStatement>(var));

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

@ -40,11 +40,11 @@ TEST_F(MslGeneratorImplTest, Emit_ModuleConstant) {
ast::ExpressionList exprs; ast::ExpressionList exprs;
exprs.push_back(create<ast::ScalarConstructorExpression>( exprs.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
exprs.push_back(create<ast::ScalarConstructorExpression>( exprs.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f))); create<ast::FloatLiteral>(Source{}, &f32, 2.0f)));
exprs.push_back(create<ast::ScalarConstructorExpression>( exprs.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* var = create<ast::Variable>( auto* var = create<ast::Variable>(
Source{}, // source Source{}, // source
@ -69,7 +69,7 @@ TEST_F(MslGeneratorImplTest, Emit_SpecConstant) {
&f32, // type &f32, // type
true, // is_const true, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 3.0f)), // constructor
ast::VariableDecorationList{ ast::VariableDecorationList{
// decorations // decorations
create<ast::ConstantIdDecoration>(23, Source{}), create<ast::ConstantIdDecoration>(23, Source{}),

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

@ -39,7 +39,7 @@ TEST_F(MslGeneratorImplTest, Emit_Switch) {
ast::type::I32 i32; ast::type::I32 i32;
ast::CaseSelectorList case_val; ast::CaseSelectorList case_val;
case_val.push_back(create<ast::SintLiteral>(&i32, 5)); case_val.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
auto* case_body = create<ast::BlockStatement>(); auto* case_body = create<ast::BlockStatement>();
case_body->append(create<ast::BreakStatement>()); case_body->append(create<ast::BreakStatement>());

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

@ -376,7 +376,7 @@ void Builder::GenerateLabel(uint32_t id) {
uint32_t Builder::GenerateU32Literal(uint32_t val) { uint32_t Builder::GenerateU32Literal(uint32_t val) {
ast::type::U32 u32; ast::type::U32 u32;
ast::SintLiteral lit(&u32, val); ast::SintLiteral lit(Source{}, &u32, val);
return GenerateLiteralIfNeeded(nullptr, &lit); return GenerateLiteralIfNeeded(nullptr, &lit);
} }
@ -640,7 +640,7 @@ bool Builder::GenerateFunctionVariable(ast::Variable* var) {
// TODO(dsinclair) We could detect if the constructor is fully const and emit // TODO(dsinclair) We could detect if the constructor is fully const and emit
// an initializer value for the variable instead of doing the OpLoad. // an initializer value for the variable instead of doing the OpLoad.
ast::NullLiteral nl(var->type()->UnwrapPtrIfNeeded()); ast::NullLiteral nl(Source{}, var->type()->UnwrapPtrIfNeeded());
auto null_id = GenerateLiteralIfNeeded(var, &nl); auto null_id = GenerateLiteralIfNeeded(var, &nl);
if (null_id == 0) { if (null_id == 0) {
return 0; return 0;
@ -741,16 +741,16 @@ bool Builder::GenerateGlobalVariable(ast::Variable* var) {
// then WGSL requires an initializer. // then WGSL requires an initializer.
if (var->HasConstantIdDecoration()) { if (var->HasConstantIdDecoration()) {
if (type->Is<ast::type::F32>()) { if (type->Is<ast::type::F32>()) {
ast::FloatLiteral l(type, 0.0f); ast::FloatLiteral l(Source{}, type, 0.0f);
init_id = GenerateLiteralIfNeeded(var, &l); init_id = GenerateLiteralIfNeeded(var, &l);
} else if (type->Is<ast::type::U32>()) { } else if (type->Is<ast::type::U32>()) {
ast::UintLiteral l(type, 0); ast::UintLiteral l(Source{}, type, 0);
init_id = GenerateLiteralIfNeeded(var, &l); init_id = GenerateLiteralIfNeeded(var, &l);
} else if (type->Is<ast::type::I32>()) { } else if (type->Is<ast::type::I32>()) {
ast::SintLiteral l(type, 0); ast::SintLiteral l(Source{}, type, 0);
init_id = GenerateLiteralIfNeeded(var, &l); init_id = GenerateLiteralIfNeeded(var, &l);
} else if (type->Is<ast::type::Bool>()) { } else if (type->Is<ast::type::Bool>()) {
ast::BoolLiteral l(type, false); ast::BoolLiteral l(Source{}, type, false);
init_id = GenerateLiteralIfNeeded(var, &l); init_id = GenerateLiteralIfNeeded(var, &l);
} else { } else {
error_ = "invalid type for constant_id, must be scalar"; error_ = "invalid type for constant_id, must be scalar";
@ -763,7 +763,7 @@ bool Builder::GenerateGlobalVariable(ast::Variable* var) {
} else if (var->storage_class() == ast::StorageClass::kPrivate || } else if (var->storage_class() == ast::StorageClass::kPrivate ||
var->storage_class() == ast::StorageClass::kNone || var->storage_class() == ast::StorageClass::kNone ||
var->storage_class() == ast::StorageClass::kOutput) { var->storage_class() == ast::StorageClass::kOutput) {
ast::NullLiteral nl(type); ast::NullLiteral nl(Source{}, type);
init_id = GenerateLiteralIfNeeded(var, &nl); init_id = GenerateLiteralIfNeeded(var, &nl);
if (init_id == 0) { if (init_id == 0) {
return 0; return 0;
@ -1015,7 +1015,7 @@ uint32_t Builder::GenerateAccessorExpression(ast::Expression* expr) {
auto ary_result = result_op(); auto ary_result = result_op();
ast::NullLiteral nl(ary_res_type); ast::NullLiteral nl(Source{}, ary_res_type);
auto init = GenerateLiteralIfNeeded(nullptr, &nl); auto init = GenerateLiteralIfNeeded(nullptr, &nl);
// If we're access chaining into an array then we must be in a function // If we're access chaining into an array then we must be in a function
@ -1220,7 +1220,7 @@ uint32_t Builder::GenerateTypeConstructorExpression(
// Generate the zero initializer if there are no values provided. // Generate the zero initializer if there are no values provided.
if (values.empty()) { if (values.empty()) {
ast::NullLiteral nl(init->type()->UnwrapPtrIfNeeded()); ast::NullLiteral nl(Source{}, init->type()->UnwrapPtrIfNeeded());
return GenerateLiteralIfNeeded(nullptr, &nl); return GenerateLiteralIfNeeded(nullptr, &nl);
} }
@ -2053,7 +2053,7 @@ void Builder::GenerateTextureIntrinsic(ast::IdentifierExpression* ident,
spirv_params.emplace_back(gen_param(pidx.depth_ref)); spirv_params.emplace_back(gen_param(pidx.depth_ref));
ast::type::F32 f32; ast::type::F32 f32;
ast::FloatLiteral float_0(&f32, 0.0); ast::FloatLiteral float_0(Source{}, &f32, 0.0);
image_operands.emplace_back(ImageOperand{ image_operands.emplace_back(ImageOperand{
SpvImageOperandsLodMask, SpvImageOperandsLodMask,
Operand::Int(GenerateLiteralIfNeeded(nullptr, &float_0))}); Operand::Int(GenerateLiteralIfNeeded(nullptr, &float_0))});

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

@ -59,7 +59,7 @@ TEST_F(BuilderTest, ArrayAccessor) {
auto* ary = auto* ary =
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"); create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
auto* idx_expr = create<ast::ScalarConstructorExpression>( auto* idx_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)); create<ast::SintLiteral>(Source{}, &i32, 1));
ast::ArrayAccessorExpression expr(ary, idx_expr); ast::ArrayAccessorExpression expr(ary, idx_expr);
@ -152,12 +152,12 @@ TEST_F(BuilderTest, ArrayAccessor_Dynamic) {
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"); create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary");
ast::ArrayAccessorExpression expr( ast::ArrayAccessorExpression expr(
ary, ary, create<ast::BinaryExpression>(
create<ast::BinaryExpression>(ast::BinaryOp::kAdd, ast::BinaryOp::kAdd,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -201,9 +201,9 @@ TEST_F(BuilderTest, ArrayAccessor_MultiLevel) {
create<ast::ArrayAccessorExpression>( create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"), create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3))), create<ast::SintLiteral>(Source{}, &i32, 3))),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -249,7 +249,7 @@ TEST_F(BuilderTest, Accessor_ArrayWithSwizzle) {
create<ast::ArrayAccessorExpression>( create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"), create<ast::IdentifierExpression>(mod->RegisterSymbol("ary"), "ary"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod->RegisterSymbol("xy"), "xy")); create<ast::IdentifierExpression>(mod->RegisterSymbol("xy"), "xy"));
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);
@ -492,7 +492,7 @@ TEST_F(BuilderTest, MemberAccessor_Nested_Assignment_LHS) {
create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a")); create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.f)); create<ast::FloatLiteral>(Source{}, &f32, 2.f));
ast::AssignmentStatement expr(lhs, rhs); ast::AssignmentStatement expr(lhs, rhs);
@ -766,7 +766,7 @@ TEST_F(BuilderTest, MemberAccessor_Array_of_Swizzle) {
"ident"), "ident"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")), create<ast::IdentifierExpression>(mod->RegisterSymbol("yxz"), "yxz")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -840,11 +840,11 @@ TEST_F(BuilderTest, Accessor_Mixed_ArrayAndMember) {
create<ast::IdentifierExpression>( create<ast::IdentifierExpression>(
mod->RegisterSymbol("index"), "index"), mod->RegisterSymbol("index"), "index"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 0))), create<ast::SintLiteral>(Source{}, &i32, 0))),
create<ast::IdentifierExpression>( create<ast::IdentifierExpression>(
mod->RegisterSymbol("foo"), "foo")), mod->RegisterSymbol("foo"), "foo")),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))), create<ast::SintLiteral>(Source{}, &i32, 2))),
create<ast::IdentifierExpression>(mod->RegisterSymbol("bar"), create<ast::IdentifierExpression>(mod->RegisterSymbol("bar"),
"bar")), "bar")),
create<ast::IdentifierExpression>(mod->RegisterSymbol("baz"), "baz")), create<ast::IdentifierExpression>(mod->RegisterSymbol("baz"), "baz")),
@ -903,25 +903,25 @@ TEST_F(BuilderTest, Accessor_Array_Of_Vec) {
ary_params.push_back(create<ast::TypeConstructorExpression>( ary_params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.0)), create<ast::FloatLiteral>(Source{}, &f32, 0.0)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.5)), create<ast::FloatLiteral>(Source{}, &f32, 0.5)),
})); }));
ary_params.push_back(create<ast::TypeConstructorExpression>( ary_params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, -0.5)), create<ast::FloatLiteral>(Source{}, &f32, -0.5)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, -0.5)), create<ast::FloatLiteral>(Source{}, &f32, -0.5)),
})); }));
ary_params.push_back(create<ast::TypeConstructorExpression>( ary_params.push_back(create<ast::TypeConstructorExpression>(
&vec, ast::ExpressionList{ &vec, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.5)), create<ast::FloatLiteral>(Source{}, &f32, 0.5)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, -0.5)), create<ast::FloatLiteral>(Source{}, &f32, -0.5)),
})); }));
ast::Variable var(Source{}, "pos", ast::StorageClass::kPrivate, &arr, true, ast::Variable var(Source{}, "pos", ast::StorageClass::kPrivate, &arr, true,
@ -931,7 +931,7 @@ TEST_F(BuilderTest, Accessor_Array_Of_Vec) {
ast::ArrayAccessorExpression expr( ast::ArrayAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"), create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1))); create<ast::UintLiteral>(Source{}, &u32, 1)));
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error(); ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error();
@ -977,9 +977,9 @@ TEST_F(BuilderTest, Accessor_Const_Vec) {
ast::ExpressionList vec_params; ast::ExpressionList vec_params;
vec_params.push_back(create<ast::ScalarConstructorExpression>( vec_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.0))); create<ast::FloatLiteral>(Source{}, &f32, 0.0)));
vec_params.push_back(create<ast::ScalarConstructorExpression>( vec_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.5))); create<ast::FloatLiteral>(Source{}, &f32, 0.5)));
ast::Variable var( ast::Variable var(
Source{}, "pos", ast::StorageClass::kPrivate, &vec, true, Source{}, "pos", ast::StorageClass::kPrivate, &vec, true,
@ -989,7 +989,7 @@ TEST_F(BuilderTest, Accessor_Const_Vec) {
ast::ArrayAccessorExpression expr( ast::ArrayAccessorExpression expr(
create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"), create<ast::IdentifierExpression>(mod->RegisterSymbol("pos"), "pos"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1))); create<ast::UintLiteral>(Source{}, &u32, 1)));
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);
ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error(); ASSERT_TRUE(td.DetermineResultType(var.constructor())) << td.error();

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

@ -50,7 +50,7 @@ TEST_F(BuilderTest, Assign_Var) {
auto* ident = auto* ident =
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"); create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var");
auto* val = create<ast::ScalarConstructorExpression>( auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)); create<ast::FloatLiteral>(Source{}, &f32, 1.0f));
ast::AssignmentStatement assign(ident, val); ast::AssignmentStatement assign(ident, val);
@ -120,16 +120,16 @@ TEST_F(BuilderTest, Assign_Var_Complex_ConstructorWithExtract) {
auto* first = create<ast::TypeConstructorExpression>( auto* first = create<ast::TypeConstructorExpression>(
&vec2, ast::ExpressionList{ &vec2, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)), create<ast::FloatLiteral>(Source{}, &f32, 1.0f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f)), create<ast::FloatLiteral>(Source{}, &f32, 2.0f)),
}); });
auto* init = create<ast::TypeConstructorExpression>( auto* init = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
first, first,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f)), create<ast::FloatLiteral>(Source{}, &f32, 3.0f)),
}); });
ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false, ast::Variable v(Source{}, "var", ast::StorageClass::kOutput, &vec3, false,
@ -174,11 +174,11 @@ TEST_F(BuilderTest, Assign_Var_Complex_Constructor) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f))); create<ast::FloatLiteral>(Source{}, &f32, 2.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec3, vals); auto* init = create<ast::TypeConstructorExpression>(&vec3, vals);
@ -239,7 +239,7 @@ TEST_F(BuilderTest, Assign_StructMember) {
create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b")); create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"));
auto* val = create<ast::ScalarConstructorExpression>( auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 4.0f)); create<ast::FloatLiteral>(Source{}, &f32, 4.0f));
ast::AssignmentStatement assign(ident, val); ast::AssignmentStatement assign(ident, val);
@ -282,11 +282,11 @@ TEST_F(BuilderTest, Assign_Vector) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* val = create<ast::TypeConstructorExpression>(&vec3, vals); auto* val = create<ast::TypeConstructorExpression>(&vec3, vals);
@ -330,7 +330,7 @@ TEST_F(BuilderTest, Assign_Vector_MemberByName) {
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"), create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::IdentifierExpression>(mod->RegisterSymbol("y"), "y")); create<ast::IdentifierExpression>(mod->RegisterSymbol("y"), "y"));
auto* val = create<ast::ScalarConstructorExpression>( auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)); create<ast::FloatLiteral>(Source{}, &f32, 1.0f));
ast::AssignmentStatement assign(ident, val); ast::AssignmentStatement assign(ident, val);
@ -375,9 +375,9 @@ TEST_F(BuilderTest, Assign_Vector_MemberByIndex) {
auto* ident = create<ast::ArrayAccessorExpression>( auto* ident = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"), create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
auto* val = create<ast::ScalarConstructorExpression>( auto* val = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)); create<ast::FloatLiteral>(Source{}, &f32, 1.0f));
ast::AssignmentStatement assign(ident, val); ast::AssignmentStatement assign(ident, val);

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

@ -57,9 +57,9 @@ TEST_P(BinaryArithSignedIntegerTest, Scalar) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)); create<ast::SintLiteral>(Source{}, &i32, 3));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4)); create<ast::SintLiteral>(Source{}, &i32, 4));
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -84,21 +84,21 @@ TEST_P(BinaryArithSignedIntegerTest, Vector) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
}); });
auto* rhs = create<ast::TypeConstructorExpression>( auto* rhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
}); });
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -175,9 +175,9 @@ TEST_P(BinaryArithUnsignedIntegerTest, Scalar) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3)); create<ast::UintLiteral>(Source{}, &u32, 3));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 4)); create<ast::UintLiteral>(Source{}, &u32, 4));
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -202,21 +202,21 @@ TEST_P(BinaryArithUnsignedIntegerTest, Vector) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
}); });
auto* rhs = create<ast::TypeConstructorExpression>( auto* rhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
}); });
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -256,9 +256,9 @@ TEST_P(BinaryArithFloatTest, Scalar) {
ast::type::F32 f32; ast::type::F32 f32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.2f)); create<ast::FloatLiteral>(Source{}, &f32, 3.2f));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 4.5f)); create<ast::FloatLiteral>(Source{}, &f32, 4.5f));
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -283,21 +283,21 @@ TEST_P(BinaryArithFloatTest, Vector) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
}); });
auto* rhs = create<ast::TypeConstructorExpression>( auto* rhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
}); });
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -331,9 +331,9 @@ TEST_P(BinaryCompareUnsignedIntegerTest, Scalar) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3)); create<ast::UintLiteral>(Source{}, &u32, 3));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 4)); create<ast::UintLiteral>(Source{}, &u32, 4));
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -360,21 +360,21 @@ TEST_P(BinaryCompareUnsignedIntegerTest, Vector) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
}); });
auto* rhs = create<ast::TypeConstructorExpression>( auto* rhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1)), create<ast::UintLiteral>(Source{}, &u32, 1)),
}); });
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -412,9 +412,9 @@ TEST_P(BinaryCompareSignedIntegerTest, Scalar) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)); create<ast::SintLiteral>(Source{}, &i32, 3));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4)); create<ast::SintLiteral>(Source{}, &i32, 4));
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -441,21 +441,21 @@ TEST_P(BinaryCompareSignedIntegerTest, Vector) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
}); });
auto* rhs = create<ast::TypeConstructorExpression>( auto* rhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
}); });
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -493,9 +493,9 @@ TEST_P(BinaryCompareFloatTest, Scalar) {
ast::type::F32 f32; ast::type::F32 f32;
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.2f)); create<ast::FloatLiteral>(Source{}, &f32, 3.2f));
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 4.5f)); create<ast::FloatLiteral>(Source{}, &f32, 4.5f));
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -522,21 +522,21 @@ TEST_P(BinaryCompareFloatTest, Vector) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
}); });
auto* rhs = create<ast::TypeConstructorExpression>( auto* rhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
}); });
ast::BinaryExpression expr(param.op, lhs, rhs); ast::BinaryExpression expr(param.op, lhs, rhs);
@ -574,15 +574,15 @@ TEST_F(BuilderTest, Binary_Multiply_VectorScalar) {
auto* lhs = create<ast::TypeConstructorExpression>( auto* lhs = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)), create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
}); });
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs); ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs);
@ -605,15 +605,15 @@ TEST_F(BuilderTest, Binary_Multiply_ScalarVector) {
ast::type::Vector vec3(&f32, 3); ast::type::Vector vec3(&f32, 3);
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals); auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals);
ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs); ast::BinaryExpression expr(ast::BinaryOp::kMultiply, lhs, rhs);
@ -647,7 +647,7 @@ TEST_F(BuilderTest, Binary_Multiply_MatrixScalar) {
auto* lhs = auto* lhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat"); create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
auto* rhs = create<ast::ScalarConstructorExpression>( auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
td.RegisterVariableForTesting(var); td.RegisterVariableForTesting(var);
@ -685,7 +685,7 @@ TEST_F(BuilderTest, Binary_Multiply_ScalarMatrix) {
nullptr, // constructor nullptr, // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::ScalarConstructorExpression>( auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f)); create<ast::FloatLiteral>(Source{}, &f32, 1.f));
auto* rhs = auto* rhs =
create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat"); create<ast::IdentifierExpression>(mod->RegisterSymbol("mat"), "mat");
@ -730,11 +730,11 @@ TEST_F(BuilderTest, Binary_Multiply_MatrixVector) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals); auto* rhs = create<ast::TypeConstructorExpression>(&vec3, vals);
td.RegisterVariableForTesting(var); td.RegisterVariableForTesting(var);
@ -777,11 +777,11 @@ TEST_F(BuilderTest, Binary_Multiply_VectorMatrix) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals); auto* lhs = create<ast::TypeConstructorExpression>(&vec3, vals);
auto* rhs = auto* rhs =
@ -855,19 +855,19 @@ TEST_F(BuilderTest, Binary_Multiply_MatrixMatrix) {
TEST_F(BuilderTest, Binary_LogicalAnd) { TEST_F(BuilderTest, Binary_LogicalAnd) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lhs = auto* lhs = create<ast::BinaryExpression>(
create<ast::BinaryExpression>(ast::BinaryOp::kEqual, ast::BinaryOp::kEqual,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
auto* rhs = auto* rhs = create<ast::BinaryExpression>(
create<ast::BinaryExpression>(ast::BinaryOp::kEqual, ast::BinaryOp::kEqual,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)), create<ast::SintLiteral>(Source{}, &i32, 3)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4))); create<ast::SintLiteral>(Source{}, &i32, 4)));
ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, lhs, rhs); ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, lhs, rhs);
@ -907,17 +907,17 @@ TEST_F(BuilderTest, Binary_LogicalAnd_WithLoads) {
&bool_type, // type &bool_type, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)), // constructor create<ast::BoolLiteral>(Source{}, &bool_type, true)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* b_var = create<ast::Variable>( auto* b_var = create<ast::Variable>(
Source{}, // source Source{}, // source
"b", // name "b", // name
ast::StorageClass::kFunction, // storage_class ast::StorageClass::kFunction, // storage_class
&bool_type, // type &bool_type, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(create<ast::BoolLiteral>(
create<ast::BoolLiteral>(&bool_type, false)), // constructor Source{}, &bool_type, false)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"); auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a");
auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"); auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b");
@ -966,14 +966,15 @@ TEST_F(BuilderTest, Binary_logicalOr_Nested_LogicalAnd) {
auto* logical_and_expr = create<ast::BinaryExpression>( auto* logical_and_expr = create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd, ast::BinaryOp::kLogicalAnd,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_ty, true)), create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_ty, false))); create<ast::BoolLiteral>(Source{}, &bool_ty, false)));
ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, ast::BinaryExpression expr(
create<ast::ScalarConstructorExpression>( ast::BinaryOp::kLogicalOr,
create<ast::BoolLiteral>(&bool_ty, true)), create<ast::ScalarConstructorExpression>(
logical_and_expr); create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
logical_and_expr);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -1012,14 +1013,15 @@ TEST_F(BuilderTest, Binary_logicalAnd_Nested_LogicalOr) {
auto* logical_or_expr = create<ast::BinaryExpression>( auto* logical_or_expr = create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr, ast::BinaryOp::kLogicalOr,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_ty, true)), create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_ty, false))); create<ast::BoolLiteral>(Source{}, &bool_ty, false)));
ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, ast::BinaryExpression expr(
create<ast::ScalarConstructorExpression>( ast::BinaryOp::kLogicalAnd,
create<ast::BoolLiteral>(&bool_ty, true)), create<ast::ScalarConstructorExpression>(
logical_or_expr); create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
logical_or_expr);
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -1051,19 +1053,19 @@ OpBranch %4
TEST_F(BuilderTest, Binary_LogicalOr) { TEST_F(BuilderTest, Binary_LogicalOr) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lhs = auto* lhs = create<ast::BinaryExpression>(
create<ast::BinaryExpression>(ast::BinaryOp::kEqual, ast::BinaryOp::kEqual,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)), create<ast::SintLiteral>(Source{}, &i32, 1)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2))); create<ast::SintLiteral>(Source{}, &i32, 2)));
auto* rhs = auto* rhs = create<ast::BinaryExpression>(
create<ast::BinaryExpression>(ast::BinaryOp::kEqual, ast::BinaryOp::kEqual,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)), create<ast::SintLiteral>(Source{}, &i32, 3)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4))); create<ast::SintLiteral>(Source{}, &i32, 4)));
ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, lhs, rhs); ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, lhs, rhs);
@ -1103,17 +1105,17 @@ TEST_F(BuilderTest, Binary_LogicalOr_WithLoads) {
&bool_type, // type &bool_type, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)), // constructor create<ast::BoolLiteral>(Source{}, &bool_type, true)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* b_var = create<ast::Variable>( auto* b_var = create<ast::Variable>(
Source{}, // source Source{}, // source
"b", // name "b", // name
ast::StorageClass::kFunction, // storage_class ast::StorageClass::kFunction, // storage_class
&bool_type, // type &bool_type, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(create<ast::BoolLiteral>(
create<ast::BoolLiteral>(&bool_type, false)), // constructor Source{}, &bool_type, false)), // constructor
ast::VariableDecorationList{}); // decorations ast::VariableDecorationList{}); // decorations
auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a"); auto* lhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("a"), "a");
auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b"); auto* rhs = create<ast::IdentifierExpression>(mod->RegisterSymbol("b"), "b");

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

@ -35,9 +35,9 @@ TEST_F(BuilderTest, Bitcast) {
ast::type::U32 u32; ast::type::U32 u32;
ast::type::F32 f32; ast::type::F32 f32;
ast::BitcastExpression bitcast(&u32, ast::BitcastExpression bitcast(
create<ast::ScalarConstructorExpression>( &u32, create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.4))); create<ast::FloatLiteral>(Source{}, &f32, 2.4)));
ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error();
@ -56,9 +56,9 @@ TEST_F(BuilderTest, Bitcast) {
TEST_F(BuilderTest, Bitcast_DuplicateType) { TEST_F(BuilderTest, Bitcast_DuplicateType) {
ast::type::F32 f32; ast::type::F32 f32;
ast::BitcastExpression bitcast(&f32, ast::BitcastExpression bitcast(
create<ast::ScalarConstructorExpression>( &f32, create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.4))); create<ast::FloatLiteral>(Source{}, &f32, 2.4)));
ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error();

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

@ -52,7 +52,7 @@ TEST_F(BuilderTest, Block) {
outer.append(create<ast::AssignmentStatement>( outer.append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"), create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f))));
auto* inner = create<ast::BlockStatement>(); auto* inner = create<ast::BlockStatement>();
inner->append(create<ast::VariableDeclStatement>( inner->append(create<ast::VariableDeclStatement>(
@ -66,13 +66,13 @@ TEST_F(BuilderTest, Block) {
inner->append(create<ast::AssignmentStatement>( inner->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"), create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f)))); create<ast::FloatLiteral>(Source{}, &f32, 2.0f))));
outer.append(inner); outer.append(inner);
outer.append(create<ast::AssignmentStatement>( outer.append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"), create<ast::IdentifierExpression>(mod->RegisterSymbol("var"), "var"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f)))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f))));
ASSERT_TRUE(td.DetermineResultType(&outer)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&outer)) << td.error();

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

@ -77,9 +77,9 @@ TEST_F(BuilderTest, Expression_Call) {
ast::ExpressionList call_params; ast::ExpressionList call_params;
call_params.push_back(create<ast::ScalarConstructorExpression>( call_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
call_params.push_back(create<ast::ScalarConstructorExpression>( call_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
ast::CallExpression expr(create<ast::IdentifierExpression>( ast::CallExpression expr(create<ast::IdentifierExpression>(
mod->RegisterSymbol("a_func"), "a_func"), mod->RegisterSymbol("a_func"), "a_func"),
@ -159,9 +159,9 @@ TEST_F(BuilderTest, Statement_Call) {
ast::ExpressionList call_params; ast::ExpressionList call_params;
call_params.push_back(create<ast::ScalarConstructorExpression>( call_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
call_params.push_back(create<ast::ScalarConstructorExpression>( call_params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.f))); create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
ast::CallStatement expr( ast::CallStatement expr(
create<ast::CallExpression>(create<ast::IdentifierExpression>( create<ast::CallExpression>(create<ast::IdentifierExpression>(

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

@ -70,11 +70,11 @@ TEST_F(BuilderTest, FunctionVar_WithConstantConstructor) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);
@ -110,16 +110,16 @@ TEST_F(BuilderTest, FunctionVar_WithNonConstantConstructor) {
ast::type::F32 f32; ast::type::F32 f32;
ast::type::Vector vec(&f32, 2); ast::type::Vector vec(&f32, 2);
auto* rel = auto* rel = create<ast::BinaryExpression>(
create<ast::BinaryExpression>(ast::BinaryOp::kAdd, ast::BinaryOp::kAdd,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f)), create<ast::FloatLiteral>(Source{}, &f32, 3.0f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(rel); vals.push_back(rel);
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);
@ -160,7 +160,7 @@ TEST_F(BuilderTest, FunctionVar_WithNonConstantConstructorLoadedFromVar) {
ast::type::F32 f32; ast::type::F32 f32;
auto* init = create<ast::ScalarConstructorExpression>( auto* init = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)); create<ast::FloatLiteral>(Source{}, &f32, 1.0f));
ASSERT_TRUE(td.DetermineResultType(init)) << td.error(); ASSERT_TRUE(td.DetermineResultType(init)) << td.error();
@ -207,7 +207,7 @@ TEST_F(BuilderTest, FunctionVar_ConstWithVarInitializer) {
ast::type::F32 f32; ast::type::F32 f32;
auto* init = create<ast::ScalarConstructorExpression>( auto* init = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)); create<ast::FloatLiteral>(Source{}, &f32, 1.0f));
EXPECT_TRUE(td.DetermineResultType(init)) << td.error(); EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
@ -250,11 +250,11 @@ TEST_F(BuilderTest, FunctionVar_Const) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);

28
src/writer/spirv/builder_global_variable_test.cc
View File

@ -99,11 +99,11 @@ TEST_F(BuilderTest, GlobalVar_WithConstructor) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);
@ -135,11 +135,11 @@ TEST_F(BuilderTest, GlobalVar_Const) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);
@ -168,11 +168,11 @@ TEST_F(BuilderTest, GlobalVar_Complex_Constructor) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f))); create<ast::FloatLiteral>(Source{}, &f32, 2.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec3, vals); auto* init = create<ast::TypeConstructorExpression>(&vec3, vals);
EXPECT_TRUE(td.DetermineResultType(init)) << td.error(); EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
@ -201,16 +201,16 @@ TEST_F(BuilderTest, GlobalVar_Complex_ConstructorWithExtract) {
auto* first = create<ast::TypeConstructorExpression>( auto* first = create<ast::TypeConstructorExpression>(
&vec2, ast::ExpressionList{ &vec2, ast::ExpressionList{
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f)), create<ast::FloatLiteral>(Source{}, &f32, 1.0f)),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0f)), create<ast::FloatLiteral>(Source{}, &f32, 2.0f)),
}); });
auto* init = create<ast::TypeConstructorExpression>( auto* init = create<ast::TypeConstructorExpression>(
&vec3, ast::ExpressionList{ &vec3, ast::ExpressionList{
first, first,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f)), create<ast::FloatLiteral>(Source{}, &f32, 3.0f)),
}); });
EXPECT_TRUE(td.DetermineResultType(init)) << td.error(); EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
@ -328,7 +328,7 @@ TEST_F(BuilderTest, GlobalVar_ConstantId_Bool) {
&bool_type, // type &bool_type, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)), // constructor create<ast::BoolLiteral>(Source{}, &bool_type, true)), // constructor
ast::VariableDecorationList{ ast::VariableDecorationList{
// decorations // decorations
create<ast::ConstantIdDecoration>(1200, Source{}), create<ast::ConstantIdDecoration>(1200, Source{}),
@ -383,7 +383,7 @@ TEST_F(BuilderTest, GlobalVar_ConstantId_Scalar) {
&f32, // type &f32, // type
false, // is_const false, // is_const
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)), // constructor create<ast::FloatLiteral>(Source{}, &f32, 2.0)), // constructor
ast::VariableDecorationList{ ast::VariableDecorationList{
// decorations // decorations
create<ast::ConstantIdDecoration>(0, Source{}), create<ast::ConstantIdDecoration>(0, Source{}),

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

@ -43,11 +43,11 @@ TEST_F(BuilderTest, IdentifierExpression_GlobalConst) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);
@ -102,11 +102,11 @@ TEST_F(BuilderTest, IdentifierExpression_FunctionConst) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* init = create<ast::TypeConstructorExpression>(&vec, vals); auto* init = create<ast::TypeConstructorExpression>(&vec, vals);
@ -195,7 +195,7 @@ TEST_F(BuilderTest, IdentifierExpression_NoLoadConst) {
ast::Variable var(Source{}, "var", ast::StorageClass::kNone, &i32, true, ast::Variable var(Source{}, "var", ast::StorageClass::kNone, &i32, true,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)), create<ast::SintLiteral>(Source{}, &i32, 2)),
ast::VariableDecorationList{}); ast::VariableDecorationList{});
td.RegisterVariableForTesting(&var); td.RegisterVariableForTesting(&var);

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

@ -46,7 +46,7 @@ TEST_F(BuilderTest, If_Empty) {
// if (true) { // if (true) {
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
ast::IfStatement expr(Source{}, cond, create<ast::BlockStatement>(), ast::IfStatement expr(Source{}, cond, create<ast::BlockStatement>(),
ast::ElseStatementList{}); ast::ElseStatementList{});
@ -88,10 +88,10 @@ TEST_F(BuilderTest, If_WithStatements) {
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
ast::IfStatement expr(Source{}, cond, body, ast::ElseStatementList{}); ast::IfStatement expr(Source{}, cond, body, ast::ElseStatementList{});
@ -142,16 +142,16 @@ TEST_F(BuilderTest, If_WithElse) {
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* else_body = create<ast::BlockStatement>(); auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::AssignmentStatement>( else_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
ast::IfStatement expr(Source{}, cond, body, ast::IfStatement expr(Source{}, cond, body,
{create<ast::ElseStatement>(else_body)}); {create<ast::ElseStatement>(else_body)});
@ -208,19 +208,19 @@ TEST_F(BuilderTest, If_WithElseIf) {
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* else_body = create<ast::BlockStatement>(); auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::AssignmentStatement>( else_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
auto* else_cond = create<ast::ScalarConstructorExpression>( auto* else_cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
ast::IfStatement expr(Source{}, cond, body, ast::IfStatement expr(Source{}, cond, body,
{create<ast::ElseStatement>(else_cond, else_body)}); {create<ast::ElseStatement>(else_cond, else_body)});
@ -286,30 +286,30 @@ TEST_F(BuilderTest, If_WithMultiple) {
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* elseif_1_body = create<ast::BlockStatement>(); auto* elseif_1_body = create<ast::BlockStatement>();
elseif_1_body->append(create<ast::AssignmentStatement>( elseif_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
auto* elseif_2_body = create<ast::BlockStatement>(); auto* elseif_2_body = create<ast::BlockStatement>();
elseif_2_body->append(create<ast::AssignmentStatement>( elseif_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 4)))); create<ast::SintLiteral>(Source{}, &i32, 4))));
auto* else_body = create<ast::BlockStatement>(); auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::AssignmentStatement>( else_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 5)))); create<ast::SintLiteral>(Source{}, &i32, 5))));
auto* elseif_1_cond = create<ast::ScalarConstructorExpression>( auto* elseif_1_cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* elseif_2_cond = create<ast::ScalarConstructorExpression>( auto* elseif_2_cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, false)); create<ast::BoolLiteral>(Source{}, &bool_type, false));
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
ast::IfStatement expr( ast::IfStatement expr(
Source{}, cond, body, Source{}, cond, body,
@ -376,7 +376,7 @@ TEST_F(BuilderTest, If_WithBreak) {
// } // }
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* if_body = create<ast::BlockStatement>(); auto* if_body = create<ast::BlockStatement>();
if_body->append(create<ast::BreakStatement>()); if_body->append(create<ast::BreakStatement>());
@ -424,7 +424,7 @@ TEST_F(BuilderTest, If_WithElseBreak) {
// } // }
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* else_body = create<ast::BlockStatement>(); auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::BreakStatement>()); else_body->append(create<ast::BreakStatement>());
@ -474,7 +474,7 @@ TEST_F(BuilderTest, If_WithContinue) {
// } // }
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* if_body = create<ast::BlockStatement>(); auto* if_body = create<ast::BlockStatement>();
if_body->append(create<ast::ContinueStatement>()); if_body->append(create<ast::ContinueStatement>());
@ -522,7 +522,7 @@ TEST_F(BuilderTest, If_WithElseContinue) {
// } // }
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* else_body = create<ast::BlockStatement>(); auto* else_body = create<ast::BlockStatement>();
else_body->append(create<ast::ContinueStatement>()); else_body->append(create<ast::ContinueStatement>());
@ -570,7 +570,7 @@ TEST_F(BuilderTest, If_WithReturn) {
// return; // return;
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* if_body = create<ast::BlockStatement>(); auto* if_body = create<ast::BlockStatement>();
if_body->append(create<ast::ReturnStatement>(Source{})); if_body->append(create<ast::ReturnStatement>(Source{}));
@ -600,9 +600,9 @@ TEST_F(BuilderTest, If_WithReturnValue) {
// return false; // return false;
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)); create<ast::BoolLiteral>(Source{}, &bool_type, true));
auto* cond2 = create<ast::ScalarConstructorExpression>( auto* cond2 = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, false)); create<ast::BoolLiteral>(Source{}, &bool_type, false));
auto* if_body = create<ast::BlockStatement>(); auto* if_body = create<ast::BlockStatement>();
if_body->append(create<ast::ReturnStatement>(Source{}, cond2)); if_body->append(create<ast::ReturnStatement>(Source{}, cond2));

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

@ -35,7 +35,7 @@ using BuilderTest = TestHelper;
TEST_F(BuilderTest, Literal_Bool_True) { TEST_F(BuilderTest, Literal_Bool_True) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
ast::BoolLiteral b_true(&bool_type, true); ast::BoolLiteral b_true(Source{}, &bool_type, true);
auto id = b.GenerateLiteralIfNeeded(nullptr, &b_true); auto id = b.GenerateLiteralIfNeeded(nullptr, &b_true);
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
@ -48,7 +48,7 @@ TEST_F(BuilderTest, Literal_Bool_True) {
TEST_F(BuilderTest, Literal_Bool_False) { TEST_F(BuilderTest, Literal_Bool_False) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
ast::BoolLiteral b_false(&bool_type, false); ast::BoolLiteral b_false(Source{}, &bool_type, false);
auto id = b.GenerateLiteralIfNeeded(nullptr, &b_false); auto id = b.GenerateLiteralIfNeeded(nullptr, &b_false);
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
@ -61,8 +61,8 @@ TEST_F(BuilderTest, Literal_Bool_False) {
TEST_F(BuilderTest, Literal_Bool_Dedup) { TEST_F(BuilderTest, Literal_Bool_Dedup) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
ast::BoolLiteral b_true(&bool_type, true); ast::BoolLiteral b_true(Source{}, &bool_type, true);
ast::BoolLiteral b_false(&bool_type, false); ast::BoolLiteral b_false(Source{}, &bool_type, false);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_true), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_true), 0u);
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
@ -79,7 +79,7 @@ TEST_F(BuilderTest, Literal_Bool_Dedup) {
TEST_F(BuilderTest, Literal_I32) { TEST_F(BuilderTest, Literal_I32) {
ast::type::I32 i32; ast::type::I32 i32;
ast::SintLiteral i(&i32, -23); ast::SintLiteral i(Source{}, &i32, -23);
auto id = b.GenerateLiteralIfNeeded(nullptr, &i); auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
@ -92,8 +92,8 @@ TEST_F(BuilderTest, Literal_I32) {
TEST_F(BuilderTest, Literal_I32_Dedup) { TEST_F(BuilderTest, Literal_I32_Dedup) {
ast::type::I32 i32; ast::type::I32 i32;
ast::SintLiteral i1(&i32, -23); ast::SintLiteral i1(Source{}, &i32, -23);
ast::SintLiteral i2(&i32, -23); ast::SintLiteral i2(Source{}, &i32, -23);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
@ -106,7 +106,7 @@ TEST_F(BuilderTest, Literal_I32_Dedup) {
TEST_F(BuilderTest, Literal_U32) { TEST_F(BuilderTest, Literal_U32) {
ast::type::U32 u32; ast::type::U32 u32;
ast::UintLiteral i(&u32, 23); ast::UintLiteral i(Source{}, &u32, 23);
auto id = b.GenerateLiteralIfNeeded(nullptr, &i); auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
@ -119,8 +119,8 @@ TEST_F(BuilderTest, Literal_U32) {
TEST_F(BuilderTest, Literal_U32_Dedup) { TEST_F(BuilderTest, Literal_U32_Dedup) {
ast::type::U32 u32; ast::type::U32 u32;
ast::UintLiteral i1(&u32, 23); ast::UintLiteral i1(Source{}, &u32, 23);
ast::UintLiteral i2(&u32, 23); ast::UintLiteral i2(Source{}, &u32, 23);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
@ -133,7 +133,7 @@ TEST_F(BuilderTest, Literal_U32_Dedup) {
TEST_F(BuilderTest, Literal_F32) { TEST_F(BuilderTest, Literal_F32) {
ast::type::F32 f32; ast::type::F32 f32;
ast::FloatLiteral i(&f32, 23.245f); ast::FloatLiteral i(Source{}, &f32, 23.245f);
auto id = b.GenerateLiteralIfNeeded(nullptr, &i); auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
@ -146,8 +146,8 @@ TEST_F(BuilderTest, Literal_F32) {
TEST_F(BuilderTest, Literal_F32_Dedup) { TEST_F(BuilderTest, Literal_F32_Dedup) {
ast::type::F32 f32; ast::type::F32 f32;
ast::FloatLiteral i1(&f32, 23.245f); ast::FloatLiteral i1(Source{}, &f32, 23.245f);
ast::FloatLiteral i2(&f32, 23.245f); ast::FloatLiteral i2(Source{}, &f32, 23.245f);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u); ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);

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

@ -78,7 +78,7 @@ TEST_F(BuilderTest, Loop_WithoutContinuing) {
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
ast::LoopStatement expr(body, create<ast::BlockStatement>()); ast::LoopStatement expr(body, create<ast::BlockStatement>());
@ -131,13 +131,13 @@ TEST_F(BuilderTest, Loop_WithContinuing) {
body->append(create<ast::AssignmentStatement>( body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* continuing = create<ast::BlockStatement>(); auto* continuing = create<ast::BlockStatement>();
continuing->append(create<ast::AssignmentStatement>( continuing->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
ast::LoopStatement expr(body, continuing); ast::LoopStatement expr(body, continuing);
td.RegisterVariableForTesting(var); td.RegisterVariableForTesting(var);

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

@ -51,11 +51,11 @@ TEST_F(BuilderTest, Return_WithValue) {
ast::ExpressionList vals; ast::ExpressionList vals;
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0f))); create<ast::FloatLiteral>(Source{}, &f32, 1.0f)));
vals.push_back(create<ast::ScalarConstructorExpression>( vals.push_back(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.0f))); create<ast::FloatLiteral>(Source{}, &f32, 3.0f)));
auto* val = create<ast::TypeConstructorExpression>(&vec, vals); auto* val = create<ast::TypeConstructorExpression>(&vec, vals);

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

@ -45,7 +45,7 @@ TEST_F(BuilderTest, Switch_Empty) {
// switch (1) { // switch (1) {
// } // }
auto* cond = create<ast::ScalarConstructorExpression>( auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)); create<ast::SintLiteral>(Source{}, &i32, 1));
ast::SwitchStatement expr(cond, ast::CaseStatementList{}); ast::SwitchStatement expr(cond, ast::CaseStatementList{});
@ -97,19 +97,19 @@ TEST_F(BuilderTest, Switch_WithCase) {
case_1_body->append(create<ast::AssignmentStatement>( case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
auto* case_2_body = create<ast::BlockStatement>(); auto* case_2_body = create<ast::BlockStatement>();
case_2_body->append(create<ast::AssignmentStatement>( case_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
ast::CaseSelectorList selector_1; ast::CaseSelectorList selector_1;
selector_1.push_back(create<ast::SintLiteral>(&i32, 1)); selector_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
ast::CaseSelectorList selector_2; ast::CaseSelectorList selector_2;
selector_2.push_back(create<ast::SintLiteral>(&i32, 2)); selector_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 2));
ast::CaseStatementList cases; ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body)); cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
@ -191,7 +191,7 @@ TEST_F(BuilderTest, Switch_WithDefault) {
default_body->append(create<ast::AssignmentStatement>( default_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
ast::CaseStatementList cases; ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(default_body)); cases.push_back(create<ast::CaseStatement>(default_body));
@ -270,26 +270,26 @@ TEST_F(BuilderTest, Switch_WithCaseAndDefault) {
case_1_body->append(create<ast::AssignmentStatement>( case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
auto* case_2_body = create<ast::BlockStatement>(); auto* case_2_body = create<ast::BlockStatement>();
case_2_body->append(create<ast::AssignmentStatement>( case_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* default_body = create<ast::BlockStatement>(); auto* default_body = create<ast::BlockStatement>();
default_body->append(create<ast::AssignmentStatement>( default_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
ast::CaseSelectorList selector_1; ast::CaseSelectorList selector_1;
selector_1.push_back(create<ast::SintLiteral>(&i32, 1)); selector_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
ast::CaseSelectorList selector_2; ast::CaseSelectorList selector_2;
selector_2.push_back(create<ast::SintLiteral>(&i32, 2)); selector_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 2));
selector_2.push_back(create<ast::SintLiteral>(&i32, 3)); selector_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 3));
ast::CaseStatementList cases; ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body)); cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
@ -379,26 +379,26 @@ TEST_F(BuilderTest, Switch_CaseWithFallthrough) {
case_1_body->append(create<ast::AssignmentStatement>( case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
case_1_body->append(create<ast::FallthroughStatement>()); case_1_body->append(create<ast::FallthroughStatement>());
auto* case_2_body = create<ast::BlockStatement>(); auto* case_2_body = create<ast::BlockStatement>();
case_2_body->append(create<ast::AssignmentStatement>( case_2_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)))); create<ast::SintLiteral>(Source{}, &i32, 2))));
auto* default_body = create<ast::BlockStatement>(); auto* default_body = create<ast::BlockStatement>();
default_body->append(create<ast::AssignmentStatement>( default_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 3)))); create<ast::SintLiteral>(Source{}, &i32, 3))));
ast::CaseSelectorList selector_1; ast::CaseSelectorList selector_1;
selector_1.push_back(create<ast::SintLiteral>(&i32, 1)); selector_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
ast::CaseSelectorList selector_2; ast::CaseSelectorList selector_2;
selector_2.push_back(create<ast::SintLiteral>(&i32, 2)); selector_2.push_back(create<ast::SintLiteral>(Source{}, &i32, 2));
ast::CaseStatementList cases; ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body)); cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
@ -484,11 +484,11 @@ TEST_F(BuilderTest, Switch_CaseFallthroughLastStatement) {
case_1_body->append(create<ast::AssignmentStatement>( case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
case_1_body->append(create<ast::FallthroughStatement>()); case_1_body->append(create<ast::FallthroughStatement>());
ast::CaseSelectorList selector_1; ast::CaseSelectorList selector_1;
selector_1.push_back(create<ast::SintLiteral>(&i32, 1)); selector_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
ast::CaseStatementList cases; ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body)); cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
@ -545,19 +545,19 @@ TEST_F(BuilderTest, Switch_WithNestedBreak) {
if_body->append(create<ast::BreakStatement>()); if_body->append(create<ast::BreakStatement>());
auto* case_1_body = create<ast::BlockStatement>(); auto* case_1_body = create<ast::BlockStatement>();
case_1_body->append( case_1_body->append(create<ast::IfStatement>(
create<ast::IfStatement>(Source{}, Source{},
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true)), create<ast::BoolLiteral>(Source{}, &bool_type, true)),
if_body, ast::ElseStatementList{})); if_body, ast::ElseStatementList{}));
case_1_body->append(create<ast::AssignmentStatement>( case_1_body->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"), create<ast::IdentifierExpression>(mod->RegisterSymbol("v"), "v"),
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1)))); create<ast::SintLiteral>(Source{}, &i32, 1))));
ast::CaseSelectorList selector_1; ast::CaseSelectorList selector_1;
selector_1.push_back(create<ast::SintLiteral>(&i32, 1)); selector_1.push_back(create<ast::SintLiteral>(Source{}, &i32, 1));
ast::CaseStatementList cases; ast::CaseStatementList cases;
cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body)); cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));

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

@ -42,7 +42,7 @@ TEST_F(BuilderTest, UnaryOp_Negation_Integer) {
ast::UnaryOpExpression expr(ast::UnaryOp::kNegation, ast::UnaryOpExpression expr(ast::UnaryOp::kNegation,
create<ast::ScalarConstructorExpression>( create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1))); create<ast::SintLiteral>(Source{}, &i32, 1)));
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -59,9 +59,10 @@ TEST_F(BuilderTest, UnaryOp_Negation_Integer) {
TEST_F(BuilderTest, UnaryOp_Negation_Float) { TEST_F(BuilderTest, UnaryOp_Negation_Float) {
ast::type::F32 f32; ast::type::F32 f32;
ast::UnaryOpExpression expr(ast::UnaryOp::kNegation, ast::UnaryOpExpression expr(
create<ast::ScalarConstructorExpression>( ast::UnaryOp::kNegation,
create<ast::FloatLiteral>(&f32, 1))); create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(Source{}, &f32, 1)));
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@ -78,9 +79,10 @@ TEST_F(BuilderTest, UnaryOp_Negation_Float) {
TEST_F(BuilderTest, UnaryOp_Not) { TEST_F(BuilderTest, UnaryOp_Not) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
ast::UnaryOpExpression expr(ast::UnaryOp::kNot, ast::UnaryOpExpression expr(
create<ast::ScalarConstructorExpression>( ast::UnaryOp::kNot,
create<ast::BoolLiteral>(&bool_type, false))); create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(Source{}, &bool_type, false)));
ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();

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

@ -32,7 +32,7 @@ using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) { TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, 5); auto* lit = create<ast::SintLiteral>(Source{}, &i32, 5);
auto* idx = create<ast::ScalarConstructorExpression>(lit); auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* ary = auto* ary =
create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary"); create<ast::IdentifierExpression>(mod.RegisterSymbol("ary"), "ary");

6
src/writer/wgsl/generator_impl_case_test.cc
View File

@ -37,7 +37,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Case) {
body->append(create<ast::BreakStatement>()); body->append(create<ast::BreakStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();
@ -56,8 +56,8 @@ TEST_F(WgslGeneratorImplTest, Emit_Case_MultipleSelectors) {
body->append(create<ast::BreakStatement>()); body->append(create<ast::BreakStatement>());
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(&i32, 5)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
lit.push_back(create<ast::SintLiteral>(&i32, 6)); lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 6));
ast::CaseStatement c(lit, body); ast::CaseStatement c(lit, body);
gen.increment_indent(); gen.increment_indent();

44
src/writer/wgsl/generator_impl_constructor_test.cc
View File

@ -37,7 +37,7 @@ using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitConstructor_Bool) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Bool) {
ast::type::Bool bool_type; ast::type::Bool bool_type;
auto* lit = create<ast::BoolLiteral>(&bool_type, false); auto* lit = create<ast::BoolLiteral>(Source{}, &bool_type, false);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -46,7 +46,7 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Bool) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_Int) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Int) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, -12345); auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -55,7 +55,7 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Int) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_UInt) { TEST_F(WgslGeneratorImplTest, EmitConstructor_UInt) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lit = create<ast::UintLiteral>(&u32, 56779); auto* lit = create<ast::UintLiteral>(Source{}, &u32, 56779);
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -65,8 +65,8 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_UInt) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_Float) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Float) {
ast::type::F32 f32; ast::type::F32 f32;
// Use a number close to 1<<30 but whose decimal representation ends in 0. // Use a number close to 1<<30 but whose decimal representation ends in 0.
auto* lit = auto* lit = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>((1 << 30) - 4)); static_cast<float>((1 << 30) - 4));
ast::ScalarConstructorExpression expr(lit); ast::ScalarConstructorExpression expr(lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@ -76,7 +76,7 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Float) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Float) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Float) {
ast::type::F32 f32; ast::type::F32 f32;
auto* lit = create<ast::FloatLiteral>(&f32, -1.2e-5); auto* lit = create<ast::FloatLiteral>(Source{}, &f32, -1.2e-5);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -89,7 +89,7 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Float) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Bool) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Bool) {
ast::type::Bool b; ast::type::Bool b;
auto* lit = create<ast::BoolLiteral>(&b, true); auto* lit = create<ast::BoolLiteral>(Source{}, &b, true);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -102,7 +102,7 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Bool) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Int) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Int) {
ast::type::I32 i32; ast::type::I32 i32;
auto* lit = create<ast::SintLiteral>(&i32, -12345); auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -115,7 +115,7 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Int) {
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Uint) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Uint) {
ast::type::U32 u32; ast::type::U32 u32;
auto* lit = create<ast::UintLiteral>(&u32, 12345); auto* lit = create<ast::UintLiteral>(Source{}, &u32, 12345);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit)); values.push_back(create<ast::ScalarConstructorExpression>(lit));
@ -129,9 +129,9 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Vec) {
ast::type::F32 f32; ast::type::F32 f32;
ast::type::Vector vec(&f32, 3); ast::type::Vector vec(&f32, 3);
auto* lit1 = create<ast::FloatLiteral>(&f32, 1.f); auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32, 1.f);
auto* lit2 = create<ast::FloatLiteral>(&f32, 2.f); auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32, 2.f);
auto* lit3 = create<ast::FloatLiteral>(&f32, 3.f); auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32, 3.f);
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
values.push_back(create<ast::ScalarConstructorExpression>(lit2)); values.push_back(create<ast::ScalarConstructorExpression>(lit2));
@ -152,10 +152,10 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Mat) {
ast::ExpressionList mat_values; ast::ExpressionList mat_values;
for (size_t i = 0; i < 3; i++) { for (size_t i = 0; i < 3; i++) {
auto* lit1 = auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 2))); static_cast<float>(1 + (i * 2)));
auto* lit2 = auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 2))); static_cast<float>(2 + (i * 2)));
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));
@ -179,12 +179,12 @@ TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Array) {
ast::ExpressionList ary_values; ast::ExpressionList ary_values;
for (size_t i = 0; i < 3; i++) { for (size_t i = 0; i < 3; i++) {
auto* lit1 = auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 3))); static_cast<float>(1 + (i * 3)));
auto* lit2 = auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 3))); static_cast<float>(2 + (i * 3)));
auto* lit3 = auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 3))); static_cast<float>(3 + (i * 3)));
ast::ExpressionList values; ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(lit1)); values.push_back(create<ast::ScalarConstructorExpression>(lit1));

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

@ -38,7 +38,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Switch) {
ast::type::I32 i32; ast::type::I32 i32;
ast::CaseSelectorList case_val; ast::CaseSelectorList case_val;
case_val.push_back(create<ast::SintLiteral>(&i32, 5)); case_val.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
auto* case_body = create<ast::BlockStatement>(); auto* case_body = create<ast::BlockStatement>();
case_body->append(create<ast::BreakStatement>()); case_body->append(create<ast::BreakStatement>());