Coverage Report

Created: 2018-09-23 03:40

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/ASTImporter.h
Line
Count
Source (jump to first uncovered line)
1
//===- ASTImporter.h - Importing ASTs from other Contexts -------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
//  This file defines the ASTImporter class which imports AST nodes from one
11
//  context into another context.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_AST_ASTIMPORTER_H
16
#define LLVM_CLANG_AST_ASTIMPORTER_H
17
18
#include "clang/AST/DeclarationName.h"
19
#include "clang/AST/NestedNameSpecifier.h"
20
#include "clang/AST/TemplateName.h"
21
#include "clang/AST/Type.h"
22
#include "clang/Basic/Diagnostic.h"
23
#include "clang/Basic/IdentifierTable.h"
24
#include "clang/Basic/LLVM.h"
25
#include "clang/Basic/SourceLocation.h"
26
#include "llvm/ADT/DenseMap.h"
27
#include "llvm/ADT/DenseSet.h"
28
#include "llvm/ADT/SmallVector.h"
29
#include <utility>
30
31
namespace clang {
32
33
class ASTContext;
34
class CXXBaseSpecifier;
35
class CXXCtorInitializer;
36
class Decl;
37
class DeclContext;
38
class Expr;
39
class FileManager;
40
class NamedDecl;
41
class Stmt;
42
class TagDecl;
43
class TypeSourceInfo;
44
class Attr;
45
46
  // \brief Returns with a list of declarations started from the canonical decl
47
  // then followed by subsequent decls in the translation unit.
48
  // This gives a canonical list for each entry in the redecl chain.
49
  // `Decl::redecls()` gives a list of decls which always start from the
50
  // previous decl and the next item is actually the previous item in the order
51
  // of source locations.  Thus, `Decl::redecls()` gives different lists for
52
  // the different entries in a given redecl chain.
53
  llvm::SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D);
54
55
  /// Imports selected nodes from one AST context into another context,
56
  /// merging AST nodes where appropriate.
57
  class ASTImporter {
58
  public:
59
    using NonEquivalentDeclSet = llvm::DenseSet<std::pair<Decl *, Decl *>>;
60
    using ImportedCXXBaseSpecifierMap =
61
        llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>;
62
63
  private:
64
    /// The contexts we're importing to and from.
65
    ASTContext &ToContext, &FromContext;
66
67
    /// The file managers we're importing to and from.
68
    FileManager &ToFileManager, &FromFileManager;
69
70
    /// Whether to perform a minimal import.
71
    bool Minimal;
72
73
    /// Whether the last diagnostic came from the "from" context.
74
    bool LastDiagFromFrom = false;
75
76
    /// Mapping from the already-imported types in the "from" context
77
    /// to the corresponding types in the "to" context.
78
    llvm::DenseMap<const Type *, const Type *> ImportedTypes;
79
80
    /// Mapping from the already-imported declarations in the "from"
81
    /// context to the corresponding declarations in the "to" context.
82
    llvm::DenseMap<Decl *, Decl *> ImportedDecls;
83
84
    /// Mapping from the already-imported statements in the "from"
85
    /// context to the corresponding statements in the "to" context.
86
    llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
87
88
    /// Mapping from the already-imported FileIDs in the "from" source
89
    /// manager to the corresponding FileIDs in the "to" source manager.
90
    llvm::DenseMap<FileID, FileID> ImportedFileIDs;
91
92
    /// Mapping from the already-imported CXXBasesSpecifier in
93
    ///  the "from" source manager to the corresponding CXXBasesSpecifier
94
    ///  in the "to" source manager.
95
    ImportedCXXBaseSpecifierMap ImportedCXXBaseSpecifiers;
96
97
    /// Declaration (from, to) pairs that are known not to be equivalent
98
    /// (which we have already complained about).
99
    NonEquivalentDeclSet NonEquivalentDecls;
100
101
  public:
102
    /// Create a new AST importer.
103
    ///
104
    /// \param ToContext The context we'll be importing into.
105
    ///
106
    /// \param ToFileManager The file manager we'll be importing into.
107
    ///
108
    /// \param FromContext The context we'll be importing from.
109
    ///
110
    /// \param FromFileManager The file manager we'll be importing into.
111
    ///
112
    /// \param MinimalImport If true, the importer will attempt to import
113
    /// as little as it can, e.g., by importing declarations as forward
114
    /// declarations that can be completed at a later point.
115
    ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
116
                ASTContext &FromContext, FileManager &FromFileManager,
117
                bool MinimalImport);
118
119
    virtual ~ASTImporter();
120
121
    /// Whether the importer will perform a minimal import, creating
122
    /// to-be-completed forward declarations when possible.
