20#include "llvm/Support/VersionTuple.h"
21#include "llvm/Support/YAMLParser.h"
22#include "llvm/Support/YAMLTraits.h"
26using namespace api_notes;
29enum class APIAvailability {
40template <>
struct ScalarEnumerationTraits<APIAvailability> {
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);
53enum class MethodKind {
61template <>
struct ScalarEnumerationTraits<MethodKind> {
63 IO.enumCase(MK,
"Class", MethodKind::Class);
64 IO.enumCase(MK,
"Instance", MethodKind::Instance);
73 std::optional<bool> NoEscape =
false;
75 std::optional<RetainCountConventionKind> RetainCountConvention;
79typedef std::vector<Param> ParamsSeq;
82LLVM_YAML_IS_SEQUENCE_VECTOR(Param)
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);
95 IO.enumCase(NK,
"Scalar", NullabilityKind::Unspecified);
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);
107 IO.enumCase(RCCK,
"none", RetainCountConventionKind::None);
108 IO.enumCase(RCCK,
"CFReturnsRetained",
109 RetainCountConventionKind::CFReturnsRetained);
110 IO.enumCase(RCCK,
"CFReturnsNotRetained",
111 RetainCountConventionKind::CFReturnsNotRetained);
112 IO.enumCase(RCCK,
"NSReturnsRetained",
113 RetainCountConventionKind::NSReturnsRetained);
114 IO.enumCase(RCCK,
"NSReturnsNotRetained",
115 RetainCountConventionKind::NSReturnsNotRetained);
119template <>
struct MappingTraits<Param> {
121 IO.mapRequired(
"Position",
P.Position);
122 IO.mapOptional(
"Nullability",
P.Nullability, std::nullopt);
123 IO.mapOptional(
"RetainCountConvention",
P.RetainCountConvention);
124 IO.mapOptional(
"NoEscape",
P.NoEscape);
125 IO.mapOptional(
"Type",
P.Type, StringRef(
""));
132typedef std::vector<NullabilityKind> NullabilitySeq;
134struct AvailabilityItem {
135 APIAvailability Mode = APIAvailability::Available;
140enum class FactoryAsInitKind {
154 std::optional<NullabilityKind> NullabilityOfRet;
155 std::optional<RetainCountConventionKind> RetainCountConvention;
156 AvailabilityItem Availability;
157 std::optional<bool> SwiftPrivate;
159 FactoryAsInitKind FactoryAsInit = FactoryAsInitKind::Infer;
160 bool DesignatedInit =
false;
161 bool Required =
false;
162 StringRef ResultType;
165typedef std::vector<Method> MethodsSeq;
168LLVM_YAML_IS_SEQUENCE_VECTOR(Method)
172template <>
struct ScalarEnumerationTraits<FactoryAsInitKind> {
174 IO.enumCase(FIK,
"A", FactoryAsInitKind::Infer);
175 IO.enumCase(FIK,
"C", FactoryAsInitKind::AsClassMethod);
176 IO.enumCase(FIK,
"I", FactoryAsInitKind::AsInitializer);
180template <>
struct MappingTraits<Method> {
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, std::nullopt);
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(
""));
205 std::optional<MethodKind>
Kind;
207 AvailabilityItem Availability;
208 std::optional<bool> SwiftPrivate;
210 std::optional<bool> SwiftImportAsAccessors;
214typedef std::vector<Property> PropertiesSeq;
217LLVM_YAML_IS_SEQUENCE_VECTOR(Property)
223 IO.mapRequired(
"Name",
P.Name);
224 IO.mapOptional(
"PropertyKind",
P.Kind);
225 IO.mapOptional(
"Nullability",
P.Nullability, std::nullopt);
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(
""));
241 bool AuditedForNullability =
false;
242 AvailabilityItem Availability;
243 std::optional<bool> SwiftPrivate;
245 std::optional<StringRef> SwiftBridge;
246 std::optional<StringRef> NSErrorDomain;
247 std::optional<bool> SwiftImportAsNonGeneric;
248 std::optional<bool> SwiftObjCMembers;
250 PropertiesSeq Properties;
253typedef std::vector<Class> ClassesSeq;
256LLVM_YAML_IS_SEQUENCE_VECTOR(Class)
260template <>
struct MappingTraits<Class> {
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);
285 std::optional<NullabilityKind> NullabilityOfRet;
286 std::optional<api_notes::RetainCountConventionKind> RetainCountConvention;
287 AvailabilityItem Availability;
288 std::optional<bool> SwiftPrivate;
291 StringRef ResultType;
294typedef std::vector<Function> FunctionsSeq;
297LLVM_YAML_IS_SEQUENCE_VECTOR(Function)
301template <>
struct MappingTraits<Function> {
303 IO.mapRequired(
"Name", F.Name);
304 IO.mapOptional(
"Parameters", F.Params);
305 IO.mapOptional(
"Nullability", F.Nullability);
306 IO.mapOptional(
"NullabilityOfRet", F.NullabilityOfRet, std::nullopt);
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(
""));
320struct GlobalVariable {
323 AvailabilityItem Availability;
324 std::optional<bool> SwiftPrivate;
329typedef std::vector<GlobalVariable> GlobalVariablesSeq;
332LLVM_YAML_IS_SEQUENCE_VECTOR(GlobalVariable)
336template <>
struct MappingTraits<GlobalVariable> {
337 static void mapping(IO &IO, GlobalVariable &GV) {
338 IO.mapRequired(
"Name", GV.Name);
339 IO.mapOptional(
"Nullability", GV.Nullability, std::nullopt);
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(
""));
354 AvailabilityItem Availability;
355 std::optional<bool> SwiftPrivate;
359typedef std::vector<EnumConstant> EnumConstantsSeq;
362LLVM_YAML_IS_SEQUENCE_VECTOR(EnumConstant)
366template <>
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(
""));
381enum class EnumConvenienceAliasKind {
395template <>
struct ScalarEnumerationTraits<EnumConvenienceAliasKind> {
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);
412 AvailabilityItem Availability;
414 std::optional<bool> SwiftPrivate;
415 std::optional<StringRef> SwiftBridge;
416 std::optional<StringRef> NSErrorDomain;
417 std::optional<EnumExtensibilityKind> EnumExtensibility;
418 std::optional<bool> FlagEnum;
419 std::optional<EnumConvenienceAliasKind> EnumConvenienceKind;
422typedef std::vector<Tag> TagsSeq;
425LLVM_YAML_IS_SEQUENCE_VECTOR(Tag)
431 IO.enumCase(EEK,
"none", EnumExtensibilityKind::None);
432 IO.enumCase(EEK,
"open", EnumExtensibilityKind::Open);
433 IO.enumCase(EEK,
"closed", EnumExtensibilityKind::Closed);
437template <>
struct MappingTraits<Tag> {
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);
458 AvailabilityItem Availability;
460 std::optional<bool> SwiftPrivate;
461 std::optional<StringRef> SwiftBridge;
462 std::optional<StringRef> NSErrorDomain;
463 std::optional<SwiftNewTypeKind> SwiftType;
466typedef std::vector<Typedef> TypedefsSeq;
469LLVM_YAML_IS_SEQUENCE_VECTOR(Typedef)
475 IO.enumCase(SWK,
"none", SwiftNewTypeKind::None);
476 IO.enumCase(SWK,
"struct", SwiftNewTypeKind::Struct);
477 IO.enumCase(SWK,
"enum", SwiftNewTypeKind::Enum);
481template <>
struct MappingTraits<Typedef> {
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);
498struct TopLevelItems {
500 ClassesSeq Protocols;
501 FunctionsSeq Functions;
502 GlobalVariablesSeq Globals;
503 EnumConstantsSeq EnumConstants;
505 TypedefsSeq Typedefs;
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);
525 VersionTuple Version;
529typedef std::vector<Versioned> VersionedSeq;
532LLVM_YAML_IS_SEQUENCE_VECTOR(Versioned)
536template <>
struct MappingTraits<Versioned> {
538 IO.mapRequired(
"Version",
V.Version);
548 AvailabilityItem Availability;
549 TopLevelItems TopLevel;
550 VersionedSeq SwiftVersions;
552 std::optional<bool> SwiftInferImportAsMember;
554#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
555 LLVM_DUMP_METHOD
void dump() ;
562template <>
struct MappingTraits<
Module> {
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);
570 IO.mapOptional(
"SwiftVersions", M.SwiftVersions);
576#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
577LLVM_DUMP_METHOD
void Module::dump() {
578 llvm::yaml::Output OS(llvm::errs());
584bool parseAPINotes(StringRef YI,
Module &M, llvm::SourceMgr::DiagHandlerTy
Diag,
586 llvm::yaml::Input IS(YI,
nullptr,
Diag, DiagContext);
588 return static_cast<bool>(IS.error());
593 llvm::raw_ostream &OS) {
595 if (parseAPINotes(YI, M,
nullptr,
nullptr))
598 llvm::yaml::Output YOS(OS);
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.
Describes a module or submodule.
std::string Name
The name of this module.
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.
RetainCountConventionKind
SwiftNewTypeKind
The kind of a swift_wrapper/swift_newtype.
EnumExtensibilityKind
The payload for an enum_extensibility attribute.
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.
@ C
Languages that the frontend can parse and compile.
@ Property
The type of a property.
static void mapTopLevelItems(IO &IO, TopLevelItems &TLI)
YAML serialization mapping.
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, 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, MethodKind &MK)
static void enumeration(IO &IO, NullabilityKind &NK)
static void enumeration(IO &IO, RetainCountConventionKind &RCCK)
static void enumeration(IO &IO, SwiftNewTypeKind &SWK)