Add unit tests for AsExpression

This CL adds unit tests for the as expression and fixes up a few issues
along the way.

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

src/CMakeLists.txt

@@ -194,6 +194,7 @@ endif()
 
 set(TINT_TEST_SRCS
   ast/array_accessor_expression_test.cc
+  ast/as_expression_test.cc
   ast/binding_decoration_test.cc
   ast/bool_literal_test.cc
   ast/builtin_decoration_test.cc

src/ast/array_accessor_expression_test.cc

@@ -48,7 +48,6 @@ TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) {
   EXPECT_TRUE(exp.IsArrayAccessor());
 }
 
-
 TEST_F(ArrayAccessorExpressionTest, IsValid) {
   auto ary = std::make_unique<IdentifierExpression>("ary");
   auto idx = std::make_unique<IdentifierExpression>("idx");
@@ -79,12 +78,12 @@ TEST_F(ArrayAccessorExpressionTest, ToStr) {
 
   ArrayAccessorExpression exp(std::move(ary), std::move(idx));
   std::ostringstream out;
-  exp.to_str(out, 0);
+  exp.to_str(out, 2);
 
-  EXPECT_EQ(out.str(), R"(ArrayAccessor{
-  Identifier{ary}
-  Identifier{idx}
-}
+  EXPECT_EQ(out.str(), R"(  ArrayAccessor{
+    Identifier{ary}
+    Identifier{idx}
+  }
 )");
 }
 

src/ast/as_expression.cc

@@ -17,6 +17,8 @@
 namespace tint {
 namespace ast {
 
+AsExpression::AsExpression() : Expression() {}
+
 AsExpression::AsExpression(type::Type* type, std::unique_ptr<Expression> expr)
     : Expression(), type_(type), expr_(std::move(expr)) {}
 
@@ -28,13 +30,17 @@ AsExpression::AsExpression(const Source& source,
 AsExpression::~AsExpression() = default;
 
 bool AsExpression::IsValid() const {
-  return type_ != nullptr && expr_ != nullptr;
+  if (expr_ == nullptr || !expr_->IsValid())
+    return false;
+  return type_ != nullptr;
 }
 
 void AsExpression::to_str(std::ostream& out, size_t indent) const {
-  out << "as<" << type_->type_name() << ">(";
-  expr_->to_str(out, indent);
-  out << ")";
+  make_indent(out, indent);
+  out << "As<" << type_->type_name() << ">{" << std::endl;
+  expr_->to_str(out, indent + 2);
+  make_indent(out, indent);
+  out << "}" << std::endl;
 }
 
 }  // namespace ast

src/ast/as_expression.h

@@ -29,6 +29,8 @@ namespace ast {
 /// An as expression
 class AsExpression : public Expression {
  public:
+  /// Constructor
+  AsExpression();
   /// Constructor
   /// @param type the type
   /// @param expr the expr
@@ -70,7 +72,7 @@ class AsExpression : public Expression {
  private:
   AsExpression(const AsExpression&) = delete;
 
-  type::Type* type_;
+  type::Type* type_ = nullptr;
   std::unique_ptr<Expression> expr_;
 };
 

src/ast/as_expression_test.cc

@@ -0,0 +1,98 @@
+// 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/as_expression.h"
+
+#include "gtest/gtest.h"
+#include "src/ast/identifier_expression.h"
+#include "src/ast/type/f32_type.h"
+
+namespace tint {
+namespace ast {
+
+using AsExpressionTest = testing::Test;
+
+TEST_F(AsExpressionTest, Create) {
+  type::F32Type f32;
+  auto expr = std::make_unique<IdentifierExpression>("expr");
+
+  auto expr_ptr = expr.get();
+
+  AsExpression exp(&f32, std::move(expr));
+  ASSERT_EQ(exp.type(), &f32);
+  ASSERT_EQ(exp.expr(), expr_ptr);
+}
+
+TEST_F(AsExpressionTest, CreateWithSource) {
+  type::F32Type f32;
+  auto expr = std::make_unique<IdentifierExpression>("expr");
+
+  AsExpression exp(Source{20, 2}, &f32, std::move(expr));
+  auto src = exp.source();
+  EXPECT_EQ(src.line, 20);
+  EXPECT_EQ(src.column, 2);
+}
+
+TEST_F(AsExpressionTest, IsAs) {
+  AsExpression exp;
+  EXPECT_TRUE(exp.IsAs());
+}
+
+TEST_F(AsExpressionTest, IsValid) {
+  type::F32Type f32;
+  auto expr = std::make_unique<IdentifierExpression>("expr");
+
+  AsExpression exp(&f32, std::move(expr));
+  EXPECT_TRUE(exp.IsValid());
+}
+
+TEST_F(AsExpressionTest, IsValid_MissingType) {
+  auto expr = std::make_unique<IdentifierExpression>("expr");
+
+  AsExpression exp;
+  exp.set_expr(std::move(expr));
+  EXPECT_FALSE(exp.IsValid());
+}
+
+TEST_F(AsExpressionTest, IsValid_MissingExpr) {
+  type::F32Type f32;
+
+  AsExpression exp;
+  exp.set_type(&f32);
+  EXPECT_FALSE(exp.IsValid());
+}
+
+TEST_F(AsExpressionTest, IsValid_InvalidExpr) {
+  type::F32Type f32;
+  auto expr = std::make_unique<IdentifierExpression>("");
+  AsExpression e(&f32, std::move(expr));
+  EXPECT_FALSE(e.IsValid());
+}
+
+TEST_F(AsExpressionTest, ToStr) {
+  type::F32Type f32;
+  auto expr = std::make_unique<IdentifierExpression>("expr");
+
+  AsExpression exp(&f32, std::move(expr));
+  std::ostringstream out;
+  exp.to_str(out, 2);
+
+  EXPECT_EQ(out.str(), R"(  As<__f32>{
+    Identifier{expr}
+  }
+)");
+}
+
+}  // namespace ast
+}  // namespace tint

src/ast/identifier_expression.cc

@@ -34,7 +34,7 @@ IdentifierExpression::IdentifierExpression(const Source& source,
 IdentifierExpression::~IdentifierExpression() = default;
 
 bool IdentifierExpression::IsValid() const {
-  return name_.size() > 0 && name_[1].size() > 0;
+  return name_.size() > 0 && name_[0].size() > 0;
 }
 
 void IdentifierExpression::to_str(std::ostream& out, size_t indent) const {