Method loadType

lib/loader/ast/component/component_type.cpp:11–82

namespace Loader {

Expect<void> Loader::loadType(AST::Component::CoreDefType &Ty) {
  auto ReportError = [](auto E) {
    spdlog::error(ErrInfo::InfoAST(ASTNodeAttr::Comp_CoreDefType));
    return E;
  };
  /// FROM:
  /// https://github.com/WebAssembly/component-model/blob/main/design/mvp/Binary.md#type-definitions
  ///
  /// Unfortunately, the `core:deftype` rule results in an encoding ambiguity:
  /// the `0x50` opcode is used by both `core:moduletype` and a non-final
  /// `core:subtype`, which can be decoded as a top-level form of
  /// `core:rectype`.
  ///
  /// To resolve this, prior to v1.0 of this specification, we require
  /// `core:subtype` to be prefixed by `0x00` in this context (i.e., a non-final
  /// sub as a component core type is `0x00 0x50`; elsewhere, `0x50`). By the
  /// v1.0 release of this specification, `core:moduletype` will receive a new,
  /// non-overlapping opcode.

  // core:type       ::= dt:<core:deftype> => (type dt)
  // core:deftype    ::= rt:<core:rectype>
  //                   => rt (WebAssembly 3.0)
  //                   | 0x00 0x50 x*:vec(<core:typeidx>) ct:<core:comptype>
  //                   => sub x* ct (WebAssembly 3.0)
  //                   | mt:<core:moduletype>
  //                   => mt
  // core:moduletype ::= 0x50 md*:vec(<core:moduledecl>) => (module md*)

  // Peek the first byte to determine the type to load.
  EXPECTED_TRY(uint8_t Flag, FMgr.peekByte().map_error([this](auto E) {
    return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Comp_CoreDefType);
  }));
  switch (Flag) {
  case 0x50: {
    FMgr.readByte();
    std::vector<AST::Component::CoreModuleDecl> Decls;
    EXPECTED_TRY(loadVec<AST::Component::CoreDefType>(
        Decls, [this](AST::Component::CoreModuleDecl &Decl) {
          return loadDecl(Decl);
        }));
    Ty.setModuleType(std::move(Decls));
    return {};
  }
  case 0x00: // sub non-final case
    FMgr.readByte();
    [[fallthrough]];
  default: { // recursive type case
    std::vector<AST::SubType> STypes;
    if (static_cast<TypeCode>(Flag) == TypeCode::Rec) {
      // Case: 0x4E vec(subtype).
      FMgr.readByte();
      EXPECTED_TRY(uint32_t RecVecCnt, loadVecCnt().map_error([this](auto E) {
        return logLoadError(E, FMgr.getLastOffset(),
                            ASTNodeAttr::Comp_CoreDefType);
      }));
      for (uint32_t I = 0; I < RecVecCnt; ++I) {
        STypes.emplace_back();
        EXPECTED_TRY(loadType(STypes.back()).map_error(ReportError));