// 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 "gmock/gmock.h"
#include "src/ast/stage_decoration.h"
#include "src/ast/struct_block_decoration.h"
#include "src/sem/access_control_type.h"
#include "src/writer/hlsl/test_helper.h"

namespace tint {
namespace writer {
namespace hlsl {
namespace {

using ::testing::HasSubstr;

using create_type_func_ptr =
    sem::Type* (*)(const ProgramBuilder::TypesBuilder& ty);

inline sem::Type* ty_i32(const ProgramBuilder::TypesBuilder& ty) {
  return ty.i32();
}
inline sem::Type* ty_u32(const ProgramBuilder::TypesBuilder& ty) {
  return ty.u32();
}
inline sem::Type* ty_f32(const ProgramBuilder::TypesBuilder& ty) {
  return ty.f32();
}
template <typename T>
inline sem::Type* ty_vec2(const ProgramBuilder::TypesBuilder& ty) {
  return ty.vec2<T>();
}
template <typename T>
inline sem::Type* ty_vec3(const ProgramBuilder::TypesBuilder& ty) {
  return ty.vec3<T>();
}
template <typename T>
inline sem::Type* ty_vec4(const ProgramBuilder::TypesBuilder& ty) {
  return ty.vec4<T>();
}
template <typename T>
inline sem::Type* ty_mat2x2(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat2x2<T>();
}
template <typename T>
inline sem::Type* ty_mat2x3(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat2x3<T>();
}
template <typename T>
inline sem::Type* ty_mat2x4(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat2x4<T>();
}
template <typename T>
inline sem::Type* ty_mat3x2(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat3x2<T>();
}
template <typename T>
inline sem::Type* ty_mat3x3(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat3x3<T>();
}
template <typename T>
inline sem::Type* ty_mat3x4(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat3x4<T>();
}
template <typename T>
inline sem::Type* ty_mat4x2(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat4x2<T>();
}
template <typename T>
inline sem::Type* ty_mat4x3(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat4x3<T>();
}
template <typename T>
inline sem::Type* ty_mat4x4(const ProgramBuilder::TypesBuilder& ty) {
  return ty.mat4x4<T>();
}

using i32 = ProgramBuilder::i32;
using u32 = ProgramBuilder::u32;
using f32 = ProgramBuilder::f32;

template <typename BASE>
class HlslGeneratorImplTest_MemberAccessorBase : public BASE {
 public:
  void SetupStorageBuffer(ast::StructMemberList members) {
    ProgramBuilder& b = *this;

    auto* s =
        b.Structure("Data", members, {b.create<ast::StructBlockDecoration>()});

    auto* ac_ty =
        b.create<sem::AccessControl>(ast::AccessControl::kReadWrite, s);

    b.Global("data", ac_ty, ast::StorageClass::kStorage, nullptr,
             ast::DecorationList{
                 b.create<ast::BindingDecoration>(0),
                 b.create<ast::GroupDecoration>(1),
             });
  }

  void SetupFunction(ast::StatementList statements) {
    ProgramBuilder& b = *this;
    b.Func("main", ast::VariableList{}, b.ty.void_(), statements,
           ast::DecorationList{
               b.create<ast::StageDecoration>(ast::PipelineStage::kVertex),
           });
  }
};

using HlslGeneratorImplTest_MemberAccessor =
    HlslGeneratorImplTest_MemberAccessorBase<TestHelper>;

template <typename T>
using HlslGeneratorImplTest_MemberAccessorWithParam =
    HlslGeneratorImplTest_MemberAccessorBase<TestParamHelper<T>>;

TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
  auto* s = Structure("Data", {Member("mem", ty.f32())});
  Global("str", s, ast::StorageClass::kPrivate);

