// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <lib/fidl/coding.h>
#include <lib/fidl/internal.h>
#include <lib/fidl/transformer.h>

#include <cassert>
#include <cinttypes>
#include <cstdio>
#include <cstring>
#include <string>

// Disable warning about implicit fallthrough, since it's intentionally used a
// lot in this code, and the switch()es end up being harder to read without it.
// Note that "#pragma GCC" works for both GCC & Clang.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"

namespace {

// This is an array of 32-bit ordinals that's intended to help debugging. The
// array is normally empty, but you can add an ordinal to this array in your
// local tree if you encounter a message in-the-field that the transformer is
// having issues with.
constexpr uint64_t kDebugOrdinals[] = {
    // 0x61f19458'00000000,  // example ordinal
};

enum struct WireFormat {
  kOld,
  kV1,
};

// Call this macro instead of assert() when inside a TransformerBase method: it
// will print out useful debugging information. This macro inlines the code in
// order to get precise line number information, and to know the assertion being
// evaluated.
#define TRANSFORMER_ASSERT(assertion, position)                       \
  {                                                                   \
    const auto ok = static_cast<bool>(assertion);                     \
    if (!ok) {                                                        \
      debug_info_->RecordFailure(__LINE__, (#assertion), (position)); \
      assert(assertion);                                              \
    }                                                                 \
  }

// Call this macro instead of the TransformerBase::Fail() method. This is a simple wrapper to pass
// the current __LINE__ number to Fail().
#define TRANSFORMER_FAIL(status, position, error_message) \
  Fail(status, position, __LINE__, error_message);

// Every Transform() method outputs a TraversalResult, which indicates how many out-of-line bytes
// that transform method consumed, and the actual (not max) number of handles that were encountered
// during the transformation. This is needed for writing the correct size and handle information in
// an envelope. (This isn't a great name. A better name would be welcome!)
struct TraversalResult {
  uint32_t src_out_of_line_size = 0u;
  uint32_t dst_out_of_line_size = 0u;
  uint32_t handle_count = 0u;

  TraversalResult& operator+=(const TraversalResult rhs) {
    src_out_of_line_size += rhs.src_out_of_line_size;
    dst_out_of_line_size += rhs.dst_out_of_line_size;
    handle_count += rhs.handle_count;

    return *this;
  }
};

constexpr uint32_t PrimitiveSize(const FidlCodedPrimitive primitive) {
  switch (primitive) {
    case kFidlCodedPrimitive_Bool:
    case kFidlCodedPrimitive_Int8:
    case kFidlCodedPrimitive_Uint8:
      return 1;
    case kFidlCodedPrimitive_Int16:
    case kFidlCodedPrimitive_Uint16:
      return 2;
    case kFidlCodedPrimitive_Int32:
    case kFidlCodedPrimitive_Uint32:
    case kFidlCodedPrimitive_Float32:
      return 4;
    case kFidlCodedPrimitive_Int64:
    case kFidlCodedPrimitive_Uint64:
    case kFidlCodedPrimitive_Float64:
      return 8;
  }
  __builtin_unreachable();
}

// This function is named UnsafeInlineSize since it assumes that |type| will be
// non-null. Don't call this function directly; instead, call
// TransformerBase::InlineSize().
uint32_t UnsafeInlineSize(const fidl_type_t* type, WireFormat wire_format) {
  assert(type);

  switch (type->type_tag) {
    case kFidlTypePrimitive:
      return PrimitiveSize(type->coded_primitive);
    case kFidlTypeEnum:
      return PrimitiveSize(type->coded_enum.underlying_type);
    case kFidlTypeBits:
      return PrimitiveSize(type->coded_bits.underlying_type);
    case kFidlTypeStructPointer:
      return 8;
    case kFidlTypeUnionPointer:
      assert(wire_format == WireFormat::kOld);
      return 8;
    case kFidlTypeVector:
    case kFidlTypeString:
      return 16;
    case kFidlTypeStruct:
      return type->coded_struct.size;
    case kFidlTypeUnion:
      assert(wire_format == WireFormat::kOld);
      return type->coded_union.size;
    case kFidlTypeArray:
      return type->coded_array.array_size;
    case kFidlTypeXUnion:
      return 24;
    case kFidlTypeHandle:
      return 4;
    case kFidlTypeTable:
      return 16;
  }

  // This is needed to suppress a GCC warning "control reaches end of non-void function", since GCC
  // treats switch() on enums as non-exhaustive without a default case.
  assert(false && "unexpected non-exhaustive switch on FidlTypeTag");
  return 0;
}

struct Position {
  uint32_t src_inline_offset = 0;
  uint32_t src_out_of_line_offset = 0;
  uint32_t dst_inline_offset = 0;
  uint32_t dst_out_of_line_offset = 0;

  Position(uint32_t src_inline_offset, uint32_t src_out_of_line_offset, uint32_t dst_inline_offset,
           uint32_t dst_out_of_line_offset)
      : src_inline_offset(src_inline_offset),
        src_out_of_line_offset(src_out_of_line_offset),
        dst_inline_offset(dst_inline_offset),
        dst_out_of_line_offset(dst_out_of_line_offset) {}

  Position(const Position&) = default;
  Position& operator=(const Position&) = default;

  inline Position IncreaseInlineOffset(uint32_t increase) const
      __attribute__((warn_unused_result)) {
    return IncreaseSrcInlineOffset(increase).IncreaseDstInlineOffset(increase);
  }

  inline Position IncreaseSrcInlineOffset(uint32_t increase) const
      __attribute__((warn_unused_result)) {
    return Position(src_inline_offset + increase, src_out_of_line_offset, dst_inline_offset,
                    dst_out_of_line_offset);
  }

  inline Position IncreaseSrcOutOfLineOffset(uint32_t increase) const
      __attribute__((warn_unused_result)) {
    return Position(src_inline_offset, src_out_of_line_offset + increase, dst_inline_offset,
                    dst_out_of_line_offset);
  }

  inline Position IncreaseDstInlineOffset(uint32_t increase) const
      __attribute__((warn_unused_result)) {
    return Position(src_inline_offset, src_out_of_line_offset, dst_inline_offset + increase,
                    dst_out_of_line_offset);
  }

  inline Position IncreaseDstOutOfLineOffset(uint32_t increase) const
      __attribute__((warn_unused_result)) {
    return Position(src_inline_offset, src_out_of_line_offset, dst_inline_offset,
                    dst_out_of_line_offset + increase);
  }

  std::string ToString() const {
    char buffer[32];

    snprintf(buffer, sizeof(buffer), "{0x%02x, 0x%02x, 0x%02x, 0x%02x}", src_inline_offset,
             src_out_of_line_offset, dst_inline_offset, dst_out_of_line_offset);
    return std::string(buffer);
  }
};

class SrcDst final {
 public:
  SrcDst(const uint8_t* src_bytes, const uint32_t src_num_bytes, uint8_t* dst_bytes,
         uint32_t dst_num_bytes_capacity)
      : src_bytes_(src_bytes),
        src_max_offset_(src_num_bytes),
        dst_bytes_(dst_bytes),
        dst_max_offset_(dst_num_bytes_capacity) {}
  SrcDst(const SrcDst&) = delete;

  // Reads |T| from |src_bytes|.
  // This may update the max src read offset if needed.
  template <typename T>
  const T* __attribute__((warn_unused_result)) Read(const Position& position) {
    return Read<T>(position, sizeof(T));
  }

  // Reads |size| bytes from |src_bytes|, but only returns a pointer to |T|
  // which may be smaller, i.e. |sizeof(T)| can be smaller than |size|.
  // This may update the max src read offset if needed.
  template <typename T>
  const T* __attribute__((warn_unused_result)) Read(const Position& position, uint32_t size) {
    assert(sizeof(T) <= size);
    const auto status = src_max_offset_.Update(position.src_inline_offset + size);
    if (status != ZX_OK) {
      return nullptr;
    }

    return reinterpret_cast<const T*>(src_bytes_ + position.src_inline_offset);
  }

  // Copies |size| bytes from |src_bytes| to |dst_bytes|.
  // This may update the max src read offset if needed.
  // This may update the max dst written offset if needed.
  zx_status_t __attribute__((warn_unused_result)) Copy(const Position& position, uint32_t size) {
    const auto src_status = src_max_offset_.Update(position.src_inline_offset + size);
    if (src_status != ZX_OK) {
      return src_status;
    }
    const auto dst_status = dst_max_offset_.Update(position.dst_inline_offset + size);
    if (dst_status != ZX_OK) {
      return dst_status;
    }

    memcpy(dst_bytes_ + position.dst_inline_offset, src_bytes_ + position.src_inline_offset, size);
    return ZX_OK;
  }

  // Pads |size| bytes in |dst_bytes|.
  // This may update the max dst written offset if needed.
  zx_status_t __attribute__((warn_unused_result)) Pad(const Position& position, uint32_t size) {
    const auto status = dst_max_offset_.Update(position.dst_inline_offset + size);
    if (status != ZX_OK) {
      return status;
    }
    memset(dst_bytes_ + position.dst_inline_offset, 0, size);
    return ZX_OK;
  }

  // Writes |value| in |dst_bytes|.
  // This may update the max dst written offset if needed.
  template <typename T>
  zx_status_t __attribute__((warn_unused_result)) Write(const Position& position, T value) {
    const auto size = static_cast<uint32_t>(sizeof(value));
    const auto status = dst_max_offset_.Update(position.dst_inline_offset + size);
    if (status != ZX_OK) {
      return status;
    }
    auto ptr = reinterpret_cast<T*>(dst_bytes_ + position.dst_inline_offset);
    *ptr = value;
    return ZX_OK;
  }

  const uint8_t* src_bytes() const { return src_bytes_; }
  uint32_t src_num_bytes() const { return src_max_offset_.capacity_; }
  uint32_t src_max_offset_read() const { return src_max_offset_.max_offset_; }

  uint8_t* dst_bytes() const { return dst_bytes_; }
  uint32_t dst_num_bytes_capacity() const { return dst_max_offset_.capacity_; }
  uint32_t dst_max_offset_written() const { return dst_max_offset_.max_offset_; }

 private:
  struct MaxOffset {
    MaxOffset(uint32_t capacity) : capacity_(capacity) {}
    const uint32_t capacity_;
    uint32_t max_offset_ = 0;

    zx_status_t __attribute__((warn_unused_result)) Update(uint32_t offset) {
      if (offset > capacity_) {
        return ZX_ERR_BAD_STATE;
      }
      if (offset > max_offset_) {
        max_offset_ = offset;
      }
      return ZX_OK;
    }
  };

  const uint8_t* src_bytes_;
  MaxOffset src_max_offset_;
  uint8_t* dst_bytes_;
  MaxOffset dst_max_offset_;
};

// Debug related information, which is set both on construction, and as we
// transform. On destruction, this object writes any collected error message
// if an |out_error_msg| is provided.
class DebugInfo final {
 public:
  DebugInfo(fidl_transformation_t transformation, const fidl_type_t* type, const SrcDst& src_dst,
            const char** out_error_msg)
      : transformation_(transformation),
        type_(type),
        src_dst_(src_dst),
        out_error_msg_(out_error_msg) {}
  DebugInfo(const DebugInfo&) = delete;

  ~DebugInfo() {
    if (has_failed_) {
      Print("ERROR");
    }
    if (out_error_msg_) {
      *out_error_msg_ = error_msg_;
    }
  }

  void RecordFailure(int line_number, const char* error_msg) {
    has_failed_ = true;
    error_msg_ = error_msg;
    line_number_ = line_number;
  }

  void RecordFailure(int line_number, const char* error_msg, const Position& position) {
    RecordFailure(line_number, error_msg);
    position_ = position;
  }

  void DebugPrint(int line_number, const char* error_msg, const Position& position) const {
    DebugInfo dup(transformation_, type_, src_dst_, nullptr);
    dup.RecordFailure(line_number, error_msg, position);
    dup.Print("INFO");
    // Avoid printing twice.
    dup.has_failed_ = false;
  }

 private:
  void Print(const std::string& failure_type) const {
    printf("=== TRANSFORMER %s ===\n", failure_type.c_str());

    char type_desc[256] = {};
    fidl_format_type_name(type_, type_desc, sizeof(type_desc));

    printf("src: " __FILE__ "\n");
    printf("direction: %s\n", direction().c_str());
    printf("transformer.cc:%d: %s\n", line_number_, error_msg_);
    printf("top level type: %s\n", type_desc);
    printf("position: %s\n", position_.ToString().c_str());

    auto print_bytes = [&](const uint8_t* buffer, uint32_t size, uint32_t out_of_line_offset) {
      for (uint32_t i = 0; i < size; i++) {
        if (i == out_of_line_offset) {
          printf("  // out-of-line\n");
        }

        if (i % 8 == 0) {
          printf("  ");
        }

        printf("0x%02x, ", buffer[i]);

        if (i % 0x10 == 0x07) {
          printf("  // 0x%02x\n", i - 7);
        } else if (i % 0x08 == 0x07) {
          printf("\n");
        }
      }
    };

    printf("uint8_t src_bytes[0x%02x] = {\n", src_dst_.src_num_bytes());
    print_bytes(src_dst_.src_bytes(), src_dst_.src_num_bytes(), position_.src_out_of_line_offset);
    printf("}\n");

    printf("uint8_t dst_bytes[0x%02x] = {  // capacity = 0x%02x\n",
           src_dst_.dst_max_offset_written(), src_dst_.dst_num_bytes_capacity());
    print_bytes(src_dst_.dst_bytes(), src_dst_.dst_max_offset_written(),
                position_.dst_out_of_line_offset);
    printf("}\n");

    printf("=== END TRANSFORMER %s ===\n", failure_type.c_str());
  }

  std::string direction() const {
    switch (transformation_) {
      case FIDL_TRANSFORMATION_NONE:
        return "none";
      case FIDL_TRANSFORMATION_V1_TO_OLD:
        return "v1 to old";
      case FIDL_TRANSFORMATION_OLD_TO_V1:
        return "old to v1";
      default:
        return "unknown";
    }
  }

  // Set on construction, and duplicated.
  const fidl_transformation_t transformation_;
  const fidl_type_t* type_;
  const SrcDst& src_dst_;

  // Set on construction, never duplicated.
  const char** out_error_msg_;

  // Set post construction, never duplicated.
  bool has_failed_ = false;
  const char* error_msg_ = nullptr;
  int line_number_ = -1;
  Position position_{0, 0, 0, 0};
};

class TransformerBase {
 public:
  TransformerBase(SrcDst* src_dst, const fidl_type_t* top_level_src_type, DebugInfo* debug_info)
      : src_dst(src_dst), debug_info_(debug_info), top_level_src_type_(top_level_src_type) {}
  virtual ~TransformerBase() = default;

  uint32_t InlineSize(const fidl_type_t* type, WireFormat wire_format, const Position& position) {
    TRANSFORMER_ASSERT(type, position);

    return UnsafeInlineSize(type, wire_format);
  }

  uint32_t AltInlineSize(const fidl_type_t* type, const Position& position) {
    TRANSFORMER_ASSERT(type, position);

    switch (type->type_tag) {
      case kFidlTypeStruct:
        return InlineSize(type->coded_struct.alt_type, To(), position);
      case kFidlTypeUnion:
        return InlineSize(type->coded_union.alt_type, To(), position);
      case kFidlTypeArray:
        return InlineSize(type->coded_array.alt_type, To(), position);
      case kFidlTypeXUnion:
        return InlineSize(type->coded_xunion.alt_type, To(), position);
      case kFidlTypePrimitive:
      case kFidlTypeEnum:
      case kFidlTypeBits:
      case kFidlTypeStructPointer:
      case kFidlTypeUnionPointer:
      case kFidlTypeVector:
      case kFidlTypeString:
      case kFidlTypeHandle:
      case kFidlTypeTable:
        return InlineSize(type, To(), position);
    }

    TRANSFORMER_ASSERT(false && "unexpected non-exhaustive switch on FidlTypeTag", position);
    return 0;
  }

  void MaybeDebugPrintTopLevelStruct(const Position& position) {
    if (sizeof(kDebugOrdinals) == 0) {
      return;
    }

    auto maybe_ordinal = src_dst->Read<uint64_t>(
        position.IncreaseSrcInlineOffset(offsetof(fidl_message_header_t, ordinal)));
    if (!maybe_ordinal) {
      return;
    }

    for (uint64_t debug_ordinal : kDebugOrdinals) {
      if (debug_ordinal != *maybe_ordinal) {
        continue;
      }

      char buffer[16];
      snprintf(buffer, sizeof(buffer), "0x%016" PRIx64, debug_ordinal);

      debug_info_->DebugPrint(__LINE__, buffer, position);
    }
  }

  zx_status_t TransformTopLevelStruct() {
    if (top_level_src_type_->type_tag != kFidlTypeStruct) {
      return TRANSFORMER_FAIL(ZX_ERR_INVALID_ARGS, (Position{0, 0, 0, 0}),
                              "only top-level structs supported");
    }

    const auto& src_coded_struct = top_level_src_type_->coded_struct;
    const auto& dst_coded_struct = src_coded_struct.alt_type->coded_struct;
    // Since this is the top-level struct, the first secondary object (i.e.
    // out-of-line offset) is exactly placed after this struct, i.e. the
    // struct's inline size.
    const auto start_position = Position(0, src_coded_struct.size, 0, dst_coded_struct.size);

    TraversalResult discarded_traversal_result;
    const zx_status_t status =
        TransformStruct(src_coded_struct, dst_coded_struct, start_position,
                        FIDL_ALIGN(dst_coded_struct.size), &discarded_traversal_result);
    MaybeDebugPrintTopLevelStruct(start_position);
    return status;
  }

 protected:
  zx_status_t Transform(const fidl_type_t* type, const Position& position, const uint32_t dst_size,
                        TraversalResult* out_traversal_result) {
    if (!type) {
      return src_dst->Copy(position, dst_size);
    }
    switch (type->type_tag) {
      case kFidlTypeHandle:
        return TransformHandle(position, dst_size, out_traversal_result);
      case kFidlTypePrimitive:
      case kFidlTypeEnum:
      case kFidlTypeBits:
        return src_dst->Copy(position, dst_size);
      case kFidlTypeStructPointer: {
        const auto& src_coded_struct = *type->coded_struct_pointer.struct_type;
        const auto& dst_coded_struct = src_coded_struct.alt_type->coded_struct;
        return TransformStructPointer(src_coded_struct, dst_coded_struct, position,
                                      out_traversal_result);
      }
      case kFidlTypeUnionPointer: {
        const auto& src_coded_union = *type->coded_union_pointer.union_type;
        const auto& dst_coded_xunion = src_coded_union.alt_type->coded_xunion;
        return TransformUnionPointerToOptionalXUnion(src_coded_union, dst_coded_xunion, position,
                                                     out_traversal_result);
      }
      case kFidlTypeStruct: {
        const auto& src_coded_struct = type->coded_struct;
        const auto& dst_coded_struct = src_coded_struct.alt_type->coded_struct;
        return TransformStruct(src_coded_struct, dst_coded_struct, position, dst_size,
                               out_traversal_result);
      }
      case kFidlTypeUnion: {
        const auto& src_coded_union = type->coded_union;
        const auto& dst_coded_union = src_coded_union.alt_type->coded_xunion;
        return TransformUnionToXUnion(src_coded_union, dst_coded_union, position, dst_size,
                                      out_traversal_result);
      }
      case kFidlTypeArray: {
        const auto convert = [](const FidlCodedArray& coded_array) {
          FidlCodedArrayNew result = {
              .element = coded_array.element,
              .element_count = coded_array.array_size / coded_array.element_size,
              .element_size = coded_array.element_size,
              .element_padding = 0,
              .alt_type = nullptr /* alt_type unused, we provide both src and dst */};
          return result;
        };
        auto src_coded_array = convert(type->coded_array);
        auto dst_coded_array = convert(type->coded_array.alt_type->coded_array);
        return TransformArray(src_coded_array, dst_coded_array, position, dst_size,
                              out_traversal_result);
      }
      case kFidlTypeString:
        return TransformString(position, out_traversal_result);
      case kFidlTypeVector: {
        const auto& src_coded_vector = type->coded_vector;
        const auto& dst_coded_vector = src_coded_vector.alt_type->coded_vector;
        return TransformVector(src_coded_vector, dst_coded_vector, position, out_traversal_result);
      }
      case kFidlTypeTable:
        return TransformTable(type->coded_table, position, out_traversal_result);
      case kFidlTypeXUnion:
        TRANSFORMER_ASSERT(type->coded_xunion.alt_type, position);

        switch (type->coded_xunion.alt_type->type_tag) {
          case kFidlTypeUnion:
            return TransformXUnionToUnion(type->coded_xunion,
                                          type->coded_xunion.alt_type->coded_union, position,
                                          dst_size, out_traversal_result);
          case kFidlTypeUnionPointer:
            return TransformOptionalXUnionToUnionPointer(
                type->coded_xunion, *type->coded_xunion.alt_type->coded_union_pointer.union_type,
                position, out_traversal_result);
          case kFidlTypeXUnion:
            // NOTE: after https://fuchsia-review.googlesource.com/c/fuchsia/+/365937,
            // the alt type of a xunion should always be a union, so this path should
            // never be exercised
            return TransformXUnion(type->coded_xunion, position, out_traversal_result);
          case kFidlTypePrimitive:
          case kFidlTypeEnum:
          case kFidlTypeBits:
          case kFidlTypeStruct:
          case kFidlTypeStructPointer:
          case kFidlTypeArray:
          case kFidlTypeString:
          case kFidlTypeHandle:
          case kFidlTypeVector:
          case kFidlTypeTable:
            TRANSFORMER_ASSERT(false && "Invalid src_xunion alt_type->type_tag", position);
            __builtin_unreachable();
        }
    }

    return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "unknown type tag");
  }

  zx_status_t TransformHandle(const Position& position, uint32_t dst_size,
                              TraversalResult* out_traversal_result) {
    auto presence = src_dst->Read<uint32_t>(position);
    if (!presence) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "handle presence missing");
    }
    switch (*presence) {
      case FIDL_HANDLE_ABSENT:
        // Ok
        break;
      case FIDL_HANDLE_PRESENT:
        out_traversal_result->handle_count++;
        break;
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "handle presence invalid");
    }
    return src_dst->Copy(position, dst_size);
  }

  zx_status_t TransformStructPointer(const FidlCodedStruct& src_coded_struct,
                                     const FidlCodedStruct& dst_coded_struct,
                                     const Position& position,
                                     TraversalResult* out_traversal_result) {
    auto presence = src_dst->Read<uint64_t>(position);
    if (!presence) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "struct pointer missing");
    }

    auto status_copy_struct_pointer = src_dst->Copy(position, sizeof(uint64_t));
    if (status_copy_struct_pointer != ZX_OK) {
      return status_copy_struct_pointer;
    }

    switch (*presence) {
      case FIDL_ALLOC_ABSENT:
        // Early exit on absent struct.
        return ZX_OK;
      case FIDL_ALLOC_PRESENT:
        // Ok
        break;
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "struct pointer invalid");
    }

    uint32_t src_aligned_size = FIDL_ALIGN(src_coded_struct.size);
    uint32_t dst_aligned_size = FIDL_ALIGN(dst_coded_struct.size);
    const auto struct_position = Position{
        position.src_out_of_line_offset,
        position.src_out_of_line_offset + src_aligned_size,
        position.dst_out_of_line_offset,
        position.dst_out_of_line_offset + dst_aligned_size,
    };

    out_traversal_result->src_out_of_line_size += src_aligned_size;
    out_traversal_result->dst_out_of_line_size += dst_aligned_size;

    return TransformStruct(src_coded_struct, dst_coded_struct, struct_position, dst_aligned_size,
                           out_traversal_result);
  }

  zx_status_t TransformStruct(const FidlCodedStruct& src_coded_struct,
                              const FidlCodedStruct& dst_coded_struct, const Position& position,
                              uint32_t dst_size, TraversalResult* out_traversal_result) {
    TRANSFORMER_ASSERT(src_coded_struct.field_count == dst_coded_struct.field_count, position);
    // Note: we cannot use dst_coded_struct.size, and must instead rely on
    // the provided dst_size since this struct could be placed in an alignment
    // context that is larger than its inherent size.

    // Copy structs without any coded fields, and done.
    if (src_coded_struct.field_count == 0) {
      return src_dst->Copy(position, dst_size);
    }

    const uint32_t src_start_of_struct = position.src_inline_offset;
    const uint32_t dst_start_of_struct = position.dst_inline_offset;

    auto current_position = position;
    for (uint32_t field_index = 0; field_index < src_coded_struct.field_count; field_index++) {
      const auto& src_field = src_coded_struct.fields[field_index];
      const auto& dst_field = dst_coded_struct.fields[field_index];

      if (!src_field.type) {
        const uint32_t dst_field_size =
            src_start_of_struct + src_field.padding_offset - current_position.src_inline_offset;
        const auto status_copy_field = src_dst->Copy(current_position, dst_field_size);
        if (status_copy_field != ZX_OK) {
          return status_copy_field;
        }
        current_position = current_position.IncreaseInlineOffset(dst_field_size);
      } else {
        // The only case where the amount we've written shouldn't match the specified offset is
        // for request/response structs, where the txn header is not specified in the coding table.
        if (current_position.src_inline_offset != src_start_of_struct + src_field.offset) {
          TRANSFORMER_ASSERT(src_field.offset == dst_field.offset, current_position);
          const auto status_copy_field = src_dst->Copy(current_position, src_field.offset);
          if (status_copy_field != ZX_OK) {
            return status_copy_field;
          }
          current_position = current_position.IncreaseInlineOffset(src_field.offset);
        }

        TRANSFORMER_ASSERT(
            current_position.src_inline_offset == src_start_of_struct + src_field.offset,
            current_position);
        TRANSFORMER_ASSERT(
            current_position.dst_inline_offset == dst_start_of_struct + dst_field.offset,
            current_position);

        // Transform field.
        uint32_t src_next_field_offset = current_position.src_inline_offset +
                                         InlineSize(src_field.type, From(), current_position);
        uint32_t dst_next_field_offset =
            current_position.dst_inline_offset + InlineSize(dst_field.type, To(), current_position);
        uint32_t dst_field_size = dst_next_field_offset - (dst_start_of_struct + dst_field.offset);

        TraversalResult field_traversal_result;
        const zx_status_t status =
            Transform(src_field.type, current_position, dst_field_size, &field_traversal_result);
        if (status != ZX_OK) {
          return status;
        }

        *out_traversal_result += field_traversal_result;

        // Update current position for next iteration.
        current_position.src_inline_offset = src_next_field_offset;
        current_position.dst_inline_offset = dst_next_field_offset;
        current_position.src_out_of_line_offset += field_traversal_result.src_out_of_line_size;
        current_position.dst_out_of_line_offset += field_traversal_result.dst_out_of_line_size;
      }

      // Pad (possibly with 0 bytes).
      const auto status_pad = src_dst->Pad(current_position, dst_field.padding);
      if (status_pad != ZX_OK) {
        return TRANSFORMER_FAIL(status_pad, current_position,
                                "unable to pad end of struct element");
      }
      current_position = current_position.IncreaseDstInlineOffset(dst_field.padding);
      current_position = current_position.IncreaseSrcInlineOffset(src_field.padding);
    }

    // Pad (possibly with 0 bytes).
    const uint32_t dst_end_of_struct = position.dst_inline_offset + dst_size;
    const auto status_pad =
        src_dst->Pad(current_position, dst_end_of_struct - current_position.dst_inline_offset);
    if (status_pad != ZX_OK) {
      return TRANSFORMER_FAIL(status_pad, current_position, "unable to pad end of struct");
    }

    return ZX_OK;
  }

  zx_status_t TransformVector(const FidlCodedVector& src_coded_vector,
                              const FidlCodedVector& dst_coded_vector, const Position& position,
                              TraversalResult* out_traversal_result) {
    const auto src_vector = src_dst->Read<fidl_vector_t>(position);
    if (!src_vector) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "vector missing");
    }

    // Copy vector header.
    const auto status_copy_vector_hdr = src_dst->Copy(position, sizeof(fidl_vector_t));
    if (status_copy_vector_hdr != ZX_OK) {
      return status_copy_vector_hdr;
    }

    const auto presence = reinterpret_cast<uint64_t>(src_vector->data);
    switch (presence) {
      case FIDL_ALLOC_ABSENT:
        // Early exit on nullable vectors.
        return ZX_OK;
      case FIDL_ALLOC_PRESENT:
        // OK
        break;
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "vector presence invalid");
    }

    const auto convert = [&](const FidlCodedVector& coded_vector) {
      FidlCodedArrayNew result = {
          .element = coded_vector.element,
          .element_count = static_cast<uint32_t>(src_vector->count),
          .element_size = coded_vector.element_size,
          .element_padding = 0,
          .alt_type = nullptr /* alt_type unused, we provide both src and dst */};
      return result;
    };
    const auto src_vector_data_as_coded_array = convert(src_coded_vector);
    const auto dst_vector_data_as_coded_array = convert(dst_coded_vector);

    // Calculate vector size. They fit in uint32_t due to automatic bounds.
    uint32_t src_vector_size =
        FIDL_ALIGN(static_cast<uint32_t>(src_vector->count * (src_coded_vector.element_size)));
    uint32_t dst_vector_size =
        FIDL_ALIGN(static_cast<uint32_t>(src_vector->count * (dst_coded_vector.element_size)));

    // Transform elements.
    auto vector_data_position = Position{
        position.src_out_of_line_offset, position.src_out_of_line_offset + src_vector_size,
        position.dst_out_of_line_offset, position.dst_out_of_line_offset + dst_vector_size};

    const zx_status_t status =
        TransformArray(src_vector_data_as_coded_array, dst_vector_data_as_coded_array,
                       vector_data_position, dst_vector_size, out_traversal_result);
    if (status != ZX_OK) {
      return status;
    }

    out_traversal_result->src_out_of_line_size += src_vector_size;
    out_traversal_result->dst_out_of_line_size += dst_vector_size;

    return ZX_OK;
  }

  zx_status_t TransformString(const Position& position, TraversalResult* out_traversal_result) {
    FidlCodedVector string_as_coded_vector = {
        .element = nullptr,
        .max_count = 0 /*unused*/,
        .element_size = 1,
        .nullable = kFidlNullability_Nullable, /* constraints are not checked, i.e. unused */
        .alt_type = nullptr /* alt_type unused, we provide both src and dst */};
    return TransformVector(string_as_coded_vector, string_as_coded_vector, position,
                           out_traversal_result);
  }

  zx_status_t TransformEnvelope(bool known_type, const fidl_type_t* type, const Position& position,
                                TraversalResult* out_traversal_result) {
    auto src_envelope = src_dst->Read<const fidl_envelope_t>(position);
    if (!src_envelope) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "envelope missing");
    }

    switch (src_envelope->presence) {
      case FIDL_ALLOC_ABSENT: {
        const auto status = src_dst->Copy(position, sizeof(fidl_envelope_t));
        if (status != ZX_OK) {
          return TRANSFORMER_FAIL(status, position, "unable to copy envelope header");
        }
        return ZX_OK;
      }
      case FIDL_ALLOC_PRESENT:
        // We write the transformed envelope after the transformation, since
        // the num_bytes may be different in the dst.
        break;
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "envelope presence invalid");
    }

    if (!known_type) {
      // When we encounter an unknown type, the best we can do is to copy the
      // envelope header (which includes the num_bytes and num_handles), and
      // copy the envelope's data. While it's possible that transformation was
      // needed, since we do not have the type, we cannot perform it.

      const auto status_copy_hdr = src_dst->Copy(position, sizeof(fidl_envelope_t));
      if (status_copy_hdr != ZX_OK) {
        return TRANSFORMER_FAIL(status_copy_hdr, position,
                                "unable to copy envelope header (unknown type)");
      }

      const auto data_position =
          Position{position.src_out_of_line_offset,
                   position.src_out_of_line_offset + src_envelope->num_bytes,
                   position.dst_out_of_line_offset,
                   position.dst_out_of_line_offset + src_envelope->num_bytes};
      const auto status_copy_data = src_dst->Copy(data_position, src_envelope->num_bytes);
      if (status_copy_data != ZX_OK) {
        return TRANSFORMER_FAIL(status_copy_data, data_position,
                                "unable to copy envelope data (unknown type)");
      }

      out_traversal_result->src_out_of_line_size += src_envelope->num_bytes;
      out_traversal_result->dst_out_of_line_size += src_envelope->num_bytes;
      out_traversal_result->handle_count += src_envelope->num_handles;

      return ZX_OK;
    }

    const uint32_t src_contents_inline_size = [&] {
      if (!type) {
        // The envelope contents are either a primitive or an array of primitives,
        // because |type| is nullptr. There's no size information
        // available for the type in the coding tables, but since the data is a
        // primitive or array of primitives, there can never be any out-of-line
        // data, so it's safe to use the envelope's num_bytes to determine the
        // content's inline size.
        return src_envelope->num_bytes;
      }

      return InlineSize(type, From(), position);
    }();

    const uint32_t dst_contents_inline_size = FIDL_ALIGN(AltInlineSize(type, position));
    Position data_position = Position{position.src_out_of_line_offset,
                                      position.src_out_of_line_offset + src_contents_inline_size,
                                      position.dst_out_of_line_offset,
                                      position.dst_out_of_line_offset + dst_contents_inline_size};
    TraversalResult contents_traversal_result;
    zx_status_t result =
        Transform(type, data_position, dst_contents_inline_size, &contents_traversal_result);
    if (result != ZX_OK) {
      return result;
    }

    const uint32_t src_contents_size =
        FIDL_ALIGN(src_contents_inline_size) + contents_traversal_result.src_out_of_line_size;
    const uint32_t dst_contents_size =
        dst_contents_inline_size + contents_traversal_result.dst_out_of_line_size;

    fidl_envelope_t dst_envelope = *src_envelope;
    dst_envelope.num_bytes = dst_contents_size;
    const auto status_write = src_dst->Write(position, dst_envelope);
    if (status_write != ZX_OK) {
      return TRANSFORMER_FAIL(status_write, position, "unable to write envelope");
    }

    out_traversal_result->src_out_of_line_size += src_contents_size;
    out_traversal_result->dst_out_of_line_size += dst_contents_size;
    out_traversal_result->handle_count += src_envelope->num_handles;

    return ZX_OK;
  }

  zx_status_t TransformXUnion(const FidlCodedXUnion& coded_xunion, const Position& position,
                              TraversalResult* out_traversal_result) {
    auto xunion = src_dst->Read<const fidl_xunion_t>(position);
    if (!xunion) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "xunion missing");
    }

    const auto status_copy_xunion_hdr = src_dst->Copy(position, sizeof(fidl_xunion_t));
    if (status_copy_xunion_hdr != ZX_OK) {
      return status_copy_xunion_hdr;
    }

    const FidlXUnionField* field = nullptr;
    for (uint32_t i = 0; i < coded_xunion.field_count; i++) {
      const FidlXUnionField* candidate_field = coded_xunion.fields + i;
      if (candidate_field->ordinal == xunion->tag) {
        field = candidate_field;
        break;
      }
    }

    const Position envelope_position = {
        position.src_inline_offset + static_cast<uint32_t>(offsetof(fidl_xunion_t, envelope)),
        position.src_out_of_line_offset,
        position.dst_inline_offset + static_cast<uint32_t>(offsetof(fidl_xunion_t, envelope)),
        position.dst_out_of_line_offset,
    };

    return TransformEnvelope(field != nullptr, field ? field->type : nullptr, envelope_position,
                             out_traversal_result);
  }

  zx_status_t TransformTable(const FidlCodedTable& coded_table, const Position& position,
                             TraversalResult* out_traversal_result) {
    auto table = src_dst->Read<const fidl_table_t>(position);
    if (!table) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "table header missing");
    }

    const auto status_copy_table_hdr = src_dst->Copy(position, sizeof(fidl_table_t));
    if (status_copy_table_hdr != ZX_OK) {
      return TRANSFORMER_FAIL(status_copy_table_hdr, position, "unable to copy table header");
    }

    const uint32_t envelopes_vector_size =
        static_cast<uint32_t>(table->envelopes.count * sizeof(fidl_envelope_t));
    out_traversal_result->src_out_of_line_size += envelopes_vector_size;
    out_traversal_result->dst_out_of_line_size += envelopes_vector_size;

    auto current_envelope_position = Position{
        position.src_out_of_line_offset,
        position.src_out_of_line_offset + envelopes_vector_size,
        position.dst_out_of_line_offset,
        position.dst_out_of_line_offset + envelopes_vector_size,
    };
    const auto max_field_index = coded_table.field_count - 1;
    for (uint32_t ordinal = 1, field_index = 0; ordinal <= table->envelopes.count; ordinal++) {
      const FidlTableField& field = coded_table.fields[field_index];

      const bool known_field = (ordinal == field.ordinal);
      if (known_field) {
        if (field_index < max_field_index)
          field_index++;
      }

      TraversalResult envelope_traversal_result;
      zx_status_t status = TransformEnvelope(known_field, known_field ? field.type : nullptr,
                                             current_envelope_position, &envelope_traversal_result);
      if (status != ZX_OK) {
        return status;
      }

      current_envelope_position.src_inline_offset += static_cast<uint32_t>(sizeof(fidl_envelope_t));
      current_envelope_position.dst_inline_offset += static_cast<uint32_t>(sizeof(fidl_envelope_t));
      current_envelope_position.src_out_of_line_offset +=
          envelope_traversal_result.src_out_of_line_size;
      current_envelope_position.dst_out_of_line_offset +=
          envelope_traversal_result.dst_out_of_line_size;

      *out_traversal_result += envelope_traversal_result;
    }

    return ZX_OK;
  }

  zx_status_t TransformArray(const FidlCodedArrayNew& src_coded_array,
                             const FidlCodedArrayNew& dst_coded_array, const Position& position,
                             uint32_t dst_array_size, TraversalResult* out_traversal_result) {
    TRANSFORMER_ASSERT(src_coded_array.element_count == dst_coded_array.element_count, position);

    // Fast path for elements without coding tables (e.g. strings).
    if (!src_coded_array.element) {
      return src_dst->Copy(position, dst_array_size);
    }

    // Slow path otherwise.
    auto current_element_position = position;
    for (uint32_t i = 0; i < src_coded_array.element_count; i++) {
      TraversalResult element_traversal_result;
      const zx_status_t status = Transform(src_coded_array.element, current_element_position,
                                           dst_coded_array.element_size, &element_traversal_result);

      if (status != ZX_OK) {
        return status;
      }

      // Pad end of an element.
      auto padding_position =
          current_element_position.IncreaseSrcInlineOffset(src_coded_array.element_size)
              .IncreaseDstInlineOffset(dst_coded_array.element_size);
      const auto status_pad = src_dst->Pad(padding_position, dst_coded_array.element_padding);
      if (status_pad != ZX_OK) {
        return TRANSFORMER_FAIL(status_pad, padding_position, "unable to pad array element");
      }

      current_element_position =
          padding_position.IncreaseSrcInlineOffset(src_coded_array.element_padding)
              .IncreaseDstInlineOffset(dst_coded_array.element_padding)
              .IncreaseSrcOutOfLineOffset(element_traversal_result.src_out_of_line_size)
              .IncreaseDstOutOfLineOffset(element_traversal_result.dst_out_of_line_size);

      *out_traversal_result += element_traversal_result;
    }

    // Pad end of elements.
    uint32_t padding =
        dst_array_size + position.dst_inline_offset - current_element_position.dst_inline_offset;
    const auto status_pad = src_dst->Pad(current_element_position, padding);
    if (status_pad != ZX_OK) {
      return TRANSFORMER_FAIL(status_pad, current_element_position, "unable to pad end of array");
    }

    return ZX_OK;
  }

  zx_status_t TransformUnionPointerToOptionalXUnion(const FidlCodedUnion& src_coded_union,
                                                    const FidlCodedXUnion& dst_coded_xunion,
                                                    const Position& position,
                                                    TraversalResult* out_traversal_result) {
    auto presence = src_dst->Read<uint64_t>(position);
    if (!presence) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "union pointer missing");
    }

    switch (*presence) {
      case FIDL_ALLOC_ABSENT: {
        fidl_xunion_t absent = {};
        const auto status = src_dst->Write(position, absent);
        if (status != ZX_OK) {
          return TRANSFORMER_FAIL(status, position, "unable to write union pointer absense");
        }
        return ZX_OK;
      }
      case FIDL_ALLOC_PRESENT:
        // Ok
        break;
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "union pointer invalid");
    }

    uint32_t src_aligned_size = FIDL_ALIGN(src_coded_union.size);
    const auto union_position = Position{
        position.src_out_of_line_offset,
        position.src_out_of_line_offset + src_aligned_size,
        position.dst_inline_offset,
        position.dst_out_of_line_offset,
    };

    out_traversal_result->src_out_of_line_size += src_aligned_size;
    return TransformUnionToXUnion(src_coded_union, dst_coded_xunion, union_position,
                                  0 /* unused: xunions are FIDL_ALIGNed */, out_traversal_result);
  }

  zx_status_t TransformUnionToXUnion(const FidlCodedUnion& src_coded_union,
                                     const FidlCodedXUnion& dst_coded_xunion,
                                     const Position& position, uint32_t /* unused: dst_size */,
                                     TraversalResult* out_traversal_result) {
    TRANSFORMER_ASSERT(src_coded_union.field_count == dst_coded_xunion.field_count, position);

    // Read: union tag.
    const auto union_tag_ptr =
        src_dst->Read<const fidl_union_tag_t>(position, src_coded_union.size);
    if (!union_tag_ptr) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "union tag missing");
    }
    const auto union_tag = *union_tag_ptr;

    // Retrieve: union field/variant.
    if (union_tag >= src_coded_union.field_count) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "invalid union tag");
    }

    const FidlUnionField& src_field = src_coded_union.fields[union_tag];
    const FidlXUnionField& dst_field = dst_coded_xunion.fields[union_tag];

    // Write: xunion tag & envelope.
    const uint32_t dst_inline_field_size = [&] {
      if (src_field.type) {
        return AltInlineSize(src_field.type, position);
      } else {
        return src_coded_union.size - src_coded_union.data_offset - src_field.padding;
      }
    }();

    // Transform: static-union field to xunion field.
    auto field_position = Position{
        position.src_inline_offset + src_coded_union.data_offset,
        position.src_out_of_line_offset,
        position.dst_out_of_line_offset,
        position.dst_out_of_line_offset + FIDL_ALIGN(dst_inline_field_size),
    };
    TraversalResult field_traversal_result;
    zx_status_t status =
        Transform(src_field.type, field_position, dst_inline_field_size, &field_traversal_result);
    if (status != ZX_OK) {
      return status;
    }

    // Pad field (if needed).
    const uint32_t dst_field_size =
        dst_inline_field_size + field_traversal_result.dst_out_of_line_size;
    const uint32_t dst_padding = FIDL_ALIGN(dst_field_size) - dst_field_size;
    const auto status_pad_field =
        src_dst->Pad(field_position.IncreaseDstInlineOffset(dst_field_size), dst_padding);
    if (status_pad_field != ZX_OK) {
      return TRANSFORMER_FAIL(status_pad_field, field_position,
                              "unable to pad union-as-xunion variant");
    }

    // Write envelope header.
    fidl_xunion_t xunion;
    xunion.tag = dst_field.ordinal;
    xunion.envelope.num_bytes = FIDL_ALIGN(dst_field_size);
    xunion.envelope.num_handles = field_traversal_result.handle_count;
    xunion.envelope.presence = FIDL_ALLOC_PRESENT;
    const auto status_write_xunion = src_dst->Write(position, xunion);
    if (status_write_xunion != ZX_OK) {
      return TRANSFORMER_FAIL(status_write_xunion, position,
                              "unable to write union-as-xunion header");
    }

    out_traversal_result->src_out_of_line_size += field_traversal_result.src_out_of_line_size;
    out_traversal_result->dst_out_of_line_size += FIDL_ALIGN(dst_field_size);
    out_traversal_result->handle_count += field_traversal_result.handle_count;

    return ZX_OK;
  }

  zx_status_t TransformOptionalXUnionToUnionPointer(const FidlCodedXUnion& src_coded_xunion,
                                                    const FidlCodedUnion& dst_coded_union,
                                                    const Position& position,
                                                    TraversalResult* out_traversal_result) {
    auto src_xunion = src_dst->Read<const fidl_xunion_t>(position);
    if (!src_xunion) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "union-as-xunion missing");
    }

    switch (src_xunion->envelope.presence) {
      case FIDL_ALLOC_ABSENT:
      case FIDL_ALLOC_PRESENT: {
        const auto status = src_dst->Write(position, src_xunion->envelope.presence);
        if (status != ZX_OK) {
          return TRANSFORMER_FAIL(status, position, "unable to write union pointer absence");
        }
        if (src_xunion->envelope.presence == FIDL_ALLOC_ABSENT) {
          return ZX_OK;
        }
        break;
      }
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position,
                                "union-as-xunion envelope presence invalid");
    }

    const uint32_t dst_aligned_size = FIDL_ALIGN(dst_coded_union.size);
    const auto union_position = Position{
        position.src_inline_offset,
        position.src_out_of_line_offset,
        position.dst_out_of_line_offset,
        position.dst_out_of_line_offset + dst_aligned_size,
    };

    out_traversal_result->dst_out_of_line_size += dst_aligned_size;

    return TransformXUnionToUnion(src_coded_xunion, dst_coded_union, union_position,
                                  FIDL_ALIGN(dst_coded_union.size), out_traversal_result);
  }

  zx_status_t TransformXUnionToUnion(const FidlCodedXUnion& src_coded_xunion,
                                     const FidlCodedUnion& dst_coded_union,
                                     const Position& position, uint32_t dst_size,
                                     TraversalResult* out_traversal_result) {
    TRANSFORMER_ASSERT(src_coded_xunion.field_count == dst_coded_union.field_count, position);

    // Read: extensible-union ordinal.
    const auto src_xunion = src_dst->Read<const fidl_xunion_t>(position);
    if (!src_xunion) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "union-as-xunion missing");
    }

    switch (src_xunion->envelope.presence) {
      case FIDL_ALLOC_PRESENT:
        // OK
        break;
      case FIDL_ALLOC_ABSENT:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position,
                                "union-as-xunion envelope is invalid FIDL_ALLOC_ABSENT");
      default:
        return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position,
                                "union-as-xunion envelope presence invalid");
    }

    // Retrieve: flexible-union field (or variant).
    bool src_field_found = false;
    uint32_t src_field_index = 0;
    const FidlXUnionField* src_field = nullptr;
    for (/* src_field_index needed after the loop */;
         src_field_index < src_coded_xunion.field_count; src_field_index++) {
      const FidlXUnionField* candidate_src_field = &src_coded_xunion.fields[src_field_index];
      if (candidate_src_field->ordinal == src_xunion->tag) {
        src_field_found = true;
        src_field = candidate_src_field;
        break;
      }
    }
    if (!src_field_found) {
      return TRANSFORMER_FAIL(ZX_ERR_BAD_STATE, position, "ordinal has no corresponding variant");
    }

    const FidlUnionField& dst_field = dst_coded_union.fields[src_field_index];

    // Write: static-union tag, and pad (if needed).
    switch (dst_coded_union.data_offset) {
      case 4: {
        const auto status = src_dst->Write(position, src_field_index);
        if (status != ZX_OK) {
          return TRANSFORMER_FAIL(status, position, "unable to write union tag");
        }
        break;
      }
      case 8: {
        const auto status = src_dst->Write(position, static_cast<uint64_t>(src_field_index));
        if (status != ZX_OK) {
          return TRANSFORMER_FAIL(status, position, "unable to write union tag");
        }
        break;
      }
      default:
        TRANSFORMER_ASSERT(false && "static-union data offset can only be 4 or 8", position);
    }

    const uint32_t src_field_inline_size = [&] {
      if (!src_field->type) {
        // src_field's type is either a primitive or an array of primitives,
        // because src_field->type is nullptr. There's no size information
        // available for the field in the coding tables, but since the data is a
        // primitive or array of primitives, there can never be any out-of-line
        // data, so it's safe to use the envelope's num_bytes to determine the
        // field's inline size.
        return src_xunion->envelope.num_bytes;
      }

      return FIDL_ALIGN(InlineSize(src_field->type, From(), position));
    }();

    // Transform: xunion field to static-union field (or variant).
    auto field_position = Position{
        position.src_out_of_line_offset,
        position.src_out_of_line_offset + src_field_inline_size,
        position.dst_inline_offset + dst_coded_union.data_offset,
        position.dst_out_of_line_offset,
    };
    uint32_t dst_field_unpadded_size =
        dst_coded_union.size - dst_coded_union.data_offset - dst_field.padding;

    zx_status_t status =
        Transform(src_field->type, field_position, dst_field_unpadded_size, out_traversal_result);
    if (status != ZX_OK) {
      return status;
    }

    // Pad after static-union data.
    auto field_padding_position = field_position.IncreaseDstInlineOffset(dst_field_unpadded_size);
    const auto dst_padding = (dst_size - dst_coded_union.size) + dst_field.padding;
    const auto status_pad_field = src_dst->Pad(field_padding_position, dst_padding);
    if (status_pad_field != ZX_OK) {
      return TRANSFORMER_FAIL(status_pad_field, field_padding_position,
                              "unable to pad union variant");
    }

    out_traversal_result->src_out_of_line_size += src_field_inline_size;
    return ZX_OK;
  }

  virtual WireFormat From() const = 0;
  virtual WireFormat To() const = 0;

  inline zx_status_t Fail(zx_status_t status, const Position& position, const int line_number,
                          const char* error_msg) {
    debug_info_->RecordFailure(line_number, error_msg, position);
    return status;
  }

  SrcDst* src_dst;
  DebugInfo* const debug_info_;

 private:
  const fidl_type_t* top_level_src_type_;
};

