21#include "llvm/ADT/StringSet.h"
22#include "llvm/Support/SourceMgr.h"
23#include "llvm/Support/VersionTuple.h"
24#include "llvm/Support/YAMLTraits.h"
29using namespace api_notes;
32enum class APIAvailability {
41template <>
struct ScalarEnumerationTraits<APIAvailability> {
43 IO.enumCase(AA,
"none", APIAvailability::None);
44 IO.enumCase(AA,
"nonswift", APIAvailability::NonSwift);
45 IO.enumCase(AA,
"available", APIAvailability::Available);
52enum class MethodKind {
60template <>
struct ScalarEnumerationTraits<MethodKind> {
62 IO.enumCase(MK,
"Class", MethodKind::Class);
63 IO.enumCase(MK,
"Instance", MethodKind::Instance);
72 std::optional<bool> NoEscape =
false;
74 std::optional<RetainCountConventionKind> RetainCountConvention;
78typedef std::vector<Param> ParamsSeq;
81LLVM_YAML_IS_SEQUENCE_VECTOR(Param)
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);
94 IO.enumCase(NK,
"Scalar", NullabilityKind::Unspecified);
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);
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);
118template <>
struct MappingTraits<Param> {
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(
""));
131typedef std::vector<NullabilityKind> NullabilitySeq;
133struct AvailabilityItem {
134 APIAvailability Mode = APIAvailability::Available;
139enum class FactoryAsInitKind {
153 std::optional<NullabilityKind> NullabilityOfRet;
154 std::optional<RetainCountConventionKind> RetainCountConvention;
155 AvailabilityItem Availability;
156 std::optional<bool> SwiftPrivate;
158 FactoryAsInitKind FactoryAsInit = FactoryAsInitKind::Infer;
159 bool DesignatedInit =
false;
161 StringRef ResultType;
164typedef std::vector<Method> MethodsSeq;
167LLVM_YAML_IS_SEQUENCE_VECTOR(Method)
171template <>
struct ScalarEnumerationTraits<FactoryAsInitKind> {
173 IO.enumCase(FIK,
"A", FactoryAsInitKind::Infer);
174 IO.enumCase(FIK,
"C", FactoryAsInitKind::AsClassMethod);
175 IO.enumCase(FIK,
"I", FactoryAsInitKind::AsInitializer);
179template <>
struct MappingTraits<Method> {
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(
""));
204 std::optional<MethodKind>
Kind;
206 AvailabilityItem Availability;
207 std::optional<bool> SwiftPrivate;
209 std::optional<bool> SwiftImportAsAccessors;
213typedef std::vector<Property> PropertiesSeq;
216LLVM_YAML_IS_SEQUENCE_VECTOR(Property)
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(
""));
240 bool AuditedForNullability =
false;
241 AvailabilityItem Availability;
242 std::optional<bool> SwiftPrivate;
244 std::optional<StringRef> SwiftBridge;
245 std::optional<StringRef> NSErrorDomain;
246 std::optional<bool> SwiftImportAsNonGeneric;
247 std::optional<bool> SwiftObjCMembers;
249 PropertiesSeq Properties;
252typedef std::vector<Class> ClassesSeq;
255LLVM_YAML_IS_SEQUENCE_VECTOR(Class)
259template <>
struct MappingTraits<
Class> {
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);
284 std::optional<NullabilityKind> NullabilityOfRet;
285 std::optional<api_notes::RetainCountConventionKind> RetainCountConvention;
286 AvailabilityItem Availability;
287 std::optional<bool> SwiftPrivate;
290 StringRef ResultType;
293typedef std::vector<Function> FunctionsSeq;
296LLVM_YAML_IS_SEQUENCE_VECTOR(Function)
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(
""));
319struct GlobalVariable {
322 AvailabilityItem Availability;
323 std::optional<bool> SwiftPrivate;
328typedef std::vector<GlobalVariable> GlobalVariablesSeq;
331LLVM_YAML_IS_SEQUENCE_VECTOR(GlobalVariable)
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(
""));
353 AvailabilityItem Availability;
354 std::optional<bool> SwiftPrivate;
358typedef std::vector<EnumConstant> EnumConstantsSeq;
361LLVM_YAML_IS_SEQUENCE_VECTOR(EnumConstant)
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(
""));
380enum class EnumConvenienceAliasKind {
394template <>
struct ScalarEnumerationTraits<EnumConvenienceAliasKind> {
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);
410typedef std::vector<Tag> TagsSeq;
414 AvailabilityItem Availability;
416 std::optional<bool> SwiftPrivate;
417 std::optional<StringRef> SwiftBridge;
418 std::optional<StringRef> NSErrorDomain;
419 std::optional<std::string> SwiftImportAs;
420 std::optional<std::string> SwiftRetainOp;
421 std::optional<std::string> SwiftReleaseOp;
422 std::optional<EnumExtensibilityKind> EnumExtensibility;
423 std::optional<bool> FlagEnum;
424 std::optional<EnumConvenienceAliasKind> EnumConvenienceKind;
425 std::optional<bool> SwiftCopyable;
426 FunctionsSeq Methods;
434LLVM_YAML_IS_SEQUENCE_VECTOR(Tag)
440 IO.enumCase(EEK,
"none", EnumExtensibilityKind::None);
441 IO.enumCase(EEK,
"open", EnumExtensibilityKind::Open);
442 IO.enumCase(EEK,
"closed", EnumExtensibilityKind::Closed);
446template <>
struct MappingTraits<
Tag> {
448 IO.mapRequired(
"Name",
T.Name);
449 IO.mapOptional(
"Availability",
T.Availability.Mode,
450 APIAvailability::Available);
451 IO.mapOptional(
"AvailabilityMsg",
T.Availability.Msg, StringRef(
""));
452 IO.mapOptional(
"SwiftPrivate",
T.SwiftPrivate);
453 IO.mapOptional(
"SwiftName",
T.SwiftName, StringRef(
""));
454 IO.mapOptional(
"SwiftBridge",
T.SwiftBridge);
455 IO.mapOptional(
"NSErrorDomain",
T.NSErrorDomain);
456 IO.mapOptional(
"SwiftImportAs",
T.SwiftImportAs);
457 IO.mapOptional(
"SwiftReleaseOp",
T.SwiftReleaseOp);
458 IO.mapOptional(
"SwiftRetainOp",
T.SwiftRetainOp);
459 IO.mapOptional(
"EnumExtensibility",
T.EnumExtensibility);
460 IO.mapOptional(
"FlagEnum",
T.FlagEnum);
461 IO.mapOptional(
"EnumKind",
T.EnumConvenienceKind);
462 IO.mapOptional(
"SwiftCopyable",
T.SwiftCopyable);
463 IO.mapOptional(
"Methods",
T.Methods);
464 IO.mapOptional(
"Tags",
T.Tags);
473 AvailabilityItem Availability;
475 std::optional<bool> SwiftPrivate;
476 std::optional<StringRef> SwiftBridge;
477 std::optional<StringRef> NSErrorDomain;
478 std::optional<SwiftNewTypeKind> SwiftType;
481typedef std::vector<Typedef> TypedefsSeq;
484LLVM_YAML_IS_SEQUENCE_VECTOR(Typedef)
490 IO.enumCase(SWK,
"none", SwiftNewTypeKind::None);
491 IO.enumCase(SWK,
"struct", SwiftNewTypeKind::Struct);
492 IO.enumCase(SWK,
"enum", SwiftNewTypeKind::Enum);
496template <>
struct MappingTraits<Typedef> {
498 IO.mapRequired(
"Name",
T.Name);
499 IO.mapOptional(
"Availability",
T.Availability.Mode,
500 APIAvailability::Available);
501 IO.mapOptional(
"AvailabilityMsg",
T.Availability.Msg, StringRef(
""));
502 IO.mapOptional(
"SwiftPrivate",
T.SwiftPrivate);
503 IO.mapOptional(
"SwiftName",
T.SwiftName, StringRef(
""));
504 IO.mapOptional(
"SwiftBridge",
T.SwiftBridge);
505 IO.mapOptional(
"NSErrorDomain",
T.NSErrorDomain);
506 IO.mapOptional(
"SwiftWrapper",
T.SwiftType);
514typedef std::vector<Namespace> NamespacesSeq;
516struct TopLevelItems {
518 ClassesSeq Protocols;
519 FunctionsSeq Functions;
520 GlobalVariablesSeq Globals;
521 EnumConstantsSeq EnumConstants;
523 TypedefsSeq Typedefs;
524 NamespacesSeq Namespaces;
531 IO.mapOptional(
"Classes", TLI.Classes);
532 IO.mapOptional(
"Protocols", TLI.Protocols);
533 IO.mapOptional(
"Functions", TLI.Functions);
534 IO.mapOptional(
"Globals", TLI.Globals);
535 IO.mapOptional(
"Enumerators", TLI.EnumConstants);
536 IO.mapOptional(
"Tags", TLI.Tags);
537 IO.mapOptional(
"Typedefs", TLI.Typedefs);
538 IO.mapOptional(
"Namespaces", TLI.Namespaces);
546 AvailabilityItem Availability;
548 std::optional<bool> SwiftPrivate;
553LLVM_YAML_IS_SEQUENCE_VECTOR(Namespace)
559 IO.mapRequired(
"Name",
T.Name);
560 IO.mapOptional(
"Availability",
T.Availability.Mode,
561 APIAvailability::Available);
562 IO.mapOptional(
"AvailabilityMsg",
T.Availability.Msg, StringRef(
""));
563 IO.mapOptional(
"SwiftPrivate",
T.SwiftPrivate);
564 IO.mapOptional(
"SwiftName",
T.SwiftName, StringRef(
""));
573 VersionTuple Version;
577typedef std::vector<Versioned> VersionedSeq;
580LLVM_YAML_IS_SEQUENCE_VECTOR(Versioned)
584template <>
struct MappingTraits<Versioned> {
586 IO.mapRequired(
"Version",
V.Version);
596 AvailabilityItem Availability;
597 TopLevelItems TopLevel;
598 VersionedSeq SwiftVersions;
600 std::optional<bool> SwiftInferImportAsMember;
602#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
603 LLVM_DUMP_METHOD
void dump() ;
610template <>
struct MappingTraits<
Module> {
612 IO.mapRequired(
"Name", M.
Name);
613 IO.mapOptional(
"Availability", M.Availability.Mode,
614 APIAvailability::Available);
615 IO.mapOptional(
"AvailabilityMsg", M.Availability.Msg, StringRef(
""));
616 IO.mapOptional(
"SwiftInferImportAsMember", M.SwiftInferImportAsMember);
618 IO.mapOptional(
"SwiftVersions", M.SwiftVersions);
624#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
625LLVM_DUMP_METHOD
void Module::dump() {
626 llvm::yaml::Output OS(llvm::errs());
632bool parseAPINotes(StringRef YI,
Module &M, llvm::SourceMgr::DiagHandlerTy
Diag,
634 llvm::yaml::Input IS(YI,
nullptr,
Diag, DiagContext);
636 return static_cast<bool>(IS.error());
641 llvm::raw_ostream &OS) {
643 if (parseAPINotes(YI, M,
nullptr,
nullptr))
646 llvm::yaml::Output YOS(OS);
653using namespace api_notes;
658 llvm::raw_ostream &OS;
659 llvm::SourceMgr::DiagHandlerTy DiagHandler;
660 void *DiagHandlerCtxt;
664 bool emitError(llvm::Twine Message) {
666 llvm::SMDiagnostic(
"", llvm::SourceMgr::DK_Error, Message.str()),
674 llvm::raw_ostream &OS,
675 llvm::SourceMgr::DiagHandlerTy DiagHandler,
676 void *DiagHandlerCtxt)
677 : M(TheModule), Writer(TheModule.Name, SourceFile), OS(OS),
678 DiagHandler(DiagHandler), DiagHandlerCtxt(DiagHandlerCtxt),
679 ErrorOccured(
false) {}
681 void convertAvailability(
const AvailabilityItem &Availability,
684 CEI.
Unavailable = (Availability.Mode == APIAvailability::None);
689 if (!Availability.Msg.empty())
690 emitError(llvm::Twine(
"availability message for available API '") +
691 APIName +
"' will not be used");
695 void convertParams(
const ParamsSeq &Params,
FunctionInfo &OutInfo) {
696 for (
const auto &
P : Params) {
703 if (OutInfo.
Params.size() <=
P.Position)
704 OutInfo.
Params.resize(
P.Position + 1);
705 OutInfo.
Params[
P.Position] |= PI;
709 void convertNullability(
const NullabilitySeq &Nullability,
710 std::optional<NullabilityKind> ReturnNullability,
713 emitError(llvm::Twine(
"nullability info for '") + APIName +
718 bool audited =
false;
719 unsigned int idx = 1;
720 for (
const auto &N : Nullability)
722 audited =
Nullability.size() > 0 || ReturnNullability;
724 OutInfo.
addTypeInfo(0, ReturnNullability ? *ReturnNullability
725 : NullabilityKind::NonNull);
733 template <
typename T>
736 convertAvailability(Common.Availability, Info, APIName);
738 Info.
SwiftName = std::string(Common.SwiftName);
742 template <
typename T>
745 convertCommonEntity(Common, Info, APIName);
746 if (Common.SwiftBridge)
752 void convertMethod(
const Method &M,
ContextID ClassID, StringRef ClassName,
753 VersionTuple SwiftVersion) {
755 convertCommonEntity(M, MI, M.Selector);
758 bool takesArguments = M.Selector.ends_with(
":");
762 M.Selector.split(Args,
":", -1,
false);
763 if (!takesArguments && Args.size() > 1) {
764 emitError(
"selector '" + M.Selector +
"' is missing a ':' at the end");
770 Selector.NumArgs = !takesArguments ? 0 : Args.size();
776 if (M.FactoryAsInit != FactoryAsInitKind::Infer)
777 emitError(
"'FactoryAsInit' is no longer valid; use 'SwiftName' instead");
782 convertParams(M.Params, MI);
785 convertNullability(M.Nullability, M.NullabilityOfRet, MI, M.Selector);
794 void convertContext(std::optional<ContextID> ParentContextID,
const Class &
C,
798 convertCommonType(
C, CI,
C.Name);
800 if (
C.AuditedForNullability)
802 if (
C.SwiftImportAsNonGeneric)
804 if (
C.SwiftObjCMembers)
811 llvm::StringMap<std::pair<bool, bool>> KnownMethods;
812 for (
const auto &method :
C.Methods) {
816 : KnownMethods[method.Selector].second;
818 emitError(llvm::Twine(
"duplicate definition of method '") +
819 (IsInstanceMethod ?
"-" :
"+") +
"[" +
C.Name +
" " +
820 method.Selector +
"]'");
825 convertMethod(method, CtxID,
C.Name, SwiftVersion);
829 llvm::StringSet<> KnownInstanceProperties;
830 llvm::StringSet<> KnownClassProperties;
831 for (
const auto &Property :
C.Properties) {
834 !KnownInstanceProperties.insert(
Property.Name).second) {
835 emitError(llvm::Twine(
"duplicate definition of instance property '") +
841 !KnownClassProperties.insert(
Property.Name).second) {
842 emitError(llvm::Twine(
"duplicate definition of class property '") +
854 if (
Property.SwiftImportAsAccessors)
861 *
Property.Kind == MethodKind::Instance, PI,
870 void convertNamespaceContext(std::optional<ContextID> ParentContextID,
871 const Namespace &TheNamespace,
872 VersionTuple SwiftVersion) {
875 convertCommonEntity(TheNamespace, CI, TheNamespace.Name);
878 Writer.
addContext(ParentContextID, TheNamespace.Name,
879 ContextKind::Namespace, CI, SwiftVersion);
881 convertTopLevelItems(
Context(CtxID, ContextKind::Namespace),
882 TheNamespace.Items, SwiftVersion);
885 void convertFunction(
const Function &Function,
FunctionInfo &FI) {
896 void convertTagContext(std::optional<Context> ParentContext,
const Tag &
T,
897 VersionTuple SwiftVersion) {
899 std::optional<ContextID> ParentContextID =
900 ParentContext ? std::optional<ContextID>(ParentContext->id)
902 convertCommonType(
T, TI,
T.Name);
904 if ((
T.SwiftRetainOp ||
T.SwiftReleaseOp) && !
T.SwiftImportAs) {
905 emitError(llvm::Twine(
"should declare SwiftImportAs to use "
906 "SwiftRetainOp and SwiftReleaseOp (for ") +
910 if (
T.SwiftReleaseOp.has_value() !=
T.SwiftRetainOp.has_value()) {
911 emitError(llvm::Twine(
"should declare both SwiftReleaseOp and "
912 "SwiftRetainOp (for ") +
921 if (
T.SwiftReleaseOp)
927 if (
T.EnumConvenienceKind) {
928 if (
T.EnumExtensibility) {
930 llvm::Twine(
"cannot mix EnumKind and EnumExtensibility (for ") +
935 emitError(llvm::Twine(
"cannot mix EnumKind and FlagEnum (for ") +
939 switch (*
T.EnumConvenienceKind) {
940 case EnumConvenienceAliasKind::None:
944 case EnumConvenienceAliasKind::CFEnum:
948 case EnumConvenienceAliasKind::CFOptions:
952 case EnumConvenienceAliasKind::CFClosedEnum:
962 Writer.
addTag(ParentContext,
T.Name, TI, SwiftVersion);
965 auto TagCtxID = Writer.
addContext(ParentContextID,
T.Name, ContextKind::Tag,
967 Context TagCtx(TagCtxID, ContextKind::Tag);
969 for (
const auto &CXXMethod :
T.Methods) {
971 convertFunction(CXXMethod, MI);
972 Writer.
addCXXMethod(TagCtxID, CXXMethod.Name, MI, SwiftVersion);
976 for (
const auto &Tag :
T.Tags)
977 convertTagContext(TagCtx, Tag, SwiftVersion);
980 void convertTopLevelItems(std::optional<Context> Ctx,
981 const TopLevelItems &TLItems,
982 VersionTuple SwiftVersion) {
983 std::optional<ContextID> CtxID =
984 Ctx ? std::optional(Ctx->id) :
std::nullopt;
987 llvm::StringSet<> KnownClasses;
988 for (
const auto &Class : TLItems.Classes) {
990 if (!KnownClasses.insert(
Class.Name).second) {
991 emitError(llvm::Twine(
"multiple definitions of class '") +
Class.Name +
996 convertContext(CtxID, Class, ContextKind::ObjCClass, SwiftVersion);
1000 llvm::StringSet<> KnownProtocols;
1001 for (
const auto &Protocol : TLItems.Protocols) {
1003 if (!KnownProtocols.insert(
Protocol.Name).second) {
1004 emitError(llvm::Twine(
"multiple definitions of protocol '") +
1009 convertContext(CtxID, Protocol, ContextKind::ObjCProtocol, SwiftVersion);
1013 llvm::StringSet<> KnownNamespaces;
1014 for (
const auto &Namespace : TLItems.Namespaces) {
1016 if (!KnownNamespaces.insert(
Namespace.Name).second) {
1017 emitError(llvm::Twine(
"multiple definitions of namespace '") +
1022 convertNamespaceContext(CtxID, Namespace, SwiftVersion);
1026 llvm::StringSet<> KnownGlobals;
1027 for (
const auto &
Global : TLItems.Globals) {
1029 if (!KnownGlobals.insert(
Global.Name).second) {
1030 emitError(llvm::Twine(
"multiple definitions of global variable '") +
1036 convertAvailability(
Global.Availability, GVI,
Global.Name);
1046 llvm::StringSet<> KnownFunctions;
1047 for (
const auto &Function : TLItems.Functions) {
1049 if (!KnownFunctions.insert(
Function.Name).second) {
1050 emitError(llvm::Twine(
"multiple definitions of global function '") +
1056 convertFunction(Function, GFI);
1061 llvm::StringSet<> KnownEnumConstants;
1062 for (
const auto &EnumConstant : TLItems.EnumConstants) {
1064 if (!KnownEnumConstants.insert(
EnumConstant.Name).second) {
1065 emitError(llvm::Twine(
"multiple definitions of enumerator '") +
1078 llvm::StringSet<> KnownTags;
1079 for (
const auto &Tag : TLItems.Tags) {
1081 if (!KnownTags.insert(
Tag.Name).second) {
1082 emitError(llvm::Twine(
"multiple definitions of tag '") +
Tag.Name +
1087 convertTagContext(Ctx, Tag, SwiftVersion);
1091 llvm::StringSet<> KnownTypedefs;
1092 for (
const auto &Typedef : TLItems.Typedefs) {
1094 if (!KnownTypedefs.insert(Typedef.Name).second) {
1095 emitError(llvm::Twine(
"multiple definitions of typedef '") +
1096 Typedef.Name +
"'");
1101 convertCommonType(Typedef, TInfo, Typedef.Name);
1104 Writer.
addTypedef(Ctx, Typedef.Name, TInfo, SwiftVersion);
1108 bool convertModule() {
1110 convertTopLevelItems( std::nullopt, M.TopLevel,
1114 for (
const auto &Versioned : M.SwiftVersions)
1115 convertTopLevelItems( std::nullopt, Versioned.Items,
1121 return ErrorOccured;
1127 llvm::raw_ostream &OS,
1128 llvm::SourceMgr::DiagHandlerTy DiagHandler,
1129 void *DiagHandlerCtxt) {
1130 YAMLConverter
C(M, SourceFile, OS, DiagHandler, DiagHandlerCtxt);
1131 return C.convertModule();
1136 Diag.print(
nullptr, llvm::errs());
1141 llvm::raw_ostream &OS,
1142 llvm::SourceMgr::DiagHandlerTy DiagHandler,
1143 void *DiagHandlerCtxt) {
1149 if (parseAPINotes(YAMLInput, TheModule, DiagHandler, DiagHandlerCtxt))
1152 return compile(TheModule, SourceFile, OS, DiagHandler, DiagHandlerCtxt);
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)
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
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).
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.
A class that writes API notes data to a binary representation that can be read by the APINotesReader.
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.
ContextID addContext(std::optional< ContextID > ParentCtxID, llvm::StringRef Name, ContextKind Kind, const ContextInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a specific Objective-C class or protocol or a C++ namespace.
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)
void addCXXMethod(ContextID CtxID, llvm::StringRef Name, const CXXMethodInfo &Info, llvm::VersionTuple SwiftVersion)
Add information about a specific C++ method.
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 a C++ method.
Describes API notes data for any entity.
unsigned UnavailableInSwift
Whether this entity is marked unavailable in Swift.
unsigned Unavailable
Whether this entity is marked unavailable.
std::string SwiftName
Swift name of this entity.
void setSwiftPrivate(std::optional< bool > Private)
std::string UnavailableMsg
Message to use when this entity is unavailable.
Describes API notes for types.
void setNSErrorDomain(const std::optional< std::string > &Domain)
void setSwiftBridge(std::optional< std::string > SwiftType)
Opaque context ID used to refer to an Objective-C class or protocol or a C++ namespace.
Describes API notes data for an Objective-C class or protocol or a C++ namespace.
void setDefaultNullability(NullabilityKind Kind)
Set the default nullability for properties and methods of this class.
void setSwiftObjCMembers(std::optional< bool > Value)
void setSwiftImportAsNonGeneric(std::optional< bool > Value)
Describes API notes data for an enumerator.
API notes for a function or method.
void addTypeInfo(unsigned index, NullabilityKind kind)
void setRetainCountConvention(std::optional< RetainCountConventionKind > Value)
std::vector< ParamInfo > Params
The function parameters.
unsigned NumAdjustedNullable
Number of types whose nullability is encoded with the NullabilityPayload.
std::string ResultType
The result type of this function, as a C type.
static unsigned getMaxNullabilityIndex()
unsigned NullabilityAudited
Whether the signature has been audited with respect to nullability.
Describes API notes data for a global function.
Describes API notes data for a global variable.
Describes API notes data for an Objective-C method.
unsigned DesignatedInit
Whether this is a designated initializer of its class.
unsigned RequiredInit
Whether this is a required initializer.
Describes API notes data for an Objective-C property.
void setSwiftImportAsAccessors(std::optional< bool > Value)
Describes a function or method parameter.
void setNoEscape(std::optional< bool > Value)
void setRetainCountConvention(std::optional< RetainCountConventionKind > Value)
Describes API notes data for a tag.
std::optional< std::string > SwiftReleaseOp
std::optional< std::string > SwiftRetainOp
std::optional< std::string > SwiftImportAs
std::optional< EnumExtensibilityKind > EnumExtensibility
void setSwiftCopyable(std::optional< bool > Value)
void setFlagEnum(std::optional< bool > Value)
Describes API notes data for a typedef.
std::optional< SwiftNewTypeKind > SwiftWrapper
void setNullabilityAudited(NullabilityKind kind)
void setType(const std::string &type)
RetainCountConventionKind
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.
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.
The JSON file list parser is used to communicate input to InstallAPI.
NullabilityKind
Describes the nullability of a particular type.
@ Property
The type of a property.
const FunctionProtoType * T
@ Class
The "class" keyword introduces the elaborated-type-specifier.
static void mapTopLevelItems(IO &IO, TopLevelItems &TLI)
Diagnostic wrappers for TextAPI types for error reporting.
A temporary reference to an Objective-C selector, suitable for referencing selector data on the stack...
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, MethodKind &MK)
static void enumeration(IO &IO, NullabilityKind &NK)
static void enumeration(IO &IO, RetainCountConventionKind &RCCK)
static void enumeration(IO &IO, SwiftNewTypeKind &SWK)