[writer]: AppendVector() - support zero value vectors

These were not correctly handled, causing multiple writer issues.

Updated test stats:
3248 tests run, 2693 tests pass, 555 tests skipped, 0 tests failed

Fixed: tint:757
Change-Id: If92e9c2ceefe986c92ca47d23c8d6b64b155ca49
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/53081
Auto-Submit: Ben Clayton <bclayton@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: David Neto <dneto@google.com>

src/writer/append_vector.cc

@@ -57,6 +57,11 @@ ast::TypeConstructorExpression* AppendVector(ProgramBuilder* b,
     packed_el_ty = b->create<ast::U32>();
   } else if (packed_el_sem_ty->Is<sem::F32>()) {
     packed_el_ty = b->create<ast::F32>();
+  } else if (packed_el_sem_ty->Is<sem::Bool>()) {
+    packed_el_ty = b->create<ast::Bool>();
+  } else {
+    TINT_UNREACHABLE(b->Diagnostics()) << "unsupported vector element type: "
+                                       << packed_el_sem_ty->TypeInfo().name;
   }
 
   auto* statement = vector_sem->Stmt();
@@ -69,6 +74,32 @@ ast::TypeConstructorExpression* AppendVector(ProgramBuilder* b,
   ast::ExpressionList packed;
   if (auto* vc = AsVectorConstructor(b, vector)) {
     packed = vc->values();
+    if (packed.size() == 0) {
+      // Zero-value vector constructor. Populate with zeros
+      auto buildZero = [&]() -> ast::ScalarConstructorExpression* {
+        if (packed_el_sem_ty->Is<sem::I32>()) {
+          return b->Expr(0);
+        } else if (packed_el_sem_ty->Is<sem::U32>()) {
+          return b->Expr(0u);
+        } else if (packed_el_sem_ty->Is<sem::F32>()) {
+          return b->Expr(0.0f);
+        } else if (packed_el_sem_ty->Is<sem::Bool>()) {
+          return b->Expr(false);
+        } else {
+          TINT_UNREACHABLE(b->Diagnostics())
+              << "unsupported vector element type: "
+              << packed_el_sem_ty->TypeInfo().name;
+        }
+        return nullptr;
+      };
+
+      for (uint32_t i = 0; i < packed_size - 1; i++) {
+        auto* zero = buildZero();
+        b->Sem().Add(zero, b->create<sem::Expression>(zero, packed_el_sem_ty,
+                                                      statement));
+        packed.emplace_back(zero);
+      }
+    }
   } else {
     packed.emplace_back(vector);
   }

src/writer/append_vector.h

@@ -27,9 +27,6 @@ class TypeConstructorExpression;
 namespace writer {
 
 /// A helper function used to append a vector with an additional scalar.
-/// AppendVector is used to generate texture intrinsic function calls for
-/// backends that expect the texture coordinates to be packed with an additional
-/// mip-level or array-index parameter.
 /// All types must have been assigned to the expressions and their child nodes
 /// before calling.
 /// @param builder the program builder.

src/writer/append_vector_test.cc

@@ -162,6 +162,46 @@ TEST_F(AppendVectorTest, Vec2i32Var_f32Var) {
   EXPECT_EQ(f32_to_i32->values()[0], scalar_3);
 }
 
+TEST_F(AppendVectorTest, Vec2boolVar_boolVar) {
+  Global("vec_12", ty.vec2<bool>(), ast::StorageClass::kInput);
+  Global("scalar_3", ty.bool_(), ast::StorageClass::kInput);
+  auto* vec_12 = Expr("vec_12");
+  auto* scalar_3 = Expr("scalar_3");
+  WrapInFunction(vec_12, scalar_3);
+
+  resolver::Resolver resolver(this);
+  ASSERT_TRUE(resolver.Resolve()) << resolver.error();
+
+  auto* vec_123 = AppendVector(this, vec_12, scalar_3)
+                      ->As<ast::TypeConstructorExpression>();
+  ASSERT_NE(vec_123, nullptr);
+  ASSERT_EQ(vec_123->values().size(), 2u);
+  EXPECT_EQ(vec_123->values()[0], vec_12);
+  EXPECT_EQ(vec_123->values()[1], scalar_3);
+}
+
+TEST_F(AppendVectorTest, ZeroVec3i32_i32) {
+  auto* scalar = Expr(4);
+  auto* vec000 = vec3<i32>();
+  WrapInFunction(vec000, scalar);
+
+  resolver::Resolver resolver(this);
+  ASSERT_TRUE(resolver.Resolve()) << resolver.error();
+
+  auto* vec_0004 =
+      AppendVector(this, vec000, scalar)->As<ast::TypeConstructorExpression>();
+  ASSERT_NE(vec_0004, nullptr);
+  ASSERT_EQ(vec_0004->values().size(), 4u);
+  for (size_t i = 0; i < 3; i++) {
+    auto* ctor = vec_0004->values()[i]->As<ast::ScalarConstructorExpression>();
+    ASSERT_NE(ctor, nullptr);
+    auto* literal = As<ast::SintLiteral>(ctor->literal());
+    ASSERT_NE(literal, nullptr);
+    EXPECT_EQ(literal->value(), 0);
+  }
+  EXPECT_EQ(vec_0004->values()[3], scalar);
+}
+
 }  // namespace
 }  // namespace writer
 }  // namespace tint