/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/ExtractAPI/API.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- ExtractAPI/API.h -----------------------------------------*- 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 | | /// \file |
10 | | /// This file defines the APIRecord-based structs and the APISet class. |
11 | | /// |
12 | | /// Clang ExtractAPI is a tool to collect API information from a given set of |
13 | | /// header files. The structures in this file describe data representations of |
14 | | /// the API information collected for various kinds of symbols. |
15 | | /// |
16 | | //===----------------------------------------------------------------------===// |
17 | | |
18 | | #ifndef LLVM_CLANG_EXTRACTAPI_API_H |
19 | | #define LLVM_CLANG_EXTRACTAPI_API_H |
20 | | |
21 | | #include "clang/AST/Decl.h" |
22 | | #include "clang/AST/DeclObjC.h" |
23 | | #include "clang/AST/RawCommentList.h" |
24 | | #include "clang/Basic/SourceLocation.h" |
25 | | #include "clang/ExtractAPI/AvailabilityInfo.h" |
26 | | #include "clang/ExtractAPI/DeclarationFragments.h" |
27 | | #include "llvm/ADT/MapVector.h" |
28 | | #include "llvm/ADT/StringRef.h" |
29 | | #include "llvm/ADT/Triple.h" |
30 | | #include "llvm/Support/Allocator.h" |
31 | | #include "llvm/Support/Casting.h" |
32 | | #include <memory> |
33 | | #include <type_traits> |
34 | | |
35 | | namespace clang { |
36 | | namespace extractapi { |
37 | | |
38 | | /// DocComment is a vector of RawComment::CommentLine. |
39 | | /// |
40 | | /// Each line represents one line of striped documentation comment, |
41 | | /// with source range information. This simplifies calculating the source |
42 | | /// location of a character in the doc comment for pointing back to the source |
43 | | /// file. |
44 | | /// e.g. |
45 | | /// \code |
46 | | /// /// This is a documentation comment |
47 | | /// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' First line. |
48 | | /// /// with multiple lines. |
49 | | /// ^~~~~~~~~~~~~~~~~~~~~~~' Second line. |
50 | | /// \endcode |
51 | | using DocComment = std::vector<RawComment::CommentLine>; |
52 | | |
53 | | // Classes deriving from APIRecord need to have USR be the first constructor |
54 | | // argument. This is so that they are compatible with `addTopLevelRecord` |
55 | | // defined in API.cpp |
56 | | /// The base representation of an API record. Holds common symbol information. |
57 | | struct APIRecord { |
58 | | StringRef USR; |
59 | | StringRef Name; |
60 | | PresumedLoc Location; |
61 | | AvailabilityInfo Availability; |
62 | | LinkageInfo Linkage; |
63 | | |
64 | | /// Documentation comment lines attached to this symbol declaration. |
65 | | DocComment Comment; |
66 | | |
67 | | /// Declaration fragments of this symbol declaration. |
68 | | DeclarationFragments Declaration; |
69 | | |
70 | | /// SubHeading provides a more detailed representation than the plain |
71 | | /// declaration name. |
72 | | /// |
73 | | /// SubHeading is an array of declaration fragments of tagged declaration |
74 | | /// name, with potentially more tokens (for example the \c +/- symbol for |
75 | | /// Objective-C class/instance methods). |
76 | | DeclarationFragments SubHeading; |
77 | | |
78 | | /// Discriminator for LLVM-style RTTI (dyn_cast<> et al.) |
79 | | enum RecordKind { |
80 | | RK_GlobalFunction, |
81 | | RK_GlobalVariable, |
82 | | RK_EnumConstant, |
83 | | RK_Enum, |
84 | | RK_StructField, |
85 | | RK_Struct, |
86 | | RK_ObjCProperty, |
87 | | RK_ObjCIvar, |
88 | | RK_ObjCMethod, |
89 | | RK_ObjCInterface, |
90 | | RK_ObjCCategory, |
91 | | RK_ObjCProtocol, |
92 | | RK_MacroDefinition, |
93 | | RK_Typedef, |
94 | | }; |
95 | | |
96 | | private: |
97 | | const RecordKind Kind; |
98 | | |
99 | | public: |
100 | 74 | RecordKind getKind() const { return Kind; } |
101 | | |
102 | | APIRecord() = delete; |
103 | | |
104 | | APIRecord(RecordKind Kind, StringRef USR, StringRef Name, |
105 | | PresumedLoc Location, const AvailabilityInfo &Availability, |
106 | | LinkageInfo Linkage, const DocComment &Comment, |
107 | | DeclarationFragments Declaration, DeclarationFragments SubHeading) |
108 | | : USR(USR), Name(Name), Location(Location), Availability(Availability), |
109 | | Linkage(Linkage), Comment(Comment), Declaration(Declaration), |
110 | 74 | SubHeading(SubHeading), Kind(Kind) {} |
111 | | |
112 | | // Pure virtual destructor to make APIRecord abstract |
113 | | virtual ~APIRecord() = 0; |
114 | | }; |
115 | | |
116 | | /// This holds information associated with global functions. |
117 | | struct GlobalFunctionRecord : APIRecord { |
118 | | FunctionSignature Signature; |
119 | | |
120 | | GlobalFunctionRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
121 | | const AvailabilityInfo &Availability, |
122 | | LinkageInfo Linkage, const DocComment &Comment, |
123 | | DeclarationFragments Declaration, |
124 | | DeclarationFragments SubHeading, |
125 | | FunctionSignature Signature) |
126 | | : APIRecord(RK_GlobalFunction, USR, Name, Loc, Availability, Linkage, |
127 | | Comment, Declaration, SubHeading), |
128 | 4 | Signature(Signature) {} |
129 | | |
130 | 0 | static bool classof(const APIRecord *Record) { |
131 | 0 | return Record->getKind() == RK_GlobalFunction; |
132 | 0 | } |
133 | | |
134 | | private: |
135 | | virtual void anchor(); |
136 | | }; |
137 | | |
138 | | /// This holds information associated with global functions. |
139 | | struct GlobalVariableRecord : APIRecord { |
140 | | GlobalVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
141 | | const AvailabilityInfo &Availability, |
142 | | LinkageInfo Linkage, const DocComment &Comment, |
143 | | DeclarationFragments Declaration, |
144 | | DeclarationFragments SubHeading) |
145 | | : APIRecord(RK_GlobalVariable, USR, Name, Loc, Availability, Linkage, |
146 | 11 | Comment, Declaration, SubHeading) {} |
147 | | |
148 | 0 | static bool classof(const APIRecord *Record) { |
149 | 0 | return Record->getKind() == RK_GlobalVariable; |
150 | 0 | } |
151 | | |
152 | | private: |
153 | | virtual void anchor(); |
154 | | }; |
155 | | |
156 | | /// This holds information associated with enum constants. |
157 | | struct EnumConstantRecord : APIRecord { |
158 | | EnumConstantRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
159 | | const AvailabilityInfo &Availability, |
160 | | const DocComment &Comment, |
161 | | DeclarationFragments Declaration, |
162 | | DeclarationFragments SubHeading) |
163 | | : APIRecord(RK_EnumConstant, USR, Name, Loc, Availability, |
164 | 11 | LinkageInfo::none(), Comment, Declaration, SubHeading) {} |
165 | | |
166 | 0 | static bool classof(const APIRecord *Record) { |
167 | 0 | return Record->getKind() == RK_EnumConstant; |
168 | 0 | } |
169 | | |
170 | | private: |
171 | | virtual void anchor(); |
172 | | }; |
173 | | |
174 | | /// This holds information associated with enums. |
175 | | struct EnumRecord : APIRecord { |
176 | | SmallVector<std::unique_ptr<EnumConstantRecord>> Constants; |
177 | | |
178 | | EnumRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
179 | | const AvailabilityInfo &Availability, const DocComment &Comment, |
180 | | DeclarationFragments Declaration, DeclarationFragments SubHeading) |
181 | | : APIRecord(RK_Enum, USR, Name, Loc, Availability, LinkageInfo::none(), |
182 | 4 | Comment, Declaration, SubHeading) {} |
183 | | |
184 | 0 | static bool classof(const APIRecord *Record) { |
185 | 0 | return Record->getKind() == RK_Enum; |
186 | 0 | } |
187 | | |
188 | | private: |
189 | | virtual void anchor(); |
190 | | }; |
191 | | |
192 | | /// This holds information associated with struct fields. |
193 | | struct StructFieldRecord : APIRecord { |
194 | | StructFieldRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
195 | | const AvailabilityInfo &Availability, |
196 | | const DocComment &Comment, DeclarationFragments Declaration, |
197 | | DeclarationFragments SubHeading) |
198 | | : APIRecord(RK_StructField, USR, Name, Loc, Availability, |
199 | 6 | LinkageInfo::none(), Comment, Declaration, SubHeading) {} |
200 | | |
201 | 0 | static bool classof(const APIRecord *Record) { |
202 | 0 | return Record->getKind() == RK_StructField; |
203 | 0 | } |
204 | | |
205 | | private: |
206 | | virtual void anchor(); |
207 | | }; |
208 | | |
209 | | /// This holds information associated with structs. |
210 | | struct StructRecord : APIRecord { |
211 | | SmallVector<std::unique_ptr<StructFieldRecord>> Fields; |
212 | | |
213 | | StructRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
214 | | const AvailabilityInfo &Availability, const DocComment &Comment, |
215 | | DeclarationFragments Declaration, |
216 | | DeclarationFragments SubHeading) |
217 | | : APIRecord(RK_Struct, USR, Name, Loc, Availability, LinkageInfo::none(), |
218 | 5 | Comment, Declaration, SubHeading) {} |
219 | | |
220 | 0 | static bool classof(const APIRecord *Record) { |
221 | 0 | return Record->getKind() == RK_Struct; |
222 | 0 | } |
223 | | |
224 | | private: |
225 | | virtual void anchor(); |
226 | | }; |
227 | | |
228 | | /// This holds information associated with Objective-C properties. |
229 | | struct ObjCPropertyRecord : APIRecord { |
230 | | /// The attributes associated with an Objective-C property. |
231 | | enum AttributeKind : unsigned { |
232 | | NoAttr = 0, |
233 | | ReadOnly = 1, |
234 | | Class = 1 << 1, |
235 | | Dynamic = 1 << 2, |
236 | | }; |
237 | | |
238 | | AttributeKind Attributes; |
239 | | StringRef GetterName; |
240 | | StringRef SetterName; |
241 | | bool IsOptional; |
242 | | |
243 | | ObjCPropertyRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
244 | | const AvailabilityInfo &Availability, |
245 | | const DocComment &Comment, |
246 | | DeclarationFragments Declaration, |
247 | | DeclarationFragments SubHeading, AttributeKind Attributes, |
248 | | StringRef GetterName, StringRef SetterName, |
249 | | bool IsOptional) |
250 | | : APIRecord(RK_ObjCProperty, USR, Name, Loc, Availability, |
251 | | LinkageInfo::none(), Comment, Declaration, SubHeading), |
252 | | Attributes(Attributes), GetterName(GetterName), SetterName(SetterName), |
253 | 2 | IsOptional(IsOptional) {} |
254 | | |
255 | 0 | bool isReadOnly() const { return Attributes & ReadOnly; } |
256 | 0 | bool isDynamic() const { return Attributes & Dynamic; } |
257 | 0 | bool isClassProperty() const { return Attributes & Class; } |
258 | | |
259 | 0 | static bool classof(const APIRecord *Record) { |
260 | 0 | return Record->getKind() == RK_ObjCProperty; |
261 | 0 | } |
262 | | |
263 | | private: |
264 | | virtual void anchor(); |
265 | | }; |
266 | | |
267 | | /// This holds information associated with Objective-C instance variables. |
268 | | struct ObjCInstanceVariableRecord : APIRecord { |
269 | | using AccessControl = ObjCIvarDecl::AccessControl; |
270 | | AccessControl Access; |
271 | | |
272 | | ObjCInstanceVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
273 | | const AvailabilityInfo &Availability, |
274 | | const DocComment &Comment, |
275 | | DeclarationFragments Declaration, |
276 | | DeclarationFragments SubHeading, |
277 | | AccessControl Access) |
278 | | : APIRecord(RK_ObjCIvar, USR, Name, Loc, Availability, |
279 | | LinkageInfo::none(), Comment, Declaration, SubHeading), |
280 | 1 | Access(Access) {} |
281 | | |
282 | 0 | static bool classof(const APIRecord *Record) { |
283 | 0 | return Record->getKind() == RK_ObjCIvar; |
284 | 0 | } |
285 | | |
286 | | private: |
287 | | virtual void anchor(); |
288 | | }; |
289 | | |
290 | | /// This holds information associated with Objective-C methods. |
291 | | struct ObjCMethodRecord : APIRecord { |
292 | | FunctionSignature Signature; |
293 | | bool IsInstanceMethod; |
294 | | |
295 | | ObjCMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
296 | | const AvailabilityInfo &Availability, |
297 | | const DocComment &Comment, DeclarationFragments Declaration, |
298 | | DeclarationFragments SubHeading, FunctionSignature Signature, |
299 | | bool IsInstanceMethod) |
300 | | : APIRecord(RK_ObjCMethod, USR, Name, Loc, Availability, |
301 | | LinkageInfo::none(), Comment, Declaration, SubHeading), |
302 | 5 | Signature(Signature), IsInstanceMethod(IsInstanceMethod) {} |
303 | | |
304 | 5 | static bool classof(const APIRecord *Record) { |
305 | 5 | return Record->getKind() == RK_ObjCMethod; |
306 | 5 | } |
307 | | |
308 | | private: |
309 | | virtual void anchor(); |
310 | | }; |
311 | | |
312 | | /// This represents a reference to another symbol that might come from external |
313 | | /// sources. |
314 | | struct SymbolReference { |
315 | | StringRef Name; |
316 | | StringRef USR; |
317 | | |
318 | | /// The source project/module/product of the referred symbol. |
319 | | StringRef Source; |
320 | | |
321 | 3 | SymbolReference() = default; |
322 | | SymbolReference(StringRef Name, StringRef USR = "", StringRef Source = "") |
323 | 14 | : Name(Name), USR(USR), Source(Source) {} |
324 | | SymbolReference(const APIRecord &Record) |
325 | 52 | : Name(Record.Name), USR(Record.USR) {} |
326 | | |
327 | | /// Determine if this SymbolReference is empty. |
328 | | /// |
329 | | /// \returns true if and only if all \c Name, \c USR, and \c Source is empty. |
330 | 3 | bool empty() const { return Name.empty() && USR.empty()2 && Source.empty()2 ; } |
331 | | }; |
332 | | |
333 | | /// The base representation of an Objective-C container record. Holds common |
334 | | /// information associated with Objective-C containers. |
335 | | struct ObjCContainerRecord : APIRecord { |
336 | | SmallVector<std::unique_ptr<ObjCMethodRecord>> Methods; |
337 | | SmallVector<std::unique_ptr<ObjCPropertyRecord>> Properties; |
338 | | SmallVector<std::unique_ptr<ObjCInstanceVariableRecord>> Ivars; |
339 | | SmallVector<SymbolReference> Protocols; |
340 | | |
341 | | ObjCContainerRecord() = delete; |
342 | | |
343 | | ObjCContainerRecord(RecordKind Kind, StringRef USR, StringRef Name, |
344 | | PresumedLoc Loc, const AvailabilityInfo &Availability, |
345 | | LinkageInfo Linkage, const DocComment &Comment, |
346 | | DeclarationFragments Declaration, |
347 | | DeclarationFragments SubHeading) |
348 | | : APIRecord(Kind, USR, Name, Loc, Availability, Linkage, Comment, |
349 | 6 | Declaration, SubHeading) {} |
350 | | |
351 | | virtual ~ObjCContainerRecord() = 0; |
352 | | }; |
353 | | |
354 | | /// This holds information associated with Objective-C categories. |
355 | | struct ObjCCategoryRecord : ObjCContainerRecord { |
356 | | SymbolReference Interface; |
357 | | |
358 | | ObjCCategoryRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
359 | | const AvailabilityInfo &Availability, |
360 | | const DocComment &Comment, |
361 | | DeclarationFragments Declaration, |
362 | | DeclarationFragments SubHeading, SymbolReference Interface) |
363 | | : ObjCContainerRecord(RK_ObjCCategory, USR, Name, Loc, Availability, |
364 | | LinkageInfo::none(), Comment, Declaration, |
365 | | SubHeading), |
366 | 1 | Interface(Interface) {} |
367 | | |
368 | 0 | static bool classof(const APIRecord *Record) { |
369 | 0 | return Record->getKind() == RK_ObjCCategory; |
370 | 0 | } |
371 | | |
372 | | private: |
373 | | virtual void anchor(); |
374 | | }; |
375 | | |
376 | | /// This holds information associated with Objective-C interfaces/classes. |
377 | | struct ObjCInterfaceRecord : ObjCContainerRecord { |
378 | | SymbolReference SuperClass; |
379 | | // ObjCCategoryRecord%s are stored in and owned by APISet. |
380 | | SmallVector<ObjCCategoryRecord *> Categories; |
381 | | |
382 | | ObjCInterfaceRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
383 | | const AvailabilityInfo &Availability, LinkageInfo Linkage, |
384 | | const DocComment &Comment, |
385 | | DeclarationFragments Declaration, |
386 | | DeclarationFragments SubHeading, |
387 | | SymbolReference SuperClass) |
388 | | : ObjCContainerRecord(RK_ObjCInterface, USR, Name, Loc, Availability, |
389 | | Linkage, Comment, Declaration, SubHeading), |
390 | 3 | SuperClass(SuperClass) {} |
391 | | |
392 | 5 | static bool classof(const APIRecord *Record) { |
393 | 5 | return Record->getKind() == RK_ObjCInterface; |
394 | 5 | } |
395 | | |
396 | | private: |
397 | | virtual void anchor(); |
398 | | }; |
399 | | |
400 | | /// This holds information associated with Objective-C protocols. |
401 | | struct ObjCProtocolRecord : ObjCContainerRecord { |
402 | | ObjCProtocolRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
403 | | const AvailabilityInfo &Availability, |
404 | | const DocComment &Comment, |
405 | | DeclarationFragments Declaration, |
406 | | DeclarationFragments SubHeading) |
407 | | : ObjCContainerRecord(RK_ObjCProtocol, USR, Name, Loc, Availability, |
408 | | LinkageInfo::none(), Comment, Declaration, |
409 | 2 | SubHeading) {} |
410 | | |
411 | 0 | static bool classof(const APIRecord *Record) { |
412 | 0 | return Record->getKind() == RK_ObjCProtocol; |
413 | 0 | } |
414 | | |
415 | | private: |
416 | | virtual void anchor(); |
417 | | }; |
418 | | |
419 | | /// This holds information associated with macro definitions. |
420 | | struct MacroDefinitionRecord : APIRecord { |
421 | | MacroDefinitionRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
422 | | DeclarationFragments Declaration, |
423 | | DeclarationFragments SubHeading) |
424 | | : APIRecord(RK_MacroDefinition, USR, Name, Loc, AvailabilityInfo(), |
425 | 9 | LinkageInfo(), {}, Declaration, SubHeading) {} |
426 | | |
427 | 0 | static bool classof(const APIRecord *Record) { |
428 | 0 | return Record->getKind() == RK_MacroDefinition; |
429 | 0 | } |
430 | | |
431 | | private: |
432 | | virtual void anchor(); |
433 | | }; |
434 | | |
435 | | /// This holds information associated with typedefs. |
436 | | /// |
437 | | /// Note: Typedefs for anonymous enums and structs typically don't get emitted |
438 | | /// by the serializers but still get a TypedefRecord. Instead we use the |
439 | | /// typedef name as a name for the underlying anonymous struct or enum. |
440 | | struct TypedefRecord : APIRecord { |
441 | | SymbolReference UnderlyingType; |
442 | | |
443 | | TypedefRecord(StringRef USR, StringRef Name, PresumedLoc Loc, |
444 | | const AvailabilityInfo &Availability, const DocComment &Comment, |
445 | | DeclarationFragments Declaration, |
446 | | DeclarationFragments SubHeading, SymbolReference UnderlyingType) |
447 | | : APIRecord(RK_Typedef, USR, Name, Loc, Availability, LinkageInfo(), |
448 | | Comment, Declaration, SubHeading), |
449 | 10 | UnderlyingType(UnderlyingType) {} |
450 | | |
451 | 0 | static bool classof(const APIRecord *Record) { |
452 | 0 | return Record->getKind() == RK_Typedef; |
453 | 0 | } |
454 | | |
455 | | private: |
456 | | virtual void anchor(); |
457 | | }; |
458 | | |
459 | | /// Check if a record type has a function signature mixin. |
460 | | /// |
461 | | /// This is denoted by the record type having a ``Signature`` field of type |
462 | | /// FunctionSignature. |
463 | | template <typename RecordTy> |
464 | | struct has_function_signature : public std::false_type {}; |
465 | | template <> |
466 | | struct has_function_signature<GlobalFunctionRecord> : public std::true_type {}; |
467 | | template <> |
468 | | struct has_function_signature<ObjCMethodRecord> : public std::true_type {}; |
469 | | |
470 | | /// APISet holds the set of API records collected from given inputs. |
471 | | class APISet { |
472 | | public: |
473 | | /// Create and add a global variable record into the API set. |
474 | | /// |
475 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
476 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
477 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
478 | | /// to generate the USR for \c D and keep it alive in APISet. |
479 | | GlobalVariableRecord * |
480 | | addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc, |
481 | | const AvailabilityInfo &Availability, LinkageInfo Linkage, |
482 | | const DocComment &Comment, DeclarationFragments Declaration, |
483 | | DeclarationFragments SubHeading); |
484 | | |
485 | | /// Create and add a function record into the API set. |
486 | | /// |
487 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
488 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
489 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
490 | | /// to generate the USR for \c D and keep it alive in APISet. |
491 | | GlobalFunctionRecord * |
492 | | addGlobalFunction(StringRef Name, StringRef USR, PresumedLoc Loc, |
493 | | const AvailabilityInfo &Availability, LinkageInfo Linkage, |
494 | | const DocComment &Comment, DeclarationFragments Declaration, |
495 | | DeclarationFragments SubHeading, |
496 | | FunctionSignature Signature); |
497 | | |
498 | | /// Create and add an enum constant record into the API set. |
499 | | /// |
500 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
501 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
502 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
503 | | /// to generate the USR for \c D and keep it alive in APISet. |
504 | | EnumConstantRecord *addEnumConstant(EnumRecord *Enum, StringRef Name, |
505 | | StringRef USR, PresumedLoc Loc, |
506 | | const AvailabilityInfo &Availability, |
507 | | const DocComment &Comment, |
508 | | DeclarationFragments Declaration, |
509 | | DeclarationFragments SubHeading); |
510 | | |
511 | | /// Create and add an enum record into the API set. |
512 | | /// |
513 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
514 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
515 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
516 | | /// to generate the USR for \c D and keep it alive in APISet. |
517 | | EnumRecord *addEnum(StringRef Name, StringRef USR, PresumedLoc Loc, |
518 | | const AvailabilityInfo &Availability, |
519 | | const DocComment &Comment, |
520 | | DeclarationFragments Declaration, |
521 | | DeclarationFragments SubHeading); |
522 | | |
523 | | /// Create and add a struct field record into the API set. |
524 | | /// |
525 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
526 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
527 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
528 | | /// to generate the USR for \c D and keep it alive in APISet. |
529 | | StructFieldRecord *addStructField(StructRecord *Struct, StringRef Name, |
530 | | StringRef USR, PresumedLoc Loc, |
531 | | const AvailabilityInfo &Availability, |
532 | | const DocComment &Comment, |
533 | | DeclarationFragments Declaration, |
534 | | DeclarationFragments SubHeading); |
535 | | |
536 | | /// Create and add a struct record into the API set. |
537 | | /// |
538 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
539 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
540 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
541 | | /// to generate the USR for \c D and keep it alive in APISet. |
542 | | StructRecord *addStruct(StringRef Name, StringRef USR, PresumedLoc Loc, |
543 | | const AvailabilityInfo &Availability, |
544 | | const DocComment &Comment, |
545 | | DeclarationFragments Declaration, |
546 | | DeclarationFragments SubHeading); |
547 | | |
548 | | /// Create and add an Objective-C category record into the API set. |
549 | | /// |
550 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
551 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
552 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
553 | | /// to generate the USR for \c D and keep it alive in APISet. |
554 | | ObjCCategoryRecord * |
555 | | addObjCCategory(StringRef Name, StringRef USR, PresumedLoc Loc, |
556 | | const AvailabilityInfo &Availability, |
557 | | const DocComment &Comment, DeclarationFragments Declaration, |
558 | | DeclarationFragments SubHeading, SymbolReference Interface); |
559 | | |
560 | | /// Create and add an Objective-C interface record into the API set. |
561 | | /// |
562 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
563 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
564 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
565 | | /// to generate the USR for \c D and keep it alive in APISet. |
566 | | ObjCInterfaceRecord * |
567 | | addObjCInterface(StringRef Name, StringRef USR, PresumedLoc Loc, |
568 | | const AvailabilityInfo &Availability, LinkageInfo Linkage, |
569 | | const DocComment &Comment, DeclarationFragments Declaration, |
570 | | DeclarationFragments SubHeading, SymbolReference SuperClass); |
571 | | |
572 | | /// Create and add an Objective-C method record into the API set. |
573 | | /// |
574 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
575 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
576 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
577 | | /// to generate the USR for \c D and keep it alive in APISet. |
578 | | ObjCMethodRecord * |
579 | | addObjCMethod(ObjCContainerRecord *Container, StringRef Name, StringRef USR, |
580 | | PresumedLoc Loc, const AvailabilityInfo &Availability, |
581 | | const DocComment &Comment, DeclarationFragments Declaration, |
582 | | DeclarationFragments SubHeading, FunctionSignature Signature, |
583 | | bool IsInstanceMethod); |
584 | | |
585 | | /// Create and add an Objective-C property record into the API set. |
586 | | /// |
587 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
588 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
589 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
590 | | /// to generate the USR for \c D and keep it alive in APISet. |
591 | | ObjCPropertyRecord * |
592 | | addObjCProperty(ObjCContainerRecord *Container, StringRef Name, StringRef USR, |
593 | | PresumedLoc Loc, const AvailabilityInfo &Availability, |
594 | | const DocComment &Comment, DeclarationFragments Declaration, |
595 | | DeclarationFragments SubHeading, |
596 | | ObjCPropertyRecord::AttributeKind Attributes, |
597 | | StringRef GetterName, StringRef SetterName, bool IsOptional); |
598 | | |
599 | | /// Create and add an Objective-C instance variable record into the API set. |
600 | | /// |
601 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
602 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
603 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
604 | | /// to generate the USR for \c D and keep it alive in APISet. |
605 | | ObjCInstanceVariableRecord *addObjCInstanceVariable( |
606 | | ObjCContainerRecord *Container, StringRef Name, StringRef USR, |
607 | | PresumedLoc Loc, const AvailabilityInfo &Availability, |
608 | | const DocComment &Comment, DeclarationFragments Declaration, |
609 | | DeclarationFragments SubHeading, |
610 | | ObjCInstanceVariableRecord::AccessControl Access); |
611 | | |
612 | | /// Create and add an Objective-C protocol record into the API set. |
613 | | /// |
614 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
615 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
616 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
617 | | /// to generate the USR for \c D and keep it alive in APISet. |
618 | | ObjCProtocolRecord *addObjCProtocol(StringRef Name, StringRef USR, |
619 | | PresumedLoc Loc, |
620 | | const AvailabilityInfo &Availability, |
621 | | const DocComment &Comment, |
622 | | DeclarationFragments Declaration, |
623 | | DeclarationFragments SubHeading); |
624 | | |
625 | | /// Create a macro definition record into the API set. |
626 | | /// |
627 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
628 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
629 | | /// APISet itself, and APISet::recordUSRForMacro(StringRef Name, |
630 | | /// SourceLocation SL, const SourceManager &SM) is a helper method to generate |
631 | | /// the USR for the macro and keep it alive in APISet. |
632 | | MacroDefinitionRecord *addMacroDefinition(StringRef Name, StringRef USR, |
633 | | PresumedLoc Loc, |
634 | | DeclarationFragments Declaration, |
635 | | DeclarationFragments SubHeading); |
636 | | |
637 | | /// Create a typedef record into the API set. |
638 | | /// |
639 | | /// Note: the caller is responsible for keeping the StringRef \p Name and |
640 | | /// \p USR alive. APISet::copyString provides a way to copy strings into |
641 | | /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method |
642 | | /// to generate the USR for \c D and keep it alive in APISet. |
643 | | TypedefRecord *addTypedef(StringRef Name, StringRef USR, PresumedLoc Loc, |
644 | | const AvailabilityInfo &Availability, |
645 | | const DocComment &Comment, |
646 | | DeclarationFragments Declaration, |
647 | | DeclarationFragments SubHeading, |
648 | | SymbolReference UnderlyingType); |
649 | | |
650 | | /// A mapping type to store a set of APIRecord%s with the USR as the key. |
651 | | template <typename RecordTy, |
652 | | typename = |
653 | | std::enable_if_t<std::is_base_of<APIRecord, RecordTy>::value>> |
654 | | using RecordMap = llvm::MapVector<StringRef, std::unique_ptr<RecordTy>>; |
655 | | |
656 | | /// Get the target triple for the ExtractAPI invocation. |
657 | 17 | const llvm::Triple &getTarget() const { return Target; } |
658 | | |
659 | | /// Get the language used by the APIs. |
660 | 128 | Language getLanguage() const { return Lang; } |
661 | | |
662 | 17 | const RecordMap<GlobalFunctionRecord> &getGlobalFunctions() const { |
663 | 17 | return GlobalFunctions; |
664 | 17 | } |
665 | 17 | const RecordMap<GlobalVariableRecord> &getGlobalVariables() const { |
666 | 17 | return GlobalVariables; |
667 | 17 | } |
668 | 17 | const RecordMap<EnumRecord> &getEnums() const { return Enums; } |
669 | 17 | const RecordMap<StructRecord> &getStructs() const { return Structs; } |
670 | 0 | const RecordMap<ObjCCategoryRecord> &getObjCCategories() const { |
671 | 0 | return ObjCCategories; |
672 | 0 | } |
673 | 17 | const RecordMap<ObjCInterfaceRecord> &getObjCInterfaces() const { |
674 | 17 | return ObjCInterfaces; |
675 | 17 | } |
676 | 17 | const RecordMap<ObjCProtocolRecord> &getObjCProtocols() const { |
677 | 17 | return ObjCProtocols; |
678 | 17 | } |
679 | 17 | const RecordMap<MacroDefinitionRecord> &getMacros() const { return Macros; } |
680 | 17 | const RecordMap<TypedefRecord> &getTypedefs() const { return Typedefs; } |
681 | | |
682 | | /// Generate and store the USR of declaration \p D. |
683 | | /// |
684 | | /// Note: The USR string is stored in and owned by Allocator. |
685 | | /// |
686 | | /// \returns a StringRef of the generated USR string. |
687 | | StringRef recordUSR(const Decl *D); |
688 | | |
689 | | /// Generate and store the USR for a macro \p Name. |
690 | | /// |
691 | | /// Note: The USR string is stored in and owned by Allocator. |
692 | | /// |
693 | | /// \returns a StringRef to the generate USR string. |
694 | | StringRef recordUSRForMacro(StringRef Name, SourceLocation SL, |
695 | | const SourceManager &SM); |
696 | | |
697 | | /// Copy \p String into the Allocator in this APISet. |
698 | | /// |
699 | | /// \returns a StringRef of the copied string in APISet::Allocator. |
700 | | StringRef copyString(StringRef String); |
701 | | |
702 | | APISet(const llvm::Triple &Target, Language Lang) |
703 | 17 | : Target(Target), Lang(Lang) {} |
704 | | |
705 | | private: |
706 | | /// BumpPtrAllocator to store generated/copied strings. |
707 | | /// |
708 | | /// Note: The main use for this is being able to deduplicate strings. |
709 | | llvm::BumpPtrAllocator StringAllocator; |
710 | | |
711 | | const llvm::Triple Target; |
712 | | const Language Lang; |
713 | | |
714 | | RecordMap<GlobalFunctionRecord> GlobalFunctions; |
715 | | RecordMap<GlobalVariableRecord> GlobalVariables; |
716 | | RecordMap<EnumRecord> Enums; |
717 | | RecordMap<StructRecord> Structs; |
718 | | RecordMap<ObjCCategoryRecord> ObjCCategories; |
719 | | RecordMap<ObjCInterfaceRecord> ObjCInterfaces; |
720 | | RecordMap<ObjCProtocolRecord> ObjCProtocols; |
721 | | RecordMap<MacroDefinitionRecord> Macros; |
722 | | RecordMap<TypedefRecord> Typedefs; |
723 | | }; |
724 | | |
725 | | } // namespace extractapi |
726 | | } // namespace clang |
727 | | |
728 | | #endif // LLVM_CLANG_EXTRACTAPI_API_H |