123
3.05k
    bool isMinimalImport() const { return Minimal; }
124
125
    /// Import the given type from the "from" context into the "to"
126
    /// context.
127
    ///
128
    /// \returns the equivalent type in the "to" context, or a NULL type if
129
    /// an error occurred.
130
    QualType Import(QualType FromT);
131
132
    /// Import the given type source information from the
133
    /// "from" context into the "to" context.
134
    ///
135
    /// \returns the equivalent type source information in the "to"
136
    /// context, or NULL if an error occurred.
137
    TypeSourceInfo *Import(TypeSourceInfo *FromTSI);
138
139
    /// Import the given attribute from the "from" context into the
140
    /// "to" context.
141
    ///
142
    /// \returns the equivalent attribute in the "to" context.
143
    Attr *Import(const Attr *FromAttr);
144
145
    /// Import the given declaration from the "from" context into the
146
    /// "to" context.
147
    ///
148
    /// \returns the equivalent declaration in the "to" context, or a NULL type
149
    /// if an error occurred.
150
    Decl *Import(Decl *FromD);
151
    Decl *Import(const Decl *FromD) {
152
      return Import(const_cast<Decl *>(FromD));
153
    }
154
155
    /// Return the copy of the given declaration in the "to" context if
156
    /// it has already been imported from the "from" context.  Otherwise return
157
    /// NULL.
158
    Decl *GetAlreadyImportedOrNull(Decl *FromD);
159
160
    /// Import the given declaration context from the "from"
161
    /// AST context into the "to" AST context.
162
    ///
163
    /// \returns the equivalent declaration context in the "to"
164
    /// context, or a NULL type if an error occurred.
165
    DeclContext *ImportContext(DeclContext *FromDC);
166
167
    /// Import the given expression from the "from" context into the
168
    /// "to" context.
169
    ///
170
    /// \returns the equivalent expression in the "to" context, or NULL if
171
    /// an error occurred.
172
    Expr *Import(Expr *FromE);
173
174
    /// Import the given statement from the "from" context into the
175
    /// "to" context.
176
    ///
177
    /// \returns the equivalent statement in the "to" context, or NULL if
178
    /// an error occurred.
179
    Stmt *Import(Stmt *FromS);
180
181
    /// Import the given nested-name-specifier from the "from"
182
    /// context into the "to" context.
183
    ///
184
    /// \returns the equivalent nested-name-specifier in the "to"
185
    /// context, or NULL if an error occurred.
186
    NestedNameSpecifier *Import(NestedNameSpecifier *FromNNS);
187
188
    /// Import the given nested-name-specifier from the "from"
189
    /// context into the "to" context.
190
    ///
191
    /// \returns the equivalent nested-name-specifier in the "to"
192
    /// context.
193
    NestedNameSpecifierLoc Import(NestedNameSpecifierLoc FromNNS);
194
195
    /// Import the goven template name from the "from" context into the
196
    /// "to" context.
197
    TemplateName Import(TemplateName From);
198
199
    /// Import the given source location from the "from" context into
200
    /// the "to" context.
201
    ///
202
    /// \returns the equivalent source location in the "to" context, or an
203
    /// invalid source location if an error occurred.
204
    SourceLocation Import(SourceLocation FromLoc);
205
206
    /// Import the given source range from the "from" context into
207
    /// the "to" context.
208
    ///
209
    /// \returns the equivalent source range in the "to" context, or an
210
    /// invalid source location if an error occurred.
211
    SourceRange Import(SourceRange FromRange);
212
213
    /// Import the given declaration name from the "from"
214
    /// context into the "to" context.
215
    ///
216
    /// \returns the equivalent declaration name in the "to" context,
217
    /// or an empty declaration name if an error occurred.
218
    DeclarationName Import(DeclarationName FromName);
219
220
    /// Import the given identifier from the "from" context
221
    /// into the "to" context.
222
    ///
223
    /// \returns the equivalent identifier in the "to" context.
224
    IdentifierInfo *Import(const IdentifierInfo *FromId);
225
226
    /// Import the given Objective-C selector from the "from"
227
    /// context into the "to" context.
228
    ///
229
    /// \returns the equivalent selector in the "to" context.
230
    Selector Import(Selector FromSel);
231
232
    /// Import the given file ID from the "from" context into the
233
    /// "to" context.
234
    ///
235
    /// \returns the equivalent file ID in the source manager of the "to"
236
    /// context.
237
    FileID Import(FileID);
238
239
    /// Import the given C++ constructor initializer from the "from"
240
    /// context into the "to" context.
241
    ///
242
    /// \returns the equivalent initializer in the "to" context.
