| // Part of the Crubit project, under the Apache License v2.0 with LLVM |
| // Exceptions. See /LICENSE for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| |
| #include "rs_bindings_from_cc/importers/function.h" |
| |
| #include <algorithm> |
| #include <memory> |
| #include <optional> |
| #include <set> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "absl/log/check.h" |
| #include "absl/status/statusor.h" |
| #include "absl/strings/str_cat.h" |
| #include "absl/strings/substitute.h" |
| #include "lifetime_annotations/lifetime.h" |
| #include "lifetime_annotations/lifetime_annotations.h" |
| #include "lifetime_annotations/lifetime_error.h" |
| #include "lifetime_annotations/lifetime_symbol_table.h" |
| #include "lifetime_annotations/type_lifetimes.h" |
| #include "rs_bindings_from_cc/ast_util.h" |
| #include "rs_bindings_from_cc/bazel_types.h" |
| #include "rs_bindings_from_cc/ir.h" |
| #include "rs_bindings_from_cc/recording_diagnostic_consumer.h" |
| #include "clang/AST/Attr.h" |
| #include "clang/AST/Attrs.inc" |
| #include "clang/AST/DeclarationName.h" |
| #include "clang/AST/Type.h" |
| #include "clang/Basic/Diagnostic.h" |
| #include "clang/Basic/LLVM.h" |
| #include "clang/Basic/Specifiers.h" |
| #include "clang/Sema/Sema.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/Support/Error.h" |
| |
| namespace crubit { |
| |
| static bool IsInStdNamespace(const clang::FunctionDecl* decl) { |
| const clang::DeclContext* context = decl->getDeclContext(); |
| while (context) { |
| if (context->isStdNamespace()) { |
| return true; |
| } |
| context = context->getParent(); |
| } |
| return false; |
| } |
| |
| Identifier FunctionDeclImporter::GetTranslatedParamName( |
| const clang::ParmVarDecl* param_decl) { |
| int param_pos = param_decl->getFunctionScopeIndex(); |
| absl::StatusOr<Identifier> name = ictx_.GetTranslatedIdentifier(param_decl); |
| if (!name.ok()) { |
| return {Identifier(absl::StrCat("__param_", param_pos))}; |
| } |
| if (auto* sttpt = |
| param_decl->getType()->getAs<clang::SubstTemplateTypeParmType>(); |
| sttpt && sttpt->getReplacedParameter()->isParameterPack()) { |
| // Avoid giving the same name to all parameters expanded from a pack. |
| return {Identifier(absl::StrCat("__", name->Ident(), "_", param_pos))}; |
| } |
| return *name; |
| } |
| |
| std::optional<IR::Item> FunctionDeclImporter::Import( |
| clang::FunctionDecl* function_decl) { |
| if (!ictx_.IsFromCurrentTarget(function_decl)) return std::nullopt; |
| if (function_decl->isDeleted()) return std::nullopt; |
| |
| clang::FunctionDecl* template_decl_for_method = |
| function_decl->getInstantiatedFromMemberFunction(); |
| if (IsInStdNamespace(function_decl)) { |
| if (clang::IdentifierInfo* id = function_decl->getIdentifier(); |
| id != nullptr && id->getName().find("__") != llvm::StringRef::npos) { |
| return ictx_.ImportUnsupportedItem( |
| function_decl, |
| "Internal functions from the standard library are not supported"); |
| } |
| } |
| // Method is private, we don't need to import it. |
| if (auto* method_decl = |
| clang::dyn_cast<clang::CXXMethodDecl>(function_decl)) { |
| switch (method_decl->getAccess()) { |
| case clang::AS_public: |
| break; |
| case clang::AS_protected: |
| case clang::AS_private: |
| case clang::AS_none: |
| // No need for IR to include Func representing private methods. |
| // TODO(lukasza): Revisit this for protected methods. |
| return std::nullopt; |
| } |
| } |
| |
| // We should only import methods of class template specializations |
| // that can be instantiated: the template may spell out the method, |
| // but it's not guaranteed to be instantiable for the template parameter(s); |
| // importing an un-instantiable method causes Crubit to generate a thunk to |
| // invoke this method, which triggers instantiation when compiling the |
| // generated bindings, which fails the build. |
| if (template_decl_for_method) { |
| // Some methods in STL are explicitly marked with |
| // `__attribute__((exclude_from_explicit_instantiation))`, and attempt to |
| // instantiate them may crash clang, so we skip them for now. |
| bool skip_instantiation = false; |
| if (template_decl_for_method->hasAttrs()) { |
| skip_instantiation = std::any_of( |
| function_decl->attr_begin(), function_decl->attr_end(), |
| [](auto attr) { |
| return clang::isa<clang::ExcludeFromExplicitInstantiationAttr>( |
| attr); |
| }); |
| } |
| if (!function_decl->isDefined() && !skip_instantiation) { |
| // Here, we have the option to instantiate the function |
| // definition recursively, that is, to instantiate the function |
| // templates invoked within the (templated) body. This checks the |
| // validity of the function template more thoroughly than simply |
| // ensuring the type of the invoked function template is correct: e.g., |
| // If `Recursive` is set, a diagnostic would be emitted if the function |
| // template invoked in the body fails to instantiate (e.g., due to a |
| // static_assert) but still passes type checking. However, this has the |
| // side effect of actually instantiating the invoked function template |
| // and the invoked function template would be considered "defined", so |
| // we wouldn't be able to get diagnostics when actually importing the |
| // invoked function template. |
| // TODO(b/248542210): Propagate the validity check of function templates |
| // in a function template body. |
| // TODO(b/248542210): `clang::Sema::InstantiateClassMembers` checks more |
| // constraints (than here) when instantiating the methods, consider use |
| // that API instead (and avoid calling `InstantiateFunctionDefinition` |
| // here). We don't use it now because we cannot clearly attribute |
| // emitted diagnostics to a member decl (we need diagnostics because the |
| // decl may be considered valid `!decl->isInvalidDecl()` while its |
| // instantiation may fail.) |
| auto point_of_instantiation = function_decl->getPointOfInstantiation(); |
| // Point of instantiation is invalid if Crubit is eagerly |
| // instantiating a method of a class template specialization. |
| if (point_of_instantiation.isInvalid()) { |
| point_of_instantiation = function_decl->getLocation(); |
| } |
| crubit::RecordingDiagnosticConsumer diagnostic_recorder = |
| crubit::RecordDiagnostics(ictx_.sema_.getDiagnostics(), [&] { |
| ictx_.sema_.InstantiateFunctionDefinition(point_of_instantiation, |
| function_decl); |
| }); |
| std::string diagnostics = diagnostic_recorder.ConcatenatedDiagnostics( |
| ": Diagnostics emitted:\n"); |
| if (diagnostic_recorder.getNumErrors() != 0) { |
| // Clang considers the function decl valid even fatal diagnostics is |
| // emitted during instantiation. However, such diagnostics would fail |
| // compilation of generated bindings, so it's invalid as far as Crubit |
| // is concerned, thus set it as invalid here. |
| function_decl->setInvalidDecl(); |
| return ictx_.ImportUnsupportedItem( |
| function_decl, |
| absl::StrCat("Failed to instantiate the function/method template", |
| diagnostics)); |
| } |
| } |
| } |
| if (function_decl->isInvalidDecl()) { |
| return ictx_.ImportUnsupportedItem( |
| function_decl, "Function declaration is considered invalid"); |
| } |
| |
| clang::tidy::lifetimes::LifetimeSymbolTable lifetime_symbol_table; |
| std::optional<clang::tidy::lifetimes::FunctionLifetimes> lifetimes; |
| llvm::Expected<clang::tidy::lifetimes::FunctionLifetimes> lifetimes_or_err = |
| clang::tidy::lifetimes::GetLifetimeAnnotations( |
| function_decl, *ictx_.invocation_.lifetime_context_, |
| &lifetime_symbol_table); |
| if (lifetimes_or_err) { |
| lifetimes = std::move(*lifetimes_or_err); |
| } else { |
| using clang::tidy::lifetimes::LifetimeError; |
| llvm::Error remaining_err = llvm::handleErrors( |
| lifetimes_or_err.takeError(), |
| [](std::unique_ptr<LifetimeError> lifetime_err) -> llvm::Error { |
| switch (lifetime_err->type()) { |
| case LifetimeError::Type::ElisionNotEnabled: |
| case LifetimeError::Type::CannotElideOutputLifetimes: |
| // If elision is not enabled or output lifetimes cannot be |
| // elided, we want to import the function with raw lifetime-less |
| // pointers. Just return success here; this will leave the |
| // `lifetimes` optional empty, and we will then handle this |
| // accordingly below. |
| return llvm::Error::success(); |
| break; |
| default: |
| return llvm::Error(std::move(lifetime_err)); |
| break; |
| } |
| }); |
| if (remaining_err) { |
| return ictx_.ImportUnsupportedItem( |
| function_decl, llvm::toString(std::move(remaining_err))); |
| } |
| } |
| |
| absl::StatusOr<UnqualifiedIdentifier> translated_name = |
| ictx_.GetTranslatedName(function_decl); |
| if (!translated_name.ok()) { |
| return ictx_.ImportUnsupportedItem( |
| function_decl, absl::StrCat("Function name is not supported: ", |
| translated_name.status().message())); |
| } |
| |
| std::vector<FuncParam> params; |
| std::set<std::string> errors; |
| auto add_error = [&errors](std::string msg) { |
| auto result = errors.insert(std::move(msg)); |
| CHECK(result.second) << "Duplicated error message"; |
| }; |
| if (auto* method_decl = |
| clang::dyn_cast<clang::CXXMethodDecl>(function_decl)) { |
| if (!ictx_.HasBeenAlreadySuccessfullyImported(method_decl->getParent())) { |
| return ictx_.ImportUnsupportedItem(function_decl, |
| "Couldn't import the parent"); |
| } |
| |
| // non-static member functions receive an implicit `this` parameter. |
| if (method_decl->isInstance()) { |
| const clang::tidy::lifetimes::ValueLifetimes* this_lifetimes = nullptr; |
| if (lifetimes) { |
| this_lifetimes = &lifetimes->GetThisLifetimes(); |
| } |
| auto param_type = |
| ictx_.ConvertQualType(method_decl->getThisType(), this_lifetimes, |
| std::optional<clang::RefQualifierKind>( |
| method_decl->getRefQualifier()), |
| /*nullable=*/false); |
| if (!param_type.ok()) { |
| add_error(absl::StrCat("`this` parameter is not supported: ", |
| param_type.status().message())); |
| } else { |
| params.push_back( |
| {.type = *std::move(param_type), |
| .identifier = Identifier("__this"), |
| // TODO(b/319524852): catch `[[clang::lifetimbound]]` on `this`. |
| .unknown_attr = {}}); |
| } |
| } |
| } |
| |
| if (lifetimes) { |
| CHECK(lifetimes->IsValidForDecl(function_decl)); |
| } |
| |
| for (unsigned i = 0; i < function_decl->getNumParams(); ++i) { |
| const clang::ParmVarDecl* param = function_decl->getParamDecl(i); |
| const clang::tidy::lifetimes::ValueLifetimes* param_lifetimes = nullptr; |
| if (lifetimes) { |
| param_lifetimes = &lifetimes->GetParamLifetimes(i); |
| } |
| auto param_type = |
| ictx_.ConvertQualType(param->getType(), param_lifetimes, std::nullopt); |
| if (!param_type.ok()) { |
| add_error(absl::Substitute("Parameter #$0 is not supported: $1", i, |
| param_type.status().message())); |
| continue; |
| } |
| |
| std::optional<Identifier> param_name = GetTranslatedParamName(param); |
| CHECK(param_name.has_value()); // No known failure cases. |
| params.push_back({.type = *param_type, |
| .identifier = *std::move(param_name), |
| .unknown_attr = CollectUnknownAttrs(*param)}); |
| } |
| |
| bool undeduced_return_type = |
| function_decl->getReturnType()->isUndeducedType(); |
| if (undeduced_return_type) { |
| // Use a custom diagnoser as the `DeduceReturnType` call may fail, which |
| // is OK if this is a method of a class template, since Crubit |
| // instantiates the members of the class templates eagerly. |
| crubit::RecordingDiagnosticConsumer diagnostic_recorder = |
| crubit::RecordDiagnostics(ictx_.sema_.getDiagnostics(), [&] { |
| undeduced_return_type = ictx_.sema_.DeduceReturnType( |
| function_decl, function_decl->getLocation()); |
| }); |
| if (undeduced_return_type) { |
| add_error(absl::StrCat("Couldn't deduce the return type", |
| diagnostic_recorder.ConcatenatedDiagnostics( |
| ": Diagnostics emitted:\n"))); |
| } |
| } |
| absl::StatusOr<MappedType> return_type; |
| if (!undeduced_return_type) { |
| const clang::tidy::lifetimes::ValueLifetimes* return_lifetimes = nullptr; |
| if (lifetimes) { |
| return_lifetimes = &lifetimes->GetReturnLifetimes(); |
| } |
| return_type = ictx_.ConvertQualType(function_decl->getReturnType(), |
| return_lifetimes, std::nullopt); |
| if (!return_type.ok()) { |
| add_error(absl::StrCat("Return type is not supported: ", |
| return_type.status().message())); |
| } |
| } |
| |
| llvm::DenseSet<clang::tidy::lifetimes::Lifetime> all_free_lifetimes; |
| if (lifetimes) { |
| all_free_lifetimes = lifetimes->AllFreeLifetimes(); |
| } |
| |
| std::vector<LifetimeName> lifetime_params; |
| for (clang::tidy::lifetimes::Lifetime lifetime : all_free_lifetimes) { |
| std::optional<llvm::StringRef> name = |
| lifetime_symbol_table.LookupLifetime(lifetime); |
| CHECK(name.has_value()); |
| lifetime_params.push_back( |
| {.name = name->str(), .id = LifetimeId(lifetime.Id())}); |
| } |
| llvm::sort(lifetime_params, |
| [](const LifetimeName& l1, const LifetimeName& l2) { |
| return l1.name < l2.name; |
| }); |
| |
| std::optional<MemberFuncMetadata> member_func_metadata; |
| if (auto* method_decl = |
| clang::dyn_cast<clang::CXXMethodDecl>(function_decl)) { |
| std::optional<MemberFuncMetadata::InstanceMethodMetadata> instance_metadata; |
| if (method_decl->isInstance()) { |
| MemberFuncMetadata::ReferenceQualification reference; |
| switch (method_decl->getRefQualifier()) { |
| case clang::RQ_LValue: |
| reference = MemberFuncMetadata::kLValue; |
| break; |
| case clang::RQ_RValue: |
| reference = MemberFuncMetadata::kRValue; |
| break; |
| case clang::RQ_None: |
| reference = MemberFuncMetadata::kUnqualified; |
| break; |
| } |
| instance_metadata = MemberFuncMetadata::InstanceMethodMetadata{ |
| .reference = reference, |
| .is_const = method_decl->isConst(), |
| .is_virtual = method_decl->isVirtual(), |
| }; |
| } |
| |
| member_func_metadata = MemberFuncMetadata{ |
| .record_id = ictx_.GenerateItemId(method_decl->getParent()), |
| .instance_method_metadata = instance_metadata}; |
| } |
| |
| if (!errors.empty()) { |
| return ictx_.ImportUnsupportedItem(function_decl, errors); |
| } |
| |
| bool has_c_calling_convention = |
| function_decl->getType()->getAs<clang::FunctionType>()->getCallConv() == |
| clang::CC_C; |
| bool is_member_or_descendant_of_class_template = |
| IsFullClassTemplateSpecializationOrChild(function_decl); |
| |
| std::optional<std::string> doc_comment = ictx_.GetComment(function_decl); |
| if (!doc_comment.has_value() && is_member_or_descendant_of_class_template) { |
| // Despite `is_member_or_descendant_of_class_template` check above, we are |
| // not guaranteed that a `func_pattern` exists below. For example, it may |
| // be missing when `function_decl` is an implicitly defined constructor of |
| // a class template -- such decls are generated, not instantiated. |
| if (clang::FunctionDecl* func_pattern = |
| function_decl->getTemplateInstantiationPattern()) { |
| doc_comment = ictx_.GetComment(func_pattern); |
| } |
| } |
| |
| std::optional<std::string> nodiscard; |
| std::optional<std::string> deprecated; |
| std::optional<std::string> unknown_attr = |
| CollectUnknownAttrs(*function_decl, [&](const clang::Attr& attr) { |
| if (auto* unused_attr = |
| clang::dyn_cast<clang::WarnUnusedResultAttr>(&attr)) { |
| nodiscard.emplace(unused_attr->getMessage()); |
| return true; |
| } else if (auto* deprecated_attr = |
| clang::dyn_cast<clang::DeprecatedAttr>(&attr)) { |
| deprecated.emplace(deprecated_attr->getMessage()); |
| return true; |
| } else if (clang::isa<clang::NoReturnAttr>(attr)) { |
| return true; // we call isNoReturn below, instead |
| } else if (clang::isa<clang::NoThrowAttr>(attr)) { |
| // nothrow attributes don't affect Rust. |
| return true; |
| } |
| return false; |
| }); |
| |
| // Silence ClangTidy, checked above: calling `add_error` if |
| // `!return_type.ok()` and returning early if `!errors.empty()`. |
| CHECK_OK(return_type); |
| |
| auto enclosing_item_id = ictx_.GetEnclosingItemId(function_decl); |
| if (!enclosing_item_id.ok()) { |
| return ictx_.ImportUnsupportedItem( |
| function_decl, std::string(enclosing_item_id.status().message())); |
| } |
| |
| return Func{ |
| .name = *translated_name, |
| .owning_target = ictx_.GetOwningTarget(function_decl), |
| .doc_comment = std::move(doc_comment), |
| .mangled_name = ictx_.GetMangledName(function_decl), |
| .return_type = *return_type, |
| .params = std::move(params), |
| .lifetime_params = std::move(lifetime_params), |
| .is_inline = function_decl->isInlined(), |
| .member_func_metadata = std::move(member_func_metadata), |
| .is_extern_c = function_decl->isExternC(), |
| .is_noreturn = function_decl->isNoReturn(), |
| .nodiscard = std::move(nodiscard), |
| .deprecated = std::move(deprecated), |
| .unknown_attr = std::move(unknown_attr), |
| .has_c_calling_convention = has_c_calling_convention, |
| .is_member_or_descendant_of_class_template = |
| is_member_or_descendant_of_class_template, |
| .source_loc = ictx_.ConvertSourceLocation(function_decl->getBeginLoc()), |
| .id = ictx_.GenerateItemId(function_decl), |
| .enclosing_item_id = *std::move(enclosing_item_id), |
| }; |
| } |
| |
| } // namespace crubit |
