Add tests for if statement AST

This CL adds tests for the if statement AST node.

Bug: tint:11
Change-Id: Ice3f281e1dfd72d76f43767f7b3040af862f4a58
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/16540
Reviewed-by: Sarah Mashayekhi <sarahmashay@google.com>

src/CMakeLists.txt

@@ -216,6 +216,7 @@ set(TINT_TEST_SRCS
   ast/fallthrough_statement_test.cc
   ast/function_test.cc
   ast/identifier_expression_test.cc
+  ast/if_statement_test.cc
   ast/import_test.cc
   ast/int_literal_test.cc
   ast/location_decoration_test.cc

src/ast/else_statement.cc

@@ -53,8 +53,15 @@ bool ElseStatement::IsValid() const {
 void ElseStatement::to_str(std::ostream& out, size_t indent) const {
   make_indent(out, indent);
   out << "Else{" << std::endl;
-  if (condition_ != nullptr)
+  if (condition_ != nullptr) {
-    condition_->to_str(out, indent + 2);
+    make_indent(out, indent + 2);
+    out << "(" << std::endl;
+
+    condition_->to_str(out, indent + 4);
+
+    make_indent(out, indent + 2);
+    out << ")" << std::endl;
+  }
 
   make_indent(out, indent + 2);
   out << "{" << std::endl;

src/ast/else_statement_test.cc

@@ -110,7 +110,9 @@ TEST_F(ElseStatementTest, ToStr) {
   std::ostringstream out;
   e.to_str(out, 2);
   EXPECT_EQ(out.str(), R"(  Else{
-    ConstInitializer{true}
+    (
+      ConstInitializer{true}
+    )
     {
       Nop{}
     }

src/ast/if_statement.cc

@@ -35,11 +35,40 @@ IfStatement::IfStatement(const Source& source,
 IfStatement::~IfStatement() = default;
 
 bool IfStatement::IsValid() const {
-  if (condition_ == nullptr)
+  if (condition_ == nullptr || !condition_->IsValid())
     return false;
 
-  if (premerge_.size() > 0 && else_statements_.size() > 1)
+  for (const auto& stmt : body_) {
-    return false;
+    if (stmt == nullptr || !stmt->IsValid())
+      return false;
+  }
+
+  bool found_else = false;
+  for (const auto& el : else_statements_) {
+    // Else statement must be last
+    if (found_else)
+      return false;
+
+    if (el == nullptr || !el->IsValid())
+      return false;
+
+    if (el->condition() == nullptr)
+      found_else = true;
+  }
+
+  for (const auto& stmt : premerge_) {
+    if (stmt == nullptr || !stmt->IsValid())
+      return false;
+  }
+
+  if (premerge_.size() > 0) {
+    // Premerge only with a single else statement
+    if (else_statements_.size() != 1)
+      return false;
+    // Must be an else, not an elseif
+    if (else_statements_[0]->condition() != nullptr)
+      return false;
+  }
 
   return true;
 }
@@ -47,28 +76,43 @@ bool IfStatement::IsValid() const {
 void IfStatement::to_str(std::ostream& out, size_t indent) const {
   make_indent(out, indent);
   out << "If{" << std::endl;
-  condition_->to_str(out, indent + 2);
+
-  out << std::endl;
+  // Open if conditional
+  make_indent(out, indent + 2);
+  out << "(" << std::endl;
+
+  condition_->to_str(out, indent + 4);
+
+  // Close if conditional
+  make_indent(out, indent + 2);
+  out << ")" << std::endl;
+
+  // Open if body
   make_indent(out, indent + 2);
   out << "{" << std::endl;
 
   for (const auto& stmt : body_)
     stmt->to_str(out, indent + 4);
 
+  // Close the if body
   make_indent(out, indent + 2);
   out << "}" << std::endl;
 
+  // Close the If
+  make_indent(out, indent);
+  out << "}" << std::endl;
+
   for (const auto& e : else_statements_)
-    e->to_str(out, indent + 2);
+    e->to_str(out, indent);
 
   if (premerge_.size() > 0) {
-    make_indent(out, indent + 2);
+    make_indent(out, indent);
     out << "premerge{" << std::endl;
 
     for (const auto& stmt : premerge_)
-      stmt->to_str(out, indent + 4);
+      stmt->to_str(out, indent + 2);
 
-    make_indent(out, indent + 2);
+    make_indent(out, indent);
     out << "}" << std::endl;
   }
 }

src/ast/if_statement_test.cc

@@ -0,0 +1,365 @@
+// 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.
+
+#include "src/ast/if_statement.h"
+
+#include "gtest/gtest.h"
+#include "src/ast/identifier_expression.h"
+#include "src/ast/kill_statement.h"
+#include "src/ast/nop_statement.h"
+
+namespace tint {
+namespace ast {
+
+using IfStatementTest = testing::Test;
+
+TEST_F(IfStatementTest, Creation) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  auto cond_ptr = cond.get();
+  auto stmt_ptr = body[0].get();
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  EXPECT_EQ(stmt.condition(), cond_ptr);
+  ASSERT_EQ(stmt.body().size(), 1);
+  EXPECT_EQ(stmt.body()[0].get(), stmt_ptr);
+}
+
+TEST_F(IfStatementTest, Creation_WithSource) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(Source{20, 2}, std::move(cond), std::move(body));
+  auto src = stmt.source();
+  EXPECT_EQ(src.line, 20);
+  EXPECT_EQ(src.column, 2);
+}
+
+TEST_F(IfStatementTest, IsIf) {
+  IfStatement stmt;
+  EXPECT_TRUE(stmt.IsIf());
+}
+
+TEST_F(IfStatementTest, IsValid) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  EXPECT_TRUE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_WithElseStatements) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[0]->set_condition(std::make_unique<IdentifierExpression>("Ident"));
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  EXPECT_TRUE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_WithPremerge) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+
+  std::vector<std::unique_ptr<Statement>> premerge;
+  premerge.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  stmt.set_premerge(std::move(premerge));
+  EXPECT_TRUE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_MissingCondition) {
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(nullptr, std::move(body));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_InvalidCondition) {
+  auto cond = std::make_unique<IdentifierExpression>("");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_NullBodyStatement) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+  body.push_back(nullptr);
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_InvalidBodyStatement) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+  body.push_back(std::make_unique<IfStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_NullElseStatement) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[0]->set_condition(std::make_unique<IdentifierExpression>("Ident"));
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts.push_back(nullptr);
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_InvalidElseStatement) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[0]->set_condition(std::make_unique<IdentifierExpression>(""));
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_NullPremergeStatement) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+
+  std::vector<std::unique_ptr<Statement>> premerge;
+  premerge.push_back(std::make_unique<NopStatement>());
+  premerge.push_back(nullptr);
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  stmt.set_premerge(std::move(premerge));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_InvalidPremergeStatement) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+
+  std::vector<std::unique_ptr<Statement>> premerge;
+  premerge.push_back(std::make_unique<IfStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  stmt.set_premerge(std::move(premerge));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_PremergeWithElseIf) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[0]->set_condition(std::make_unique<IdentifierExpression>("ident"));
+
+  std::vector<std::unique_ptr<Statement>> premerge;
+  premerge.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  stmt.set_premerge(std::move(premerge));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_PremergeWithoutElse) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<Statement>> premerge;
+  premerge.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_premerge(std::move(premerge));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_MultipleElseWiththoutCondition) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, IsValid_ElseNotLast) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[1]->set_condition(std::make_unique<IdentifierExpression>("ident"));
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  EXPECT_FALSE(stmt.IsValid());
+}
+
+TEST_F(IfStatementTest, ToStr) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+
+  std::ostringstream out;
+  stmt.to_str(out, 2);
+  EXPECT_EQ(out.str(), R"(  If{
+    (
+      Identifier{cond}
+    )
+    {
+      Nop{}
+    }
+  }
+)");
+}
+
+TEST_F(IfStatementTest, ToStr_WithElseStatements) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<Statement>> else_if_body;
+  else_if_body.push_back(std::make_unique<KillStatement>());
+
+  std::vector<std::unique_ptr<Statement>> else_body;
+  else_body.push_back(std::make_unique<NopStatement>());
+  else_body.push_back(std::make_unique<KillStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[0]->set_condition(std::make_unique<IdentifierExpression>("ident"));
+  else_stmts[0]->set_body(std::move(else_if_body));
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+  else_stmts[1]->set_body(std::move(else_body));
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+
+  std::ostringstream out;
+  stmt.to_str(out, 2);
+  EXPECT_EQ(out.str(), R"(  If{
+    (
+      Identifier{cond}
+    )
+    {
+      Nop{}
+    }
+  }
+  Else{
+    (
+      Identifier{ident}
+    )
+    {
+      Kill{}
+    }
+  }
+  Else{
+    {
+      Nop{}
+      Kill{}
+    }
+  }
+)");
+}
+
+TEST_F(IfStatementTest, ToStr_WithPremerge) {
+  auto cond = std::make_unique<IdentifierExpression>("cond");
+  std::vector<std::unique_ptr<Statement>> body;
+  body.push_back(std::make_unique<NopStatement>());
+
+  std::vector<std::unique_ptr<ElseStatement>> else_stmts;
+  else_stmts.push_back(std::make_unique<ElseStatement>());
+
+  std::vector<std::unique_ptr<Statement>> premerge;
+  premerge.push_back(std::make_unique<NopStatement>());
+
+  IfStatement stmt(std::move(cond), std::move(body));
+  stmt.set_else_statements(std::move(else_stmts));
+  stmt.set_premerge(std::move(premerge));
+
+  std::ostringstream out;
+  stmt.to_str(out, 2);
+  EXPECT_EQ(out.str(), R"(  If{
+    (
+      Identifier{cond}
+    )
+    {
+      Nop{}
+    }
+  }
+  Else{
+    {
+    }
+  }
+  premerge{
+    Nop{}
+  }
+)");
+}
+
+}  // namespace ast
+}  // namespace tint