clang 18.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
19#include "clang/Basic/LLVM.h"
21#include "llvm/ADT/StringSet.h"
22#include "llvm/Support/SourceMgr.h"
23#include "llvm/Support/VersionTuple.h"
24#include "llvm/Support/YAMLTraits.h"
25#include <optional>
26#include <vector>
27
28using namespace clang;
29using namespace api_notes;
30
31namespace {
32enum class APIAvailability {
33 Available = 0,
34 None,
35 NonSwift,
36};
37} // namespace
38
39namespace llvm {
40namespace yaml {
41template <> struct ScalarEnumerationTraits<APIAvailability> {
42 static void enumeration(IO &IO, APIAvailability &AA) {
43 IO.enumCase(AA, "none", APIAvailability::None);
44 IO.enumCase(AA, "nonswift", APIAvailability::NonSwift);
45 IO.enumCase(AA, "available", APIAvailability::Available);
46 }
47};
48} // namespace yaml
49} // namespace llvm
50
51namespace {
52enum class MethodKind {
53 Class,
54 Instance,
55};
56} // namespace
57
58namespace llvm {
59namespace yaml {
60template <> struct ScalarEnumerationTraits<MethodKind> {
61 static void enumeration(IO &IO, MethodKind &MK) {
62 IO.enumCase(MK, "Class", MethodKind::Class);
63 IO.enumCase(MK, "Instance", MethodKind::Instance);
64 }
65};
66} // namespace yaml
67} // namespace llvm
68
69namespace {
70struct Param {
71 unsigned Position;
72 std::optional<bool> NoEscape = false;
73 std::optional<NullabilityKind> Nullability;
74 std::optional<RetainCountConventionKind> RetainCountConvention;
75 StringRef Type;
76};
77
78typedef std::vector<Param> ParamsSeq;
79} // namespace
80
81LLVM_YAML_IS_SEQUENCE_VECTOR(Param)
82LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(NullabilityKind)
83
84namespace llvm {
85namespace yaml {
86template <> struct ScalarEnumerationTraits<NullabilityKind> {
87 static void enumeration(IO &IO, NullabilityKind &NK) {
88 IO.enumCase(NK, "Nonnull", NullabilityKind::NonNull);
89 IO.enumCase(NK, "Optional", NullabilityKind::Nullable);
90 IO.enumCase(NK, "Unspecified", NullabilityKind::Unspecified);
91 IO.enumCase(NK, "NullableResult", NullabilityKind::NullableResult);
92 // TODO: Mapping this to it's own value would allow for better cross
93 // checking. Also the default should be Unknown.
94 IO.enumCase(NK, "Scalar", NullabilityKind::Unspecified);
95
96 // Aliases for compatibility with existing APINotes.
97 IO.enumCase(NK, "N", NullabilityKind::NonNull);
98 IO.enumCase(NK, "O", NullabilityKind::Nullable);
99 IO.enumCase(NK, "U", NullabilityKind::Unspecified);
100 IO.enumCase(NK, "S", NullabilityKind::Unspecified);
101 }
102};
103
104template <> struct ScalarEnumerationTraits<RetainCountConventionKind> {
105 static void enumeration(IO &IO, RetainCountConventionKind &RCCK) {
106 IO.enumCase(RCCK, "none", RetainCountConventionKind::None);
107 IO.enumCase(RCCK, "CFReturnsRetained",
108 RetainCountConventionKind::CFReturnsRetained);
109 IO.enumCase(RCCK, "CFReturnsNotRetained",
110 RetainCountConventionKind::CFReturnsNotRetained);
111 IO.enumCase(RCCK, "NSReturnsRetained",
112 RetainCountConventionKind::NSReturnsRetained);
113 IO.enumCase(RCCK, "NSReturnsNotRetained",
114 RetainCountConventionKind::NSReturnsNotRetained);
115 }
116};
117
118template <> struct MappingTraits<Param> {
119 static void mapping(IO &IO, Param &P) {
120 IO.mapRequired("Position", P.Position);
121 IO.mapOptional("Nullability", P.Nullability, std::nullopt);
122 IO.mapOptional("RetainCountConvention", P.RetainCountConvention);
123 IO.mapOptional("NoEscape", P.NoEscape);
124 IO.mapOptional("Type", P.Type, StringRef(""));
125 }
126};
127} // namespace yaml
128} // namespace llvm
129
130namespace {
131typedef std::vector<NullabilityKind> NullabilitySeq;
132
133struct AvailabilityItem {
134 APIAvailability Mode = APIAvailability::Available;
135 StringRef Msg;
136};
137
138/// Old attribute deprecated in favor of SwiftName.
139enum class FactoryAsInitKind {
140 /// Infer based on name and type (the default).
141 Infer,
142 /// Treat as a class method.
143 AsClassMethod,
144 /// Treat as an initializer.
145 AsInitializer,
146};
147
148struct Method {
149 StringRef Selector;
150 MethodKind Kind;
151 ParamsSeq Params;
152 NullabilitySeq Nullability;
153 std::optional<NullabilityKind> NullabilityOfRet;
154 std::optional<RetainCountConventionKind> RetainCountConvention;
155 AvailabilityItem Availability;
156 std::optional<bool> SwiftPrivate;
157 StringRef SwiftName;
158 FactoryAsInitKind FactoryAsInit = FactoryAsInitKind::Infer;
159 bool DesignatedInit = false;
160 bool Required = false;
161 StringRef ResultType;
162};
163
164typedef std::vector<Method> MethodsSeq;
165} // namespace
166
167LLVM_YAML_IS_SEQUENCE_VECTOR(Method)
168
169namespace llvm {
170namespace yaml {
171template <> struct ScalarEnumerationTraits<FactoryAsInitKind> {
172 static void enumeration(IO &IO, FactoryAsInitKind &FIK) {
173 IO.enumCase(FIK, "A", FactoryAsInitKind::Infer);
174 IO.enumCase(FIK, "C", FactoryAsInitKind::AsClassMethod);
175 IO.enumCase(FIK, "I", FactoryAsInitKind::AsInitializer);
176 }
177};
178
179template <> struct MappingTraits<Method> {
180 static void mapping(IO &IO, Method &M) {
181 IO.mapRequired("Selector", M.Selector);
182 IO.mapRequired("MethodKind", M.Kind);
183 IO.mapOptional("Parameters", M.Params);
184 IO.mapOptional("Nullability", M.Nullability);
185 IO.mapOptional("NullabilityOfRet", M.NullabilityOfRet, std::nullopt);
186 IO.mapOptional("RetainCountConvention", M.RetainCountConvention);
187 IO.mapOptional("Availability", M.Availability.Mode,
188 APIAvailability::Available);
189 IO.mapOptional("AvailabilityMsg", M.Availability.Msg, StringRef(""));
190 IO.mapOptional("SwiftPrivate", M.SwiftPrivate);
191 IO.mapOptional("SwiftName", M.SwiftName, StringRef(""));
192 IO.mapOptional("FactoryAsInit", M.FactoryAsInit, FactoryAsInitKind::Infer);
193 IO.mapOptional("DesignatedInit", M.DesignatedInit, false);
194 IO.mapOptional("Required", M.Required, false);
195 IO.mapOptional("ResultType", M.ResultType, StringRef(""));
196 }
197};
198} // namespace yaml
199} // namespace llvm
200
201namespace {
202struct Property {
203 StringRef Name;
204 std::optional<MethodKind> Kind;
205 std::optional<NullabilityKind> Nullability;
206 AvailabilityItem Availability;
207 std::optional<bool> SwiftPrivate;
208 StringRef SwiftName;
209 std::optional<bool> SwiftImportAsAccessors;
210 StringRef Type;
211};
212
213typedef std::vector<Property> PropertiesSeq;
214} // namespace
215
216LLVM_YAML_IS_SEQUENCE_VECTOR(Property)
217
218namespace llvm {
219namespace yaml {
220template <> struct MappingTraits<Property> {
221 static void mapping(IO &IO, Property &P) {
222 IO.mapRequired("Name", P.Name);
223 IO.mapOptional("PropertyKind", P.Kind);
224 IO.mapOptional("Nullability", P.Nullability, std::nullopt);
225 IO.mapOptional("Availability", P.Availability.Mode,
226 APIAvailability::Available);
227 IO.mapOptional("AvailabilityMsg", P.Availability.Msg, StringRef(""));
228 IO.mapOptional("SwiftPrivate", P.SwiftPrivate);
229 IO.mapOptional("SwiftName", P.SwiftName, StringRef(""));
230 IO.mapOptional("SwiftImportAsAccessors", P.SwiftImportAsAccessors);
231 IO.mapOptional("Type", P.Type, StringRef(""));
232 }
233};
234} // namespace yaml
235} // namespace llvm
236
237namespace {
238struct Class {
239 StringRef Name;
240 bool AuditedForNullability = false;
241 AvailabilityItem Availability;
242 std::optional<bool> SwiftPrivate;
243 StringRef SwiftName;
244 std::optional<StringRef> SwiftBridge;
245 std::optional<StringRef> NSErrorDomain;
246 std::optional<bool> SwiftImportAsNonGeneric;
247 std::optional<bool> SwiftObjCMembers;
248 MethodsSeq Methods;
249 PropertiesSeq Properties;
250};
251
252typedef std::vector<Class> ClassesSeq;
253} // namespace
254
255LLVM_YAML_IS_SEQUENCE_VECTOR(Class)
256
257namespace llvm {
258namespace yaml {
259template <> struct MappingTraits<Class> {
260 static void mapping(IO &IO, Class &C) {
261 IO.mapRequired("Name", C.Name);
262 IO.mapOptional("AuditedForNullability", C.AuditedForNullability, false);
263 IO.mapOptional("Availability", C.Availability.Mode,
264 APIAvailability::Available);
265 IO.mapOptional("AvailabilityMsg", C.Availability.Msg, StringRef(""));
266 IO.mapOptional("SwiftPrivate", C.SwiftPrivate);
267 IO.mapOptional("SwiftName", C.SwiftName, StringRef(""));
268 IO.mapOptional("SwiftBridge", C.SwiftBridge);
269 IO.mapOptional("NSErrorDomain", C.NSErrorDomain);
270 IO.mapOptional("SwiftImportAsNonGeneric", C.SwiftImportAsNonGeneric);
271 IO.mapOptional("SwiftObjCMembers", C.SwiftObjCMembers);
272 IO.mapOptional("Methods", C.Methods);
273 IO.mapOptional("Properties", C.Properties);
274 }
275};
276} // namespace yaml
277} // namespace llvm
278
279namespace {
280struct Function {
281 StringRef Name;
282 ParamsSeq Params;
283 NullabilitySeq Nullability;
284 std::optional<NullabilityKind> NullabilityOfRet;
285 std::optional<api_notes::RetainCountConventionKind> RetainCountConvention;
286 AvailabilityItem Availability;
287 std::optional<bool> SwiftPrivate;
288 StringRef SwiftName;
289 StringRef Type;
290 StringRef ResultType;
291};
292
293typedef std::vector<Function> FunctionsSeq;
294} // namespace
295
296LLVM_YAML_IS_SEQUENCE_VECTOR(Function)
297
298namespace llvm {
299namespace yaml {
300template <> struct MappingTraits<Function> {
301 static void mapping(IO &IO, Function &F) {
302 IO.mapRequired("Name", F.Name);
303 IO.mapOptional("Parameters", F.Params);
304 IO.mapOptional("Nullability", F.Nullability);
305 IO.mapOptional("NullabilityOfRet", F.NullabilityOfRet, std::nullopt);
306 IO.mapOptional("RetainCountConvention", F.RetainCountConvention);
307 IO.mapOptional("Availability", F.Availability.Mode,
308 APIAvailability::Available);
309 IO.mapOptional("AvailabilityMsg", F.Availability.Msg, StringRef(""));
310 IO.mapOptional("SwiftPrivate", F.SwiftPrivate);
311 IO.mapOptional("SwiftName", F.SwiftName, StringRef(""));
312 IO.mapOptional("ResultType", F.ResultType, StringRef(""));
313 }
314};
315} // namespace yaml
316} // namespace llvm
317
318namespace {
319struct GlobalVariable {
320 StringRef Name;
321 std::optional<NullabilityKind> Nullability;
322 AvailabilityItem Availability;
323 std::optional<bool> SwiftPrivate;
324 StringRef SwiftName;
325 StringRef Type;
326};
327
328typedef std::vector<GlobalVariable> GlobalVariablesSeq;
329} // namespace
330
331LLVM_YAML_IS_SEQUENCE_VECTOR(GlobalVariable)
332
333namespace llvm {
334namespace yaml {
335template <> struct MappingTraits<GlobalVariable> {
336 static void mapping(IO &IO, GlobalVariable &GV) {
337 IO.mapRequired("Name", GV.Name);
338 IO.mapOptional("Nullability", GV.Nullability, std::nullopt);
339 IO.mapOptional("Availability", GV.Availability.Mode,
340 APIAvailability::Available);
341 IO.mapOptional("AvailabilityMsg", GV.Availability.Msg, StringRef(""));
342 IO.mapOptional("SwiftPrivate", GV.SwiftPrivate);
343 IO.mapOptional("SwiftName", GV.SwiftName, StringRef(""));
344 IO.mapOptional("Type", GV.Type, StringRef(""));
345 }
346};
347} // namespace yaml
348} // namespace llvm
349
350namespace {
351struct EnumConstant {
352 StringRef Name;
353 AvailabilityItem Availability;
354 std::optional<bool> SwiftPrivate;
355 StringRef SwiftName;
356};
357
358typedef std::vector<EnumConstant> EnumConstantsSeq;
359} // namespace
360
361LLVM_YAML_IS_SEQUENCE_VECTOR(EnumConstant)
362
363namespace llvm {
364namespace yaml {
365template <> struct MappingTraits<EnumConstant> {
366 static void mapping(IO &IO, EnumConstant &EC) {
367 IO.mapRequired("Name", EC.Name);
368 IO.mapOptional("Availability", EC.Availability.Mode,
369 APIAvailability::Available);
370 IO.mapOptional("AvailabilityMsg", EC.Availability.Msg, StringRef(""));
371 IO.mapOptional("SwiftPrivate", EC.SwiftPrivate);
372 IO.mapOptional("SwiftName", EC.SwiftName, StringRef(""));
373 }
374};
375} // namespace yaml
376} // namespace llvm
377
378namespace {
379/// Syntactic sugar for EnumExtensibility and FlagEnum
380enum class EnumConvenienceAliasKind {
381 /// EnumExtensibility: none, FlagEnum: false
382 None,
383 /// EnumExtensibility: open, FlagEnum: false
384 CFEnum,
385 /// EnumExtensibility: open, FlagEnum: true
386 CFOptions,
387 /// EnumExtensibility: closed, FlagEnum: false
388 CFClosedEnum
389};
390} // namespace
391
392namespace llvm {
393namespace yaml {
394template <> struct ScalarEnumerationTraits<EnumConvenienceAliasKind> {
395 static void enumeration(IO &IO, EnumConvenienceAliasKind &ECAK) {
396 IO.enumCase(ECAK, "none", EnumConvenienceAliasKind::None);
397 IO.enumCase(ECAK, "CFEnum", EnumConvenienceAliasKind::CFEnum);
398 IO.enumCase(ECAK, "NSEnum", EnumConvenienceAliasKind::CFEnum);
399 IO.enumCase(ECAK, "CFOptions", EnumConvenienceAliasKind::CFOptions);
400 IO.enumCase(ECAK, "NSOptions", EnumConvenienceAliasKind::CFOptions);
401 IO.enumCase(ECAK, "CFClosedEnum", EnumConvenienceAliasKind::CFClosedEnum);
402 IO.enumCase(ECAK, "NSClosedEnum", EnumConvenienceAliasKind::CFClosedEnum);
403 }
404};
405} // namespace yaml
406} // namespace llvm
407
408namespace {
409struct Tag {
410 StringRef Name;
411 AvailabilityItem Availability;
412 StringRef SwiftName;
413 std::optional<bool> SwiftPrivate;
414 std::optional<StringRef> SwiftBridge;
415 std::optional<StringRef> NSErrorDomain;
416 std::optional<std::string> SwiftImportAs;
417 std::optional<std::string> SwiftRetainOp;
418 std::optional<std::string> SwiftReleaseOp;
419 std::optional<EnumExtensibilityKind> EnumExtensibility;
420 std::optional<bool> FlagEnum;
421 std::optional<EnumConvenienceAliasKind> EnumConvenienceKind;
422};
423
424typedef std::vector<Tag> TagsSeq;
425} // namespace
426
427LLVM_YAML_IS_SEQUENCE_VECTOR(Tag)
428
429namespace llvm {
430namespace yaml {
431template <> struct ScalarEnumerationTraits<EnumExtensibilityKind> {
432 static void enumeration(IO &IO, EnumExtensibilityKind &EEK) {
433 IO.enumCase(EEK, "none", EnumExtensibilityKind::None);
434 IO.enumCase(EEK, "open", EnumExtensibilityKind::Open);
435 IO.enumCase(EEK, "closed", EnumExtensibilityKind::Closed);
436 }
437};
438
439template <> struct MappingTraits<Tag> {
440 static void mapping(IO &IO, Tag &T) {
441 IO.mapRequired("Name", T.Name);
442 IO.mapOptional("Availability", T.Availability.Mode,
443 APIAvailability::Available);
444 IO.mapOptional("AvailabilityMsg", T.Availability.Msg, StringRef(""));
445 IO.mapOptional("SwiftPrivate", T.SwiftPrivate);
446 IO.mapOptional("SwiftName", T.SwiftName, StringRef(""));
447 IO.mapOptional("SwiftBridge", T.SwiftBridge);
448 IO.mapOptional("NSErrorDomain", T.NSErrorDomain);
449 IO.mapOptional("SwiftImportAs", T.SwiftImportAs);
450 IO.mapOptional("SwiftReleaseOp", T.SwiftReleaseOp);
451 IO.mapOptional("SwiftRetainOp", T.SwiftRetainOp);
452 IO.mapOptional("EnumExtensibility", T.EnumExtensibility);
453 IO.mapOptional("FlagEnum", T.FlagEnum);
454 IO.mapOptional("EnumKind", T.EnumConvenienceKind);
455 }
456};
457} // namespace yaml
458} // namespace llvm
459
460namespace {
461struct Typedef {
462 StringRef Name;
463 AvailabilityItem Availability;
464 StringRef SwiftName;
465 std::optional<bool> SwiftPrivate;
466 std::optional<StringRef> SwiftBridge;
467 std::optional<StringRef> NSErrorDomain;
468 std::optional<SwiftNewTypeKind> SwiftType;
469};
470
471typedef std::vector<Typedef> TypedefsSeq;
472} // namespace
473
474LLVM_YAML_IS_SEQUENCE_VECTOR(Typedef)
475
476namespace llvm {
477namespace yaml {
478template <> struct ScalarEnumerationTraits<SwiftNewTypeKind> {
479 static void enumeration(IO &IO, SwiftNewTypeKind &SWK) {
480 IO.enumCase(SWK, "none", SwiftNewTypeKind::None);
481 IO.enumCase(SWK, "struct", SwiftNewTypeKind::Struct);
482 IO.enumCase(SWK, "enum", SwiftNewTypeKind::Enum);
483 }
484};
485
486template <> struct MappingTraits<Typedef> {
487 static void mapping(IO &IO, Typedef &T) {
488 IO.mapRequired("Name", T.Name);
489 IO.mapOptional("Availability", T.Availability.Mode,
490 APIAvailability::Available);
491 IO.mapOptional("AvailabilityMsg", T.Availability.Msg, StringRef(""));
492 IO.mapOptional("SwiftPrivate", T.SwiftPrivate);
493 IO.mapOptional("SwiftName", T.SwiftName, StringRef(""));
494 IO.mapOptional("SwiftBridge", T.SwiftBridge);
495 IO.mapOptional("NSErrorDomain", T.NSErrorDomain);
496 IO.mapOptional("SwiftWrapper", T.SwiftType);
497 }
498};
499} // namespace yaml
500} // namespace llvm
501
502namespace {
503struct Namespace;
504typedef std::vector<Namespace> NamespacesSeq;
505
506struct TopLevelItems {
507 ClassesSeq Classes;
508 ClassesSeq Protocols;
509 FunctionsSeq Functions;
510 GlobalVariablesSeq Globals;
511 EnumConstantsSeq EnumConstants;
512 TagsSeq Tags;
513 TypedefsSeq Typedefs;
514 NamespacesSeq Namespaces;
515};
516} // namespace
517
518namespace llvm {
519namespace yaml {
520static void mapTopLevelItems(IO &IO, TopLevelItems &TLI) {
521 IO.mapOptional("Classes", TLI.Classes);
522 IO.mapOptional("Protocols", TLI.Protocols);
523 IO.mapOptional("Functions", TLI.Functions);
524 IO.mapOptional("Globals", TLI.Globals);
525 IO.mapOptional("Enumerators", TLI.EnumConstants);
526 IO.mapOptional("Tags", TLI.Tags);
527 IO.mapOptional("Typedefs", TLI.Typedefs);
528 IO.mapOptional("Namespaces", TLI.Namespaces);
529}
530} // namespace yaml
531} // namespace llvm
532
533namespace {
534struct Namespace {
535 StringRef Name;
536 AvailabilityItem Availability;
537 StringRef SwiftName;
538 std::optional<bool> SwiftPrivate;
539 TopLevelItems Items;
540};
541} // namespace
542
543LLVM_YAML_IS_SEQUENCE_VECTOR(Namespace)
544
545namespace llvm {
546namespace yaml {
547template <> struct MappingTraits<Namespace> {
548 static void mapping(IO &IO, Namespace &T) {
549 IO.mapRequired("Name", T.Name);
550 IO.mapOptional("Availability", T.Availability.Mode,
551 APIAvailability::Available);
552 IO.mapOptional("AvailabilityMsg", T.Availability.Msg, StringRef(""));
553 IO.mapOptional("SwiftPrivate", T.SwiftPrivate);
554 IO.mapOptional("SwiftName", T.SwiftName, StringRef(""));
555 mapTopLevelItems(IO, T.Items);
556 }
557};
558} // namespace yaml
559} // namespace llvm
560
561namespace {
562struct Versioned {
563 VersionTuple Version;
564 TopLevelItems Items;
565};
566
567typedef std::vector<Versioned> VersionedSeq;
568} // namespace
569
570LLVM_YAML_IS_SEQUENCE_VECTOR(Versioned)
571
572namespace llvm {
573namespace yaml {
574template <> struct MappingTraits<Versioned> {
575 static void mapping(IO &IO, Versioned &V) {
576 IO.mapRequired("Version", V.Version);
577 mapTopLevelItems(IO, V.Items);
578 }
579};
580} // namespace yaml
581} // namespace llvm
582
583namespace {
584struct Module {
585 StringRef Name;
586 AvailabilityItem Availability;
587 TopLevelItems TopLevel;
588 VersionedSeq SwiftVersions;
589
590 std::optional<bool> SwiftInferImportAsMember;
591
592#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
593 LLVM_DUMP_METHOD void dump() /*const*/;
594#endif
595};
596} // namespace
597
598namespace llvm {
599namespace yaml {
600template <> struct MappingTraits<Module> {
601 static void mapping(IO &IO, Module &M) {
602 IO.mapRequired("Name", M.Name);
603 IO.mapOptional("Availability", M.Availability.Mode,
604 APIAvailability::Available);
605 IO.mapOptional("AvailabilityMsg", M.Availability.Msg, StringRef(""));
606 IO.mapOptional("SwiftInferImportAsMember", M.SwiftInferImportAsMember);
607 mapTopLevelItems(IO, M.TopLevel);
608 IO.mapOptional("SwiftVersions", M.SwiftVersions);
609 }
610};
611} // namespace yaml
612} // namespace llvm
613
614#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
615LLVM_DUMP_METHOD void Module::dump() {
616 llvm::yaml::Output OS(llvm::errs());
617 OS << *this;
618}
619#endif
620
621namespace {
622bool parseAPINotes(StringRef YI, Module &M, llvm::SourceMgr::DiagHandlerTy Diag,
623 void *DiagContext) {
624 llvm::yaml::Input IS(YI, nullptr, Diag, DiagContext);
625 IS >> M;
626 return static_cast<bool>(IS.error());
627}
628} // namespace
629
631 llvm::raw_ostream &OS) {
632 Module M;
633 if (parseAPINotes(YI, M, nullptr, nullptr))
634 return true;
635
636 llvm::yaml::Output YOS(OS);
637 YOS << M;
638
639 return false;
640}
641
642namespace {
643using namespace api_notes;
644
645class YAMLConverter {
646 const Module &M;
647 APINotesWriter Writer;
648 llvm::raw_ostream &OS;
649 llvm::SourceMgr::DiagHandlerTy DiagHandler;
650 void *DiagHandlerCtxt;
651 bool ErrorOccured;
652
653 /// Emit a diagnostic
654 bool emitError(llvm::Twine Message) {
655 DiagHandler(
656 llvm::SMDiagnostic("", llvm::SourceMgr::DK_Error, Message.str()),
657 DiagHandlerCtxt);
658 ErrorOccured = true;
659 return true;
660 }
661
662public:
663 YAMLConverter(const Module &TheModule, const FileEntry *SourceFile,
664 llvm::raw_ostream &OS,
665 llvm::SourceMgr::DiagHandlerTy DiagHandler,
666 void *DiagHandlerCtxt)
667 : M(TheModule), Writer(TheModule.Name, SourceFile), OS(OS),
668 DiagHandler(DiagHandler), DiagHandlerCtxt(DiagHandlerCtxt),
669 ErrorOccured(false) {}
670
671 void convertAvailability(const AvailabilityItem &Availability,
672 CommonEntityInfo &CEI, llvm::StringRef APIName) {
673 // Populate the unavailability information.
674 CEI.Unavailable = (Availability.Mode == APIAvailability::None);
675 CEI.UnavailableInSwift = (Availability.Mode == APIAvailability::NonSwift);
676 if (CEI.Unavailable || CEI.UnavailableInSwift) {
677 CEI.UnavailableMsg = std::string(Availability.Msg);
678 } else {
679 if (!Availability.Msg.empty())
680 emitError(llvm::Twine("availability message for available API '") +
681 APIName + "' will not be used");
682 }
683 }
684
685 void convertParams(const ParamsSeq &Params, FunctionInfo &OutInfo) {
686 for (const auto &P : Params) {
687 ParamInfo PI;
688 if (P.Nullability)
689 PI.setNullabilityAudited(*P.Nullability);
690 PI.setNoEscape(P.NoEscape);
691 PI.setType(std::string(P.Type));
692 PI.setRetainCountConvention(P.RetainCountConvention);
693 if (OutInfo.Params.size() <= P.Position)
694 OutInfo.Params.resize(P.Position + 1);
695 OutInfo.Params[P.Position] |= PI;
696 }
697 }
698
699 void convertNullability(const NullabilitySeq &Nullability,
700 std::optional<NullabilityKind> ReturnNullability,
701 FunctionInfo &OutInfo, llvm::StringRef APIName) {
703 emitError(llvm::Twine("nullability info for '") + APIName +
704 "' does not fit");
705 return;
706 }
707
708 bool audited = false;
709 unsigned int idx = 1;
710 for (const auto &N : Nullability)
711 OutInfo.addTypeInfo(idx++, N);
712 audited = Nullability.size() > 0 || ReturnNullability;
713 if (audited)
714 OutInfo.addTypeInfo(0, ReturnNullability ? *ReturnNullability
715 : NullabilityKind::NonNull);
716 if (!audited)
717 return;
718 OutInfo.NullabilityAudited = audited;
719 OutInfo.NumAdjustedNullable = idx;
720 }
721
722 /// Convert the common parts of an entity from YAML.
723 template <typename T>
724 void convertCommonEntity(const T &Common, CommonEntityInfo &Info,
725 StringRef APIName) {
726 convertAvailability(Common.Availability, Info, APIName);
727 Info.setSwiftPrivate(Common.SwiftPrivate);
728 Info.SwiftName = std::string(Common.SwiftName);
729 }
730
731 /// Convert the common parts of a type entity from YAML.
732 template <typename T>
733 void convertCommonType(const T &Common, CommonTypeInfo &Info,
734 StringRef APIName) {
735 convertCommonEntity(Common, Info, APIName);
736 if (Common.SwiftBridge)
737 Info.setSwiftBridge(std::string(*Common.SwiftBridge));
738 Info.setNSErrorDomain(Common.NSErrorDomain);
739 }
740
741 // Translate from Method into ObjCMethodInfo and write it out.
742 void convertMethod(const Method &M, ContextID ClassID, StringRef ClassName,
743 VersionTuple SwiftVersion) {
745 convertCommonEntity(M, MI, M.Selector);
746
747 // Check if the selector ends with ':' to determine if it takes arguments.
748 bool takesArguments = M.Selector.endswith(":");
749
750 // Split the selector into pieces.
752 M.Selector.split(Args, ":", /*MaxSplit*/ -1, /*KeepEmpty*/ false);
753 if (!takesArguments && Args.size() > 1) {
754 emitError("selector '" + M.Selector + "' is missing a ':' at the end");
755 return;
756 }
757
758 // Construct ObjCSelectorRef.
760 Selector.NumArgs = !takesArguments ? 0 : Args.size();
761 Selector.Identifiers = Args;
762
763 // Translate the initializer info.
764 MI.DesignatedInit = M.DesignatedInit;
765 MI.RequiredInit = M.Required;
766 if (M.FactoryAsInit != FactoryAsInitKind::Infer)
767 emitError("'FactoryAsInit' is no longer valid; use 'SwiftName' instead");
768
769 MI.ResultType = std::string(M.ResultType);
770
771 // Translate parameter information.
772 convertParams(M.Params, MI);
773
774 // Translate nullability info.
775 convertNullability(M.Nullability, M.NullabilityOfRet, MI, M.Selector);
776
777 MI.setRetainCountConvention(M.RetainCountConvention);
778
779 // Write it.
780 Writer.addObjCMethod(ClassID, Selector, M.Kind == MethodKind::Instance, MI,
781 SwiftVersion);
782 }
783
784 void convertContext(std::optional<ContextID> ParentContextID, const Class &C,
785 ContextKind Kind, VersionTuple SwiftVersion) {
786 // Write the class.
788 convertCommonType(C, CI, C.Name);
789
790 if (C.AuditedForNullability)
791 CI.setDefaultNullability(NullabilityKind::NonNull);
792 if (C.SwiftImportAsNonGeneric)
793 CI.setSwiftImportAsNonGeneric(*C.SwiftImportAsNonGeneric);
794 if (C.SwiftObjCMembers)
795 CI.setSwiftObjCMembers(*C.SwiftObjCMembers);
796
797 ContextID CtxID =
798 Writer.addObjCContext(ParentContextID, C.Name, Kind, CI, SwiftVersion);
799
800 // Write all methods.
801 llvm::StringMap<std::pair<bool, bool>> KnownMethods;
802 for (const auto &method : C.Methods) {
803 // Check for duplicate method definitions.
804 bool IsInstanceMethod = method.Kind == MethodKind::Instance;
805 bool &Known = IsInstanceMethod ? KnownMethods[method.Selector].first
806 : KnownMethods[method.Selector].second;
807 if (Known) {
808 emitError(llvm::Twine("duplicate definition of method '") +
809 (IsInstanceMethod ? "-" : "+") + "[" + C.Name + " " +
810 method.Selector + "]'");
811 continue;
812 }
813 Known = true;
814
815 convertMethod(method, CtxID, C.Name, SwiftVersion);
816 }
817
818 // Write all properties.
819 llvm::StringSet<> KnownInstanceProperties;
820 llvm::StringSet<> KnownClassProperties;
821 for (const auto &Property : C.Properties) {
822 // Check for duplicate property definitions.
823 if ((!Property.Kind || *Property.Kind == MethodKind::Instance) &&
824 !KnownInstanceProperties.insert(Property.Name).second) {
825 emitError(llvm::Twine("duplicate definition of instance property '") +
826 C.Name + "." + Property.Name + "'");
827 continue;
828 }
829
830 if ((!Property.Kind || *Property.Kind == MethodKind::Class) &&
831 !KnownClassProperties.insert(Property.Name).second) {
832 emitError(llvm::Twine("duplicate definition of class property '") +
833 C.Name + "." + Property.Name + "'");
834 continue;
835 }
836
837 // Translate from Property into ObjCPropertyInfo.
839 convertAvailability(Property.Availability, PI, Property.Name);
840 PI.setSwiftPrivate(Property.SwiftPrivate);
841 PI.SwiftName = std::string(Property.SwiftName);
842 if (Property.Nullability)
843 PI.setNullabilityAudited(*Property.Nullability);
844 if (Property.SwiftImportAsAccessors)
845 PI.setSwiftImportAsAccessors(*Property.SwiftImportAsAccessors);
846 PI.setType(std::string(Property.Type));
847
848 // Add both instance and class properties with this name.
849 if (Property.Kind) {
850 Writer.addObjCProperty(CtxID, Property.Name,
851 *Property.Kind == MethodKind::Instance, PI,
852 SwiftVersion);
853 } else {
854 Writer.addObjCProperty(CtxID, Property.Name, true, PI, SwiftVersion);
855 Writer.addObjCProperty(CtxID, Property.Name, false, PI, SwiftVersion);
856 }
857 }
858 }
859
860 void convertNamespaceContext(std::optional<ContextID> ParentContextID,
861 const Namespace &TheNamespace,
862 VersionTuple SwiftVersion) {
863 // Write the namespace.
865 convertCommonEntity(TheNamespace, CI, TheNamespace.Name);
866
867 ContextID CtxID =
868 Writer.addObjCContext(ParentContextID, TheNamespace.Name,
869 ContextKind::Namespace, CI, SwiftVersion);
870
871 convertTopLevelItems(Context(CtxID, ContextKind::Namespace),
872 TheNamespace.Items, SwiftVersion);
873 }
874
875 void convertTopLevelItems(std::optional<Context> Ctx,
876 const TopLevelItems &TLItems,
877 VersionTuple SwiftVersion) {
878 std::optional<ContextID> CtxID =
879 Ctx ? std::optional(Ctx->id) : std::nullopt;
880
881 // Write all classes.
882 llvm::StringSet<> KnownClasses;
883 for (const auto &Class : TLItems.Classes) {
884 // Check for duplicate class definitions.
885 if (!KnownClasses.insert(Class.Name).second) {
886 emitError(llvm::Twine("multiple definitions of class '") + Class.Name +
887 "'");
888 continue;
889 }
890
891 convertContext(CtxID, Class, ContextKind::ObjCClass, SwiftVersion);
892 }
893
894 // Write all protocols.
895 llvm::StringSet<> KnownProtocols;
896 for (const auto &Protocol : TLItems.Protocols) {
897 // Check for duplicate protocol definitions.
898 if (!KnownProtocols.insert(Protocol.Name).second) {
899 emitError(llvm::Twine("multiple definitions of protocol '") +
900 Protocol.Name + "'");
901 continue;
902 }
903
904 convertContext(CtxID, Protocol, ContextKind::ObjCProtocol, SwiftVersion);
905 }
906
907 // Write all namespaces.
908 llvm::StringSet<> KnownNamespaces;
909 for (const auto &Namespace : TLItems.Namespaces) {
910 // Check for duplicate namespace definitions.
911 if (!KnownNamespaces.insert(Namespace.Name).second) {
912 emitError(llvm::Twine("multiple definitions of namespace '") +
913 Namespace.Name + "'");
914 continue;
915 }
916
917 convertNamespaceContext(CtxID, Namespace, SwiftVersion);
918 }
919
920 // Write all global variables.
921 llvm::StringSet<> KnownGlobals;
922 for (const auto &Global : TLItems.Globals) {
923 // Check for duplicate global variables.
924 if (!KnownGlobals.insert(Global.Name).second) {
925 emitError(llvm::Twine("multiple definitions of global variable '") +
926 Global.Name + "'");
927 continue;
928 }
929
931 convertAvailability(Global.Availability, GVI, Global.Name);
932 GVI.setSwiftPrivate(Global.SwiftPrivate);
933 GVI.SwiftName = std::string(Global.SwiftName);
934 if (Global.Nullability)
935 GVI.setNullabilityAudited(*Global.Nullability);
936 GVI.setType(std::string(Global.Type));
937 Writer.addGlobalVariable(Ctx, Global.Name, GVI, SwiftVersion);
938 }
939
940 // Write all global functions.
941 llvm::StringSet<> KnownFunctions;
942 for (const auto &Function : TLItems.Functions) {
943 // Check for duplicate global functions.
944 if (!KnownFunctions.insert(Function.Name).second) {
945 emitError(llvm::Twine("multiple definitions of global function '") +
946 Function.Name + "'");
947 continue;
948 }
949
951 convertAvailability(Function.Availability, GFI, Function.Name);
952 GFI.setSwiftPrivate(Function.SwiftPrivate);
953 GFI.SwiftName = std::string(Function.SwiftName);
954 convertParams(Function.Params, GFI);
955 convertNullability(Function.Nullability, Function.NullabilityOfRet, GFI,
956 Function.Name);
957 GFI.ResultType = std::string(Function.ResultType);
958 GFI.setRetainCountConvention(Function.RetainCountConvention);
959 Writer.addGlobalFunction(Ctx, Function.Name, GFI, SwiftVersion);
960 }
961
962 // Write all enumerators.
963 llvm::StringSet<> KnownEnumConstants;
964 for (const auto &EnumConstant : TLItems.EnumConstants) {
965 // Check for duplicate enumerators
966 if (!KnownEnumConstants.insert(EnumConstant.Name).second) {
967 emitError(llvm::Twine("multiple definitions of enumerator '") +
968 EnumConstant.Name + "'");
969 continue;
970 }
971
973 convertAvailability(EnumConstant.Availability, ECI, EnumConstant.Name);
974 ECI.setSwiftPrivate(EnumConstant.SwiftPrivate);
975 ECI.SwiftName = std::string(EnumConstant.SwiftName);
976 Writer.addEnumConstant(EnumConstant.Name, ECI, SwiftVersion);
977 }
978
979 // Write all tags.
980 llvm::StringSet<> KnownTags;
981 for (const auto &Tag : TLItems.Tags) {
982 // Check for duplicate tag definitions.
983 if (!KnownTags.insert(Tag.Name).second) {
984 emitError(llvm::Twine("multiple definitions of tag '") + Tag.Name +
985 "'");
986 continue;
987 }
988
989 TagInfo TI;
990 convertCommonType(Tag, TI, Tag.Name);
991
992 if ((Tag.SwiftRetainOp || Tag.SwiftReleaseOp) && !Tag.SwiftImportAs) {
993 emitError(llvm::Twine("should declare SwiftImportAs to use "
994 "SwiftRetainOp and SwiftReleaseOp (for ") +
995 Tag.Name + ")");
996 continue;
997 }
998 if (Tag.SwiftReleaseOp.has_value() != Tag.SwiftRetainOp.has_value()) {
999 emitError(llvm::Twine("should declare both SwiftReleaseOp and "
1000 "SwiftRetainOp (for ") +
1001 Tag.Name + ")");
1002 continue;
1003 }
1004
1005 if (Tag.SwiftImportAs)
1006 TI.SwiftImportAs = Tag.SwiftImportAs;
1007 if (Tag.SwiftRetainOp)
1008 TI.SwiftRetainOp = Tag.SwiftRetainOp;
1009 if (Tag.SwiftReleaseOp)
1010 TI.SwiftReleaseOp = Tag.SwiftReleaseOp;
1011
1012 if (Tag.EnumConvenienceKind) {
1013 if (Tag.EnumExtensibility) {
1014 emitError(
1015 llvm::Twine("cannot mix EnumKind and EnumExtensibility (for ") +
1016 Tag.Name + ")");
1017 continue;
1018 }
1019 if (Tag.FlagEnum) {
1020 emitError(llvm::Twine("cannot mix EnumKind and FlagEnum (for ") +
1021 Tag.Name + ")");
1022 continue;
1023 }
1024 switch (*Tag.EnumConvenienceKind) {
1025 case EnumConvenienceAliasKind::None:
1026 TI.EnumExtensibility = EnumExtensibilityKind::None;
1027 TI.setFlagEnum(false);
1028 break;
1029 case EnumConvenienceAliasKind::CFEnum:
1030 TI.EnumExtensibility = EnumExtensibilityKind::Open;
1031 TI.setFlagEnum(false);
1032 break;
1033 case EnumConvenienceAliasKind::CFOptions:
1034 TI.EnumExtensibility = EnumExtensibilityKind::Open;
1035 TI.setFlagEnum(true);
1036 break;
1037 case EnumConvenienceAliasKind::CFClosedEnum:
1038 TI.EnumExtensibility = EnumExtensibilityKind::Closed;
1039 TI.setFlagEnum(false);
1040 break;
1041 }
1042 } else {
1043 TI.EnumExtensibility = Tag.EnumExtensibility;
1044 TI.setFlagEnum(Tag.FlagEnum);
1045 }
1046
1047 Writer.addTag(Ctx, Tag.Name, TI, SwiftVersion);
1048 }
1049
1050 // Write all typedefs.
1051 llvm::StringSet<> KnownTypedefs;
1052 for (const auto &Typedef : TLItems.Typedefs) {
1053 // Check for duplicate typedef definitions.
1054 if (!KnownTypedefs.insert(Typedef.Name).second) {
1055 emitError(llvm::Twine("multiple definitions of typedef '") +
1056 Typedef.Name + "'");
1057 continue;
1058 }
1059
1060 TypedefInfo TInfo;
1061 convertCommonType(Typedef, TInfo, Typedef.Name);
1062 TInfo.SwiftWrapper = Typedef.SwiftType;
1063
1064 Writer.addTypedef(Ctx, Typedef.Name, TInfo, SwiftVersion);
1065 }
1066 }
1067
1068 bool convertModule() {
1069 // Write the top-level items.
1070 convertTopLevelItems(/* context */ std::nullopt, M.TopLevel,
1071 VersionTuple());
1072
1073 // Convert the versioned information.
1074 for (const auto &Versioned : M.SwiftVersions)
1075 convertTopLevelItems(/* context */ std::nullopt, Versioned.Items,
1076 Versioned.Version);
1077
1078 if (!ErrorOccured)
1079 Writer.writeToStream(OS);
1080
1081 return ErrorOccured;
1082 }
1083};
1084} // namespace
1085
1086static bool compile(const Module &M, const FileEntry *SourceFile,
1087 llvm::raw_ostream &OS,
1088 llvm::SourceMgr::DiagHandlerTy DiagHandler,
1089 void *DiagHandlerCtxt) {
1090 YAMLConverter C(M, SourceFile, OS, DiagHandler, DiagHandlerCtxt);
1091 return C.convertModule();
1092}
1093
1094/// Simple diagnostic handler that prints diagnostics to standard error.
1095static void printDiagnostic(const llvm::SMDiagnostic &Diag, void *Context) {
1096 Diag.print(nullptr, llvm::errs());
1097}
1098
1099bool api_notes::compileAPINotes(StringRef YAMLInput,
1100 const FileEntry *SourceFile,
1101 llvm::raw_ostream &OS,
1102 llvm::SourceMgr::DiagHandlerTy DiagHandler,
1103 void *DiagHandlerCtxt) {
1104 Module TheModule;
1105
1106 if (!DiagHandler)
1107 DiagHandler = &printDiagnostic;
1108
1109 if (parseAPINotes(YAMLInput, TheModule, DiagHandler, DiagHandlerCtxt))
1110 return true;
1111
1112 return compile(TheModule, SourceFile, OS, DiagHandler, DiagHandlerCtxt);
1113}
static void printDiagnostic(const llvm::SMDiagnostic &Diag, void *Context)
Simple diagnostic handler that prints diagnostics to standard error.
static bool compile(const Module &M, const FileEntry *SourceFile, llvm::raw_ostream &OS, llvm::SourceMgr::DiagHandlerTy DiagHandler, void *DiagHandlerCtxt)
#define V(N, I)
Definition: ASTContext.h:3241
StringRef P
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
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.
Defines various enumerations that describe declaration and type specifiers.
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:366
Describes a module or submodule.
Definition: Module.h:105
std::string Name
The name of this module.
Definition: Module.h:108
void dump() const
Dump the contents of this module to the given output stream.
Smart pointer class that efficiently represents Objective-C method names.
The base class of the type hierarchy.
Definition: Type.h:1602
void addObjCMethod(ContextID CtxID, ObjCSelectorRef Selector, bool IsInstanceMethod, const ObjCMethodInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a specific Objective-C method.
void addEnumConstant(llvm::StringRef Name, const EnumConstantInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about an enumerator.
void addGlobalFunction(std::optional< Context > Ctx, llvm::StringRef Name, const GlobalFunctionInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a global function.
void addObjCProperty(ContextID CtxID, llvm::StringRef Name, bool IsInstanceProperty, const ObjCPropertyInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a specific Objective-C property.
void addGlobalVariable(std::optional< Context > Ctx, llvm::StringRef Name, const GlobalVariableInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a global variable.
void addTypedef(std::optional< Context > Ctx, llvm::StringRef Name, const TypedefInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a typedef.
void writeToStream(llvm::raw_ostream &OS)
ContextID addObjCContext(std::optional< ContextID > ParentCtxID, llvm::StringRef Name, ContextKind Kind, const ObjCContextInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a specific Objective-C class or protocol or a C++ namespace.
void addTag(std::optional< Context > Ctx, llvm::StringRef Name, const TagInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a tag (struct/union/enum/C++ class).
Describes API notes data for any entity.
Definition: Types.h:52
unsigned UnavailableInSwift
Whether this entity is marked unavailable in Swift.
Definition: Types.h:61
unsigned Unavailable
Whether this entity is marked unavailable.
Definition: Types.h:58
std::string SwiftName
Swift name of this entity.
Definition: Types.h:72
void setSwiftPrivate(std::optional< bool > Private)
Definition: Types.h:83
std::string UnavailableMsg
Message to use when this entity is unavailable.
Definition: Types.h:55
Describes API notes for types.
Definition: Types.h:131
void setNSErrorDomain(const std::optional< std::string > &Domain)
Definition: Types.h:155
void setSwiftBridge(std::optional< std::string > SwiftType)
Definition: Types.h:147
Opaque context ID used to refer to an Objective-C class or protocol or a C++ namespace.
Definition: Types.h:745
Describes API notes data for an enumerator.
Definition: Types.h:646
API notes for a function or method.
Definition: Types.h:478
void addTypeInfo(unsigned index, NullabilityKind kind)
Definition: Types.h:520
void setRetainCountConvention(std::optional< RetainCountConventionKind > Value)
Definition: Types.h:560
std::vector< ParamInfo > Params
The function parameters.
Definition: Types.h:510
unsigned NumAdjustedNullable
Number of types whose nullability is encoded with the NullabilityPayload.
Definition: Types.h:494
std::string ResultType
The result type of this function, as a C type.
Definition: Types.h:507
static unsigned getMaxNullabilityIndex()
Definition: Types.h:516
unsigned NullabilityAudited
Whether the signature has been audited with respect to nullability.
Definition: Types.h:491
Describes API notes data for a global function.
Definition: Types.h:640
Describes API notes data for a global variable.
Definition: Types.h:634
Describes API notes data for an Objective-C class or protocol.
Definition: Types.h:192
void setSwiftObjCMembers(std::optional< bool > Value)
Definition: Types.h:249
void setSwiftImportAsNonGeneric(std::optional< bool > Value)
Definition: Types.h:240
void setDefaultNullability(NullabilityKind Kind)
Set the default nullability for properties and methods of this class.
Definition: Types.h:227
Describes API notes data for an Objective-C method.
Definition: Types.h:597
unsigned DesignatedInit
Whether this is a designated initializer of its class.
Definition: Types.h:600
unsigned RequiredInit
Whether this is a required initializer.
Definition: Types.h:603
Describes API notes data for an Objective-C property.
Definition: Types.h:354
void setSwiftImportAsAccessors(std::optional< bool > Value)
Definition: Types.h:367
Describes a function or method parameter.
Definition: Types.h:410
void setNoEscape(std::optional< bool > Value)
Definition: Types.h:431
void setRetainCountConvention(std::optional< RetainCountConventionKind > Value)
Definition: Types.h:442
Describes API notes data for a tag.
Definition: Types.h:652
std::optional< std::string > SwiftReleaseOp
Definition: Types.h:659
std::optional< std::string > SwiftRetainOp
Definition: Types.h:658
std::optional< std::string > SwiftImportAs
Definition: Types.h:657
std::optional< EnumExtensibilityKind > EnumExtensibility
Definition: Types.h:661
void setFlagEnum(std::optional< bool > Value)
Definition: Types.h:670
Describes API notes data for a typedef.
Definition: Types.h:713
std::optional< SwiftNewTypeKind > SwiftWrapper
Definition: Types.h:715
void setNullabilityAudited(NullabilityKind kind)
Definition: Types.h:319
void setType(const std::string &type)
Definition: Types.h:325
RetainCountConventionKind
Definition: Types.h:25
bool compileAPINotes(llvm::StringRef YAMLInput, const FileEntry *SourceFile, llvm::raw_ostream &OS, llvm::SourceMgr::DiagHandlerTy DiagHandler=nullptr, void *DiagHandlerCtxt=nullptr)
Converts API notes from YAML format to binary format.
SwiftNewTypeKind
The kind of a swift_wrapper/swift_newtype.
Definition: Types.h:43
EnumExtensibilityKind
The payload for an enum_extensibility attribute.
Definition: Types.h:36
bool parseAndDumpAPINotes(llvm::StringRef YI, llvm::raw_ostream &OS)
Parses the APINotes YAML content and writes the representation back to the specified stream.
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:329
@ Property
The type of a property.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
static void mapTopLevelItems(IO &IO, TopLevelItems &TLI)
YAML serialization mapping.
Definition: Dominators.h:30
Definition: Format.h:5226
#define false
Definition: stdbool.h:22
A temporary reference to an Objective-C selector, suitable for referencing selector data on the stack...
Definition: Types.h:771
static void mapping(IO &IO, Class &C)
static void mapping(IO &IO, EnumConstant &EC)
static void mapping(IO &IO, Function &F)
static void mapping(IO &IO, GlobalVariable &GV)
static void mapping(IO &IO, Method &M)
static void mapping(IO &IO, Module &M)
static void mapping(IO &IO, Namespace &T)
static void mapping(IO &IO, Param &P)
static void mapping(IO &IO, Property &P)
static void mapping(IO &IO, Tag &T)
static void mapping(IO &IO, Typedef &T)
static void mapping(IO &IO, Versioned &V)
static void enumeration(IO &IO, APIAvailability &AA)
static void enumeration(IO &IO, EnumConvenienceAliasKind &ECAK)
static void enumeration(IO &IO, EnumExtensibilityKind &EEK)
static void enumeration(IO &IO, FactoryAsInitKind &FIK)
static void enumeration(IO &IO, NullabilityKind &NK)
static void enumeration(IO &IO, RetainCountConventionKind &RCCK)
static void enumeration(IO &IO, SwiftNewTypeKind &SWK)