move PrintAsClang macro definitions into a separate file

Author: QuietMisdreavus

lib/PrintAsClang/ClangMacros.def

@@ -0,0 +1,233 @@
+//===--- ClangMacros.def - Macros emitted by PrintAsClang ----=--*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the database of macros emitted into compatibility headers
+// generated by PrintAsClang.
+//
+//===----------------------------------------------------------------------===//
+
+// CLANG_MACRO(NAME, ARGS, VALUE)
+// A simple name/value macro that does not depend on a condition.
+#ifndef CLANG_MACRO
+#define CLANG_MACRO(NAME, ARGS, VALUE)
+#endif
+
+// CLANG_MACRO_BODY(NAME, BODY)
+// A macro conditionalized on the name, but that defines a helper macro or
+// other kind of additional definitions other than the macro itself.
+#ifndef CLANG_MACRO_BODY
+#define CLANG_MACRO_BODY(NAME, BODY)
+#endif
+
+// CLANG_MACRO_DEFINED(NAME)
+// Used to signal that a macro is defined by another CLANG_MACRO_BODY call.
+// This is included so that these macros can be included in the generated
+// `compatibility_symbols` file.
+#ifndef CLANG_MACRO_DEFINED
+#define CLANG_MACRO_DEFINED(NAME)
+#endif
+
+// CLANG_MACRO_ALTERNATIVE(NAME, ARGS, CONDITION, VALUE, ALTERNATIVE)
+// A simple name/value macro that evaluates to the given value when the given
+// condition is true, or to the alternative value when it is false.
+#ifndef CLANG_MACRO_ALTERNATIVE
+#define CLANG_MACRO_ALTERNATIVE(NAME, ARGS, CONDITION, VALUE, ALTERNATIVE)
+#endif
+
+// CLANG_MACRO_CONDITIONAL(NAME, ARGS, CONDITION, VALUE)
+// A simple name/value macro that only evaluates to the given value when the
+// given condition is true. Otherwise the macro will evaluate to nothing.
+#ifndef CLANG_MACRO_CONDITIONAL
+#define CLANG_MACRO_CONDITIONAL(NAME, ARGS, CONDITION, VALUE) \
+    CLANG_MACRO_ALTERNATIVE(NAME, ARGS, CONDITION, VALUE, )
+#endif
+
+// CLANG_MACRO_OBJC(NAME, ARGS, VALUE)
+// A simple name/value macro that is only defined when being compiled as
+// Objective-C.
+#ifndef CLANG_MACRO_OBJC
+#define CLANG_MACRO_OBJC(NAME, ARGS, VALUE)
+#endif
+
+// CLANG_MACRO_CXX(NAME, ARGS, VALUE, ALTERNATIVE)
+// A simple name/value macro that evaluates to the given value when being
+// compiled as C++, or as the alternative when not.
+#ifndef CLANG_MACRO_CXX
+#define CLANG_MACRO_CXX(NAME, ARGS, VALUE, ALTERNATIVE)
+#endif
+
+// CLANG_MACRO_CXX_BODY(NAME, BODY)
+// A complex macro conditionalized on whether the source is being compiled as
+// C++.
+#ifndef CLANG_MACRO_CXX_BODY
+#define CLANG_MACRO_CXX_BODY(NAME, BODY)
+#endif
+
+CLANG_MACRO_BODY(SWIFT_PASTE, \
+    "# define SWIFT_PASTE_HELPER(x, y) x##y\n" \
+    "# define SWIFT_PASTE(x, y) SWIFT_PASTE_HELPER(x, y)")
+CLANG_MACRO_DEFINED(SWIFT_PASTE_HELPER)
+
+CLANG_MACRO(SWIFT_METATYPE, (X), Class)
+
+CLANG_MACRO_CONDITIONAL(SWIFT_CLASS_PROPERTY, \
+                        (...), \
+                        __has_feature(objc_class_property), \
+                        __VA_ARGS__)
+
+CLANG_MACRO_CONDITIONAL(SWIFT_RUNTIME_NAME, \
+                        (X), \
+                        __has_attribute(objc_runtime_name), \
+                        __attribute__((objc_runtime_name(X))))
+
+CLANG_MACRO_CONDITIONAL(SWIFT_COMPILE_NAME, \
+                        (X), \
+                        __has_attribute(swift_name), \
+                        __attribute__((swift_name(X))))
+
+CLANG_MACRO_CONDITIONAL(SWIFT_METHOD_FAMILY, \
+                        (X), \
+                        __has_attribute(objc_method_family),
+                        __attribute__((objc_method_family(X))))
+
+CLANG_MACRO_CONDITIONAL(SWIFT_NOESCAPE, , \
+                        __has_attribute(noescape), \
+                        __attribute__((noescape)))
+
+CLANG_MACRO_CONDITIONAL(SWIFT_RELEASES_ARGUMENT, , \
+                        __has_attribute(ns_consumed), \
+                        __attribute__((ns_consumed)))
+
+CLANG_MACRO_CONDITIONAL(SWIFT_WARN_UNUSED_RESULT, , \
+                        __has_attribute(warn_unused_result), \
+                        __attribute__((warn_unused_result)))
+
+// While this would ordinarily work with CLANG_MACRO_CONDITIONAL, this name is
+// defined in the compiler source itself, and is expanded by the time the macro
+// is printed into the resulting header
+CLANG_MACRO_BODY(SWIFT_NORETURN, \
+    "# if __has_attribute(noreturn)\n" \
+    "#  define SWIFT_NORETURN __attribute((noreturn))\n" \
+    "# else\n" \
+    "#  define SWIFT_NORETURN\n" \
+    "# endif")
+
+CLANG_MACRO(SWIFT_CLASS_EXTRA, , )
+CLANG_MACRO(SWIFT_PROTOCOL_EXTRA, , )
+CLANG_MACRO(SWIFT_ENUM_EXTRA, , )
+
+CLANG_MACRO_BODY(SWIFT_CLASS, \
+    "# if __has_attribute(objc_subclassing_restricted)\n" \
+    "#  define SWIFT_CLASS(SWIFT_NAME) " \
+        "SWIFT_RUNTIME_NAME(SWIFT_NAME) __attribute__((objc_subclassing_restricted)) " \
+        "SWIFT_CLASS_EXTRA\n" \
+    "#  define SWIFT_CLASS_NAMED(SWIFT_NAME) " \
+        "__attribute((objc_subclassing_restricted)) SWIFT_COMPILE_NAME(SWIFT_NAME) " \
+        "SWIFT_CLASS_EXTRA\n" \
+    "# else\n" \
+    "#  define SWIFT_CLASS(SWIFT_NAME) " \
+        "SWIFT_RUNTIME_NAME(SWIFT_NAME) SWIFT_CLASS_EXTRA\n" \
+    "#  define SWIFT_CLASS_NAMED(SWIFT_NAME) " \
+        "SWIFT_COMPILE_NAME(SWIFT_NAME) SWIFT_CLASS_EXTRA\n" \
+    "# endif")
+CLANG_MACRO_DEFINED(SWIFT_CLASS_NAMED)
+
+CLANG_MACRO_BODY(SWIFT_RESILIENT_CLASS, \
+    "# if __has_attribute(objc_class_stub)\n" \
+    "#  define SWIFT_RESILIENT_CLASS(SWIFT_NAME) " \
+        "SWIFT_CLASS(SWIFT_NAME) __attribute__((objc_class_stub))\n" \
+    "#  define SWIFT_RESILIENT_CLASS_NAMED(SWIFT_NAME) " \
+        "__attribute__((objc_class_stub)) SWIFT_CLASS_NAMED(SWIFT_NAME)\n" \
+    "# else\n" \
+    "#  define SWIFT_RESILIENT_CLASS(SWIFT_NAME) SWIFT_CLASS(SWIFT_NAME)\n" \
+    "#  define SWIFT_RESILIENT_CLASS_NAMED(SWIFT_NAME) SWIFT_CLASS_NAMED(SWIFT_NAME)\n" \
+    "# endif")
+CLANG_MACRO_DEFINED(SWIFT_RESILIENT_CLASS_NAMED)
+
+CLANG_MACRO_BODY(SWIFT_PROTOCOL, \
+    "# define SWIFT_PROTOCOL(SWIFT_NAME) " \
+        "SWIFT_RUNTIME_NAME(SWIFT_NAME) SWIFT_PROTOCOL_EXTRA\n" \
+    "# define SWIFT_PROTOCOL_NAMED(SWIFT_NAME) " \
+        "SWIFT_COMPILE_NAME(SWIFT_NAME) SWIFT_PROTOCOL_EXTRA")
+CLANG_MACRO_DEFINED(SWIFT_PROTOCOL_NAMED)
+
+CLANG_MACRO(SWIFT_EXTENSION, (M), SWIFT_PASTE(M##_Swift_, __LINE__))
+
+CLANG_MACRO_CONDITIONAL(OBJC_DESIGNATED_INITIALIZER, , \
+                        __has_attribute(objc_designated_initializer), \
+                        __attribute__((objc_designated_initializer)))
+
+CLANG_MACRO_CONDITIONAL(SWIFT_ENUM_ATTR, (_extensibility), \
+                        __has_attribute(enum_extensibility), \
+                        __attribute__((enum_extensibility(_extensibility))))
+
+CLANG_MACRO_BODY(SWIFT_ENUM, \
+    "# define SWIFT_ENUM(_type, _name, _extensibility) " \
+        "enum _name : _type _name; " \
+        "enum SWIFT_ENUM_ATTR(_extensibility) SWIFT_ENUM_EXTRA _name: _type\n" \
+    "# if __has_feature(generalized_swift_name)\n" \
+    "#  define SWIFT_ENUM_NAMED(_type, _name, SWIFT_NAME, _extensibility) " \
+        "enum _name : _type _name SWIFT_COMPILE_NAME(SWIFT_NAME); " \
+        "enum SWIFT_COMPILE_NAME(SWIFT_NAME) SWIFT_ENUM_ATTR(_extensibility) " \
+            "SWIFT_ENUM_EXTRA _name : _type\n" \
+    "# else\n" \
+    "#  define SWIFT_ENUM_NAMED(_type, _name, SWIFT_NAME, _extensibility) " \
+        "SWIFT_ENUM(_type, _name, _extensibility)\n" \
+    "# endif")
+
+CLANG_MACRO(SWIFT_UNAVAILABLE, , __attribute__((unavailable)))
+CLANG_MACRO(SWIFT_UNAVAILABLE_MSG, (msg), __attribute__((unavailable(msg))))
+
+CLANG_MACRO(SWIFT_AVAILABILITY, (plat, ...), __attribute__((availability(plat, __VA_ARGS__))))
+
+// SWIFT_WEAK_IMPORT is also defined within the compiler source, so use CLANG_MACRO_BODY to avoid
+// being expanded before being emitted into the header
+CLANG_MACRO_BODY(SWIFT_WEAK_IMPORT, "# define SWIFT_WEAK_IMPORT __attribute__((weak_import))")
+
+CLANG_MACRO(SWIFT_DEPRECATED, , __attribute__((deprecated)))
+CLANG_MACRO(SWIFT_DEPRECATED_MSG, (...), __attribute__((deprecated(__VA_ARGS__))))
+
+CLANG_MACRO_ALTERNATIVE(SWIFT_DEPRECATED_OBJC, (Msg), \
+                        __has_feature(attribute_diagnost_if_objc), \
+                        __attribute__((diagnose_if(1, Msg, "warning"))), \
+                        SWIFT_DEPRECATED_MSG(Msg))
+
+CLANG_MACRO_OBJC(IBSegueAction, , )
+
+CLANG_MACRO_BODY(SWIFT_EXTERN, \
+    "# if defined(__cplusplus)\n" \
+    "#  define SWIFT_EXTERN extern \"C\"\n" \
+    "# else\n" \
+    "#  define SWIFT_EXTERN extern\n"
+    "# endif")
+
+CLANG_MACRO(SWIFT_CALL, , __attribute__((swiftcall)))
+
+CLANG_MACRO_CXX(SWIFT_NOEXCEPT, , noexcept, )
+
+CLANG_MACRO_CXX_BODY(SWIFT_CXX_INT_DEFINED, \
+    "#if !defined(SWIFT_CXX_INT_DEFINED)\n" \
+    "#define SWIFT_CXX_INT_DEFINED\n" \
+    "namespace swift {\n" \
+    "using Int = ptrdiff_t;\n" \
+    "using UInt = size_t;\n" \
+    "}\n" \
+    "#endif")
+
+#undef CLANG_MACRO
+#undef CLANG_MACRO_BODY
+#undef CLANG_MACRO_DEFINED
+#undef CLANG_MACRO_ALTERNATIVE
+#undef CLANG_MACRO_CONDITIONAL
+#undef CLANG_MACRO_OBJC
+#undef CLANG_MACRO_CXX
+#undef CLANG_MACRO_CXX_BODY