EIC code displayed by LXR master/​include/​clang/​AST/​ASTImporter.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:36:28

 //===- ASTImporter.h - Importing ASTs from other Contexts -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the ASTImporter class which imports AST nodes from one
 //  context into another context.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_ASTIMPORTER_H
 #define LLVM_CLANG_AST_ASTIMPORTER_H
 
 #include "clang/AST/ASTImportError.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include <optional>
 #include <utility>
 
 namespace clang {
 
 class ASTContext;
 class ASTImporterSharedState;
 class Attr;
 class CXXBaseSpecifier;
 class CXXCtorInitializer;
 class Decl;
 class DeclContext;
 class Expr;
 class FileManager;
 class NamedDecl;
 class Stmt;
 class TagDecl;
 class TranslationUnitDecl;
 class TypeSourceInfo;
 
   // \brief Returns with a list of declarations started from the canonical decl
   // then followed by subsequent decls in the translation unit.
   // This gives a canonical list for each entry in the redecl chain.
   // `Decl::redecls()` gives a list of decls which always start from the
   // previous decl and the next item is actually the previous item in the order
   // of source locations.  Thus, `Decl::redecls()` gives different lists for
   // the different entries in a given redecl chain.
   llvm::SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D);
 
   /// Imports selected nodes from one AST context into another context,
   /// merging AST nodes where appropriate.
   class ASTImporter {
     friend class ASTNodeImporter;
   public:
     using NonEquivalentDeclSet =
         llvm::DenseSet<std::tuple<Decl *, Decl *, int>>;
     using ImportedCXXBaseSpecifierMap =
         llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>;
 
     enum class ODRHandlingType { Conservative, Liberal };
 
     // An ImportPath is the list of the AST nodes which we visit during an
     // Import call.
     // If node `A` depends on node `B` then the path contains an `A`->`B` edge.
     // From the call stack of the import functions we can read the very same
     // path.
     //
     // Now imagine the following AST, where the `->` represents dependency in
     // therms of the import.
     // ```
     // A->B->C->D
     //    `->E
     // ```
     // We would like to import A.
     // The import behaves like a DFS, so we will visit the nodes in this order:
     // ABCDE.
     // During the visitation we will have the following ImportPaths:
     // ```
     // A
     // AB
     // ABC
     // ABCD
     // ABC
     // AB
     // ABE
     // AB
     // A
     // ```
     // If during the visit of E there is an error then we set an error for E,
     // then as the call stack shrinks for B, then for A:
     // ```
     // A
     // AB
     // ABC
     // ABCD
     // ABC
     // AB
     // ABE // Error! Set an error to E
     // AB  // Set an error to B
     // A   // Set an error to A
     // ```
     // However, during the import we could import C and D without any error and
     // they are independent from A,B and E.
     // We must not set up an error for C and D.
     // So, at the end of the import we have an entry in `ImportDeclErrors` for
     // A,B,E but not for C,D.
     //
     // Now what happens if there is a cycle in the import path?
     // Let's consider this AST:
     // ```
     // A->B->C->A
     //    `->E
     // ```
     // During the visitation we will have the below ImportPaths and if during
     // the visit of E there is an error then we will set up an error for E,B,A.
     // But what's up with C?
     // ```
     // A
     // AB
     // ABC
     // ABCA
     // ABC
     // AB
     // ABE // Error! Set an error to E
     // AB  // Set an error to B
     // A   // Set an error to A
     // ```
     // This time we know that both B and C are dependent on A.
     // This means we must set up an error for C too.
     // As the call stack reverses back we get to A and we must set up an error
     // to all nodes which depend on A (this includes C).
     // But C is no longer on the import path, it just had been previously.
     // Such situation can happen only if during the visitation we had a cycle.
     // If we didn't have any cycle, then the normal way of passing an Error
     // object through the call stack could handle the situation.
     // This is why we must track cycles during the import process for each
     // visited declaration.
     class ImportPathTy {
     public:
       using VecTy = llvm::SmallVector<Decl *, 32>;
 
       void push(Decl *D) {
         Nodes.push_back(D);
         ++Aux[D];
       }
 
       void pop() {
         if (Nodes.empty())
           return;
         --Aux[Nodes.back()];
         Nodes.pop_back();
       }
 
       /// Returns true if the last element can be found earlier in the path.
       bool hasCycleAtBack() const {
         auto Pos = Aux.find(Nodes.back());
         return Pos != Aux.end() && Pos->second > 1;
       }
 
       using Cycle = llvm::iterator_range<VecTy::const_reverse_iterator>;
       Cycle getCycleAtBack() const {
         assert(Nodes.size() >= 2);
         return Cycle(Nodes.rbegin(),
                      std::find(Nodes.rbegin() + 1, Nodes.rend(), Nodes.back()) +
                          1);
       }
 
       /// Returns the copy of the cycle.
       VecTy copyCycleAtBack() const {
         auto R = getCycleAtBack();
         return VecTy(R.begin(), R.end());
       }
 
     private:
       // All nodes of the path.
       VecTy Nodes;
       // Auxiliary container to be able to answer "Do we have a cycle ending
       // at last element?" as fast as possible.
       // We count each Decl's occurrence over the path.
       llvm::SmallDenseMap<Decl *, int, 32> Aux;
     };
 
   private:
     std::shared_ptr<ASTImporterSharedState> SharedState = nullptr;
 
     /// The path which we go through during the import of a given AST node.
     ImportPathTy ImportPath;
     /// Sometimes we have to save some part of an import path, so later we can
     /// set up properties to the saved nodes.
     /// We may have several of these import paths associated to one Decl.
     using SavedImportPathsForOneDecl =
         llvm::SmallVector<ImportPathTy::VecTy, 32>;
     using SavedImportPathsTy =
         llvm::SmallDenseMap<Decl *, SavedImportPathsForOneDecl, 32>;
     SavedImportPathsTy SavedImportPaths;
 
     /// The contexts we're importing to and from.
     ASTContext &ToContext, &FromContext;
 
     /// The file managers we're importing to and from.
     FileManager &ToFileManager, &FromFileManager;
 
     /// Whether to perform a minimal import.
     bool Minimal;
 
     ODRHandlingType ODRHandling;
 
     /// Whether the last diagnostic came from the "from" context.
     bool LastDiagFromFrom = false;
 
     /// Mapping from the already-imported types in the "from" context
     /// to the corresponding types in the "to" context.
     llvm::DenseMap<const Type *, const Type *> ImportedTypes;
 
     /// Mapping from the already-imported declarations in the "from"
     /// context to the corresponding declarations in the "to" context.
     llvm::DenseMap<Decl *, Decl *> ImportedDecls;
 
     /// Mapping from the already-imported declarations in the "from"
     /// context to the error status of the import of that declaration.
     /// This map contains only the declarations that were not correctly
     /// imported. The same declaration may or may not be included in
     /// ImportedDecls. This map is updated continuously during imports and never
     /// cleared (like ImportedDecls).
     llvm::DenseMap<Decl *, ASTImportError> ImportDeclErrors;
 
     /// Mapping from the already-imported declarations in the "to"
     /// context to the corresponding declarations in the "from" context.
     llvm::DenseMap<Decl *, Decl *> ImportedFromDecls;
 
     /// Mapping from the already-imported statements in the "from"
     /// context to the corresponding statements in the "to" context.
     llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
 
     /// Mapping from the already-imported FileIDs in the "from" source
     /// manager to the corresponding FileIDs in the "to" source manager.
     llvm::DenseMap<FileID, FileID> ImportedFileIDs;
 
     /// Mapping from the already-imported CXXBasesSpecifier in
     ///  the "from" source manager to the corresponding CXXBasesSpecifier
     ///  in the "to" source manager.
     ImportedCXXBaseSpecifierMap ImportedCXXBaseSpecifiers;
 
     /// Declaration (from, to) pairs that are known not to be equivalent
     /// (which we have already complained about).
     NonEquivalentDeclSet NonEquivalentDecls;
 
     using FoundDeclsTy = SmallVector<NamedDecl *, 2>;
     FoundDeclsTy findDeclsInToCtx(DeclContext *DC, DeclarationName Name);
 
     void AddToLookupTable(Decl *ToD);
 
   protected:
     /// Can be overwritten by subclasses to implement their own import logic.
     /// The overwritten method should call this method if it didn't import the
     /// decl on its own.
     virtual Expected<Decl *> ImportImpl(Decl *From);
 
     /// Used only in unittests to verify the behaviour of the error handling.
     virtual bool returnWithErrorInTest() { return false; };
 
   public:
 
     /// \param ToContext The context we'll be importing into.
     ///
     /// \param ToFileManager The file manager we'll be importing into.
     ///
     /// \param FromContext The context we'll be importing from.
     ///
     /// \param FromFileManager The file manager we'll be importing into.
     ///
     /// \param MinimalImport If true, the importer will attempt to import
     /// as little as it can, e.g., by importing declarations as forward
     /// declarations that can be completed at a later point.
     ///
     /// \param SharedState The importer specific lookup table which may be
     /// shared amongst several ASTImporter objects.
     /// If not set then the original C/C++ lookup is used.
     ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
                 ASTContext &FromContext, FileManager &FromFileManager,
                 bool MinimalImport,
                 std::shared_ptr<ASTImporterSharedState> SharedState = nullptr);
 
     virtual ~ASTImporter();
 
     /// Whether the importer will perform a minimal import, creating
     /// to-be-completed forward declarations when possible.
     bool isMinimalImport() const { return Minimal; }
 
     void setODRHandling(ODRHandlingType T) { ODRHandling = T; }
 
     /// \brief Import the given object, returns the result.
     ///
     /// \param To Import the object into this variable.
     /// \param From Object to import.
     /// \return Error information (success or error).
     template <typename ImportT>
     [[nodiscard]] llvm::Error importInto(ImportT &To, const ImportT &From) {
       auto ToOrErr = Import(From);
       if (ToOrErr)
         To = *ToOrErr;
       return ToOrErr.takeError();
     }
 
     /// Import cleanup objects owned by ExprWithCleanup.
     llvm::Expected<ExprWithCleanups::CleanupObject>
     Import(ExprWithCleanups::CleanupObject From);
 
     /// Import the given type from the "from" context into the "to"
     /// context.
     ///
     /// \returns The equivalent type in the "to" context, or the import error.
     llvm::Expected<const Type *> Import(const Type *FromT);
 
     /// Import the given qualified type from the "from" context into the "to"
     /// context. A null type is imported as a null type (no error).
     ///
     /// \returns The equivalent type in the "to" context, or the import error.
     llvm::Expected<QualType> Import(QualType FromT);
 
     /// Import the given type source information from the
     /// "from" context into the "to" context.
     ///
     /// \returns The equivalent type source information in the "to"
     /// context, or the import error.
     llvm::Expected<TypeSourceInfo *> Import(TypeSourceInfo *FromTSI);
 
     /// Import the given attribute from the "from" context into the
     /// "to" context.
     ///
     /// \returns The equivalent attribute in the "to" context, or the import
     /// error.
     llvm::Expected<Attr *> Import(const Attr *FromAttr);
 
     /// Import the given declaration from the "from" context into the
     /// "to" context.
     ///
     /// \returns The equivalent declaration in the "to" context, or the import
     /// error.
     llvm::Expected<Decl *> Import(Decl *FromD);
     llvm::Expected<const Decl *> Import(const Decl *FromD) {
       return Import(const_cast<Decl *>(FromD));
     }
 
     llvm::Expected<InheritedConstructor>
     Import(const InheritedConstructor &From);
 
     /// Return the copy of the given declaration in the "to" context if
     /// it has already been imported from the "from" context.  Otherwise return
     /// nullptr.
     Decl *GetAlreadyImportedOrNull(const Decl *FromD) const;
 
     /// Return the translation unit from where the declaration was
     /// imported. If it does not exist nullptr is returned.
     TranslationUnitDecl *GetFromTU(Decl *ToD);
 
     /// Return the declaration in the "from" context from which the declaration
     /// in the "to" context was imported. If it was not imported or of the wrong
     /// type a null value is returned.
     template <typename DeclT>
     std::optional<DeclT *> getImportedFromDecl(const DeclT *ToD) const {
       auto FromI = ImportedFromDecls.find(ToD);
       if (FromI == ImportedFromDecls.end())
         return {};
       auto *FromD = dyn_cast<DeclT>(FromI->second);
       if (!FromD)
         return {};
       return FromD;
     }
 
     /// Import the given declaration context from the "from"
     /// AST context into the "to" AST context.
     ///
     /// \returns the equivalent declaration context in the "to"
     /// context, or error value.
     llvm::Expected<DeclContext *> ImportContext(DeclContext *FromDC);
 
     /// Import the given expression from the "from" context into the
     /// "to" context.
     ///
     /// \returns The equivalent expression in the "to" context, or the import
     /// error.
     llvm::Expected<Expr *> Import(Expr *FromE);
 
     /// Import the given statement from the "from" context into the
     /// "to" context.
     ///
     /// \returns The equivalent statement in the "to" context, or the import
     /// error.
     llvm::Expected<Stmt *> Import(Stmt *FromS);
 
     /// Import the given nested-name-specifier from the "from"
     /// context into the "to" context.
     ///
     /// \returns The equivalent nested-name-specifier in the "to"
     /// context, or the import error.
     llvm::Expected<NestedNameSpecifier *> Import(NestedNameSpecifier *FromNNS);
 
     /// Import the given nested-name-specifier-loc from the "from"
     /// context into the "to" context.
     ///
     /// \returns The equivalent nested-name-specifier-loc in the "to"
     /// context, or the import error.
     llvm::Expected<NestedNameSpecifierLoc>
     Import(NestedNameSpecifierLoc FromNNS);
 
     /// Import the given template name from the "from" context into the
     /// "to" context, or the import error.
     llvm::Expected<TemplateName> Import(TemplateName From);
 
     /// Import the given source location from the "from" context into
     /// the "to" context.
     ///
     /// \returns The equivalent source location in the "to" context, or the
     /// import error.
     llvm::Expected<SourceLocation> Import(SourceLocation FromLoc);
 
     /// Import the given source range from the "from" context into
     /// the "to" context.
     ///
     /// \returns The equivalent source range in the "to" context, or the import
     /// error.
     llvm::Expected<SourceRange> Import(SourceRange FromRange);
 
     /// Import the given declaration name from the "from"
     /// context into the "to" context.
     ///
     /// \returns The equivalent declaration name in the "to" context, or the
     /// import error.
     llvm::Expected<DeclarationName> Import(DeclarationName FromName);
 
     /// Import the given identifier from the "from" context
     /// into the "to" context.
     ///
     /// \returns The equivalent identifier in the "to" context. Note: It
     /// returns nullptr only if the FromId was nullptr.
     IdentifierInfo *Import(const IdentifierInfo *FromId);
 
     /// Import the given Objective-C selector from the "from"
     /// context into the "to" context.
     ///
     /// \returns The equivalent selector in the "to" context, or the import
     /// error.
     llvm::Expected<Selector> Import(Selector FromSel);
 
     /// Import the given file ID from the "from" context into the
     /// "to" context.
     ///
     /// \returns The equivalent file ID in the source manager of the "to"
     /// context, or the import error.
     llvm::Expected<FileID> Import(FileID, bool IsBuiltin = false);
 
     /// Import the given C++ constructor initializer from the "from"
     /// context into the "to" context.
     ///
     /// \returns The equivalent initializer in the "to" context, or the import
     /// error.
     llvm::Expected<CXXCtorInitializer *> Import(CXXCtorInitializer *FromInit);
 
     /// Import the given CXXBaseSpecifier from the "from" context into
     /// the "to" context.
     ///
     /// \returns The equivalent CXXBaseSpecifier in the source manager of the
     /// "to" context, or the import error.
     llvm::Expected<CXXBaseSpecifier *> Import(const CXXBaseSpecifier *FromSpec);
 
     /// Import the given APValue from the "from" context into
     /// the "to" context.
     ///
     /// \return the equivalent APValue in the "to" context or the import
     /// error.
     llvm::Expected<APValue> Import(const APValue &FromValue);
 
     /// Import the definition of the given declaration, including all of
     /// the declarations it contains.
     [[nodiscard]] llvm::Error ImportDefinition(Decl *From);
 
     llvm::Error
     ImportTemplateArguments(ArrayRef<TemplateArgument> FromArgs,
                             SmallVectorImpl<TemplateArgument> &ToArgs);
     Expected<TemplateArgument> Import(const TemplateArgument &From);
 
     /// Cope with a name conflict when importing a declaration into the
     /// given context.
     ///
     /// This routine is invoked whenever there is a name conflict while
     /// importing a declaration. The returned name will become the name of the
     /// imported declaration. By default, the returned name is the same as the
     /// original name, leaving the conflict unresolve such that name lookup
     /// for this name is likely to find an ambiguity later.
     ///
     /// Subclasses may override this routine to resolve the conflict, e.g., by
     /// renaming the declaration being imported.
     ///
     /// \param Name the name of the declaration being imported, which conflicts
     /// with other declarations.
     ///
     /// \param DC the declaration context (in the "to" AST context) in which
     /// the name is being imported.
     ///
     /// \param IDNS the identifier namespace in which the name will be found.
     ///
     /// \param Decls the set of declarations with the same name as the
     /// declaration being imported.
     ///
     /// \param NumDecls the number of conflicting declarations in \p Decls.
     ///
     /// \returns the name that the newly-imported declaration should have. Or
     /// an error if we can't handle the name conflict.
     virtual Expected<DeclarationName>
     HandleNameConflict(DeclarationName Name, DeclContext *DC, unsigned IDNS,
                        NamedDecl **Decls, unsigned NumDecls);
 
     /// Retrieve the context that AST nodes are being imported into.
     ASTContext &getToContext() const { return ToContext; }
 
     /// Retrieve the context that AST nodes are being imported from.
     ASTContext &getFromContext() const { return FromContext; }
 
     /// Retrieve the file manager that AST nodes are being imported into.
     FileManager &getToFileManager() const { return ToFileManager; }
 
     /// Retrieve the file manager that AST nodes are being imported from.
     FileManager &getFromFileManager() const { return FromFileManager; }
 
     /// Report a diagnostic in the "to" context.
     DiagnosticBuilder ToDiag(SourceLocation Loc, unsigned DiagID);
 
     /// Report a diagnostic in the "from" context.
     DiagnosticBuilder FromDiag(SourceLocation Loc, unsigned DiagID);
 
     /// Return the set of declarations that we know are not equivalent.
     NonEquivalentDeclSet &getNonEquivalentDecls() { return NonEquivalentDecls; }
 
     /// Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
     /// Mark the Decl as complete, filling it in as much as possible.
     ///
     /// \param D A declaration in the "to" context.
     virtual void CompleteDecl(Decl* D);
 
     /// Subclasses can override this function to observe all of the \c From ->
     /// \c To declaration mappings as they are imported.
     virtual void Imported(Decl *From, Decl *To) {}
 
     void RegisterImportedDecl(Decl *FromD, Decl *ToD);
 
     /// Store and assign the imported declaration to its counterpart.
     /// It may happen that several decls from the 'from' context are mapped to
     /// the same decl in the 'to' context.
     Decl *MapImported(Decl *From, Decl *To);
 
     /// Called by StructuralEquivalenceContext.  If a RecordDecl is
     /// being compared to another RecordDecl as part of import, completing the
     /// other RecordDecl may trigger importation of the first RecordDecl. This
     /// happens especially for anonymous structs.  If the original of the second
     /// RecordDecl can be found, we can complete it without the need for
     /// importation, eliminating this loop.
     virtual Decl *GetOriginalDecl(Decl *To) { return nullptr; }
 
     /// Return if import of the given declaration has failed and if yes
     /// the kind of the problem. This gives the first error encountered with
     /// the node.
     std::optional<ASTImportError> getImportDeclErrorIfAny(Decl *FromD) const;
 
     /// Mark (newly) imported declaration with error.
     void setImportDeclError(Decl *From, ASTImportError Error);
 
     /// Determine whether the given types are structurally
     /// equivalent.
     bool IsStructurallyEquivalent(QualType From, QualType To,
                                   bool Complain = true);
 
     /// Determine the index of a field in its parent record.
     /// F should be a field (or indirect field) declaration.
     /// \returns The index of the field in its parent context (starting from 0).
     /// On error `std::nullopt` is returned (parent context is non-record).
     static std::optional<unsigned> getFieldIndex(Decl *F);
   };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_ASTIMPORTER_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team