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

[Validation] v-0006: variables must be defined before use 

Bug:tint 6
Change-Id: I22f3117a8d59eaba97166de1f188156a9e3cd7a0
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/26381
Reviewed-by: David Neto <dneto@google.com>
Commit-Queue: Sarah Mashayekhi <sarahmashay@google.com>
This commit is contained in:
Sarah Mashayekhi 2020-08-06 21:24:14 +00:00
parent 6eb2a85adf
commit 65f88d6f1d
5 changed files with 370 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/validator_impl.cc
View File

@ -66,6 +66,9 @@ bool ValidatorImpl::ValidateFunction(const ast::Function* func) {
}
bool ValidatorImpl::ValidateStatements(const ast::BlockStatement* block) {
if (!block) {
return false;
}
for (const auto& stmt : *block) {
// TODO(sarahM0): move the folowing to a function
if (stmt->IsVariableDecl()) {
@ -80,13 +83,35 @@ bool ValidatorImpl::ValidateStatements(const ast::BlockStatement* block) {
}
bool ValidatorImpl::ValidateStatement(const ast::Statement* stmt) {
if (stmt->IsAssign() && !ValidateAssign(stmt->AsAssign()))
if (!stmt) {
return false;
}
if (stmt->IsAssign()) {
return ValidateAssign(stmt->AsAssign());
}
return true;
}
bool ValidatorImpl::ValidateAssign(const ast::AssignmentStatement* a) {
if (!a) {
return false;
}
if (!(ValidateExpression(a->lhs()) && ValidateExpression(a->rhs()))) {
return false;
}
if (!ValidateResultTypes(a)) {
return false;
}
return true;
}
bool ValidatorImpl::ValidateResultTypes(const ast::AssignmentStatement* a) {
if (!a->lhs()->result_type() || !a->rhs()->result_type()) {
set_error(a->source(), "result_type() is nullptr");
return false;
}
auto* lhs_result_type = a->lhs()->result_type()->UnwrapAliasPtrAlias();
auto* rhs_result_type = a->rhs()->result_type()->UnwrapAliasPtrAlias();
if (lhs_result_type != rhs_result_type) {
@ -99,6 +124,27 @@ bool ValidatorImpl::ValidateAssign(const ast::AssignmentStatement* a) {
return true;
}
bool ValidatorImpl::ValidateExpression(const ast::Expression* expr) {
if (!expr) {
return false;
}
if (expr->IsIdentifier()) {
return ValidateIdentifier(expr->AsIdentifier());
}
return true;
}
bool ValidatorImpl::ValidateIdentifier(const ast::IdentifierExpression* ident) {
ast::Variable* var;
if (!variable_stack_.get(ident->name(), &var)) {
set_error(ident->source(),
"v-0006: '" + ident->name() + "' is not declared");
return false;
}
return true;
}
bool ValidatorImpl::CheckImports(const ast::Module* module) {
for (const auto& import : module->imports()) {
if (import->path() != "GLSL.std.450") {

13
src/validator_impl.h
View File

@ -19,6 +19,7 @@
#include "src/ast/assignment_statement.h"
#include "src/ast/expression.h"
#include "src/ast/identifier_expression.h"
#include "src/ast/module.h"
#include "src/ast/statement.h"
#include "src/ast/variable.h"
@ -72,6 +73,18 @@ class ValidatorImpl {
/// @param module the modele to check imports
/// @returns ture if input complies with v-0001 rule
bool CheckImports(const ast::Module* module);
/// Validates an expression
/// @param expr the expression to check
/// @return true if the expresssion is valid
bool ValidateExpression(const ast::Expression* expr);
/// Validates v-0006:Variables must be defined before use
/// @param ident the identifer to check if its in the scope
/// @return true if idnet was defined
bool ValidateIdentifier(const ast::IdentifierExpression* ident);
/// Validates if the input follows type checking rules
/// @param 'a' the assignment to check
/// @returns ture if successful
bool ValidateResultTypes(const ast::AssignmentStatement* a);
private:
std::string error_;

281
src/validator_test.cc
View File

@ -20,6 +20,7 @@
#include "src/ast/as_expression.h"
#include "src/ast/assignment_statement.h"
#include "src/ast/binary_expression.h"
#include "src/ast/bool_literal.h"
#include "src/ast/break_statement.h"
#include "src/ast/call_expression.h"
#include "src/ast/case_statement.h"
@ -48,6 +49,8 @@
#include "src/ast/type/struct_type.h"
#include "src/ast/type/vector_type.h"
#include "src/ast/type_constructor_expression.h"
#include "src/ast/variable.h"
#include "src/ast/variable_decl_statement.h"
#include "src/type_determiner.h"
namespace tint {
@ -59,6 +62,7 @@ class TypeDeterminerHelper {
: td_(std::make_unique<TypeDeterminer>(&ctx_, &mod_)) {}
TypeDeterminer* td() const { return td_.get(); }
ast::Module* mod() { return &mod_; }
private:
Context ctx_;
@ -105,7 +109,7 @@ TEST_F(ValidatorTest, DISABLED_AssignToScalar_Fail) {
auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 1));
auto rhs = std::make_unique<ast::IdentifierExpression>("my_var");
ast::AssignmentStatement assign(Source{12, 32}, std::move(lhs),
ast::AssignmentStatement assign(Source{12, 34}, std::move(lhs),
std::move(rhs));
tint::ValidatorImpl v;
@ -115,13 +119,79 @@ TEST_F(ValidatorTest, DISABLED_AssignToScalar_Fail) {
EXPECT_EQ(v.error(), "12:34: v-000x: invalid assignment");
}
TEST_F(ValidatorTest, UsingUndefinedVariable_Fail) {
// b = 2;
ast::type::I32Type i32;
auto lhs = std::make_unique<ast::IdentifierExpression>(Source{12, 34}, "b");
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2));
auto assign = std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs));
EXPECT_TRUE(td()->DetermineResultType(assign.get())) << td()->error();
tint::ValidatorImpl v;
EXPECT_FALSE(v.ValidateStatement(assign.get()));
EXPECT_EQ(v.error(), "12:34: v-0006: 'b' is not declared");
}
TEST_F(ValidatorTest, UsingUndefinedVariableInBlockStatement_Fail) {
// {
// b = 2;
// }
ast::type::I32Type i32;
auto lhs = std::make_unique<ast::IdentifierExpression>(Source{12, 34}, "b");
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2));
auto body = std::make_unique<ast::BlockStatement>();
body->append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(body.get())) << td()->error();
tint::ValidatorImpl v;
EXPECT_FALSE(v.ValidateStatements(body.get()));
EXPECT_EQ(v.error(), "12:34: v-0006: 'b' is not declared");
}
TEST_F(ValidatorTest, AssignCompatibleTypes_Pass) {
// var a :i32 = 2;
// a = 2
ast::type::I32Type i32;
auto var =
std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2)));
auto lhs = std::make_unique<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2));
auto* rhs_ptr = rhs.get();
ast::AssignmentStatement assign(Source{12, 34}, std::move(lhs),
std::move(rhs));
td()->RegisterVariableForTesting(var.get());
EXPECT_TRUE(td()->DetermineResultType(&assign)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
tint::ValidatorImpl v;
EXPECT_TRUE(v.ValidateResultTypes(&assign));
}
TEST_F(ValidatorTest, AssignIncompatibleTypes_Fail) {
// var a :i32;
// a = 2.3;
// {
// var a :i32 = 2;
// a = 2.3;
// }
ast::type::F32Type f32;
ast::type::I32Type i32;
ast::Variable var("a", ast::StorageClass::kPrivate, &i32);
auto var =
std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2)));
auto lhs = std::make_unique<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
@ -130,36 +200,217 @@ TEST_F(ValidatorTest, AssignIncompatibleTypes_Fail) {
ast::AssignmentStatement assign(Source{12, 34}, std::move(lhs),
std::move(rhs));
td()->RegisterVariableForTesting(&var);
td()->RegisterVariableForTesting(var.get());
EXPECT_TRUE(td()->DetermineResultType(&assign)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
tint::ValidatorImpl v;
EXPECT_FALSE(v.ValidateAssign(&assign));
EXPECT_FALSE(v.ValidateResultTypes(&assign));
ASSERT_TRUE(v.has_error());
// TODO(sarahM0): figure out what should be the error number.
EXPECT_EQ(v.error(),
"12:34: v-000x: invalid assignment of '__i32' to '__f32'");
}
TEST_F(ValidatorTest, AssignCompatibleTypes_Pass) {
// var a :i32;
// a = 2;
TEST_F(ValidatorTest, AssignCompatibleTypesInBlockStatement_Pass) {
// {
// var a :i32 = 2;
// a = 2
// }
ast::type::I32Type i32;
auto var =
std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2)));
ast::Variable var("a", ast::StorageClass::kPrivate, &i32);
auto lhs = std::make_unique<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2));
auto* rhs_ptr = rhs.get();
ast::AssignmentStatement assign(Source{12, 34}, std::move(lhs),
std::move(rhs));
auto body = std::make_unique<ast::BlockStatement>();
body->append(std::make_unique<ast::VariableDeclStatement>(std::move(var)));
body->append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(body.get())) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
td()->RegisterVariableForTesting(&var);
EXPECT_TRUE(td()->DetermineResultType(&assign)) << td()->error();
tint::ValidatorImpl v;
EXPECT_TRUE(v.ValidateAssign(&assign));
EXPECT_TRUE(v.ValidateStatements(body.get()));
}
TEST_F(ValidatorTest, AssignIncompatibleTypesInBlockStatement_Fail) {
// {
// var a :i32 = 2;
// a = 2.3;
// }
ast::type::F32Type f32;
ast::type::I32Type i32;
auto var =
std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &i32);
var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::SintLiteral>(&i32, 2)));
auto lhs = std::make_unique<ast::IdentifierExpression>("a");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
auto* rhs_ptr = rhs.get();
ast::BlockStatement block;
block.append(std::make_unique<ast::VariableDeclStatement>(std::move(var)));
block.append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(&block)) << td()->error();
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
tint::ValidatorImpl v;
EXPECT_FALSE(v.ValidateStatements(&block));
ASSERT_TRUE(v.has_error());
// TODO(sarahM0): figure out what should be the error number.
EXPECT_EQ(v.error(),
"12:34: v-000x: invalid assignment of '__i32' to '__f32'");
}
TEST_F(ValidatorTest, UnsingUndefinedVariableGlobalVariable_Fail) {
ast::type::F32Type f32;
auto global_var = std::make_unique<ast::Variable>(
"global_var", ast::StorageClass::kPrivate, &f32);
global_var->set_constructor(
std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 2.1)));
mod()->AddGlobalVariable(std::move(global_var));
auto lhs = std::make_unique<ast::IdentifierExpression>(Source{12, 34},
"not_global_var");
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 3.14f));
ast::VariableList params;
auto func =
std::make_unique<ast::Function>("my_func", std::move(params), &f32);
auto body = std::make_unique<ast::BlockStatement>();
body->append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
func->set_body(std::move(body));
mod()->AddFunction(std::move(func));
tint::ValidatorImpl v;
EXPECT_FALSE(v.Validate(mod()));
EXPECT_EQ(v.error(), "12:34: v-0006: 'not_global_var' is not declared");
}
TEST_F(ValidatorTest, UnsingUndefinedVariableGlobalVariable_Pass) {
ast::type::F32Type f32;
auto global_var = std::make_unique<ast::Variable>(
"global_var", ast::StorageClass::kPrivate, &f32);
global_var->set_constructor(
std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 2.1)));
mod()->AddGlobalVariable(std::move(global_var));
auto lhs = std::make_unique<ast::IdentifierExpression>("global_var");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 3.14f));
auto* rhs_ptr = rhs.get();
ast::VariableList params;
auto func =
std::make_unique<ast::Function>("my_func", std::move(params), &f32);
auto body = std::make_unique<ast::BlockStatement>();
body->append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
func->set_body(std::move(body));
auto* func_ptr = func.get();
mod()->AddFunction(std::move(func));
EXPECT_TRUE(td()->Determine()) << td()->error();
EXPECT_TRUE(td()->DetermineFunction(func_ptr)) << td()->error();
tint::ValidatorImpl v;
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_TRUE(v.Validate(mod())) << v.error();
}
TEST_F(ValidatorTest, UnsingUndefinedVariableInnerScope_Fail) {
// {
// if (true) { var a : f32 = 2.0; }
// a = 3.14;
// }
ast::type::F32Type f32;
auto var =
std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 2.0)));
ast::type::BoolType bool_type;
auto cond = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::BoolLiteral>(&bool_type, true));
auto body = std::make_unique<ast::BlockStatement>();
body->append(std::make_unique<ast::VariableDeclStatement>(std::move(var)));
auto lhs = std::make_unique<ast::IdentifierExpression>(Source{12, 34}, "a");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 3.14f));
auto* rhs_ptr = rhs.get();
auto outer_body = std::make_unique<ast::BlockStatement>();
outer_body->append(
std::make_unique<ast::IfStatement>(std::move(cond), std::move(body)));
outer_body->append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
EXPECT_TRUE(td()->DetermineStatements(outer_body.get())) << td()->error();
tint::ValidatorImpl v;
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_FALSE(v.ValidateStatements(outer_body.get()));
EXPECT_EQ(v.error(), "12:34: v-0006: 'a' is not declared");
}
TEST_F(ValidatorTest, UnsingUndefinedVariableOuterScope_Pass) {
// {
// var a : f32 = 2.0;
// if (true) { a = 3.14; }
// }
ast::type::F32Type f32;
auto var =
std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 2.0)));
auto lhs = std::make_unique<ast::IdentifierExpression>(Source{12, 34}, "a");
auto* lhs_ptr = lhs.get();
auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::FloatLiteral>(&f32, 3.14f));
auto* rhs_ptr = rhs.get();
ast::type::BoolType bool_type;
auto cond = std::make_unique<ast::ScalarConstructorExpression>(
std::make_unique<ast::BoolLiteral>(&bool_type, true));
auto body = std::make_unique<ast::BlockStatement>();
body->append(std::make_unique<ast::AssignmentStatement>(
Source{12, 34}, std::move(lhs), std::move(rhs)));
auto outer_body = std::make_unique<ast::BlockStatement>();
outer_body->append(
std::make_unique<ast::VariableDeclStatement>(std::move(var)));
outer_body->append(
std::make_unique<ast::IfStatement>(std::move(cond), std::move(body)));
EXPECT_TRUE(td()->DetermineStatements(outer_body.get())) << td()->error();
tint::ValidatorImpl v;
ASSERT_NE(lhs_ptr->result_type(), nullptr);
ASSERT_NE(rhs_ptr->result_type(), nullptr);
EXPECT_TRUE(v.ValidateStatements(outer_body.get())) << v.error();
}
TEST_F(ValidatorTest, DISABLED_AssignToConstant_Fail) {

23
test/undefined-variable-global-scope.wgsl Normal file
View File

@ -0,0 +1,23 @@
# Copyright 2020 The Tint Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Vertex shader
var<private> a : i32;
fn main() -> void {
a = 2;
return;
}
entry_point vertex as "main" = main;

20
test/undefined-variable-inner-block.wgsl Normal file
View File

@ -0,0 +1,20 @@
# Copyright 2020 The Tint Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
fn main() -> void {
var a : f32 = 2.0;
{ a = 3.14;}
return;
}
entry_point fragment = main;