clang  14.0.0git
APINotesYAMLCompiler.cpp
Go to the documentation of this file.
1 //===-- APINotesYAMLCompiler.cpp - API Notes YAML Format Reader -*- 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 // The types defined locally are designed to represent the YAML state, which
10 // adds an additional bit of state: e.g. a tri-state boolean attribute (yes, no,
11 // not applied) becomes a tri-state boolean + present. As a result, while these
12 // enumerations appear to be redefining constants from the attributes table
13 // data, they are distinct.
14 //
15 
17 #include "clang/APINotes/Types.h"
18 #include "clang/Basic/LLVM.h"
19 #include "clang/Basic/Specifiers.h"
20 #include "llvm/ADT/Optional.h"
21 #include "llvm/Support/VersionTuple.h"
22 #include "llvm/Support/YAMLParser.h"
23 #include "llvm/Support/YAMLTraits.h"
24 #include <vector>
25 using namespace clang;
26 using namespace api_notes;
27 
28 namespace {
29 enum class APIAvailability {
30  Available = 0,
31  OSX,
32  IOS,
33  None,
34  NonSwift,
35 };
36 } // namespace
37 
38 namespace llvm {
39 namespace yaml {
40 template <> struct ScalarEnumerationTraits<APIAvailability> {
41  static void enumeration(IO &IO, APIAvailability &AA) {
42  IO.enumCase(AA, "OSX", APIAvailability::OSX);
43  IO.enumCase(AA, "iOS", APIAvailability::IOS);
44  IO.enumCase(AA, "none", APIAvailability::None);
45  IO.enumCase(AA, "nonswift", APIAvailability::NonSwift);
46  IO.enumCase(AA, "available", APIAvailability::Available);
47  }
48 };
49 } // namespace yaml
50 } // namespace llvm
51 
52 namespace {
53 enum class MethodKind {
54  Class,
55  Instance,
56 };
57 } // namespace
58 
59 namespace llvm {
60 namespace yaml {
61 template <> struct ScalarEnumerationTraits<MethodKind> {
62  static void enumeration(IO &IO, MethodKind &MK) {
63  IO.enumCase(MK, "Class", MethodKind::Class);
64  IO.enumCase(MK, "Instance", MethodKind::Instance);
65  }
66 };
67 } // namespace yaml
68 } // namespace llvm
69 
70 namespace {
71 struct Param {
72  unsigned Position;
73  Optional<bool> NoEscape = false;
75  Optional<RetainCountConventionKind> RetainCountConvention;
76  StringRef Type;
77 };
78 
79 typedef std::vector<Param> ParamsSeq;
80 } // namespace
81 
82 LLVM_YAML_IS_SEQUENCE_VECTOR(Param)
83 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(NullabilityKind)
84 
85 namespace llvm {
86 namespace yaml {
87 template <> struct ScalarEnumerationTraits<NullabilityKind> {
88  static void enumeration(IO &IO, NullabilityKind &NK) {
89  IO.enumCase(NK, "Nonnull", NullabilityKind::NonNull);
90  IO.enumCase(NK, "Optional", NullabilityKind::Nullable);
91  IO.enumCase(NK, "Unspecified", NullabilityKind::Unspecified);
92  IO.enumCase(NK, "NullableResult", NullabilityKind::NullableResult);
93  // TODO: Mapping this to it's own value would allow for better cross
94  // checking. Also the default should be Unknown.
95  IO.enumCase(NK, "Scalar", NullabilityKind::Unspecified);
96 
97  // Aliases for compatibility with existing APINotes.
98  IO.enumCase(NK, "N", NullabilityKind::NonNull);
99  IO.enumCase(NK, "O", NullabilityKind::Nullable);
100  IO.enumCase(NK, "U", NullabilityKind::Unspecified);
101  IO.enumCase(NK, "S", NullabilityKind::Unspecified);
102  }
103 };
104 
105 template <> struct ScalarEnumerationTraits<RetainCountConventionKind> {
106  static void enumeration(IO &IO, RetainCountConventionKind &RCCK) {
107  IO.enumCase(RCCK, "none", RetainCountConventionKind::None);
108  IO.enumCase(RCCK, "CFReturnsRetained",
110  IO.enumCase(RCCK, "CFReturnsNotRetained",
112  IO.enumCase(RCCK, "NSReturnsRetained",
114  IO.enumCase(RCCK, "NSReturnsNotRetained",
116  }
117 };
118 
119 template <> struct MappingTraits<Param> {
120  static void mapping(IO &IO, Param &P) {
121  IO.mapRequired("Position", P.Position);
122  IO.mapOptional("Nullability", P.Nullability, llvm::None);
123  IO.mapOptional("RetainCountConvention", P.RetainCountConvention);
124  IO.mapOptional("NoEscape", P.NoEscape);
125  IO.mapOptional("Type", P.Type, StringRef(""));
126  }
127 };
128 } // namespace yaml
129 } // namespace llvm
130 
131 namespace {
132 typedef std::vector<NullabilityKind> NullabilitySeq;
133 
134 struct AvailabilityItem {
135  APIAvailability Mode = APIAvailability::Available;
136  StringRef Msg;
137 };
138 
139 /// Old attribute deprecated in favor of SwiftName.
140 enum class FactoryAsInitKind {
141  /// Infer based on name and type (the default).
142  Infer,
143  /// Treat as a class method.
144  AsClassMethod,
145  /// Treat as an initializer.
146  AsInitializer,
147 };
148 
149 struct Method {
150  StringRef Selector;
151  MethodKind Kind;
152  ParamsSeq Params;
153  NullabilitySeq Nullability;
154  Optional<NullabilityKind> NullabilityOfRet;
155  Optional<RetainCountConventionKind> RetainCountConvention;
156  AvailabilityItem Availability;
157  Optional<bool> SwiftPrivate;
158  StringRef SwiftName;
159  FactoryAsInitKind FactoryAsInit = FactoryAsInitKind::Infer;
160  bool DesignatedInit = false;
161  bool Required = false;
162  StringRef ResultType;
163 };
164 
165 typedef std::vector<Method> MethodsSeq;
166 } // namespace
167 
168 LLVM_YAML_IS_SEQUENCE_VECTOR(Method)
169 
170 namespace llvm {
171 namespace yaml {
172 template <> struct ScalarEnumerationTraits<FactoryAsInitKind> {
173  static void enumeration(IO &IO, FactoryAsInitKind &FIK) {
174  IO.enumCase(FIK, "A", FactoryAsInitKind::Infer);
175  IO.enumCase(FIK, "C", FactoryAsInitKind::AsClassMethod);
176  IO.enumCase(FIK, "I", FactoryAsInitKind::AsInitializer);
177  }
178 };
179 
180 template <> struct MappingTraits<Method> {
181  static void mapping(IO &IO, Method &M) {
182  IO.mapRequired("Selector", M.Selector);
183  IO.mapRequired("MethodKind", M.Kind);
184  IO.mapOptional("Parameters", M.Params);
185  IO.mapOptional("Nullability", M.Nullability);
186  IO.mapOptional("NullabilityOfRet", M.NullabilityOfRet, llvm::None);
187  IO.mapOptional("RetainCountConvention", M.RetainCountConvention);
188  IO.mapOptional("Availability", M.Availability.Mode,
189  APIAvailability::Available);
190  IO.mapOptional("AvailabilityMsg", M.Availability.Msg, StringRef(""));
191  IO.mapOptional("SwiftPrivate", M.SwiftPrivate);
192  IO.mapOptional("SwiftName", M.SwiftName, StringRef(""));
193  IO.mapOptional("FactoryAsInit", M.FactoryAsInit, FactoryAsInitKind::Infer);
194  IO.mapOptional("DesignatedInit", M.DesignatedInit, false);
195  IO.mapOptional("Required", M.Required, false);
196  IO.mapOptional("ResultType", M.ResultType, StringRef(""));
197  }
198 };
199 } // namespace yaml
200 } // namespace llvm
201 
202 namespace {
203 struct Property {
204  StringRef Name;
207  AvailabilityItem Availability;
208  Optional<bool> SwiftPrivate;
209  StringRef SwiftName;
210  Optional<bool> SwiftImportAsAccessors;
211  StringRef Type;
212 };
213 
214 typedef std::vector<Property> PropertiesSeq;
215 } // namespace
216 
217 LLVM_YAML_IS_SEQUENCE_VECTOR(Property)
218 
219 namespace llvm {
220 namespace yaml {
221 template <> struct MappingTraits<Property> {
222  static void mapping(IO &IO, Property &P) {
223  IO.mapRequired("Name", P.Name);
224  IO.mapOptional("PropertyKind", P.Kind);
225  IO.mapOptional("Nullability", P.Nullability, llvm::None);
226  IO.mapOptional("Availability", P.Availability.Mode,
227  APIAvailability::Available);
228  IO.mapOptional("AvailabilityMsg", P.Availability.Msg, StringRef(""));
229  IO.mapOptional("SwiftPrivate", P.SwiftPrivate);
230  IO.mapOptional("SwiftName", P.SwiftName, StringRef(""));
231  IO.mapOptional("SwiftImportAsAccessors", P.SwiftImportAsAccessors);
232  IO.mapOptional("Type", P.Type, StringRef(""));
233  }
234 };
235 } // namespace yaml
236 } // namespace llvm
237 
238 namespace {
239 struct Class {
240  StringRef Name;
241  bool AuditedForNullability = false;
242  AvailabilityItem Availability;
243  Optional<bool> SwiftPrivate;
244  StringRef SwiftName;
245  Optional<StringRef> SwiftBridge;
246  Optional<StringRef> NSErrorDomain;
247  Optional<bool> SwiftImportAsNonGeneric;
248  Optional<bool> SwiftObjCMembers;
249  MethodsSeq Methods;
250  PropertiesSeq Properties;
251 };
252 
253 typedef std::vector<Class> ClassesSeq;
254 } // namespace
255 
256 LLVM_YAML_IS_SEQUENCE_VECTOR(Class)
257 
258 namespace llvm {
259 namespace yaml {
260 template <> struct MappingTraits<Class> {
261  static void mapping(IO &IO, Class &C) {
262  IO.mapRequired("Name", C.Name);
263  IO.mapOptional("AuditedForNullability", C.AuditedForNullability, false);
264  IO.mapOptional("Availability", C.Availability.Mode,
265  APIAvailability::Available);
266  IO.mapOptional("AvailabilityMsg", C.Availability.Msg, StringRef(""));
267  IO.mapOptional("SwiftPrivate", C.SwiftPrivate);
268  IO.mapOptional("SwiftName", C.SwiftName, StringRef(""));
269  IO.mapOptional("SwiftBridge", C.SwiftBridge);
270  IO.mapOptional("NSErrorDomain", C.NSErrorDomain);
271  IO.mapOptional("SwiftImportAsNonGeneric", C.SwiftImportAsNonGeneric);
272  IO.mapOptional("SwiftObjCMembers", C.SwiftObjCMembers);
273  IO.mapOptional("Methods", C.Methods);
274  IO.mapOptional("Properties", C.Properties);
275  }
276 };
277 } // namespace yaml
278 } // namespace llvm
279 
280 namespace {
281 struct Function {
282  StringRef Name;
283  ParamsSeq Params;
284  NullabilitySeq Nullability;
285  Optional<NullabilityKind> NullabilityOfRet;
287  AvailabilityItem Availability;
288  Optional<bool> SwiftPrivate;
289  StringRef SwiftName;
290  StringRef Type;
291  StringRef ResultType;
292 };
293 
294 typedef std::vector<Function> FunctionsSeq;
295 } // namespace
296 
297 LLVM_YAML_IS_SEQUENCE_VECTOR(Function)
298 
299 namespace llvm {
300 namespace yaml {
301 template <> struct MappingTraits<Function> {
302  static void mapping(IO &IO, Function &F) {
303  IO.mapRequired("Name", F.Name);
304  IO.mapOptional("Parameters", F.Params);
305  IO.mapOptional("Nullability", F.Nullability);
306  IO.mapOptional("NullabilityOfRet", F.NullabilityOfRet, llvm::None);
307  IO.mapOptional("RetainCountConvention", F.RetainCountConvention);
308  IO.mapOptional("Availability", F.Availability.Mode,
309  APIAvailability::Available);
310  IO.mapOptional("AvailabilityMsg", F.Availability.Msg, StringRef(""));
311  IO.mapOptional("SwiftPrivate", F.SwiftPrivate);
312  IO.mapOptional("SwiftName", F.SwiftName, StringRef(""));
313  IO.mapOptional("ResultType", F.ResultType, StringRef(""));
314  }
315 };
316 } // namespace yaml
317 } // namespace llvm
318 
319 namespace {
320 struct GlobalVariable {
321  StringRef Name;
323  AvailabilityItem Availability;
324  Optional<bool> SwiftPrivate;
325  StringRef SwiftName;
326  StringRef Type;
327 };
328 
329 typedef std::vector<GlobalVariable> GlobalVariablesSeq;
330 } // namespace
331 
332 LLVM_YAML_IS_SEQUENCE_VECTOR(GlobalVariable)
333 
334 namespace llvm {
335 namespace yaml {
336 template <> struct MappingTraits<GlobalVariable> {
337  static void mapping(IO &IO, GlobalVariable &GV) {
338  IO.mapRequired("Name", GV.Name);
339  IO.mapOptional("Nullability", GV.Nullability, llvm::None);
340  IO.mapOptional("Availability", GV.Availability.Mode,
341  APIAvailability::Available);
342  IO.mapOptional("AvailabilityMsg", GV.Availability.Msg, StringRef(""));
343  IO.mapOptional("SwiftPrivate", GV.SwiftPrivate);
344  IO.mapOptional("SwiftName", GV.SwiftName, StringRef(""));
345  IO.mapOptional("Type", GV.Type, StringRef(""));
346  }
347 };
348 } // namespace yaml
349 } // namespace llvm
350 
351 namespace {
352 struct EnumConstant {
353  StringRef Name;
354  AvailabilityItem Availability;
355  Optional<bool> SwiftPrivate;
356  StringRef SwiftName;
357 };
358 
359 typedef std::vector<EnumConstant> EnumConstantsSeq;
360 } // namespace
361 
362 LLVM_YAML_IS_SEQUENCE_VECTOR(EnumConstant)
363 
364 namespace llvm {
365 namespace yaml {
366 template <> struct MappingTraits<EnumConstant> {
367  static void mapping(IO &IO, EnumConstant &EC) {
368  IO.mapRequired("Name", EC.Name);
369  IO.mapOptional("Availability", EC.Availability.Mode,
370  APIAvailability::Available);
371  IO.mapOptional("AvailabilityMsg", EC.Availability.Msg, StringRef(""));
372  IO.mapOptional("SwiftPrivate", EC.SwiftPrivate);
373  IO.mapOptional("SwiftName", EC.SwiftName, StringRef(""));
374  }
375 };
376 } // namespace yaml
377 } // namespace llvm
378 
379 namespace {
380 /// Syntactic sugar for EnumExtensibility and FlagEnum
381 enum class EnumConvenienceAliasKind {
382  /// EnumExtensibility: none, FlagEnum: false
383  None,
384  /// EnumExtensibility: open, FlagEnum: false
385  CFEnum,
386  /// EnumExtensibility: open, FlagEnum: true
387  CFOptions,
388  /// EnumExtensibility: closed, FlagEnum: false
389  CFClosedEnum
390 };
391 } // namespace
392 
393 namespace llvm {
394 namespace yaml {
395 template <> struct ScalarEnumerationTraits<EnumConvenienceAliasKind> {
396  static void enumeration(IO &IO, EnumConvenienceAliasKind &ECAK) {
397  IO.enumCase(ECAK, "none", EnumConvenienceAliasKind::None);
398  IO.enumCase(ECAK, "CFEnum", EnumConvenienceAliasKind::CFEnum);
399  IO.enumCase(ECAK, "NSEnum", EnumConvenienceAliasKind::CFEnum);
400  IO.enumCase(ECAK, "CFOptions", EnumConvenienceAliasKind::CFOptions);
401  IO.enumCase(ECAK, "NSOptions", EnumConvenienceAliasKind::CFOptions);
402  IO.enumCase(ECAK, "CFClosedEnum", EnumConvenienceAliasKind::CFClosedEnum);
403  IO.enumCase(ECAK, "NSClosedEnum", EnumConvenienceAliasKind::CFClosedEnum);
404  }
405 };
406 } // namespace yaml
407 } // namespace llvm
408 
409 namespace {
410 struct Tag {
411  StringRef Name;
412  AvailabilityItem Availability;
413  StringRef SwiftName;
414  Optional<bool> SwiftPrivate;
415  Optional<StringRef> SwiftBridge;
416  Optional<StringRef> NSErrorDomain;
417  Optional<EnumExtensibilityKind> EnumExtensibility;
418  Optional<bool> FlagEnum;
419  Optional<EnumConvenienceAliasKind> EnumConvenienceKind;
420 };
421 
422 typedef std::vector<Tag> TagsSeq;
423 } // namespace
424 
425 LLVM_YAML_IS_SEQUENCE_VECTOR(Tag)
426 
427 namespace llvm {
428 namespace yaml {
429 template <> struct ScalarEnumerationTraits<EnumExtensibilityKind> {
430  static void enumeration(IO &IO, EnumExtensibilityKind &EEK) {
431  IO.enumCase(EEK, "none", EnumExtensibilityKind::None);
432  IO.enumCase(EEK, "open", EnumExtensibilityKind::Open);
433  IO.enumCase(EEK, "closed", EnumExtensibilityKind::Closed);
434  }
435 };
436 
437 template <> struct MappingTraits<Tag> {
438  static void mapping(IO &IO, Tag &T) {
439  IO.mapRequired("Name", T.Name);
440  IO.mapOptional("Availability", T.Availability.Mode,
441  APIAvailability::Available);
442  IO.mapOptional("AvailabilityMsg", T.Availability.Msg, StringRef(""));
443  IO.mapOptional("SwiftPrivate", T.SwiftPrivate);
444  IO.mapOptional("SwiftName", T.SwiftName, StringRef(""));
445  IO.mapOptional("SwiftBridge", T.SwiftBridge);
446  IO.mapOptional("NSErrorDomain", T.NSErrorDomain);
447  IO.mapOptional("EnumExtensibility", T.EnumExtensibility);
448  IO.mapOptional("FlagEnum", T.FlagEnum);
449  IO.mapOptional("EnumKind", T.EnumConvenienceKind);
450  }
451 };
452 } // namespace yaml
453 } // namespace llvm
454 
455 namespace {
456 struct Typedef {
457  StringRef Name;
458  AvailabilityItem Availability;
459  StringRef SwiftName;
460  Optional<bool> SwiftPrivate;
461  Optional<StringRef> SwiftBridge;
462  Optional<StringRef> NSErrorDomain;
463  Optional<SwiftNewTypeKind> SwiftType;
464 };
465 
466 typedef std::vector<Typedef> TypedefsSeq;
467 } // namespace
468 
469 LLVM_YAML_IS_SEQUENCE_VECTOR(Typedef)
470 
471 namespace llvm {
472 namespace yaml {
473 template <> struct ScalarEnumerationTraits<SwiftNewTypeKind> {
474  static void enumeration(IO &IO, SwiftNewTypeKind &SWK) {
475  IO.enumCase(SWK, "none", SwiftNewTypeKind::None);
476  IO.enumCase(SWK, "struct", SwiftNewTypeKind::Struct);
477  IO.enumCase(SWK, "enum", SwiftNewTypeKind::Enum);
478  }
479 };
480 
481 template <> struct MappingTraits<Typedef> {
482  static void mapping(IO &IO, Typedef &T) {
483  IO.mapRequired("Name", T.Name);
484  IO.mapOptional("Availability", T.Availability.Mode,
485  APIAvailability::Available);
486  IO.mapOptional("AvailabilityMsg", T.Availability.Msg, StringRef(""));
487  IO.mapOptional("SwiftPrivate", T.SwiftPrivate);
488  IO.mapOptional("SwiftName", T.SwiftName, StringRef(""));
489  IO.mapOptional("SwiftBridge", T.SwiftBridge);
490  IO.mapOptional("NSErrorDomain", T.NSErrorDomain);
491  IO.mapOptional("SwiftWrapper", T.SwiftType);
492  }
493 };
494 } // namespace yaml
495 } // namespace llvm
496 
497 namespace {
498 struct TopLevelItems {
499  ClassesSeq Classes;
500  ClassesSeq Protocols;
501  FunctionsSeq Functions;
502  GlobalVariablesSeq Globals;
503  EnumConstantsSeq EnumConstants;
504  TagsSeq Tags;
505  TypedefsSeq Typedefs;
506 };
507 } // namespace
508 
509 namespace llvm {
510 namespace yaml {
511 static void mapTopLevelItems(IO &IO, TopLevelItems &TLI) {
512  IO.mapOptional("Classes", TLI.Classes);
513  IO.mapOptional("Protocols", TLI.Protocols);
514  IO.mapOptional("Functions", TLI.Functions);
515  IO.mapOptional("Globals", TLI.Globals);
516  IO.mapOptional("Enumerators", TLI.EnumConstants);
517  IO.mapOptional("Tags", TLI.Tags);
518  IO.mapOptional("Typedefs", TLI.Typedefs);
519 }
520 } // namespace yaml
521 } // namespace llvm
522 
523 namespace {
524 struct Versioned {
525  VersionTuple Version;
526  TopLevelItems Items;
527 };
528 
529 typedef std::vector<Versioned> VersionedSeq;
530 } // namespace
531 
532 LLVM_YAML_IS_SEQUENCE_VECTOR(Versioned)
533 
534 namespace llvm {
535 namespace yaml {
536 template <> struct MappingTraits<Versioned> {
537  static void mapping(IO &IO, Versioned &V) {
538  IO.mapRequired("Version", V.Version);
539  mapTopLevelItems(IO, V.Items);
540  }
541 };
542 } // namespace yaml
543 } // namespace llvm
544 
545 namespace {
546 struct Module {
547  StringRef Name;
548  AvailabilityItem Availability;
549  TopLevelItems TopLevel;
550  VersionedSeq SwiftVersions;
551 
552  llvm::Optional<bool> SwiftInferImportAsMember = {llvm::None};
553 
554 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
555  LLVM_DUMP_METHOD void dump() /*const*/;
556 #endif
557 };
558 } // namespace
559 
560 namespace llvm {
561 namespace yaml {
562 template <> struct MappingTraits<Module> {
563  static void mapping(IO &IO, Module &M) {
564  IO.mapRequired("Name", M.Name);
565  IO.mapOptional("Availability", M.Availability.Mode,
566  APIAvailability::Available);
567  IO.mapOptional("AvailabilityMsg", M.Availability.Msg, StringRef(""));
568  IO.mapOptional("SwiftInferImportAsMember", M.SwiftInferImportAsMember);
569  mapTopLevelItems(IO, M.TopLevel);
570  IO.mapOptional("SwiftVersions", M.SwiftVersions);
571  }
572 };
573 } // namespace yaml
574 } // namespace llvm
575 
576 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
577 LLVM_DUMP_METHOD void Module::dump() {
578  llvm::yaml::Output OS(llvm::errs());
579  OS << *this;
580 }
581 #endif
582 
583 namespace {
584 bool parseAPINotes(StringRef YI, Module &M, llvm::SourceMgr::DiagHandlerTy Diag,
585  void *DiagContext) {
586  llvm::yaml::Input IS(YI, nullptr, Diag, DiagContext);
587  IS >> M;
588  return static_cast<bool>(IS.error());
589 }
590 } // namespace
591 
593  llvm::raw_ostream &OS) {
594  Module M;
595  if (parseAPINotes(YI, M, nullptr, nullptr))
596  return true;
597 
598  llvm::yaml::Output YOS(OS);
599  YOS << M;
600 
601  return false;
602 }
llvm
Definition: Dominators.h:30
llvm::yaml::ScalarEnumerationTraits< EnumExtensibilityKind >::enumeration
static void enumeration(IO &IO, EnumExtensibilityKind &EEK)
Definition: APINotesYAMLCompiler.cpp:430
Specifiers.h
llvm::yaml::ScalarEnumerationTraits< APIAvailability >::enumeration
static void enumeration(IO &IO, APIAvailability &AA)
Definition: APINotesYAMLCompiler.cpp:41
clang::index::SymbolKind::Class
@ Class
llvm::yaml::ScalarEnumerationTraits< RetainCountConventionKind >::enumeration
static void enumeration(IO &IO, RetainCountConventionKind &RCCK)
Definition: APINotesYAMLCompiler.cpp:106
clang::ento::Nullability
Nullability
Definition: CheckerHelpers.h:56
clang::index::SymbolKind::EnumConstant
@ EnumConstant
clang::api_notes::SwiftNewTypeKind::None
@ None
Diag
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Definition: LiteralSupport.cpp:78
llvm::yaml::MappingTraits< EnumConstant >::mapping
static void mapping(IO &IO, EnumConstant &EC)
Definition: APINotesYAMLCompiler.cpp:367
llvm::yaml::mapTopLevelItems
static void mapTopLevelItems(IO &IO, TopLevelItems &TLI)
Definition: APINotesYAMLCompiler.cpp:511
llvm::yaml::MappingTraits< Module >::mapping
static void mapping(IO &IO, Module &M)
Definition: APINotesYAMLCompiler.cpp:563
clang::Module::Name
std::string Name
The name of this module.
Definition: Module.h:99
clang::api_notes::EnumExtensibilityKind::Closed
@ Closed
llvm::yaml::ScalarEnumerationTraits< EnumConvenienceAliasKind >::enumeration
static void enumeration(IO &IO, EnumConvenienceAliasKind &ECAK)
Definition: APINotesYAMLCompiler.cpp:396
clang::api_notes::RetainCountConventionKind
RetainCountConventionKind
Definition: Types.h:20
llvm::yaml::ScalarEnumerationTraits< MethodKind >::enumeration
static void enumeration(IO &IO, MethodKind &MK)
Definition: APINotesYAMLCompiler.cpp:62
llvm::Optional< bool >
clang::api_notes::EnumExtensibilityKind
EnumExtensibilityKind
The payload for an enum_extensibility attribute.
Definition: Types.h:31
llvm::yaml::MappingTraits< Param >::mapping
static void mapping(IO &IO, Param &P)
Definition: APINotesYAMLCompiler.cpp:120
clang::api_notes::RetainCountConventionKind::NSReturnsRetained
@ NSReturnsRetained
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
llvm::yaml::MappingTraits< Tag >::mapping
static void mapping(IO &IO, Tag &T)
Definition: APINotesYAMLCompiler.cpp:438
V
#define V(N, I)
Definition: ASTContext.h:3121
llvm::yaml::MappingTraits< Versioned >::mapping
static void mapping(IO &IO, Versioned &V)
Definition: APINotesYAMLCompiler.cpp:537
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::api_notes::SwiftNewTypeKind
SwiftNewTypeKind
The kind of a swift_wrapper/swift_newtype.
Definition: Types.h:38
llvm::yaml::MappingTraits< Property >::mapping
static void mapping(IO &IO, Property &P)
Definition: APINotesYAMLCompiler.cpp:222
clang::XRayInstrKind::None
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
llvm::yaml::MappingTraits< Method >::mapping
static void mapping(IO &IO, Method &M)
Definition: APINotesYAMLCompiler.cpp:181
APINotesYAMLCompiler.h
llvm::yaml::MappingTraits< Typedef >::mapping
static void mapping(IO &IO, Typedef &T)
Definition: APINotesYAMLCompiler.cpp:482
Types.h
clang::api_notes::RetainCountConventionKind::NSReturnsNotRetained
@ NSReturnsNotRetained
llvm::yaml::ScalarEnumerationTraits< SwiftNewTypeKind >::enumeration
static void enumeration(IO &IO, SwiftNewTypeKind &SWK)
Definition: APINotesYAMLCompiler.cpp:474
llvm::yaml::MappingTraits< Class >::mapping
static void mapping(IO &IO, Class &C)
Definition: APINotesYAMLCompiler.cpp:261
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::NullabilityKind::Unspecified
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
dump
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Definition: CoverageMappingGen.cpp:1521
llvm::yaml::MappingTraits< GlobalVariable >::mapping
static void mapping(IO &IO, GlobalVariable &GV)
Definition: APINotesYAMLCompiler.cpp:337
LLVM.h
llvm::yaml::MappingTraits< Function >::mapping
static void mapping(IO &IO, Function &F)
Definition: APINotesYAMLCompiler.cpp:302
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::api_notes::SwiftNewTypeKind::Enum
@ Enum
clang::NullabilityKind
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:315
clang
Definition: CalledOnceCheck.h:17
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:748
clang::NullabilityKind::NullableResult
@ NullableResult
clang::Module::dump
void dump() const
Dump the contents of this module to the given output stream.
Definition: APINotesYAMLCompiler.cpp:577
clang::ObjCSubstitutionContext::Property
@ Property
The type of a property.
clang::NullabilityKind::Nullable
@ Nullable
Values of this type can be null.
llvm::yaml::ScalarEnumerationTraits< FactoryAsInitKind >::enumeration
static void enumeration(IO &IO, FactoryAsInitKind &FIK)
Definition: APINotesYAMLCompiler.cpp:173
clang::index::SymbolKind::Function
@ Function
clang::api_notes::RetainCountConventionKind::CFReturnsRetained
@ CFReturnsRetained
clang::api_notes::EnumExtensibilityKind::None
@ None
clang::api_notes::SwiftNewTypeKind::Struct
@ Struct
clang::NullabilityKind::NonNull
@ NonNull
Values of this type can never be null.
clang::api_notes::RetainCountConventionKind::None
@ None
clang::api_notes::EnumExtensibilityKind::Open
@ Open
llvm::yaml::ScalarEnumerationTraits< NullabilityKind >::enumeration
static void enumeration(IO &IO, NullabilityKind &NK)
Definition: APINotesYAMLCompiler.cpp:88
clang::api_notes::parseAndDumpAPINotes
bool parseAndDumpAPINotes(llvm::StringRef YI, llvm::raw_ostream &OS)
Parses the APINotes YAML content and writes the representation back to the specified stream.
clang::api_notes::RetainCountConventionKind::CFReturnsNotRetained
@ CFReturnsNotRetained