Function RecursiveMatch

src/interp/interp.cc:97–140

}

static bool RecursiveMatch(const ValueTypes& expected,
                           std::vector<FuncType>* expected_func_types,
                           const ValueTypes& actual,
                           std::vector<FuncType>* actual_func_types) {
  if (expected_func_types == nullptr || actual_func_types == nullptr) {
    return false;
  }

  size_t size = expected.size();
  if (size != actual.size()) {
    return false;
  }

  for (size_t i = 0; i < size; i++) {
    if (!expected[i].IsReferenceWithIndex()) {
      if (expected[i] != actual[i]) {
        return false;
      }
      continue;
    }

    if (static_cast<Type::Enum>(expected[i]) !=
        static_cast<Type::Enum>(actual[i])) {
      return false;
    }

    const FuncType& expected_type =
        (*expected_func_types)[expected[i].GetReferenceIndex()];
    const FuncType& actual_type =
        (*actual_func_types)[actual[i].GetReferenceIndex()];

    assert(expected_type.func_types == expected_func_types);
    assert(actual_type.func_types == actual_func_types);

    if (!RecursiveMatch(expected_type.params, expected_func_types,
                        actual_type.params, actual_func_types) ||
        !RecursiveMatch(expected_type.results, expected_func_types,
                        actual_type.results, actual_func_types)) {
      return false;
    }
  }

  return true;
}

Result Match(const FuncType& expected,
             const FuncType& actual,