writer[spirv,hlsl]: Call UnwrapRef() for splats

The TypeConstructorExpression logic that tested for splats was not considering references. This led to broken emission for the SPIR-V and HLSL backends.

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

src/writer/hlsl/generator_impl.cc

@@ -1989,7 +1989,7 @@ bool GeneratorImpl::EmitTypeConstructor(std::ostream& out,
   // vector dimension using .x
   const bool is_single_value_vector_init =
       type->is_scalar_vector() && expr->values().size() == 1 &&
-      TypeOf(expr->values()[0])->is_scalar();
+      TypeOf(expr->values()[0])->UnwrapRef()->is_scalar();
 
   auto it = structure_builders_.find(As<sem::Struct>(type));
   if (it != structure_builders_.end()) {

src/writer/hlsl/generator_impl_constructor_test.cc

@@ -116,7 +116,7 @@ TEST_F(HlslGeneratorImplTest_Constructor, EmitConstructor_Type_Vec_Empty) {
 }
 
 TEST_F(HlslGeneratorImplTest_Constructor,
-       EmitConstructor_Type_Vec_SingleScalar_Float) {
+       EmitConstructor_Type_Vec_SingleScalar_Float_Literal) {
   WrapInFunction(vec3<f32>(2.0f));
 
   GeneratorImpl& gen = Build();
@@ -126,7 +126,20 @@ TEST_F(HlslGeneratorImplTest_Constructor,
 }
 
 TEST_F(HlslGeneratorImplTest_Constructor,
-       EmitConstructor_Type_Vec_SingleScalar_Bool) {
+       EmitConstructor_Type_Vec_SingleScalar_Float_Var) {
+  auto* var = Var("v", nullptr, Expr(2.0f));
+  auto* cast = vec3<f32>(var);
+  WrapInFunction(var, cast);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(float v = 2.0f;
+  const float3 tint_symbol = float3((v).xxx);)"));
+}
+
+TEST_F(HlslGeneratorImplTest_Constructor,
+       EmitConstructor_Type_Vec_SingleScalar_Bool_Literal) {
   WrapInFunction(vec3<bool>(true));
 
   GeneratorImpl& gen = Build();
@@ -135,6 +148,19 @@ TEST_F(HlslGeneratorImplTest_Constructor,
   EXPECT_THAT(gen.result(), HasSubstr("bool3((true).xxx)"));
 }
 
+TEST_F(HlslGeneratorImplTest_Constructor,
+       EmitConstructor_Type_Vec_SingleScalar_Bool_Var) {
+  auto* var = Var("v", nullptr, Expr(true));
+  auto* cast = vec3<bool>(var);
+  WrapInFunction(var, cast);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(bool v = true;
+  const bool3 tint_symbol = bool3((v).xxx);)"));
+}
+
 TEST_F(HlslGeneratorImplTest_Constructor,
        EmitConstructor_Type_Vec_SingleScalar_Int) {
   WrapInFunction(vec3<i32>(2));

src/writer/spirv/builder.cc

@@ -1453,7 +1453,7 @@ uint32_t Builder::GenerateTypeConstructorExpression(
   // For a single-value vector initializer, splat the initializer value.
   auto* const init_result_type = TypeOf(init)->UnwrapRef();
   if (values.size() == 1 && init_result_type->is_scalar_vector() &&
-      TypeOf(values[0])->is_scalar()) {
+      TypeOf(values[0])->UnwrapRef()->is_scalar()) {
     size_t vec_size = init_result_type->As<sem::Vector>()->size();
     for (size_t i = 0; i < (vec_size - 1); ++i) {
       ops.push_back(ops[0]);

src/writer/spirv/builder_constructor_expression_test.cc

@@ -241,7 +241,7 @@ TEST_F(SpvBuilderConstructorTest, Type_F32_With_F32) {
   EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()");
 }
 
-TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Bool) {
+TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Bool_Literal) {
   auto* cast = vec2<bool>(true);
   WrapInFunction(cast);
 
@@ -255,9 +255,34 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Bool) {
 %3 = OpConstantTrue %2
 %4 = OpConstantComposite %1 %3 %3
 )");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()");
 }
 
-TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32) {
+TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Bool_Var) {
+  auto* var = Var("v", nullptr, Expr(true));
+  auto* cast = vec2<bool>(var);
+  WrapInFunction(var, cast);
+
+  spirv::Builder& b = Build();
+
+  b.push_function(Function{});
+  ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error();
+  ASSERT_EQ(b.GenerateExpression(cast), 8u) << b.error();
+
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
+%2 = OpConstantTrue %1
+%4 = OpTypePointer Function %1
+%5 = OpConstantNull %1
+%6 = OpTypeVector %1 2
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(OpStore %3 %2
+%7 = OpLoad %1 %3
+%8 = OpCompositeConstruct %6 %7 %7
+)");
+}
+
+TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_Literal) {
   auto* cast = vec2<f32>(2.0f);
   WrapInFunction(cast);
 
@@ -270,6 +295,30 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32) {
 %1 = OpTypeVector %2 2
 %3 = OpConstant %2 2
 %4 = OpConstantComposite %1 %3 %3
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()");
+}
+
+TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_Var) {
+  auto* var = Var("v", nullptr, Expr(2.0f));
+  auto* cast = vec2<f32>(var);
+  WrapInFunction(var, cast);
+
+  spirv::Builder& b = Build();
+
+  b.push_function(Function{});
+  ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error();
+  ASSERT_EQ(b.GenerateExpression(cast), 8u) << b.error();
+
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
+%2 = OpConstant %1 2
+%4 = OpTypePointer Function %1
+%5 = OpConstantNull %1
+%6 = OpTypeVector %1 2
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %3 %2
+%7 = OpLoad %1 %3
+%8 = OpCompositeConstruct %6 %7 %7
 )");
 }