Method isDefTypeEqual

include/ast/type.h:458–498

Matcher: Helper for checking the equivalence of two defined types.

private:
  /// Matcher: Helper for checking the equivalence of two defined types.
  static bool isDefTypeEqual(Span<const SubType *const> LHSList,
                             uint32_t LHSIdx,
                             Span<const SubType *const> RHSList,
                             uint32_t RHSIdx) {
    if (LHSList.data() == RHSList.data() && LHSIdx == RHSIdx) {
      // Two type indices in the same module are the same.
      return true;
    }
    const auto *LHSType = LHSList[LHSIdx];
    const auto *RHSType = RHSList[RHSIdx];
    // For GC proposal, a single subtype can be treated as a self-recursive
    // type. That is, `(rec (type $t1 (func (param (ref $t1)))))` and
    //               `(type $t1 (func (param (ref $t1))))` are the same.
    // Therefore, use the subtype length for the recursive type size.
    const uint32_t LRecSize = LHSType->getRecursiveInfo().has_value()
                                  ? LHSType->getRecursiveInfo()->RecTypeSize
                                  : 1U;
    const uint32_t RRecSize = RHSType->getRecursiveInfo().has_value()
                                  ? RHSType->getRecursiveInfo()->RecTypeSize
                                  : 1U;
    if (LRecSize != RRecSize) {
      // The two recursive type sizes are different, so they must not be the
      // same.
      return false;
    }
    if (LRecSize > 1) {
      // Both are in a recursive type with > 1 subtypes.
      if (LHSType->getRecursiveInfo()->Index !=
          RHSType->getRecursiveInfo()->Index) {
        // The recursive indices should be the same.
        return false;
      }
      // The recursive types should be the same.
      uint32_t LStartIdx = LHSIdx - LHSType->getRecursiveInfo()->Index;
      uint32_t RStartIdx = RHSIdx - RHSType->getRecursiveInfo()->Index;
      return isRecTypeEqual(LHSList, LStartIdx, RHSList, RStartIdx, LRecSize);
    } else {
      // Both are composite types or self-recursive types.
      return isRecTypeEqual(LHSList, LHSIdx, RHSList, RHSIdx, 1);
    }
  }

  /// Matcher: Helper for checking the equivalence of two recursive types.
  static bool isRecTypeEqual(Span<const SubType *const> LHSList,