class V1ToOld final : public TransformerBase {
 public:
  V1ToOld(SrcDst* src_dst, const fidl_type_t* top_level_src_type, DebugInfo* debug_info)
      : TransformerBase(src_dst, top_level_src_type, debug_info) {}

  WireFormat From() const override { return WireFormat::kV1; }
  WireFormat To() const override { return WireFormat::kOld; }
};

class OldToV1 final : public TransformerBase {
 public:
  OldToV1(SrcDst* src_dst, const fidl_type_t* top_level_src_type, DebugInfo* debug_info)
      : TransformerBase(src_dst, top_level_src_type, debug_info) {}

 private:
  WireFormat From() const override { return WireFormat::kOld; }
  WireFormat To() const override { return WireFormat::kV1; }
};

}  // namespace

zx_status_t fidl_transform(fidl_transformation_t transformation, const fidl_type_t* src_type,
                           const uint8_t* src_bytes, uint32_t src_num_bytes, uint8_t* dst_bytes,
                           uint32_t dst_num_bytes_capacity, uint32_t* out_dst_num_bytes,
                           const char** out_error_msg) {
  if (!src_type || !src_bytes || !dst_bytes || !out_dst_num_bytes || !FidlIsAligned(src_bytes) ||
      !FidlIsAligned(dst_bytes)) {
    return ZX_ERR_INVALID_ARGS;
  }

  SrcDst src_dst(src_bytes, src_num_bytes, dst_bytes, dst_num_bytes_capacity);
  DebugInfo debug_info(transformation, src_type, src_dst, out_error_msg);

  const zx_status_t status = [&] {
    switch (transformation) {
      case FIDL_TRANSFORMATION_NONE: {
        const auto start = Position{
            0, UINT16_MAX, /* unused: src_out_of_line_offset */
            0, UINT16_MAX, /* unused: dst_out_of_line_offset */
        };
        return src_dst.Copy(start, src_num_bytes);
      }
      case FIDL_TRANSFORMATION_V1_TO_OLD:
        return V1ToOld(&src_dst, src_type, &debug_info).TransformTopLevelStruct();
      case FIDL_TRANSFORMATION_OLD_TO_V1:
        return OldToV1(&src_dst, src_type, &debug_info).TransformTopLevelStruct();
      default:
        debug_info.RecordFailure(__LINE__, "unsupported transformation");
        return ZX_ERR_INVALID_ARGS;
    }
  }();

  if (status != ZX_OK) {
    return status;
  }

  if (FIDL_ALIGN(src_dst.src_max_offset_read()) != src_num_bytes) {
    debug_info.RecordFailure(__LINE__, "did not read all provided bytes during transformation");
    return ZX_ERR_INVALID_ARGS;
  }

  *out_dst_num_bytes = src_dst.dst_max_offset_written();
  return ZX_OK;
}

#pragma GCC diagnostic pop  // "-Wimplicit-fallthrough"