20 #include "llvm/Support/VersionTuple.h"
21 #include "llvm/Support/YAMLParser.h"
22 #include "llvm/Support/YAMLTraits.h"
25 using namespace clang;
26 using namespace api_notes;
29 enum class APIAvailability {
40 template <>
struct ScalarEnumerationTraits<APIAvailability> {
42 IO.enumCase(AA,
"OSX", APIAvailability::OSX);
43 IO.enumCase(AA,
"iOS", APIAvailability::IOS);
45 IO.enumCase(AA,
"nonswift", APIAvailability::NonSwift);
46 IO.enumCase(AA,
"available", APIAvailability::Available);
53 enum class MethodKind {
61 template <>
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;
79 typedef std::vector<Param> ParamsSeq;
82 LLVM_YAML_IS_SEQUENCE_VECTOR(Param)
108 IO.enumCase(RCCK,
"CFReturnsRetained",
110 IO.enumCase(RCCK,
"CFReturnsNotRetained",
112 IO.enumCase(RCCK,
"NSReturnsRetained",
114 IO.enumCase(RCCK,
"NSReturnsNotRetained",
119 template <>
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(
""));
132 typedef std::vector<NullabilityKind> NullabilitySeq;
134 struct AvailabilityItem {
135 APIAvailability Mode = APIAvailability::Available;
140 enum 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;
165 typedef std::vector<Method> MethodsSeq;
168 LLVM_YAML_IS_SEQUENCE_VECTOR(Method)
172 template <>
struct ScalarEnumerationTraits<FactoryAsInitKind> {
174 IO.enumCase(FIK,
"A", FactoryAsInitKind::Infer);
175 IO.enumCase(FIK,
"C", FactoryAsInitKind::AsClassMethod);
176 IO.enumCase(FIK,
"I", FactoryAsInitKind::AsInitializer);
180 template <>
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;
214 typedef std::vector<Property> PropertiesSeq;
217 LLVM_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;
253 typedef std::vector<Class> ClassesSeq;
256 LLVM_YAML_IS_SEQUENCE_VECTOR(Class)
260 template <>
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;
294 typedef std::vector<Function> FunctionsSeq;
297 LLVM_YAML_IS_SEQUENCE_VECTOR(Function)
301 template <>
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(
""));
320 struct GlobalVariable {
323 AvailabilityItem Availability;
324 std::optional<bool> SwiftPrivate;
329 typedef std::vector<GlobalVariable> GlobalVariablesSeq;
332 LLVM_YAML_IS_SEQUENCE_VECTOR(GlobalVariable)
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, 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;
359 typedef std::vector<EnumConstant> EnumConstantsSeq;
362 LLVM_YAML_IS_SEQUENCE_VECTOR(EnumConstant)
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(
""));
381 enum class EnumConvenienceAliasKind {
395 template <>
struct ScalarEnumerationTraits<EnumConvenienceAliasKind> {
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;
422 typedef std::vector<Tag> TagsSeq;
425 LLVM_YAML_IS_SEQUENCE_VECTOR(Tag)
437 template <>
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;
466 typedef std::vector<Typedef> TypedefsSeq;
469 LLVM_YAML_IS_SEQUENCE_VECTOR(Typedef)
481 template <>
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);
498 struct 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;
529 typedef std::vector<Versioned> VersionedSeq;
532 LLVM_YAML_IS_SEQUENCE_VECTOR(Versioned)
536 template <>
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() ;
562 template <>
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)
578 llvm::yaml::Output OS(llvm::errs());
584 bool 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);