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

Replace use of std::unique_ptr<T> with T* for AST nodes

Browse Source 
This is a minimal effort to fix up the code. There's substantial code
cleanup which can now be done, which is done in the next change.

Bug: tint:322
Change-Id: Iafcf5e814837d9534889e8c21333de4931a19cfa
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/32864
Commit-Queue: dan sinclair <dsinclair@chromium.org>
Reviewed-by: dan sinclair <dsinclair@chromium.org>
This commit is contained in:
Ben Clayton
2020-11-16 16:31:07 +00:00
committed by Commit Bot service account
parent 0613890eed
commit b053acf796
209 changed files with 3469 additions and 3608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
src/validator/validator_control_block_test.cc
View File

@@ -43,24 +43,24 @@ TEST_F(ValidateControlBlockTest, SwitchSelectorExpressionNoneIntegerType_Fail) {
// default: {}
// }
ast::type::F32Type f32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&f32, 3.14f)));
auto cond =
auto* cond =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
ast::CaseStatementList body;
body.push_back(create<ast::CaseStatement>(std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(create<ast::SwitchStatement>(std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0025: switch statement selector expression must be "
"of a scalar integer type");
@@ -72,24 +72,24 @@ TEST_F(ValidateControlBlockTest, SwitchWithoutDefault_Fail) {
// case 1: {}
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList csl;
csl.push_back(create<ast::SintLiteral>(&i32, 1));
ast::CaseStatementList body;
body.push_back(create<ast::CaseStatement>(std::move(csl),
create<ast::BlockStatement>()));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(create<ast::SwitchStatement>(Source{Source::Location{12, 34}},
std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0008: switch statement must have exactly one default "
"clause");
@@ -103,37 +103,37 @@ TEST_F(ValidateControlBlockTest, SwitchWithTwoDefault_Fail) {
// default: {}
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::CaseStatementList switch_body;
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList default_csl_1;
auto block_default_1 = create<ast::BlockStatement>();
auto* block_default_1 = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(default_csl_1),
std::move(block_default_1)));
ast::CaseSelectorList csl_case_1;
csl_case_1.push_back(create<ast::SintLiteral>(&i32, 1));
auto block_case_1 = create<ast::BlockStatement>();
auto* block_case_1 = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(csl_case_1),
std::move(block_case_1)));
ast::CaseSelectorList default_csl_2;
auto block_default_2 = create<ast::BlockStatement>();
auto* block_default_2 = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(default_csl_2),
std::move(block_default_2)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(create<ast::SwitchStatement>(Source{Source::Location{12, 34}},
std::move(cond),
std::move(switch_body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0008: switch statement must have exactly one default "
"clause");
@@ -148,12 +148,12 @@ TEST_F(ValidateControlBlockTest,
// }
ast::type::U32Type u32;
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::CaseStatementList switch_body;
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList csl;
csl.push_back(create<ast::UintLiteral>(&u32, 1));
@@ -162,17 +162,17 @@ TEST_F(ValidateControlBlockTest,
create<ast::BlockStatement>()));
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(
create<ast::SwitchStatement>(std::move(cond), std::move(switch_body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0026: the case selector values must have the same "
"type as the selector expression.");
@@ -187,12 +187,12 @@ TEST_F(ValidateControlBlockTest,
// }
ast::type::U32Type u32;
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &u32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &u32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 2)));
ast::CaseStatementList switch_body;
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList csl;
csl.push_back(create<ast::SintLiteral>(&i32, -1));
@@ -201,17 +201,17 @@ TEST_F(ValidateControlBlockTest,
create<ast::BlockStatement>()));
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(
create<ast::SwitchStatement>(std::move(cond), std::move(switch_body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0026: the case selector values must have the same "
"type as the selector expression.");
@@ -225,12 +225,12 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueUint_Fail) {
// default: {}
// }
ast::type::U32Type u32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &u32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &u32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3)));
ast::CaseStatementList switch_body;
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList csl_1;
csl_1.push_back(create<ast::UintLiteral>(&u32, 0));
@@ -245,17 +245,17 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueUint_Fail) {
create<ast::BlockStatement>()));
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(
create<ast::SwitchStatement>(std::move(cond), std::move(switch_body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0027: a literal value must not appear more than once "
"in the case selectors for a switch statement: '2'");
@@ -269,12 +269,12 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueSint_Fail) {
// default: {}
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::CaseStatementList switch_body;
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList csl_1;
csl_1.push_back(create<ast::SintLiteral>(&i32, 10));
@@ -291,17 +291,17 @@ TEST_F(ValidateControlBlockTest, NonUniqueCaseSelectorValueSint_Fail) {
create<ast::BlockStatement>()));
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
switch_body.push_back(create<ast::CaseStatement>(std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(
create<ast::SwitchStatement>(std::move(cond), std::move(switch_body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0027: a literal value must not appear more than once in "
"the case selectors for a switch statement: '10'");
@@ -313,25 +313,25 @@ TEST_F(ValidateControlBlockTest, LastClauseLastStatementIsFallthrough_Fail) {
// default: { fallthrough; }
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
block_default->append(
create<ast::FallthroughStatement>(Source{Source::Location{12, 34}}));
ast::CaseStatementList body;
body.push_back(create<ast::CaseStatement>(std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(create<ast::SwitchStatement>(std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block.get()));
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(block));
EXPECT_EQ(v()->error(),
"12:34: v-0028: a fallthrough statement must not appear as the "
"last statement in last clause of a switch");
@@ -344,29 +344,29 @@ TEST_F(ValidateControlBlockTest, SwitchCase_Pass) {
// case 5: {}
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
ast::CaseStatementList body;
body.push_back(create<ast::CaseStatement>(Source{Source::Location{12, 34}},
std::move(default_csl),
std::move(block_default)));
ast::CaseSelectorList case_csl;
case_csl.push_back(create<ast::SintLiteral>(&i32, 5));
auto block_case = create<ast::BlockStatement>();
auto* block_case = create<ast::BlockStatement>();
body.push_back(
create<ast::CaseStatement>(std::move(case_csl), std::move(block_case)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(create<ast::SwitchStatement>(std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_TRUE(v()->ValidateStatements(block.get())) << v()->error();
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_TRUE(v()->ValidateStatements(block)) << v()->error();
}
TEST_F(ValidateControlBlockTest, SwitchCaseAlias_Pass) {
@@ -379,26 +379,26 @@ TEST_F(ValidateControlBlockTest, SwitchCaseAlias_Pass) {
ast::type::U32Type u32;
ast::type::AliasType my_int{"MyInt", &u32};
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &my_int);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &my_int);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&u32, 2)));
auto cond = create<ast::IdentifierExpression>("a");
auto* cond = create<ast::IdentifierExpression>("a");
ast::CaseSelectorList default_csl;
auto block_default = create<ast::BlockStatement>();
auto* block_default = create<ast::BlockStatement>();
ast::CaseStatementList body;
body.push_back(create<ast::CaseStatement>(Source{Source::Location{12, 34}},
std::move(default_csl),
std::move(block_default)));
auto block = create<ast::BlockStatement>();
auto* block = create<ast::BlockStatement>();
block->append(create<ast::VariableDeclStatement>(std::move(var)));
block->append(create<ast::SwitchStatement>(std::move(cond), std::move(body)));
mod()->AddConstructedType(&my_int);
EXPECT_TRUE(td()->DetermineStatements(block.get())) << td()->error();
EXPECT_TRUE(v()->ValidateStatements(block.get())) << v()->error();
EXPECT_TRUE(td()->DetermineStatements(block)) << td()->error();
EXPECT_TRUE(v()->ValidateStatements(block)) << v()->error();
}
} // namespace

100
src/validator/validator_function_test.cc
View File

@@ -39,15 +39,15 @@ TEST_F(ValidateFunctionTest, VoidFunctionEndWithoutReturnStatement_Pass) {
// [[stage(vertex)]]
// fn func -> void { var a:i32 = 2; }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::VariableList params;
ast::type::VoidType void_type;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
auto func =
auto* func =
create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &void_type, std::move(body));
func->add_decoration(
@@ -64,9 +64,9 @@ TEST_F(ValidateFunctionTest,
// fn func -> void {}
ast::type::VoidType void_type;
ast::VariableList params;
auto func = create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &void_type,
create<ast::BlockStatement>());
auto* func = create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &void_type,
create<ast::BlockStatement>());
func->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
mod()->AddFunction(std::move(func));
@@ -79,16 +79,16 @@ TEST_F(ValidateFunctionTest, FunctionEndWithoutReturnStatement_Fail) {
// fn func -> int { var a:i32 = 2; }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
ast::VariableList params;
ast::type::VoidType void_type;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
auto func = create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &i32, std::move(body));
auto* func = create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &i32, std::move(body));
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();
@@ -103,9 +103,9 @@ TEST_F(ValidateFunctionTest, FunctionEndWithoutReturnStatementEmptyBody_Fail) {
ast::type::VoidType void_type;
ast::type::I32Type i32;
ast::VariableList params;
auto func = create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &i32,
create<ast::BlockStatement>());
auto* func = create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params), &i32,
create<ast::BlockStatement>());
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();
@@ -121,10 +121,10 @@ TEST_F(ValidateFunctionTest, FunctionTypeMustMatchReturnStatementType_Pass) {
ast::type::VoidType void_type;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>());
auto func = create<ast::Function>("func", std::move(params), &void_type,
std::move(body));
auto* func = create<ast::Function>("func", std::move(params), &void_type,
std::move(body));
func->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
mod()->AddFunction(std::move(func));
@@ -138,14 +138,14 @@ TEST_F(ValidateFunctionTest, FunctionTypeMustMatchReturnStatementType_fail) {
ast::type::VoidType void_type;
ast::type::I32Type i32;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto return_expr = create<ast::ScalarConstructorExpression>(
auto* body = create<ast::BlockStatement>();
auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
body->append(create<ast::ReturnStatement>(Source{Source::Location{12, 34}},
std::move(return_expr)));
auto func = create<ast::Function>("func", std::move(params), &void_type,
std::move(body));
auto* func = create<ast::Function>("func", std::move(params), &void_type,
std::move(body));
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();
@@ -161,13 +161,13 @@ TEST_F(ValidateFunctionTest, FunctionTypeMustMatchReturnStatementTypeF32_fail) {
ast::type::I32Type i32;
ast::type::F32Type f32;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto return_expr = create<ast::ScalarConstructorExpression>(
auto* body = create<ast::BlockStatement>();
auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
body->append(create<ast::ReturnStatement>(Source{Source::Location{12, 34}},
std::move(return_expr)));
auto func =
auto* func =
create<ast::Function>("func", std::move(params), &f32, std::move(body));
mod()->AddFunction(std::move(func));
@@ -186,21 +186,21 @@ TEST_F(ValidateFunctionTest, FunctionNamesMustBeUnique_fail) {
ast::type::I32Type i32;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto return_expr = create<ast::ScalarConstructorExpression>(
auto* body = create<ast::BlockStatement>();
auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
body->append(create<ast::ReturnStatement>(std::move(return_expr)));
auto func =
auto* func =
create<ast::Function>("func", std::move(params), &i32, std::move(body));
ast::VariableList params_copy;
auto body_copy = create<ast::BlockStatement>();
auto return_expr_copy = create<ast::ScalarConstructorExpression>(
auto* body_copy = create<ast::BlockStatement>();
auto* return_expr_copy = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
body_copy->append(create<ast::ReturnStatement>(std::move(return_expr_copy)));
auto func_copy =
auto* func_copy =
create<ast::Function>(Source{Source::Location{12, 34}}, "func",
std::move(params_copy), &i32, std::move(body_copy));
@@ -218,14 +218,14 @@ TEST_F(ValidateFunctionTest, RecursionIsNotAllowed_Fail) {
ast::type::F32Type f32;
ast::type::VoidType void_type;
ast::ExpressionList call_params;
auto call_expr = create<ast::CallExpression>(
auto* call_expr = create<ast::CallExpression>(
Source{Source::Location{12, 34}},
create<ast::IdentifierExpression>("func"), std::move(call_params));
ast::VariableList params0;
auto body0 = create<ast::BlockStatement>();
auto* body0 = create<ast::BlockStatement>();
body0->append(create<ast::CallStatement>(std::move(call_expr)));
body0->append(create<ast::ReturnStatement>());
auto func0 =
auto* func0 =
create<ast::Function>("func", std::move(params0), &f32, std::move(body0));
mod()->AddFunction(std::move(func0));
@@ -237,20 +237,20 @@ TEST_F(ValidateFunctionTest, RecursionIsNotAllowed_Fail) {
TEST_F(ValidateFunctionTest, RecursionIsNotAllowedExpr_Fail) {
// fn func() -> i32 {var a: i32 = func(); return 2; }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
ast::ExpressionList call_params;
auto call_expr = create<ast::CallExpression>(
auto* call_expr = create<ast::CallExpression>(
Source{Source::Location{12, 34}},
create<ast::IdentifierExpression>("func"), std::move(call_params));
var->set_constructor(std::move(call_expr));
ast::VariableList params0;
auto body0 = create<ast::BlockStatement>();
auto* body0 = create<ast::BlockStatement>();
body0->append(create<ast::VariableDeclStatement>(std::move(var)));
auto return_expr = create<ast::ScalarConstructorExpression>(
auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
body0->append(create<ast::ReturnStatement>(std::move(return_expr)));
auto func0 =
auto* func0 =
create<ast::Function>("func", std::move(params0), &i32, std::move(body0));
mod()->AddFunction(std::move(func0));
@@ -264,12 +264,12 @@ TEST_F(ValidateFunctionTest, Function_WithPipelineStage_NotVoid_Fail) {
// fn vtx_main() -> i32 { return 0; }
ast::type::I32Type i32;
ast::VariableList params;
auto return_expr = create<ast::ScalarConstructorExpression>(
auto* return_expr = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 0));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>(std::move(return_expr)));
auto func =
auto* func =
create<ast::Function>(Source{Source::Location{12, 34}}, "vtx_main",
std::move(params), &i32, std::move(body));
func->add_decoration(
@@ -289,9 +289,9 @@ TEST_F(ValidateFunctionTest, Function_WithPipelineStage_WithParams_Fail) {
ast::type::VoidType void_type;
ast::VariableList params;
params.push_back(create<ast::Variable>("a", ast::StorageClass::kNone, &i32));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>());
auto func =
auto* func =
create<ast::Function>(Source{Source::Location{12, 34}}, "vtx_func",
std::move(params), &void_type, std::move(body));
func->add_decoration(
@@ -311,9 +311,9 @@ TEST_F(ValidateFunctionTest, PipelineStage_MustBeUnique_Fail) {
// fn main() -> void { return; }
ast::type::VoidType void_type;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>());
auto func =
auto* func =
create<ast::Function>(Source{Source::Location{12, 34}}, "main",
std::move(params), &void_type, std::move(body));
func->add_decoration(
@@ -333,10 +333,10 @@ TEST_F(ValidateFunctionTest, OnePipelineStageFunctionMustBePresent_Pass) {
// fn vtx_func() -> void { return; }
ast::type::VoidType void_type;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>());
auto func = create<ast::Function>("vtx_func", std::move(params), &void_type,
std::move(body));
auto* func = create<ast::Function>("vtx_func", std::move(params), &void_type,
std::move(body));
func->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
mod()->AddFunction(std::move(func));
@@ -349,10 +349,10 @@ TEST_F(ValidateFunctionTest, OnePipelineStageFunctionMustBePresent_Fail) {
// fn vtx_func() -> void { return; }
ast::type::VoidType void_type;
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::ReturnStatement>());
auto func = create<ast::Function>("vtx_func", std::move(params), &void_type,
std::move(body));
auto* func = create<ast::Function>("vtx_func", std::move(params), &void_type,
std::move(body));
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();

40
src/validator/validator_impl.cc
View File

@@ -61,7 +61,7 @@ bool ValidatorImpl::Validate(const ast::Module* module) {
bool ValidatorImpl::ValidateGlobalVariables(
const ast::VariableList& global_vars) {
for (const auto& var : global_vars) {
for (auto* var : global_vars) {
if (variable_stack_.has(var->name())) {
set_error(var->source(),
"v-0011: redeclared global identifier '" + var->name() + "'");
@@ -78,22 +78,22 @@ bool ValidatorImpl::ValidateGlobalVariables(
"v-global01: global constants shouldn't have a storage class");
return false;
}
variable_stack_.set_global(var->name(), var.get());
variable_stack_.set_global(var->name(), var);
}
return true;
}
bool ValidatorImpl::ValidateFunctions(const ast::FunctionList& funcs) {
for (const auto& func : funcs) {
for (auto* func : funcs) {
if (function_stack_.has(func->name())) {
set_error(func->source(),
"v-0016: function names must be unique '" + func->name() + "'");
return false;
}
function_stack_.set(func->name(), func.get());
current_function_ = func.get();
if (!ValidateFunction(func.get())) {
function_stack_.set(func->name(), func);
current_function_ = func;
if (!ValidateFunction(func)) {
return false;
}
current_function_ = nullptr;
@@ -104,7 +104,7 @@ bool ValidatorImpl::ValidateFunctions(const ast::FunctionList& funcs) {
bool ValidatorImpl::ValidateEntryPoint(const ast::FunctionList& funcs) {
auto shader_is_present = false;
for (const auto& func : funcs) {
for (auto* func : funcs) {
if (func->IsEntryPoint()) {
shader_is_present = true;
if (!func->params().empty()) {
@@ -121,7 +121,7 @@ bool ValidatorImpl::ValidateEntryPoint(const ast::FunctionList& funcs) {
return false;
}
auto stage_deco_count = 0;
for (const auto& deco : func->decorations()) {
for (auto* deco : func->decorations()) {
if (deco->IsStage()) {
stage_deco_count++;
}
@@ -146,8 +146,8 @@ bool ValidatorImpl::ValidateEntryPoint(const ast::FunctionList& funcs) {
bool ValidatorImpl::ValidateFunction(const ast::Function* func) {
variable_stack_.push_scope();
for (const auto& param : func->params()) {
variable_stack_.set(param->name(), param.get());
for (auto* param : func->params()) {
variable_stack_.set(param->name(), param);
}
if (!ValidateStatements(func->body())) {
return false;
@@ -190,8 +190,8 @@ bool ValidatorImpl::ValidateStatements(const ast::BlockStatement* block) {
if (!block) {
return false;
}
for (const auto& stmt : *block) {
if (!ValidateStatement(stmt.get())) {
for (auto* stmt : *block) {
if (!ValidateStatement(stmt)) {
return false;
}
}
@@ -261,19 +261,19 @@ bool ValidatorImpl::ValidateSwitch(const ast::SwitchStatement* s) {
int default_counter = 0;
std::unordered_set<int32_t> selector_set;
for (const auto& case_stmt : s->body()) {
if (!ValidateStatement(case_stmt.get())) {
for (auto* case_stmt : s->body()) {
if (!ValidateStatement(case_stmt)) {
return false;
}
if (case_stmt.get()->IsDefault()) {
if (case_stmt->IsDefault()) {
default_counter++;
}
for (const auto& selector : case_stmt.get()->selectors()) {
auto* selector_ptr = selector.get();
for (auto* selector : case_stmt->selectors()) {
auto* selector_ptr = selector;
if (cond_type != selector_ptr->type()) {
set_error(case_stmt.get()->source(),
set_error(case_stmt->source(),
"v-0026: the case selector values must have the same "
"type as the selector expression.");
return false;
@@ -286,7 +286,7 @@ bool ValidatorImpl::ValidateSwitch(const ast::SwitchStatement* s) {
auto v_str = selector_ptr->type()->IsU32()
? selector_ptr->AsUint()->to_str()
: selector_ptr->AsSint()->to_str();
set_error(case_stmt.get()->source(),
set_error(case_stmt->source(),
"v-0027: a literal value must not appear more than once in "
"the case selectors for a switch statement: '" +
v_str + "'");
@@ -302,7 +302,7 @@ bool ValidatorImpl::ValidateSwitch(const ast::SwitchStatement* s) {
return false;
}
auto* last_clause = s->body().back().get();
auto* last_clause = s->body().back();
auto* last_stmt_of_last_clause = last_clause->AsCase()->body()->last();
if (last_stmt_of_last_clause && last_stmt_of_last_clause->IsFallthrough()) {
set_error(last_stmt_of_last_clause->source(),

257
src/validator/validator_test.cc
View File

@@ -64,9 +64,9 @@ TEST_F(ValidatorTest, DISABLED_AssignToScalar_Fail) {
// 1 = my_var;
ast::type::I32Type i32;
auto lhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 1));
auto rhs = create<ast::IdentifierExpression>("my_var");
auto* rhs = create<ast::IdentifierExpression>("my_var");
ast::AssignmentStatement assign(Source{Source::Location{12, 34}},
std::move(lhs), std::move(rhs));
@@ -80,14 +80,14 @@ TEST_F(ValidatorTest, UsingUndefinedVariable_Fail) {
// b = 2;
ast::type::I32Type i32;
auto lhs =
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "b");
auto rhs = create<ast::ScalarConstructorExpression>(
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto assign = create<ast::AssignmentStatement>(
auto* assign = create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs));
EXPECT_FALSE(td()->DetermineResultType(assign.get()));
EXPECT_FALSE(td()->DetermineResultType(assign));
EXPECT_EQ(td()->error(),
"12:34: v-0006: identifier must be declared before use: b");
}
@@ -98,16 +98,16 @@ TEST_F(ValidatorTest, UsingUndefinedVariableInBlockStatement_Fail) {
// }
ast::type::I32Type i32;
auto lhs =
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "b");
auto rhs = create<ast::ScalarConstructorExpression>(
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
EXPECT_FALSE(td()->DetermineStatements(body.get()));
EXPECT_FALSE(td()->DetermineStatements(body));
EXPECT_EQ(td()->error(),
"12:34: v-0006: identifier must be declared before use: b");
}
@@ -116,19 +116,19 @@ TEST_F(ValidatorTest, AssignCompatibleTypes_Pass) {
// var a :i32 = 2;
// a = 2
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
ast::AssignmentStatement assign(Source{Source::Location{12, 34}},
std::move(lhs), std::move(rhs));
td()->RegisterVariableForTesting(var.get());
td()->RegisterVariableForTesting(var);
EXPECT_TRUE(td()->DetermineResultType(&assign)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
@@ -143,18 +143,18 @@ TEST_F(ValidatorTest, AssignIncompatibleTypes_Fail) {
ast::type::F32Type f32;
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.3f));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
ast::AssignmentStatement assign(Source{Source::Location{12, 34}},
std::move(lhs), std::move(rhs));
td()->RegisterVariableForTesting(var.get());
td()->RegisterVariableForTesting(var);
EXPECT_TRUE(td()->DetermineResultType(&assign)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
@@ -172,26 +172,26 @@ TEST_F(ValidatorTest, AssignCompatibleTypesInBlockStatement_Pass) {
// a = 2
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(body.get())) << td()->error();
EXPECT_TRUE(td()->DetermineStatements(body)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_TRUE(v()->ValidateStatements(body.get())) << v()->error();
EXPECT_TRUE(v()->ValidateStatements(body)) << v()->error();
}
TEST_F(ValidatorTest, AssignIncompatibleTypesInBlockStatement_Fail) {
@@ -202,14 +202,14 @@ TEST_F(ValidatorTest, AssignIncompatibleTypesInBlockStatement_Fail) {
ast::type::F32Type f32;
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.3f));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
ast::BlockStatement block;
block.append(create<ast::VariableDeclStatement>(std::move(var)));
@@ -230,7 +230,7 @@ TEST_F(ValidatorTest, AssignIncompatibleTypesInBlockStatement_Fail) {
TEST_F(ValidatorTest, GlobalVariableWithStorageClass_Pass) {
// var<in> gloabl_var: f32;
ast::type::F32Type f32;
auto global_var =
auto* global_var =
create<ast::Variable>(Source{Source::Location{12, 34}}, "global_var",
ast::StorageClass::kInput, &f32);
mod()->AddGlobalVariable(std::move(global_var));
@@ -241,7 +241,7 @@ TEST_F(ValidatorTest, GlobalVariableWithStorageClass_Pass) {
TEST_F(ValidatorTest, GlobalVariableNoStorageClass_Fail) {
// var gloabl_var: f32;
ast::type::F32Type f32;
auto global_var =
auto* global_var =
create<ast::Variable>(Source{Source::Location{12, 34}}, "global_var",
ast::StorageClass::kNone, &f32);
mod()->AddGlobalVariable(std::move(global_var));
@@ -253,7 +253,7 @@ TEST_F(ValidatorTest, GlobalVariableNoStorageClass_Fail) {
TEST_F(ValidatorTest, GlobalConstantWithStorageClass_Fail) {
// const<in> gloabl_var: f32;
ast::type::F32Type f32;
auto global_var =
auto* global_var =
create<ast::Variable>(Source{Source::Location{12, 34}}, "global_var",
ast::StorageClass::kInput, &f32);
global_var->set_is_const(true);
@@ -269,7 +269,7 @@ TEST_F(ValidatorTest, GlobalConstantWithStorageClass_Fail) {
TEST_F(ValidatorTest, GlobalConstNoStorageClass_Pass) {
// const gloabl_var: f32;
ast::type::F32Type f32;
auto global_var =
auto* global_var =
create<ast::Variable>(Source{Source::Location{12, 34}}, "global_var",
ast::StorageClass::kNone, &f32);
global_var->set_is_const(true);
@@ -285,24 +285,24 @@ TEST_F(ValidatorTest, UsingUndefinedVariableGlobalVariable_Fail) {
// not_global_var = 3.14f;
// }
ast::type::F32Type f32;
auto global_var =
auto* global_var =
create<ast::Variable>("global_var", ast::StorageClass::kPrivate, &f32);
global_var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.1)));
mod()->AddGlobalVariable(std::move(global_var));
auto lhs = create<ast::IdentifierExpression>(Source{Source::Location{12, 34}},
"not_global_var");
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>(
Source{Source::Location{12, 34}}, "not_global_var");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
auto func = create<ast::Function>("my_func", std::move(params), &f32,
std::move(body));
auto* func = create<ast::Function>("my_func", std::move(params), &f32,
std::move(body));
mod()->AddFunction(std::move(func));
EXPECT_FALSE(v()->Validate(mod()));
@@ -318,24 +318,24 @@ TEST_F(ValidatorTest, UsingUndefinedVariableGlobalVariable_Pass) {
ast::type::F32Type f32;
ast::type::VoidType void_type;
auto global_var =
auto* global_var =
create<ast::Variable>("global_var", ast::StorageClass::kPrivate, &f32);
global_var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.1)));
mod()->AddGlobalVariable(std::move(global_var));
auto lhs = create<ast::IdentifierExpression>("global_var");
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>("global_var");
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
body->append(create<ast::ReturnStatement>());
auto func = create<ast::Function>("my_func", std::move(params), &void_type,
std::move(body));
auto* func = create<ast::Function>("my_func", std::move(params), &void_type,
std::move(body));
func->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
mod()->AddFunction(std::move(func));
@@ -350,33 +350,33 @@ TEST_F(ValidatorTest, UsingUndefinedVariableInnerScope_Fail) {
// a = 3.14;
// }
ast::type::F32Type f32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)));
ast::type::BoolType bool_type;
auto cond = create<ast::ScalarConstructorExpression>(
auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
auto lhs =
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
auto outer_body = create<ast::BlockStatement>();
auto* outer_body = create<ast::BlockStatement>();
outer_body->append(
create<ast::IfStatement>(std::move(cond), std::move(body)));
outer_body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(outer_body.get())) << td()->error();
EXPECT_TRUE(td()->DetermineStatements(outer_body)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_FALSE(v()->ValidateStatements(outer_body.get()));
EXPECT_FALSE(v()->ValidateStatements(outer_body));
EXPECT_EQ(v()->error(), "12:34: v-0006: 'a' is not declared");
}
@@ -386,31 +386,31 @@ TEST_F(ValidatorTest, UsingUndefinedVariableOuterScope_Pass) {
// if (true) { a = 3.14; }
// }
ast::type::F32Type f32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)));
auto lhs =
auto* lhs =
create<ast::IdentifierExpression>(Source{Source::Location{12, 34}}, "a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14f));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
ast::type::BoolType bool_type;
auto cond = create<ast::ScalarConstructorExpression>(
auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
auto outer_body = create<ast::BlockStatement>();
auto* outer_body = create<ast::BlockStatement>();
outer_body->append(create<ast::VariableDeclStatement>(std::move(var)));
outer_body->append(
create<ast::IfStatement>(std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(outer_body.get())) << td()->error();
EXPECT_TRUE(td()->DetermineStatements(outer_body)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_TRUE(v()->ValidateStatements(outer_body.get())) << v()->error();
EXPECT_TRUE(v()->ValidateStatements(outer_body)) << v()->error();
}
TEST_F(ValidatorTest, GlobalVariableUnique_Pass) {
@@ -418,13 +418,13 @@ TEST_F(ValidatorTest, GlobalVariableUnique_Pass) {
// var global_var1 : i32 = 0;
ast::type::F32Type f32;
ast::type::I32Type i32;
auto var0 =
auto* var0 =
create<ast::Variable>("global_var0", ast::StorageClass::kPrivate, &f32);
var0->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.1)));
mod()->AddGlobalVariable(std::move(var0));
auto var1 =
auto* var1 =
create<ast::Variable>(Source{Source::Location{12, 34}}, "global_var1",
ast::StorageClass::kPrivate, &f32);
var1->set_constructor(create<ast::ScalarConstructorExpression>(
@@ -440,13 +440,13 @@ TEST_F(ValidatorTest, GlobalVariableNotUnique_Fail) {
// var global_var : i32 = 0;
ast::type::F32Type f32;
ast::type::I32Type i32;
auto var0 =
auto* var0 =
create<ast::Variable>("global_var", ast::StorageClass::kPrivate, &f32);
var0->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.1)));
mod()->AddGlobalVariable(std::move(var0));
auto var1 =
auto* var1 =
create<ast::Variable>(Source{Source::Location{12, 34}}, "global_var",
ast::StorageClass::kPrivate, &f32);
var1->set_constructor(create<ast::ScalarConstructorExpression>(
@@ -464,27 +464,27 @@ TEST_F(ValidatorTest, AssignToConstant_Fail) {
// a = 2
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
var->set_is_const(true);
auto lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(body.get())) << td()->error();
EXPECT_TRUE(td()->DetermineStatements(body)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_FALSE(v()->ValidateStatements(body.get()));
EXPECT_FALSE(v()->ValidateStatements(body));
EXPECT_EQ(v()->error(), "12:34: v-0021: cannot re-assign a constant: 'a'");
}
@@ -497,22 +497,22 @@ TEST_F(ValidatorTest, GlobalVariableFunctionVariableNotUnique_Fail) {
ast::type::VoidType void_type;
ast::type::F32Type f32;
auto global_var =
auto* global_var =
create<ast::Variable>("a", ast::StorageClass::kPrivate, &f32);
global_var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.1)));
mod()->AddGlobalVariable(std::move(global_var));
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)));
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(
Source{Source::Location{12, 34}}, std::move(var)));
auto func = create<ast::Function>("my_func", std::move(params), &void_type,
std::move(body));
auto* func_ptr = func.get();
auto* func = create<ast::Function>("my_func", std::move(params), &void_type,
std::move(body));
auto* func_ptr = func;
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();
@@ -529,22 +529,23 @@ TEST_F(ValidatorTest, RedeclaredIndentifier_Fail) {
ast::type::VoidType void_type;
ast::type::I32Type i32;
ast::type::F32Type f32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2)));
auto var_a_float = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var_a_float =
create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var_a_float->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 0.1)));
ast::VariableList params;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
body->append(create<ast::VariableDeclStatement>(
Source{Source::Location{12, 34}}, std::move(var_a_float)));
auto func = create<ast::Function>("my_func", std::move(params), &void_type,
std::move(body));
auto* func_ptr = func.get();
auto* func = create<ast::Function>("my_func", std::move(params), &void_type,
std::move(body));
auto* func_ptr = func;
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();
@@ -559,28 +560,29 @@ TEST_F(ValidatorTest, RedeclaredIdentifierInnerScope_Pass) {
// var a : f32 = 3.14;
// }
ast::type::F32Type f32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)));
ast::type::BoolType bool_type;
auto cond = create<ast::ScalarConstructorExpression>(
auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
auto var_a_float = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var_a_float =
create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var_a_float->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14)));
auto outer_body = create<ast::BlockStatement>();
auto* outer_body = create<ast::BlockStatement>();
outer_body->append(
create<ast::IfStatement>(std::move(cond), std::move(body)));
outer_body->append(create<ast::VariableDeclStatement>(
Source{Source::Location{12, 34}}, std::move(var_a_float)));
EXPECT_TRUE(td()->DetermineStatements(outer_body.get())) << td()->error();
EXPECT_TRUE(v()->ValidateStatements(outer_body.get())) << v()->error();
EXPECT_TRUE(td()->DetermineStatements(outer_body)) << td()->error();
EXPECT_TRUE(v()->ValidateStatements(outer_body)) << v()->error();
}
TEST_F(ValidatorTest, DISABLED_RedeclaredIdentifierInnerScope_False) {
@@ -591,29 +593,30 @@ TEST_F(ValidatorTest, DISABLED_RedeclaredIdentifierInnerScope_False) {
// if (true) { var a : f32 = 2.0; }
// }
ast::type::F32Type f32;
auto var_a_float = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var_a_float =
create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var_a_float->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 3.14)));
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)));
ast::type::BoolType bool_type;
auto cond = create<ast::ScalarConstructorExpression>(
auto* cond = create<ast::ScalarConstructorExpression>(
create<ast::BoolLiteral>(&bool_type, true));
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(
Source{Source::Location{12, 34}}, std::move(var)));
auto outer_body = create<ast::BlockStatement>();
auto* outer_body = create<ast::BlockStatement>();
outer_body->append(
create<ast::VariableDeclStatement>(std::move(var_a_float)));
outer_body->append(
create<ast::IfStatement>(std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(outer_body.get())) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(outer_body.get()));
EXPECT_TRUE(td()->DetermineStatements(outer_body)) << td()->error();
EXPECT_FALSE(v()->ValidateStatements(outer_body));
EXPECT_EQ(v()->error(), "12:34: v-0014: redeclared identifier 'a'");
}
@@ -622,29 +625,29 @@ TEST_F(ValidatorTest, RedeclaredIdentifierDifferentFunctions_Pass) {
// func1 { var a : f32 = 3.0; return; }
ast::type::F32Type f32;
ast::type::VoidType void_type;
auto var0 = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
auto* var0 = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var0->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 2.0)));
auto var1 = create<ast::Variable>("a", ast::StorageClass::kNone, &void_type);
auto* var1 = create<ast::Variable>("a", ast::StorageClass::kNone, &void_type);
var1->set_constructor(create<ast::ScalarConstructorExpression>(
create<ast::FloatLiteral>(&f32, 1.0)));
ast::VariableList params0;
auto body0 = create<ast::BlockStatement>();
auto* body0 = create<ast::BlockStatement>();
body0->append(create<ast::VariableDeclStatement>(
Source{Source::Location{12, 34}}, std::move(var0)));
body0->append(create<ast::ReturnStatement>());
auto func0 = create<ast::Function>("func0", std::move(params0), &void_type,
std::move(body0));
auto* func0 = create<ast::Function>("func0", std::move(params0), &void_type,
std::move(body0));
ast::VariableList params1;
auto body1 = create<ast::BlockStatement>();
auto* body1 = create<ast::BlockStatement>();
body1->append(create<ast::VariableDeclStatement>(
Source{Source::Location{13, 34}}, std::move(var1)));
body1->append(create<ast::ReturnStatement>());
auto func1 = create<ast::Function>("func1", std::move(params1), &void_type,
std::move(body1));
auto* func1 = create<ast::Function>("func1", std::move(params1), &void_type,
std::move(body1));
func1->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
@@ -661,24 +664,24 @@ TEST_F(ValidatorTest, VariableDeclNoConstructor_Pass) {
// a = 2;
// }
ast::type::I32Type i32;
auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
auto* var = create<ast::Variable>("a", ast::StorageClass::kNone, &i32);
td()->RegisterVariableForTesting(var.get());
auto lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = create<ast::ScalarConstructorExpression>(
td()->RegisterVariableForTesting(var);
auto* lhs = create<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs;
auto* rhs = create<ast::ScalarConstructorExpression>(
create<ast::SintLiteral>(&i32, 2));
auto* rhs_ptr = rhs.get();
auto* rhs_ptr = rhs;
auto body = create<ast::BlockStatement>();
auto* body = create<ast::BlockStatement>();
body->append(create<ast::VariableDeclStatement>(std::move(var)));
body->append(create<ast::AssignmentStatement>(
Source{Source::Location{12, 34}}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(body.get())) << td()->error();
EXPECT_TRUE(td()->DetermineStatements(body)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_TRUE(v()->ValidateStatements(body.get())) << v()->error();
EXPECT_TRUE(v()->ValidateStatements(body)) << v()->error();
}
} // namespace

10
src/validator/validator_test_helper.h
View File

@@ -41,11 +41,13 @@ class ValidatorTestHelper {
/// @return a pointer to the test module
ast::Module* mod() { return &mod_; }
/// @return a `std::unique_ptr` to a new `T` constructed with `args`
/// @param args the arguments to forward to the constructor for `T`
/// Creates a new `ast::Node` owned by the Context. When the Context is
/// destructed, the `ast::Node` will also be destructed.
/// @param args the arguments to pass to the type constructor
/// @returns the node pointer
template <typename T, typename... ARGS>
std::unique_ptr<T> create(ARGS&&... args) {
return std::make_unique<T>(std::forward<ARGS>(args)...);
T* create(ARGS&&... args) {
return ctx_.create<T>(std::forward<ARGS>(args)...);
}
private: