clang  9.0.0svn
ASTImporter.h
Go to the documentation of this file.
1 //===- ASTImporter.h - Importing ASTs from other Contexts -------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the ASTImporter class which imports AST nodes from one
10 // context into another context.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_ASTIMPORTER_H
15 #define LLVM_CLANG_AST_ASTIMPORTER_H
16 
19 #include "clang/AST/TemplateName.h"
20 #include "clang/AST/Type.h"
21 #include "clang/Basic/Diagnostic.h"
23 #include "clang/Basic/LLVM.h"
25 #include "llvm/ADT/DenseMap.h"
26 #include "llvm/ADT/DenseSet.h"
27 #include "llvm/ADT/Optional.h"
28 #include "llvm/ADT/SmallVector.h"
29 #include "llvm/Support/Error.h"
30 #include <utility>
31 
32 namespace clang {
33 
34 class ASTContext;
35 class Attr;
36 class ASTImporterLookupTable;
37 class CXXBaseSpecifier;
38 class CXXCtorInitializer;
39 class Decl;
40 class DeclContext;
41 class Expr;
42 class FileManager;
43 class NamedDecl;
44 class Stmt;
45 class TagDecl;
46 class TranslationUnitDecl;
47 class TypeSourceInfo;
48 
49  class ImportError : public llvm::ErrorInfo<ImportError> {
50  public:
51  /// \brief Kind of error when importing an AST component.
52  enum ErrorKind {
53  NameConflict, /// Naming ambiguity (likely ODR violation).
54  UnsupportedConstruct, /// Not supported node or case.
55  Unknown /// Other error.
56  };
57 
59 
60  static char ID;
61 
62  ImportError() : Error(Unknown) { }
63  ImportError(const ImportError &Other) : Error(Other.Error) { }
64  ImportError(ErrorKind Error) : Error(Error) { }
65 
66  std::string toString() const;
67 
68  void log(raw_ostream &OS) const override;
69  std::error_code convertToErrorCode() const override;
70  };
71 
72  // \brief Returns with a list of declarations started from the canonical decl
73  // then followed by subsequent decls in the translation unit.
74  // This gives a canonical list for each entry in the redecl chain.
75  // `Decl::redecls()` gives a list of decls which always start from the
76  // previous decl and the next item is actually the previous item in the order
77  // of source locations. Thus, `Decl::redecls()` gives different lists for
78  // the different entries in a given redecl chain.
80 
81  /// Imports selected nodes from one AST context into another context,
82  /// merging AST nodes where appropriate.
83  class ASTImporter {
84  friend class ASTNodeImporter;
85  public:
88  llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>;
89 
90  private:
91 
92  /// Pointer to the import specific lookup table, which may be shared
93  /// amongst several ASTImporter objects.
94  /// This is an externally managed resource (and should exist during the
95  /// lifetime of the ASTImporter object)
96  /// If not set then the original C/C++ lookup is used.
97  ASTImporterLookupTable *LookupTable = nullptr;
98 
99  /// The contexts we're importing to and from.
100  ASTContext &ToContext, &FromContext;
101 
102  /// The file managers we're importing to and from.
103  FileManager &ToFileManager, &FromFileManager;
104 
105  /// Whether to perform a minimal import.
106  bool Minimal;
107 
108  /// Whether the last diagnostic came from the "from" context.
109  bool LastDiagFromFrom = false;
110 
111  /// Mapping from the already-imported types in the "from" context
112  /// to the corresponding types in the "to" context.
113  llvm::DenseMap<const Type *, const Type *> ImportedTypes;
114 
115  /// Mapping from the already-imported declarations in the "from"
116  /// context to the corresponding declarations in the "to" context.
117  llvm::DenseMap<Decl *, Decl *> ImportedDecls;
118 
119  /// Mapping from the already-imported declarations in the "to"
120  /// context to the corresponding declarations in the "from" context.
121  llvm::DenseMap<Decl *, Decl *> ImportedFromDecls;
122 
123  /// Mapping from the already-imported statements in the "from"
124  /// context to the corresponding statements in the "to" context.
125  llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
126 
127  /// Mapping from the already-imported FileIDs in the "from" source
128  /// manager to the corresponding FileIDs in the "to" source manager.
129  llvm::DenseMap<FileID, FileID> ImportedFileIDs;
130 
131  /// Mapping from the already-imported CXXBasesSpecifier in
132  /// the "from" source manager to the corresponding CXXBasesSpecifier
133  /// in the "to" source manager.
134  ImportedCXXBaseSpecifierMap ImportedCXXBaseSpecifiers;
135 
136  /// Declaration (from, to) pairs that are known not to be equivalent
137  /// (which we have already complained about).
138  NonEquivalentDeclSet NonEquivalentDecls;
139 
141  FoundDeclsTy findDeclsInToCtx(DeclContext *DC, DeclarationName Name);
142 
143  void AddToLookupTable(Decl *ToD);
144 
145  public:
146 
147  /// \param ToContext The context we'll be importing into.
148  ///
149  /// \param ToFileManager The file manager we'll be importing into.
150  ///
151  /// \param FromContext The context we'll be importing from.
152  ///
153  /// \param FromFileManager The file manager we'll be importing into.
154  ///
155  /// \param MinimalImport If true, the importer will attempt to import
156  /// as little as it can, e.g., by importing declarations as forward
157  /// declarations that can be completed at a later point.
158  ///
159  /// \param LookupTable The importer specific lookup table which may be
160  /// shared amongst several ASTImporter objects.
161  /// If not set then the original C/C++ lookup is used.
162  ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
163  ASTContext &FromContext, FileManager &FromFileManager,
164  bool MinimalImport,
165  ASTImporterLookupTable *LookupTable = nullptr);
166 
167  virtual ~ASTImporter();
168 
169  /// Whether the importer will perform a minimal import, creating
170  /// to-be-completed forward declarations when possible.
171  bool isMinimalImport() const { return Minimal; }
172 
173  /// \brief Import the given object, returns the result.
174  ///
175  /// \param To Import the object into this variable.
176  /// \param From Object to import.
177  /// \return Error information (success or error).
178  template <typename ImportT>
179  LLVM_NODISCARD llvm::Error importInto(ImportT &To, const ImportT &From) {
180  auto ToOrErr = Import_New(From);
181  if (ToOrErr)
182  To = *ToOrErr;
183  return ToOrErr.takeError();
184  }
185 
186  /// Import the given type from the "from" context into the "to"
187  /// context. A null type is imported as a null type (no error).
188  ///
189  /// \returns The equivalent type in the "to" context, or the import error.
190  llvm::Expected<QualType> Import_New(QualType FromT);
191  // FIXME: Remove this version.
192  QualType Import(QualType FromT);
193 
194  /// Import the given type source information from the
195  /// "from" context into the "to" context.
196  ///
197  /// \returns The equivalent type source information in the "to"
198  /// context, or the import error.
200  // FIXME: Remove this version.
201  TypeSourceInfo *Import(TypeSourceInfo *FromTSI);
202 
203  /// Import the given attribute from the "from" context into the
204  /// "to" context.
205  ///
206  /// \returns The equivalent attribute in the "to" context, or the import
207  /// error.
208  llvm::Expected<Attr *> Import_New(const Attr *FromAttr);
209  // FIXME: Remove this version.
210  Attr *Import(const Attr *FromAttr);
211 
212  /// Import the given declaration from the "from" context into the
213  /// "to" context.
214  ///
215  /// \returns The equivalent declaration in the "to" context, or the import
216  /// error.
217  llvm::Expected<Decl *> Import_New(Decl *FromD);
219  return Import_New(const_cast<Decl *>(FromD));
220  }
221  // FIXME: Remove this version.
222  Decl *Import(Decl *FromD);
223  Decl *Import(const Decl *FromD) {
224  return Import(const_cast<Decl *>(FromD));
225  }
226 
227  /// Return the copy of the given declaration in the "to" context if
228  /// it has already been imported from the "from" context. Otherwise return
229  /// nullptr.
230  Decl *GetAlreadyImportedOrNull(const Decl *FromD) const;
231 
232  /// Return the translation unit from where the declaration was
233  /// imported. If it does not exist nullptr is returned.
234  TranslationUnitDecl *GetFromTU(Decl *ToD);
235 
236  /// Import the given declaration context from the "from"
237  /// AST context into the "to" AST context.
238  ///
239  /// \returns the equivalent declaration context in the "to"
240  /// context, or error value.
241  llvm::Expected<DeclContext *> ImportContext(DeclContext *FromDC);
242 
243  /// Import the given expression from the "from" context into the
244  /// "to" context.
245  ///
246  /// \returns The equivalent expression in the "to" context, or the import
247  /// error.
248  llvm::Expected<Expr *> Import_New(Expr *FromE);
249  // FIXME: Remove this version.
250  Expr *Import(Expr *FromE);
251 
252  /// Import the given statement from the "from" context into the
253  /// "to" context.
254  ///
255  /// \returns The equivalent statement in the "to" context, or the import
256  /// error.
257  llvm::Expected<Stmt *> Import_New(Stmt *FromS);
258  // FIXME: Remove this version.
259  Stmt *Import(Stmt *FromS);
260 
261  /// Import the given nested-name-specifier from the "from"
262  /// context into the "to" context.
263  ///
264  /// \returns The equivalent nested-name-specifier in the "to"
265  /// context, or the import error.
267  Import_New(NestedNameSpecifier *FromNNS);
268  // FIXME: Remove this version.
269  NestedNameSpecifier *Import(NestedNameSpecifier *FromNNS);
270 
271  /// Import the given nested-name-specifier-loc from the "from"
272  /// context into the "to" context.
273  ///
274  /// \returns The equivalent nested-name-specifier-loc in the "to"
275  /// context, or the import error.
277  Import_New(NestedNameSpecifierLoc FromNNS);
278  // FIXME: Remove this version.
280 
281  /// Import the given template name from the "from" context into the
282  /// "to" context, or the import error.
284  // FIXME: Remove this version.
285  TemplateName Import(TemplateName From);
286 
287  /// Import the given source location from the "from" context into
288  /// the "to" context.
289  ///
290  /// \returns The equivalent source location in the "to" context, or the
291  /// import error.
293  // FIXME: Remove this version.
294  SourceLocation Import(SourceLocation FromLoc);
295 
296  /// Import the given source range from the "from" context into
297  /// the "to" context.
298  ///
299  /// \returns The equivalent source range in the "to" context, or the import
300  /// error.
301  llvm::Expected<SourceRange> Import_New(SourceRange FromRange);
302  // FIXME: Remove this version.
303  SourceRange Import(SourceRange FromRange);
304 
305  /// Import the given declaration name from the "from"
306  /// context into the "to" context.
307  ///
308  /// \returns The equivalent declaration name in the "to" context, or the
309  /// import error.
311  // FIXME: Remove this version.
312  DeclarationName Import(DeclarationName FromName);
313 
314  /// Import the given identifier from the "from" context
315  /// into the "to" context.
316  ///
317  /// \returns The equivalent identifier in the "to" context. Note: It
318  /// returns nullptr only if the FromId was nullptr.
319  IdentifierInfo *Import(const IdentifierInfo *FromId);
320 
321  /// Import the given Objective-C selector from the "from"
322  /// context into the "to" context.
323  ///
324  /// \returns The equivalent selector in the "to" context, or the import
325  /// error.
326  llvm::Expected<Selector> Import_New(Selector FromSel);
327  // FIXME: Remove this version.
328  Selector Import(Selector FromSel);
329 
330  /// Import the given file ID from the "from" context into the
331  /// "to" context.
332  ///
333  /// \returns The equivalent file ID in the source manager of the "to"
334  /// context, or the import error.
335  llvm::Expected<FileID> Import_New(FileID, bool IsBuiltin = false);
336  // FIXME: Remove this version.
337  FileID Import(FileID, bool IsBuiltin = false);
338 
339  /// Import the given C++ constructor initializer from the "from"
340  /// context into the "to" context.
341  ///
342  /// \returns The equivalent initializer in the "to" context, or the import
343  /// error.
345  Import_New(CXXCtorInitializer *FromInit);
346  // FIXME: Remove this version.
347  CXXCtorInitializer *Import(CXXCtorInitializer *FromInit);
348 
349  /// Import the given CXXBaseSpecifier from the "from" context into
350  /// the "to" context.
351  ///
352  /// \returns The equivalent CXXBaseSpecifier in the source manager of the
353  /// "to" context, or the import error.
355  Import_New(const CXXBaseSpecifier *FromSpec);
356  // FIXME: Remove this version.
357  CXXBaseSpecifier *Import(const CXXBaseSpecifier *FromSpec);
358 
359  /// Import the definition of the given declaration, including all of
360  /// the declarations it contains.
361  LLVM_NODISCARD llvm::Error ImportDefinition_New(Decl *From);
362 
363  // FIXME: Compatibility function.
364  // Usages of this should be changed to ImportDefinition_New.
365  void ImportDefinition(Decl *From);
366 
367  /// Cope with a name conflict when importing a declaration into the
368  /// given context.
369  ///
370  /// This routine is invoked whenever there is a name conflict while
371  /// importing a declaration. The returned name will become the name of the
372  /// imported declaration. By default, the returned name is the same as the
373  /// original name, leaving the conflict unresolve such that name lookup
374  /// for this name is likely to find an ambiguity later.
375  ///
376  /// Subclasses may override this routine to resolve the conflict, e.g., by
377  /// renaming the declaration being imported.
378  ///
379  /// \param Name the name of the declaration being imported, which conflicts
380  /// with other declarations.
381  ///
382  /// \param DC the declaration context (in the "to" AST context) in which
383  /// the name is being imported.
384  ///
385  /// \param IDNS the identifier namespace in which the name will be found.
386  ///
387  /// \param Decls the set of declarations with the same name as the
388  /// declaration being imported.
389  ///
390  /// \param NumDecls the number of conflicting declarations in \p Decls.
391  ///
392  /// \returns the name that the newly-imported declaration should have.
393  virtual DeclarationName HandleNameConflict(DeclarationName Name,
394  DeclContext *DC,
395  unsigned IDNS,
396  NamedDecl **Decls,
397  unsigned NumDecls);
398 
399  /// Retrieve the context that AST nodes are being imported into.
400  ASTContext &getToContext() const { return ToContext; }
401 
402  /// Retrieve the context that AST nodes are being imported from.
403  ASTContext &getFromContext() const { return FromContext; }
404 
405  /// Retrieve the file manager that AST nodes are being imported into.
406  FileManager &getToFileManager() const { return ToFileManager; }
407 
408  /// Retrieve the file manager that AST nodes are being imported from.
409  FileManager &getFromFileManager() const { return FromFileManager; }
410 
411  /// Report a diagnostic in the "to" context.
412  DiagnosticBuilder ToDiag(SourceLocation Loc, unsigned DiagID);
413 
414  /// Report a diagnostic in the "from" context.
415  DiagnosticBuilder FromDiag(SourceLocation Loc, unsigned DiagID);
416 
417  /// Return the set of declarations that we know are not equivalent.
418  NonEquivalentDeclSet &getNonEquivalentDecls() { return NonEquivalentDecls; }
419 
420  /// Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
421  /// Mark the Decl as complete, filling it in as much as possible.
422  ///
423  /// \param D A declaration in the "to" context.
424  virtual void CompleteDecl(Decl* D);
425 
426  /// Subclasses can override this function to observe all of the \c From ->
427  /// \c To declaration mappings as they are imported.
428  virtual void Imported(Decl *From, Decl *To) {}
429 
430  /// Store and assign the imported declaration to its counterpart.
431  Decl *MapImported(Decl *From, Decl *To);
432 
433  /// Called by StructuralEquivalenceContext. If a RecordDecl is
434  /// being compared to another RecordDecl as part of import, completing the
435  /// other RecordDecl may trigger importation of the first RecordDecl. This
436  /// happens especially for anonymous structs. If the original of the second
437  /// RecordDecl can be found, we can complete it without the need for
438  /// importation, eliminating this loop.
439  virtual Decl *GetOriginalDecl(Decl *To) { return nullptr; }
440 
441  /// Determine whether the given types are structurally
442  /// equivalent.
444  bool Complain = true);
445 
446  /// Determine the index of a field in its parent record.
447  /// F should be a field (or indirect field) declaration.
448  /// \returns The index of the field in its parent context (starting from 0).
449  /// On error `None` is returned (parent context is non-record).
450  static llvm::Optional<unsigned> getFieldIndex(Decl *F);
451 
452  };
453 
454 } // namespace clang
455 
456 #endif // LLVM_CLANG_AST_ASTIMPORTER_H
static char ID
Definition: ASTImporter.h:60
Smart pointer class that efficiently represents Objective-C method names.
A (possibly-)qualified type.
Definition: Type.h:639
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
Stmt - This represents one statement.
Definition: Stmt.h:65
C Language Family Type Representation.
llvm::Expected< const Decl * > Import_New(const Decl *FromD)
Definition: ASTImporter.h:218
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
A container of type source information.
Definition: Decl.h:86
Not supported node or case.
Definition: ASTImporter.h:55
virtual Decl * GetOriginalDecl(Decl *To)
Called by StructuralEquivalenceContext.
Definition: ASTImporter.h:439
FileManager & getFromFileManager() const
Retrieve the file manager that AST nodes are being imported from.
Definition: ASTImporter.h:409
One of these records is kept for each identifier that is lexed.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
A C++ nested-name-specifier augmented with source location information.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Defines the Diagnostic-related interfaces.
void log(raw_ostream &OS) const override
Definition: ASTImporter.cpp:97
llvm::DenseMap< const CXXBaseSpecifier *, CXXBaseSpecifier * > ImportedCXXBaseSpecifierMap
Definition: ASTImporter.h:88
ASTContext & getToContext() const
Retrieve the context that AST nodes are being imported into.
Definition: ASTImporter.h:400
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1044
This represents one expression.
Definition: Expr.h:108
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
llvm::SmallVector< Decl *, 2 > getCanonicalForwardRedeclChain(Decl *D)
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
std::error_code convertToErrorCode() const override
ImportError(ErrorKind Error)
Definition: ASTImporter.h:64
Encodes a location in the source.
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, QualType T1, QualType T2)
Determine structural equivalence of two types.
ImportError(const ImportError &Other)
Definition: ASTImporter.h:63
virtual void Imported(Decl *From, Decl *To)
Subclasses can override this function to observe all of the From -> To declaration mappings as they a...
Definition: ASTImporter.h:428
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isMinimalImport() const
Whether the importer will perform a minimal import, creating to-be-completed forward declarations whe...
Definition: ASTImporter.h:171
FileManager & getToFileManager() const
Retrieve the file manager that AST nodes are being imported into.
Definition: ASTImporter.h:406
Naming ambiguity (likely ODR violation).
Definition: ASTImporter.h:54
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
NonEquivalentDeclSet & getNonEquivalentDecls()
Return the set of declarations that we know are not equivalent.
Definition: ASTImporter.h:418
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
LLVM_NODISCARD llvm::Error importInto(ImportT &To, const ImportT &From)
Import the given object, returns the result.
Definition: ASTImporter.h:179
The name of a declaration.
Imports selected nodes from one AST context into another context, merging AST nodes where appropriate...
Definition: ASTImporter.h:83
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2263
Decl * Import(const Decl *FromD)
Definition: ASTImporter.h:223
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
Defines the clang::SourceLocation class and associated facilities.
ASTContext & getFromContext() const
Retrieve the context that AST nodes are being imported from.
Definition: ASTImporter.h:403
The top declaration context.
Definition: Decl.h:107
std::string toString() const
Definition: ASTImporter.cpp:83
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
Definition: Decl.h:248
Attr - This represents one attribute.
Definition: Attr.h:43
ErrorKind
Kind of error when importing an AST component.
Definition: ASTImporter.h:52