  auto* expr = MemberAccessor("str", "mem");
  WrapInFunction(expr);

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  EXPECT_EQ(result(), R"(struct Data {
  float mem;
};

Data str;

[numthreads(1, 1, 1)]
void test_function() {
  float tint_symbol = str.mem;
  return;
}

)");
}

struct TypeCase {
  create_type_func_ptr member_type;
  std::string expected;
};
inline std::ostream& operator<<(std::ostream& out, TypeCase c) {
  ProgramBuilder b;
  auto* ty = c.member_type(b.ty);
  out << ty->FriendlyName(b.Symbols());
  return out;
}

using HlslGeneratorImplTest_MemberAccessor_StorageBufferLoad =
    HlslGeneratorImplTest_MemberAccessorWithParam<TypeCase>;
TEST_P(HlslGeneratorImplTest_MemberAccessor_StorageBufferLoad, Test) {
  // struct Data {
  //   a : i32;
  //   b : <type>;
  // };
  // var<storage> data : Data;
  // data.b;

  auto p = GetParam();

  SetupStorageBuffer({
      Member("a", ty.i32()),
      Member("b", p.member_type(ty)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(Var("x", nullptr,
                                             ast::StorageClass::kFunction,
                                             MemberAccessor("data", "b"))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  EXPECT_THAT(result(), HasSubstr(p.expected));

  Validate();
}

INSTANTIATE_TEST_SUITE_P(
    HlslGeneratorImplTest_MemberAccessor,
    HlslGeneratorImplTest_MemberAccessor_StorageBufferLoad,
    testing::Values(
        TypeCase{ty_u32, "data.Load(4u)"},
        TypeCase{ty_f32, "asfloat(data.Load(4u))"},
        TypeCase{ty_i32, "asint(data.Load(4u))"},
        TypeCase{ty_vec2<u32>, "data.Load2(8u)"},
        TypeCase{ty_vec2<f32>, "asfloat(data.Load2(8u))"},
        TypeCase{ty_vec2<i32>, "asint(data.Load2(8u))"},
        TypeCase{ty_vec3<u32>, "data.Load3(16u)"},
        TypeCase{ty_vec3<f32>, "asfloat(data.Load3(16u))"},
        TypeCase{ty_vec3<i32>, "asint(data.Load3(16u))"},
        TypeCase{ty_vec4<u32>, "data.Load4(16u)"},
        TypeCase{ty_vec4<f32>, "asfloat(data.Load4(16u))"},
        TypeCase{ty_vec4<i32>, "asint(data.Load4(16u))"},
        TypeCase{
            ty_mat2x2<u32>,
            R"(return uint2x2(buffer.Load2((offset + 0u)), buffer.Load2((offset + 8u)));)"},
        TypeCase{
            ty_mat2x3<f32>,
            R"(return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))));)"},
        TypeCase{
            ty_mat2x4<i32>,
            R"(return int2x4(asint(buffer.Load4((offset + 0u))), asint(buffer.Load4((offset + 16u))));)"},
        TypeCase{
            ty_mat3x2<u32>,
            R"(return uint3x2(buffer.Load2((offset + 0u)), buffer.Load2((offset + 8u)), buffer.Load2((offset + 16u)));)"},
        TypeCase{
            ty_mat3x3<f32>,
            R"(return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))));)"},
        TypeCase{
            ty_mat3x4<i32>,
            R"(return int3x4(asint(buffer.Load4((offset + 0u))), asint(buffer.Load4((offset + 16u))), asint(buffer.Load4((offset + 32u))));)"},
        TypeCase{
            ty_mat4x2<u32>,
            R"(return uint4x2(buffer.Load2((offset + 0u)), buffer.Load2((offset + 8u)), buffer.Load2((offset + 16u)), buffer.Load2((offset + 24u)));)"},
        TypeCase{
            ty_mat4x3<f32>,
            R"(return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u))));)"},
        TypeCase{
            ty_mat4x4<i32>,
            R"(return int4x4(asint(buffer.Load4((offset + 0u))), asint(buffer.Load4((offset + 16u))), asint(buffer.Load4((offset + 32u))), asint(buffer.Load4((offset + 48u))));)"}));

using HlslGeneratorImplTest_MemberAccessor_StorageBufferStore =
    HlslGeneratorImplTest_MemberAccessorWithParam<TypeCase>;
TEST_P(HlslGeneratorImplTest_MemberAccessor_StorageBufferStore, Test) {
  // struct Data {
  //   a : i32;
  //   b : <type>;
  // };
  // var<storage> data : Data;
  // data.b = <type>();

  auto p = GetParam();

  auto* type = p.member_type(ty);

  SetupStorageBuffer({
      Member("a", ty.i32()),
      Member("b", type),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(
          Var("value", type, ast::StorageClass::kFunction, Construct(type))),
      Assign(MemberAccessor("data", "b"), Expr("value")),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  EXPECT_THAT(result(), HasSubstr(p.expected));

  Validate();
}

INSTANTIATE_TEST_SUITE_P(
    HlslGeneratorImplTest_MemberAccessor,
    HlslGeneratorImplTest_MemberAccessor_StorageBufferStore,
    testing::Values(TypeCase{ty_u32, "data.Store(4u, asuint(value))"},
                    TypeCase{ty_f32, "data.Store(4u, asuint(value))"},
                    TypeCase{ty_i32, "data.Store(4u, asuint(value))"},
                    TypeCase{ty_vec2<u32>, "data.Store2(8u, asuint(value))"},
                    TypeCase{ty_vec2<f32>, "data.Store2(8u, asuint(value))"},
                    TypeCase{ty_vec2<i32>, "data.Store2(8u, asuint(value))"},
                    TypeCase{ty_vec3<u32>, "data.Store3(16u, asuint(value))"},
                    TypeCase{ty_vec3<f32>, "data.Store3(16u, asuint(value))"},
                    TypeCase{ty_vec3<i32>, "data.Store3(16u, asuint(value))"},
                    TypeCase{ty_vec4<u32>, "data.Store4(16u, asuint(value))"},
                    TypeCase{ty_vec4<f32>, "data.Store4(16u, asuint(value))"},
                    TypeCase{ty_vec4<i32>, "data.Store4(16u, asuint(value))"},
                    TypeCase{ty_mat2x2<u32>, R"({
  buffer.Store2((offset + 0u), asuint(value[0u]));
  buffer.Store2((offset + 8u), asuint(value[1u]));
})"},
                    TypeCase{ty_mat2x3<f32>, R"({
  buffer.Store3((offset + 0u), asuint(value[0u]));
  buffer.Store3((offset + 16u), asuint(value[1u]));
})"},
                    TypeCase{ty_mat2x4<i32>, R"({
  buffer.Store4((offset + 0u), asuint(value[0u]));
  buffer.Store4((offset + 16u), asuint(value[1u]));
})"},
                    TypeCase{ty_mat3x2<u32>, R"({
  buffer.Store2((offset + 0u), asuint(value[0u]));
  buffer.Store2((offset + 8u), asuint(value[1u]));
  buffer.Store2((offset + 16u), asuint(value[2u]));
})"},
                    TypeCase{ty_mat3x3<f32>, R"({
  buffer.Store3((offset + 0u), asuint(value[0u]));
  buffer.Store3((offset + 16u), asuint(value[1u]));
  buffer.Store3((offset + 32u), asuint(value[2u]));
})"},
                    TypeCase{ty_mat3x4<i32>, R"({
  buffer.Store4((offset + 0u), asuint(value[0u]));
  buffer.Store4((offset + 16u), asuint(value[1u]));
  buffer.Store4((offset + 32u), asuint(value[2u]));
})"},
                    TypeCase{ty_mat4x2<u32>, R"({
  buffer.Store2((offset + 0u), asuint(value[0u]));
  buffer.Store2((offset + 8u), asuint(value[1u]));
  buffer.Store2((offset + 16u), asuint(value[2u]));
  buffer.Store2((offset + 24u), asuint(value[3u]));
})"},
                    TypeCase{ty_mat4x3<f32>, R"({
  buffer.Store3((offset + 0u), asuint(value[0u]));
  buffer.Store3((offset + 16u), asuint(value[1u]));
  buffer.Store3((offset + 32u), asuint(value[2u]));
  buffer.Store3((offset + 48u), asuint(value[3u]));
})"},
                    TypeCase{ty_mat4x4<i32>, R"({
  buffer.Store4((offset + 0u), asuint(value[0u]));
  buffer.Store4((offset + 16u), asuint(value[1u]));
  buffer.Store4((offset + 32u), asuint(value[2u]));
  buffer.Store4((offset + 48u), asuint(value[3u]));
})"}));

TEST_F(HlslGeneratorImplTest_MemberAccessor, StorageBuffer_Store_Matrix_Empty) {
  // struct Data {
  //   z : f32;
  //   a : mat2x3<f32>;
  // };
  // var<storage> data : Data;
  // data.a = mat2x3<f32>();

  SetupStorageBuffer({
      Member("a", ty.i32()),
      Member("b", ty.mat2x3<f32>()),
  });

  SetupFunction({
      Assign(MemberAccessor("data", "b"),
             Construct(ty.mat2x3<f32>(), ast::ExpressionList{})),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, float2x3 value) {
  buffer.Store3((offset + 0u), asuint(value[0u]));
  buffer.Store3((offset + 16u), asuint(value[1u]));
}

void main() {
  tint_symbol_1(data, 16u, float2x3(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       StorageBuffer_Load_Matrix_Single_Element) {
  // struct Data {
  //   z : f32;
  //   a : mat4x3<f32>;
  // };
  // var<storage> data : Data;
  // data.a[2][1];

  SetupStorageBuffer({
      Member("z", ty.f32()),
      Member("a", ty.mat4x3<f32>()),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(
          Var("x", nullptr, ast::StorageClass::kFunction,
              IndexAccessor(IndexAccessor(MemberAccessor("data", "a"), 2), 1))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  float x = asfloat(data.Load(52u));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       EmitExpression_ArrayAccessor_StorageBuffer_Load_Int_FromArray) {
  // struct Data {
  //   a : [[stride(4)]] array<i32, 5>;
  // };
  // var<storage> data : Data;
  // data.a[2];

  SetupStorageBuffer({
      Member("z", ty.f32()),
      Member("a", ty.array<i32, 5>(4)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(
          Var("x", nullptr, ast::StorageClass::kFunction,
              IndexAccessor(MemberAccessor("data", "a"), 2))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  int x = asint(data.Load(12u));
  return;
}

)";
  EXPECT_EQ(result(), expected);
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       EmitExpression_ArrayAccessor_StorageBuffer_Load_Int_FromArray_ExprIdx) {
  // struct Data {
  //   a : [[stride(4)]] array<i32, 5>;
  // };
  // var<storage> data : Data;
  // data.a[(2 + 4) - 3];

  SetupStorageBuffer({
      Member("z", ty.f32()),
      Member("a", ty.array<i32, 5>(4)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(
          Var("x", nullptr, ast::StorageClass::kFunction,
              IndexAccessor(MemberAccessor("data", "a"),
                            Sub(Add(2, Expr(4)), Expr(3))))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  int x = asint(data.Load((4u + (4u * uint(((2 + 4) - 3))))));
  return;
}

)";
  EXPECT_EQ(result(), expected);
}

TEST_F(HlslGeneratorImplTest_MemberAccessor, StorageBuffer_Store_ToArray) {
  // struct Data {
  //   a : [[stride(4)]] array<i32, 5>;
  // };
  // var<storage> data : Data;
  // data.a[2] = 2;

  SetupStorageBuffer({
      Member("z", ty.f32()),
      Member("a", ty.array<i32, 5>(4)),
  });

  SetupFunction({
      Assign(IndexAccessor(MemberAccessor("data", "a"), 2), 2),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  data.Store(12u, asuint(2));
  return;
}

)";
  EXPECT_EQ(result(), expected);
}

TEST_F(HlslGeneratorImplTest_MemberAccessor, StorageBuffer_Load_MultiLevel) {
  // struct Inner {
  //   a : vec3<i32>;
  //   b : vec3<f32>;
  // };
  // struct Data {
  //   var c : [[stride(32)]] array<Inner, 4>;
  // };
  //
  // var<storage> data : Pre;
  // data.c[2].b

  auto* inner = Structure("Inner", {
                                       Member("a", ty.vec3<f32>()),
                                       Member("b", ty.vec3<f32>()),
                                   });

  SetupStorageBuffer({
      Member("c", ty.array(inner, 4, 32)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(Var(
          "x", nullptr, ast::StorageClass::kFunction,
          MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2), "b"))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  float3 x = asfloat(data.Load3(80u));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       StorageBuffer_Load_MultiLevel_Swizzle) {
  // struct Inner {
  //   a : vec3<i32>;
  //   b : vec3<f32>;
  // };
  // struct Data {
  //   var c : [[stride(32)]] array<Inner, 4>;
  // };
  //
  // var<storage> data : Pre;
  // data.c[2].b.xy

  auto* inner = Structure("Inner", {
                                       Member("a", ty.vec3<f32>()),
                                       Member("b", ty.vec3<f32>()),
                                   });

  SetupStorageBuffer({
      Member("c", ty.array(inner, 4, 32)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(
          Var("x", nullptr, ast::StorageClass::kFunction,
              MemberAccessor(
                  MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2),
                                 "b"),
                  "xy"))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  float2 x = asfloat(data.Load3(80u)).xy;
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       StorageBuffer_Load_MultiLevel_Swizzle_SingleLetter) {  // NOLINT
  // struct Inner {
  //   a : vec3<i32>;
  //   b : vec3<f32>;
  // };
  // struct Data {
  //   var c : [[stride(32)]] array<Inner, 4>;
  // };
  //
  // var<storage> data : Pre;
  // data.c[2].b.g

  auto* inner = Structure("Inner", {
                                       Member("a", ty.vec3<f32>()),
                                       Member("b", ty.vec3<f32>()),
                                   });

  SetupStorageBuffer({
      Member("c", ty.array(inner, 4, 32)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(
          Var("x", nullptr, ast::StorageClass::kFunction,
              MemberAccessor(
                  MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2),
                                 "b"),
                  "g"))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  float x = asfloat(data.Load(84u));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       StorageBuffer_Load_MultiLevel_Index) {
  // struct Inner {
  //   a : vec3<i32>;
  //   b : vec3<f32>;
  // };
  // struct Data {
  //   var c : [[stride(32)]] array<Inner, 4>;
  // };
  //
  // var<storage> data : Pre;
  // data.c[2].b[1]

  auto* inner = Structure("Inner", {
                                       Member("a", ty.vec3<f32>()),
                                       Member("b", ty.vec3<f32>()),
                                   });

  SetupStorageBuffer({
      Member("c", ty.array(inner, 4, 32)),
  });

  SetupFunction({
      create<ast::VariableDeclStatement>(Var(
          "x", nullptr, ast::StorageClass::kFunction,
          IndexAccessor(MemberAccessor(
                            IndexAccessor(MemberAccessor("data", "c"), 2), "b"),
                        1))),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  float x = asfloat(data.Load(84u));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor, StorageBuffer_Store_MultiLevel) {
  // struct Inner {
  //   a : vec3<i32>;
  //   b : vec3<f32>;
  // };
  // struct Data {
  //   var c : [[stride(32)]] array<Inner, 4>;
  // };
  //
  // var<storage> data : Pre;
  // data.c[2].b = vec3<f32>(1.f, 2.f, 3.f);

  auto* inner = Structure("Inner", {
                                       Member("a", ty.vec3<f32>()),
                                       Member("b", ty.vec3<f32>()),
                                   });

  SetupStorageBuffer({
      Member("c", ty.array(inner, 4, 32)),
  });

  SetupFunction({
      Assign(MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2), "b"),
             vec3<f32>(1.f, 2.f, 3.f)),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  data.Store3(80u, asuint(float3(1.0f, 2.0f, 3.0f)));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor,
       StorageBuffer_Store_Swizzle_SingleLetter) {
  // struct Inner {
  //   a : vec3<i32>;
  //   b : vec3<f32>;
  // };
  // struct Data {
  //   var c : [[stride(32)]] array<Inner, 4>;
  // };
  //
  // var<storage> data : Pre;
  // data.c[2].b.y = 1.f;

  auto* inner = Structure("Inner", {
                                       Member("a", ty.vec3<i32>()),
                                       Member("b", ty.vec3<f32>()),
                                   });

  SetupStorageBuffer({
      Member("c", ty.array(inner, 4, 32)),
  });

  SetupFunction({
      Assign(MemberAccessor(
                 MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2),
                                "b"),
                 "y"),
             Expr(1.f)),
  });

  GeneratorImpl& gen = SanitizeAndBuild();

  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  auto* expected =
      R"(
RWByteAddressBuffer data : register(u0, space1);

void main() {
  data.Store(84u, asuint(1.0f));
  return;
}

)";
  EXPECT_EQ(result(), expected);

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor, Swizzle_xyz) {
  auto* var = Var("my_vec", ty.vec4<f32>(), ast::StorageClass::kFunction,
                  vec4<f32>(1.f, 2.f, 3.f, 4.f));
  auto* expr = MemberAccessor("my_vec", "xyz");
  WrapInFunction(var, expr);

  GeneratorImpl& gen = SanitizeAndBuild();
  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  EXPECT_THAT(result(), HasSubstr("my_vec.xyz"));

  Validate();
}

TEST_F(HlslGeneratorImplTest_MemberAccessor, Swizzle_gbr) {
  auto* var = Var("my_vec", ty.vec4<f32>(), ast::StorageClass::kFunction,
                  vec4<f32>(1.f, 2.f, 3.f, 4.f));
  auto* expr = MemberAccessor("my_vec", "gbr");
  WrapInFunction(var, expr);

  GeneratorImpl& gen = SanitizeAndBuild();
  ASSERT_TRUE(gen.Generate(out)) << gen.error();
  EXPECT_THAT(result(), HasSubstr("my_vec.gbr"));

  Validate();
}

}  // namespace
}  // namespace hlsl
}  // namespace writer
}  // namespace tint