[Bridging] Add 'const' variations to BRIDGING_WRAPPER

Only for `AvailabilityMacroMap` for now.

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -76,12 +76,17 @@ namespace swift {
 
 // Define the bridging wrappers for each AST node.
 #define AST_BRIDGING_WRAPPER(Name) BRIDGING_WRAPPER_NONNULL(swift::Name, Name)
+#define AST_BRIDGING_WRAPPER_CONST(Name)                                       \
+  BRIDGING_WRAPPER_CONST_NONNULL(swift::Name, Name)
 #include "swift/AST/ASTBridgingWrappers.def"
 
 // For nullable nodes, also define a nullable variant.
 #define AST_BRIDGING_WRAPPER_NULLABLE(Name)                                    \
   BRIDGING_WRAPPER_NULLABLE(swift::Name, Name)
+#define AST_BRIDGING_WRAPPER_CONST_NULLABLE(Name)                              \
+  BRIDGING_WRAPPER_CONST_NULLABLE(swift::Name, Name)
 #define AST_BRIDGING_WRAPPER_NONNULL(Name)
+#define AST_BRIDGING_WRAPPER_CONST_NONNULL(Name)
 #include "swift/AST/ASTBridgingWrappers.def"
 
 //===----------------------------------------------------------------------===//

include/swift/AST/ASTBridgingWrappers.def

@@ -31,6 +31,25 @@
 #define AST_BRIDGING_WRAPPER_NONNULL(Name) AST_BRIDGING_WRAPPER(Name)
 #endif
 
+/// AST_BRIDGING_WRAPPER_CONST(Name)
+///   The default macro to define a const bridging wrapper type.
+#ifndef AST_BRIDGING_WRAPPER_CONST
+#define AST_BRIDGING_WRAPPER_CONST(Name) AST_BRIDGING_WRAPPER(Name)
+#endif
+
+/// AST_BRIDGING_WRAPPER_CONST_NULLABLE(Name)
+///   Specifies that both a nullable and non-null variant of the wrapper should
+///   be created.
+#ifndef AST_BRIDGING_WRAPPER_CONST_NULLABLE
+#define AST_BRIDGING_WRAPPER_CONST_NULLABLE(Name) AST_BRIDGING_WRAPPER_CONST(Name)
+#endif
+
+/// AST_BRIDGING_WRAPPER_CONST_NONNULL(Name)
+///   Specifies that only a non-null variant of the wrapper should be created.
+#ifndef AST_BRIDGING_WRAPPER_CONST_NONNULL
+#define AST_BRIDGING_WRAPPER_CONST_NONNULL(Name) AST_BRIDGING_WRAPPER_CONST(Name)
+#endif
+
 #ifndef DECL
 #define DECL(Id, Parent) AST_BRIDGING_WRAPPER_NULLABLE(Id##Decl)
 #endif
@@ -91,11 +110,14 @@ AST_BRIDGING_WRAPPER_NULLABLE(AvailabilitySpec)
 AST_BRIDGING_WRAPPER_NULLABLE(PlatformVersionConstraintAvailabilitySpec)
 AST_BRIDGING_WRAPPER_NULLABLE(PlatformAgnosticVersionConstraintAvailabilitySpec)
 AST_BRIDGING_WRAPPER_NULLABLE(OtherPlatformAvailabilitySpec)
-AST_BRIDGING_WRAPPER_NONNULL(AvailabilityMacroMap)
+AST_BRIDGING_WRAPPER_CONST_NONNULL(AvailabilityMacroMap)
 
 // Non-AST types to generate wrappers for.
 AST_BRIDGING_WRAPPER_NULLABLE(DiagnosticEngine)
 
 #undef AST_BRIDGING_WRAPPER_NONNULL
 #undef AST_BRIDGING_WRAPPER_NULLABLE
+#undef AST_BRIDGING_WRAPPER_CONST_NONNULL
+#undef AST_BRIDGING_WRAPPER_CONST_NULLABLE
+#undef AST_BRIDGING_WRAPPER_CONST
 #undef AST_BRIDGING_WRAPPER

include/swift/AST/AvailabilitySpec.h

@@ -254,7 +254,7 @@ class AvailabilityMacroMap {
   }
 
   ArrayRef<AvailabilitySpec *> getEntry(StringRef name,
-                                        llvm::VersionTuple version) {
+                                        llvm::VersionTuple version) const {
     auto versions = Impl.find(name);
     if (versions == Impl.end()) {
       return {};

include/swift/Basic/BasicBridging.h

@@ -100,34 +100,42 @@ typedef uintptr_t SwiftUInt;
 // and Swift could import the underlying pointee type instead. We need to be
 // careful that the interface we expose remains consistent regardless of
 // PURE_BRIDGING_MODE.
-#define BRIDGING_WRAPPER_IMPL(Node, Name, Nullability)                         \
+#define BRIDGING_WRAPPER_IMPL(Node, Name, Qualifier, Nullability)              \
   class Bridged##Name {                                                        \
-    Node * Nullability Ptr;                                                    \
+    Qualifier Node *Nullability Ptr;                                           \
                                                                                \
   public:                                                                      \
     SWIFT_UNAVAILABLE("Use init(raw:) instead")                                \
-    Bridged##Name(Node * Nullability ptr) : Ptr(ptr) {}                        \
+    Bridged##Name(Qualifier Node *Nullability ptr) : Ptr(ptr) {}               \
                                                                                \
     SWIFT_UNAVAILABLE("Use '.raw' instead")                                    \
-    Node * Nullability unbridged() const { return Ptr; }                       \
+    Qualifier Node *Nullability unbridged() const { return Ptr; }              \
   };                                                                           \
                                                                                \
   SWIFT_NAME("getter:Bridged" #Name ".raw(self:)")                             \
-  inline void * Nullability Bridged##Name##_getRaw(Bridged##Name bridged) {    \
+  inline Qualifier void *Nullability Bridged##Name##_getRaw(                   \
+      Bridged##Name bridged) {                                                 \
     return bridged.unbridged();                                                \
   }                                                                            \
                                                                                \
   SWIFT_NAME("Bridged" #Name ".init(raw:)")                                    \
-  inline Bridged##Name Bridged##Name##_fromRaw(void * Nullability ptr) {       \
-    return static_cast<Node *>(ptr);                                           \
+  inline Bridged##Name Bridged##Name##_fromRaw(                                \
+      Qualifier void *Nullability ptr) {                                       \
+    return static_cast<Qualifier Node *>(ptr);                                 \
   }
 
 // Bridging wrapper macros for convenience.
-#define BRIDGING_WRAPPER_NONNULL(Node, Name) \
-  BRIDGING_WRAPPER_IMPL(Node, Name, _Nonnull)
+#define BRIDGING_WRAPPER_NONNULL(Node, Name)                                   \
+  BRIDGING_WRAPPER_IMPL(Node, Name, /*unqualified*/, _Nonnull)
 
-#define BRIDGING_WRAPPER_NULLABLE(Node, Name) \
-  BRIDGING_WRAPPER_IMPL(Node, Nullable##Name, _Nullable)
+#define BRIDGING_WRAPPER_NULLABLE(Node, Name)                                  \
+  BRIDGING_WRAPPER_IMPL(Node, Nullable##Name, /*unqualified*/, _Nullable)
+
+#define BRIDGING_WRAPPER_CONST_NONNULL(Node, Name)                             \
+  BRIDGING_WRAPPER_IMPL(Node, Name, const, _Nonnull)
+
+#define BRIDGING_WRAPPER_CONST_NULLABLE(Node, Name)                            \
+  BRIDGING_WRAPPER_IMPL(Node, Nullable##Name, const, _Nullable)
 
 void assertFail(const char * _Nonnull msg, const char * _Nonnull file,
                 SwiftUInt line, const char * _Nonnull function);

lib/AST/Bridging/ASTContextBridging.cpp

@@ -171,6 +171,5 @@ bool BridgedASTContext_canImport(BridgedASTContext cContext,
 
 BridgedAvailabilityMacroMap
 BridgedASTContext_getAvailabilityMacroMap(BridgedASTContext cContext) {
-  return const_cast<AvailabilityMacroMap *>(
-      &cContext.unbridged().getAvailabilityMacroMap());
+  return &cContext.unbridged().getAvailabilityMacroMap();
 }