Method ParseInterface

ThunkLibs/Generator/analysis.cpp:209–528

}

void AnalysisAction::ParseInterface(clang::ASTContext& context) {
  ErrorReporter report_error {context};

  const std::unordered_map<unsigned, ParameterAnnotations> no_param_annotations {};

  // TODO: Assert fex_gen_type is not declared at non-global namespaces
  if (auto template_decl = FindClassTemplateDeclByName(*context.getTranslationUnitDecl(), "fex_gen_type")) {
    for (auto* decl : template_decl->specializations()) {
      const auto& template_args = decl->getTemplateArgs();
      assert(template_args.size() == 1);

      // NOTE: Function types that are equivalent but use differently
      //       named types (e.g. GLuint/GLenum) are represented by
      //       different Type instances. The canonical type they refer
      //       to is unique, however.
      clang::QualType type = context.getCanonicalType(template_args[0].getAsType());
      type = type->getLocallyUnqualifiedSingleStepDesugaredType();

      const auto annotations = GetTypeAnnotations(context, decl);
      if (type->isFunctionPointerType() || type->isFunctionType()) {
        if (decl->getNumBases()) {
          throw report_error(decl->getBeginLoc(), "Function pointer types cannot be annotated");
        }
        thunked_funcptrs[type.getAsString()] = std::pair {type.getTypePtr(), no_param_annotations};
      } else {
        RepackedType repack_info = {.assumed_compatible = annotations.is_opaque || annotations.assumed_compatible,
                                    .pointers_only = annotations.is_opaque && !annotations.assumed_compatible,
                                    .emit_layout_wrappers = annotations.emit_layout_wrappers};
        [[maybe_unused]] auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), repack_info);
        assert(inserted);
      }
    }
  }

  // Process function parameter annotations
  std::unordered_map<const clang::FunctionDecl*, std::unordered_map<unsigned, ParameterAnnotations>> param_annotations;
  for (auto& decl_context : decl_contexts) {
    if (auto template_decl = FindClassTemplateDeclByName(*decl_context, "fex_gen_param")) {
      for (auto* decl : template_decl->specializations()) {
        const auto& template_args = decl->getTemplateArgs();
        assert(template_args.size() == 3);

        auto function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl());
        auto param_idx = template_args[1].getAsIntegral().getSExtValue();
        clang::QualType type = context.getCanonicalType(template_args[2].getAsType());
        type = type->getLocallyUnqualifiedSingleStepDesugaredType();

        if (param_idx >= function->getNumParams() || param_idx < -1) {
          throw report_error(GetTemplateArgLocation(decl, 1), "Out-of-bounds parameter index passed to fex_gen_param");
        }

        auto expected_type = param_idx == -1 ? function->getReturnType() : function->getParamDecl(param_idx)->getType();

        if (!type->isVoidType() && !context.hasSameType(type, expected_type)) {
          auto loc = param_idx == -1 ? function->getReturnTypeSourceRange().getBegin() :
                                       function->getParamDecl(param_idx)->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
          throw report_error(GetTemplateArgLocation(decl, 2), "Type passed to fex_gen_param doesn't match the function signature")
            .addNote(report_error(loc, "Expected this type instead"));