243
    CXXCtorInitializer *Import(CXXCtorInitializer *FromInit);
244
245
    /// Import the given CXXBaseSpecifier from the "from" context into
246
    /// the "to" context.
247
    ///
248
    /// \returns the equivalent CXXBaseSpecifier in the source manager of the
249
    /// "to" context.
250
    CXXBaseSpecifier *Import(const CXXBaseSpecifier *FromSpec);
251
252
    /// Import the definition of the given declaration, including all of
253
    /// the declarations it contains.
254
    ///
255
    /// This routine is intended to be used
256
    void ImportDefinition(Decl *From);
257
258
    /// Cope with a name conflict when importing a declaration into the
259
    /// given context.
260
    ///
261
    /// This routine is invoked whenever there is a name conflict while
262
    /// importing a declaration. The returned name will become the name of the
263
    /// imported declaration. By default, the returned name is the same as the
264
    /// original name, leaving the conflict unresolve such that name lookup
265
    /// for this name is likely to find an ambiguity later.
266
    ///
267
    /// Subclasses may override this routine to resolve the conflict, e.g., by
268
    /// renaming the declaration being imported.
269
    ///
270
    /// \param Name the name of the declaration being imported, which conflicts
271
    /// with other declarations.
272
    ///
273
    /// \param DC the declaration context (in the "to" AST context) in which
274
    /// the name is being imported.
275
    ///
276
    /// \param IDNS the identifier namespace in which the name will be found.
277
    ///
278
    /// \param Decls the set of declarations with the same name as the
279
    /// declaration being imported.
280
    ///
281
    /// \param NumDecls the number of conflicting declarations in \p Decls.
282
    ///
283
    /// \returns the name that the newly-imported declaration should have.
284
    virtual DeclarationName HandleNameConflict(DeclarationName Name,
285
                                               DeclContext *DC,
286
                                               unsigned IDNS,
287
                                               NamedDecl **Decls,
288
                                               unsigned NumDecls);
289
290
    /// Retrieve the context that AST nodes are being imported into.
291
23.3k
    ASTContext &getToContext() const { return ToContext; }
292
293
    /// Retrieve the context that AST nodes are being imported from.
294
3.94k
    ASTContext &getFromContext() const { return FromContext; }
295
296
    /// Retrieve the file manager that AST nodes are being imported into.
297
0
    FileManager &getToFileManager() const { return ToFileManager; }
298
299
    /// Retrieve the file manager that AST nodes are being imported from.
300
0
    FileManager &getFromFileManager() const { return FromFileManager; }
301
302
    /// Report a diagnostic in the "to" context.
303
    DiagnosticBuilder ToDiag(SourceLocation Loc, unsigned DiagID);
304
305
    /// Report a diagnostic in the "from" context.
306
    DiagnosticBuilder FromDiag(SourceLocation Loc, unsigned DiagID);
307
308
    /// Return the set of declarations that we know are not equivalent.
309
1.02k
    NonEquivalentDeclSet &getNonEquivalentDecls() { return NonEquivalentDecls; }
310
311
    /// Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
312
    /// Mark the Decl as complete, filling it in as much as possible.
313
    ///
314
    /// \param D A declaration in the "to" context.
315
    virtual void CompleteDecl(Decl* D);
316
317
    /// Subclasses can override this function to observe all of the \c From ->
318
    /// \c To declaration mappings as they are imported.
319
5.58k
    virtual Decl *Imported(Decl *From, Decl *To) { return To; }
320
321
    /// Store and assign the imported declaration to its counterpart.
322
    Decl *MapImported(Decl *From, Decl *To);
323
324
    /// Called by StructuralEquivalenceContext.  If a RecordDecl is
325
    /// being compared to another RecordDecl as part of import, completing the
326
    /// other RecordDecl may trigger importation of the first RecordDecl. This
327
    /// happens especially for anonymous structs.  If the original of the second
328
    /// RecordDecl can be found, we can complete it without the need for
329
    /// importation, eliminating this loop.
330
200
    virtual Decl *GetOriginalDecl(Decl *To) { return nullptr; }
331
332
    /// Determine whether the given types are structurally
333
    /// equivalent.
334
    bool IsStructurallyEquivalent(QualType From, QualType To,
335
                                  bool Complain = true);
336
337
    /// Determine the index of a field in its parent record.
338
    /// F should be a field (or indirect field) declaration.
339
    /// \returns The index of the field in its parent context, starting from 1.
340
    /// 0 is returned on error (parent context is non-record).
341
    static unsigned getFieldIndex(Decl *F);
342
343
  };
344
345
} // namespace clang
346
347
#endif // LLVM_CLANG_AST_ASTIMPORTER_H