Improve some bridging interfaces

Migrate a bunch of structs to classes, and
uppercase field names.

Author: hamishknight

include/swift/AST/ASTBridging.h

@@ -26,31 +26,73 @@
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 namespace swift {
-  class DiagnosticArgument;
-  class DiagnosticEngine;
+class ASTContext;
+class DiagnosticArgument;
+class DiagnosticEngine;
 }
 
 //===----------------------------------------------------------------------===//
 // MARK: Identifier
 //===----------------------------------------------------------------------===//
 
-struct BridgedIdentifier {
-  const void *_Nullable raw;
+class BridgedIdentifier {
+public:
+  SWIFT_UNAVAILABLE("Use '.raw' instead")
+  const void *_Nullable Raw;
+
+  BridgedIdentifier() : Raw(nullptr) {}
+
+  SWIFT_NAME("init(raw:)")
+  BridgedIdentifier(const void *_Nullable raw) : Raw(raw) {}
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedIdentifier(swift::Identifier ident)
+      : Raw(ident.getAsOpaquePointer()) {}
+
+  swift::Identifier unbridged() const {
+    return swift::Identifier::getFromOpaquePointer(Raw);
+  }
+#endif
 };
 
+SWIFT_NAME("getter:BridgedIdentifier.raw(self:)")
+inline const void *_Nullable BridgedIdentifier_raw(BridgedIdentifier ident) {
+  return ident.Raw;
+}
+
 struct BridgedIdentifierAndSourceLoc {
-  BridgedIdentifier name;
-  BridgedSourceLoc nameLoc;
+  SWIFT_NAME("name")
+  BridgedIdentifier Name;
+
+  SWIFT_NAME("nameLoc")
+  BridgedSourceLoc NameLoc;
 };
 
 //===----------------------------------------------------------------------===//
 // MARK: ASTContext
 //===----------------------------------------------------------------------===//
 
-struct BridgedASTContext {
-  void *_Nonnull raw;
+class BridgedASTContext {
+  swift::ASTContext * _Nonnull Ctx;
+
+public:
+#ifdef USED_IN_CPP_SOURCE
+  SWIFT_UNAVAILABLE("Use init(raw:) instead")
+  BridgedASTContext(swift::ASTContext &ctx) : Ctx(&ctx) {}
+
+  SWIFT_UNAVAILABLE("Use '.raw' instead")
+  swift::ASTContext &unbridged() const { return *Ctx; }
+#endif
 };
 
+SWIFT_NAME("getter:BridgedASTContext.raw(self:)")
+BRIDGED_INLINE
+void * _Nonnull BridgedASTContext_raw(BridgedASTContext bridged);
+
+SWIFT_NAME("BridgedASTContext.init(raw:)")
+BRIDGED_INLINE
+BridgedASTContext BridgedASTContext_fromRaw(void * _Nonnull ptr);
+
 SWIFT_NAME("BridgedASTContext.getIdentifier(self:_:)")
 BridgedIdentifier BridgedASTContext_getIdentifier(BridgedASTContext cContext,
                                                   BridgedStringRef cStr);
@@ -70,8 +112,11 @@ enum ENUM_EXTENSIBILITY_ATTR(open) ASTNodeKind : size_t {
 };
 
 struct BridgedASTNode {
-  void *_Nonnull ptr;
-  ASTNodeKind kind;
+  SWIFT_NAME("raw")
+  void *_Nonnull Raw;
+
+  SWIFT_NAME("kind")
+  ASTNodeKind Kind;
 };
 
 // Forward declare the underlying AST node type for each wrapper.
@@ -185,8 +230,18 @@ enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagnosticSeverity : size_t {
   BridgedNote,
 };
 
-struct BridgedDiagnostic {
-  void *_Nonnull raw;
+class BridgedDiagnostic {
+public:
+  struct Impl;
+
+  SWIFT_UNAVAILABLE("Unavailable in Swift")
+  Impl *_Nonnull Raw;
+
+  SWIFT_UNAVAILABLE("Unavailable in Swift")
+  BridgedDiagnostic(Impl *_Nonnull raw) : Raw(raw) {}
+
+  SWIFT_UNAVAILABLE("Unavailable in Swift")
+  Impl *_Nonnull unbridged() const { return Raw; }
 };
 
 // FIXME: Can we bridge InFlightDiagnostic?

include/swift/AST/ASTBridgingImpl.h

@@ -17,6 +17,18 @@
 
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
+//===----------------------------------------------------------------------===//
+// MARK: BridgedASTContext
+//===----------------------------------------------------------------------===//
+
+void * _Nonnull BridgedASTContext_raw(BridgedASTContext bridged) {
+  return &bridged.unbridged();
+}
+
+BridgedASTContext BridgedASTContext_fromRaw(void * _Nonnull ptr) {
+  return *static_cast<swift::ASTContext *>(ptr);
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedNominalTypeDecl
 //===----------------------------------------------------------------------===//

include/swift/AST/Identifier.h

@@ -93,6 +93,7 @@ class Identifier {
   }
 
   bool empty() const { return Pointer == nullptr; }
+  bool nonempty() const { return !empty(); }
 
   LLVM_ATTRIBUTE_USED bool is(StringRef string) const {
     return str().equals(string);
@@ -180,7 +181,7 @@ class Identifier {
       return static_cast<const void *>(Pointer);
   }
 
-  static Identifier getFromOpaquePointer(void *P) {
+  static Identifier getFromOpaquePointer(const void *P) {
     return Identifier((const char*)P);
   }
 

include/swift/Basic/BasicBridging.h

@@ -281,16 +281,62 @@ BRIDGED_INLINE bool BridgedSourceLoc_isValid(BridgedSourceLoc loc);
 // MARK: SourceRange
 //===----------------------------------------------------------------------===//
 
-struct BridgedSourceRange {
-  BridgedSourceLoc startLoc;
-  BridgedSourceLoc endLoc;
+class BridgedSourceRange {
+public:
+  SWIFT_NAME("start")
+  BridgedSourceLoc Start;
+
+  SWIFT_NAME("end")
+  BridgedSourceLoc End;
+
+  SWIFT_NAME("init(start:end:)")
+  BridgedSourceRange(BridgedSourceLoc start, BridgedSourceLoc end)
+      : Start(start), End(end) {}
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedSourceRange(swift::SourceRange range)
+      : Start(range.Start), End(range.End) {}
+
+  swift::SourceRange unbridged() const {
+    return swift::SourceRange(Start.unbridged(), End.unbridged());
+  }
+#endif
 };
 
-struct BridgedCharSourceRange {
-  void *_Nonnull start;
-  size_t byteLength;
+class BridgedCharSourceRange {
+public:
+  SWIFT_UNAVAILABLE("Use '.start' instead")
+  BridgedSourceLoc Start;
+
+  SWIFT_UNAVAILABLE("Use '.byteLength' instead")
+  unsigned ByteLength;
+
+  SWIFT_NAME("init(start:byteLength:)")
+  BridgedCharSourceRange(BridgedSourceLoc start, unsigned byteLength)
+      : Start(start), ByteLength(byteLength) {}
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedCharSourceRange(swift::CharSourceRange range)
+      : Start(range.getStart()), ByteLength(range.getByteLength()) {}
+
+  swift::CharSourceRange unbridged() const {
+    return swift::CharSourceRange(Start.unbridged(), ByteLength);
+  }
+#endif
 };
 
+SWIFT_NAME("getter:BridgedCharSourceRange.start(self:)")
+inline BridgedSourceLoc
+BridgedCharSourceRange_start(BridgedCharSourceRange range) {
+  return range.Start;
+}
+
+SWIFT_NAME("getter:BridgedCharSourceRange.byteLength(self:)")
+inline SwiftInt
+BridgedCharSourceRange_byteLength(BridgedCharSourceRange range) {
+  return static_cast<SwiftInt>(range.ByteLength);
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: Plugins
 //===----------------------------------------------------------------------===//