carbon-lang/toolchain/check/cpp/import.h

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#ifndef CARBON_TOOLCHAIN_CHECK_CPP_IMPORT_H_
#define CARBON_TOOLCHAIN_CHECK_CPP_IMPORT_H_

#include "clang/AST/Type.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/VirtualFileSystem.h"
#include "toolchain/check/context.h"
#include "toolchain/check/convert.h"
#include "toolchain/check/diagnostic_helpers.h"
#include "toolchain/diagnostics/emitter.h"
#include "toolchain/sem_ir/clang_decl.h"
#include "toolchain/sem_ir/ids.h"

namespace clang {
class ASTContext;
class CompilerInvocation;
class IdentifierInfo;
class VarDecl;
}  // namespace clang

namespace Carbon::SemIR {
class CppDomain;
}  // namespace Carbon::SemIR

namespace Carbon::Check {

// Returns whether the given function is an object member function. This is true
// if it's a non-static member function and not a constructor. Object member
// functions correspond to Carbon functions with a `self` parameter.
// TODO: Find a better home for this function.
auto IsObjectMemberFunction(const clang::FunctionDecl& decl) -> bool;

// Generates a C++ header that includes the imported cpp files, parses it,
// generates the AST from it and links `SemIR::File` to it. Reports C++ errors
// and warnings. If successful, adds a `Cpp` namespace. `domain` should be
// non-null unless there was an error initializing Clang.
auto ImportCpp(Context& context,
               llvm::ArrayRef<Parse::Tree::PackagingNames> imports,
               SemIR::CppDomain* domain) -> void;

// Given a clang declaration ID that was previously imported into another file,
// returns the corresponding clang declaration key in the current context.
// Produces an error and returns nullopt on failure.
auto FindCorrespondingClangDeclKey(Context& context, SemIR::LocId loc_id,
                                   const SemIR::File& file,
                                   SemIR::ClangDeclId clang_decl_id)
    -> std::optional<SemIR::ClangDeclKey>;

// Imports a declaration into the current context that was previously imported
// into another file.
auto ImportCppDeclFromFile(Context& context, SemIR::LocId loc_id,
                           const SemIR::File& file,
                           SemIR::ClangDeclId clang_decl_id)
    -> SemIR::ConstantId;

// Imports a constant into the current context that was previously imported into
// another file.
auto ImportCppConstantFromFile(Context& context, SemIR::LocId loc_id,
                               const SemIR::File& file, SemIR::InstId inst_id)
    -> SemIR::ConstantId;

// Imports a declaration from Clang to Carbon. If successful, returns the new
// Carbon declaration `InstId`. If the declaration was already imported, returns
// the mapped instruction. All unimported dependencies are imported first.
auto ImportCppDecl(Context& context, SemIR::LocId loc_id,
                   SemIR::ClangDeclKey key) -> SemIR::InstId;

// Imports a function declaration from Clang to Carbon. If successful, returns
// the new Carbon function declaration `InstId`. If the declaration was already
// imported, returns the mapped instruction.
inline auto ImportCppFunctionDecl(Context& context, SemIR::LocId loc_id,
                                  clang::FunctionDecl* clang_decl,
                                  SemIR::ClangDeclSignatureId signature_id)
    -> SemIR::InstId {
  return ImportCppDecl(
      context, loc_id,
      SemIR::ClangDeclKey::ForFunctionDecl(clang_decl, signature_id));
}

// Returns the type that intN_t or uintN_t is an alias for.
auto GetIntNType(const clang::ASTContext& ast_context, unsigned width,
                 bool is_signed) -> clang::QualType;

// Imports a type from Clang to Carbon. Returns a `TypeExpr` which contains
// both a `TypeId` and `TypeInstId`. All unimported dependencies are imported
// first.
//
// If a failure is diagnosed, the `TypeId` will be `ErrorInst::TypeId` and
// the `TypeInstId` will be `ErrorInst::InstId`. Types that are not yet
// supported may instead return `TypeId::None` and `TypeInstId::None`.
// Callers should handle both cases.
auto ImportCppType(Context& context, SemIR::LocId loc_id, clang::QualType type)
    -> TypeExpr;

// Imports an overloaded function set from Clang to Carbon.
auto ImportCppOverloadSet(
    Context& context, SemIR::LocId loc_id, SemIR::NameScopeId scope_id,
    SemIR::NameId name_id, clang::CXXRecordDecl* naming_class,
    clang::UnresolvedSet<4>&& overload_set,
    SemIR::CppOverloadSet::OperatorRewriteInfo operator_rewrite_info)
    -> SemIR::InstId;

// Looks up the given name in the Clang AST generated when importing C++ code
// and returns a lookup result. If using the injected class name (`X.X()`),
// imports the class constructor as a function named as the class.
auto ImportNameFromCpp(Context& context, SemIR::LocId loc_id,
                       SemIR::NameScopeId scope_id, SemIR::NameId name_id)
    -> SemIR::ScopeLookupResult;

// Given a Carbon class declaration that was imported from some kind of C++
// declaration, such as a class or enum, attempt to import a corresponding class
// definition. Returns true if nothing went wrong (whether or not a definition
// could be imported), false if a diagnostic was produced.
auto ImportClassDefinitionForClangDecl(Context& context,
                                       SemIR::ClassId class_id,
                                       SemIR::ClangDeclId clang_decl_id)
    -> bool;

// Computes the signature to use for the given imported virtual function. Unlike
// with regular imported functions, we can only use a single signature here, so
// we pick one conservatively.
auto MakeVirtualFunctionSignature(Context& context,
                                  const clang::CXXMethodDecl* method_decl)
    -> SemIR::ClangDeclSignatureId;

// Gets the identifier info for a name. Returns `nullptr` if the name is not an
// identifier name.
auto GetClangIdentifierInfo(Context& context, SemIR::NameId name_id)
    -> clang::IdentifierInfo*;

// Maps from a `VarStorage` instruction to a `clang::VarDecl`. Returns
// null if the instruction is not a `VarStorage`, or if its contents
// cannot be mapped to a `clang::VarDecl`.
auto GetAsClangVarDecl(Context& context, SemIR::InstId inst_id)
    -> clang::VarDecl*;

// Maps a Clang name to a Carbon `NameId`.
auto AddIdentifierName(Context& context, llvm::StringRef name) -> SemIR::NameId;
}  // namespace Carbon::Check

#endif  // CARBON_TOOLCHAIN_CHECK_CPP_IMPORT_H_