Revert "[cxx-interop][SwiftCompilerSources] Use swift::DiagnosticEngine instead of BridgedDiagnosticEngine"

This reverts commit e9dedf3.

The revert is required as foreign reference types are available for SwiftStdlib 5.8 and above, but the Swift compiler
sources back deploy to older stdlibs as well.

Author: hyp

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -53,11 +53,17 @@ public struct DiagnosticFixIt {
 }
 
 public struct DiagnosticEngine {
-  private let bridged: swift.DiagnosticEngine
+  private let bridged: BridgedDiagnosticEngine
 
-  public init(bridged: swift.DiagnosticEngine) {
+  public init(bridged: BridgedDiagnosticEngine) {
     self.bridged = bridged
   }
+  public init?(bridged: BridgedOptionalDiagnosticEngine) {
+    guard let object = bridged.object else {
+      return nil
+    }
+    self.bridged = BridgedDiagnosticEngine(object: object)
+  }
 
   public func diagnose(_ position: SourceLoc?,
                        _ id: DiagID,

SwiftCompilerSources/Sources/Parse/Regex.swift

@@ -46,7 +46,7 @@ private func _RegexLiteralLexingFn(
   _ curPtrPtr: UnsafeMutablePointer<UnsafePointer<CChar>>,
   _ bufferEndPtr: UnsafePointer<CChar>,
   _ mustBeRegex: CBool,
-  _ bridgedDiagnosticEngine: swift.DiagnosticEngine?
+  _ bridgedDiagnosticEngine: BridgedOptionalDiagnosticEngine
 ) -> /*CompletelyErroneous*/ CBool {
   let inputPtr = curPtrPtr.pointee
 
@@ -62,8 +62,7 @@ private func _RegexLiteralLexingFn(
 
   if let error = error {
     // Emit diagnostic if diagnostics are enabled.
-    if let bridged = bridgedDiagnosticEngine {
-      let diagEngine = DiagnosticEngine(bridged: bridged)
+    if let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine) {
       let startLoc = SourceLoc(
         locationInFile: error.location.assumingMemoryBound(to: UInt8.self))!
       diagEngine.diagnose(startLoc, .foreign_diagnostic, error.message)
@@ -94,7 +93,7 @@ public func _RegexLiteralParsingFn(
   _ captureStructureOut: UnsafeMutableRawPointer,
   _ captureStructureSize: CUnsignedInt,
   _ bridgedDiagnosticBaseLoc: swift.SourceLoc,
-  _ bridgedDiagnosticEngine: swift.DiagnosticEngine
+  _ bridgedDiagnosticEngine: BridgedDiagnosticEngine
 ) -> Bool {
   let str = String(cString: inputPtr)
   let captureBuffer = UnsafeMutableRawBufferPointer(

include/swift/AST/ASTBridging.h

@@ -32,12 +32,22 @@ typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagID : uint32_t {
 #include "swift/AST/DiagnosticsAll.def"
 } BridgedDiagID;
 
+typedef struct {
+  void * _Nonnull object;
+} BridgedDiagnosticEngine;
+
+typedef struct {
+  void *_Nullable object;
+} BridgedOptionalDiagnosticEngine;
+
 // FIXME: Can we bridge InFlightDiagnostic?
-void DiagnosticEngine_diagnose(swift::DiagnosticEngine &, swift::SourceLoc loc,
+void DiagnosticEngine_diagnose(BridgedDiagnosticEngine, swift::SourceLoc loc,
                                BridgedDiagID diagID, BridgedArrayRef arguments,
                                swift::CharSourceRange highlight,
                                BridgedArrayRef fixIts);
 
+bool DiagnosticEngine_hadAnyError(BridgedDiagnosticEngine);
+
 using ArrayRefOfDiagnosticArgument = llvm::ArrayRef<swift::DiagnosticArgument>;
 
 SWIFT_END_NULLABILITY_ANNOTATIONS

include/swift/AST/BridgingUtils.h

@@ -0,0 +1,32 @@
+//===--- BridgingUtils.h - utilities for swift bridging -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_BRIDGINGUTILS_H
+#define SWIFT_AST_BRIDGINGUTILS_H
+
+#include "swift/AST/ASTBridging.h"
+#include "swift/AST/DiagnosticEngine.h"
+
+namespace swift {
+
+inline BridgedDiagnosticEngine getBridgedDiagnosticEngine(DiagnosticEngine *D) {
+  return {(void *)D};
+}
+inline BridgedOptionalDiagnosticEngine
+getBridgedOptionalDiagnosticEngine(DiagnosticEngine *D) {
+  return {(void *)D};
+}
+
+} // namespace swift
+
+#endif
+

include/swift/AST/DiagnosticEngine.h

@@ -804,7 +804,7 @@ namespace swift {
 
   /// Class responsible for formatting diagnostics and presenting them
   /// to the user.
-  class SWIFT_IMPORT_REFERENCE DiagnosticEngine {
+  class DiagnosticEngine {
   public:
     /// The source manager used to interpret source locations and
     /// display diagnostics.

include/swift/Basic/Compiler.h

@@ -184,15 +184,6 @@
 #define SWIFT_VFORMAT(fmt)
 #endif
 
-// Tells Swift's ClangImporter to import a C++ type as a foreign reference type.
-#if __has_attribute(swift_attr)
-#define SWIFT_IMPORT_REFERENCE __attribute__((swift_attr("import_reference"))) \
-  __attribute__((swift_attr("retain:immortal")))                               \
-  __attribute__((swift_attr("release:immortal")))
-#else
-#define SWIFT_IMPORT_REFERENCE
-#endif
-
 #if __has_attribute(enum_extensibility)
 #define ENUM_EXTENSIBILITY_ATTR(arg) __attribute__((enum_extensibility(arg)))
 #else

include/swift/Parse/RegexParserBridging.h

@@ -27,16 +27,16 @@
 ///              past.
 /// - MustBeRegex: whether an error during lexing should be considered a regex
 ///                literal, or some thing else.
-/// - OptionalDiagnosticEngine: RegexLiteralLexingFn should diagnose the
-///                             token using this engine.
+/// - BridgedOptionalDiagnosticEngine: RegexLiteralLexingFn should diagnose the
+///                                    token using this engine.
 ///
 /// Returns: A bool indicating whether lexing was completely erroneous, and
 ///          cannot be recovered from, or false if there either was no error,
 ///          or there was a recoverable error.
 typedef bool (*RegexLiteralLexingFn)(
     /*CurPtrPtr*/ const char *_Nonnull *_Nonnull,
     /*BufferEnd*/ const char *_Nonnull,
-    /*MustBeRegex*/ bool, swift::DiagnosticEngine *_Nullable);
+    /*MustBeRegex*/ bool, BridgedOptionalDiagnosticEngine);
 void Parser_registerRegexLiteralLexingFn(RegexLiteralLexingFn _Nullable fn);
 
 /// Parse a regex literal string. Takes the following arguments:
@@ -48,16 +48,16 @@ void Parser_registerRegexLiteralLexingFn(RegexLiteralLexingFn _Nullable fn);
 /// - CaptureStructureSize: The size of the capture structure buffer. Must be
 ///                         greater than or equal to `strlen(InputPtr) + 3`.
 /// - DiagnosticBaseLoc: Start location of the regex literal.
-/// - DiagnosticEngine: RegexLiteralParsingFn should diagnose the
-///                     parsing errors using this engine.
+/// - BridgedDiagnosticEngine: RegexLiteralParsingFn should diagnose the
+///                            parsing errors using this engine.
 ///
 /// Returns: A bool value indicating if there was an error while parsing.
 typedef bool (*RegexLiteralParsingFn)(/*InputPtr*/ const char *_Nonnull,
                                       /*VersionOut*/ unsigned *_Nonnull,
                                       /*CaptureStructureOut*/ void *_Nonnull,
                                       /*CaptureStructureSize*/ unsigned,
                                       /*DiagnosticBaseLoc*/ swift::SourceLoc,
-                                      swift::DiagnosticEngine &);
+                                      BridgedDiagnosticEngine);
 void Parser_registerRegexLiteralParsingFn(RegexLiteralParsingFn _Nullable fn);
 
 #endif // REGEX_PARSER_BRIDGING

lib/AST/ASTBridging.cpp

@@ -17,18 +17,28 @@
 
 using namespace swift;
 
+namespace {
+/// BridgedDiagnosticEngine -> DiagnosticEngine *.
+DiagnosticEngine *getDiagnosticEngine(const BridgedDiagnosticEngine &bridged) {
+  return static_cast<DiagnosticEngine *>(bridged.object);
+}
+
+} // namespace
+
 void DiagnosticEngine_diagnose(
-    DiagnosticEngine &engine, SourceLoc loc, BridgedDiagID bridgedDiagID,
+    BridgedDiagnosticEngine bridgedEngine, SourceLoc loc,
+    BridgedDiagID bridgedDiagID,
     BridgedArrayRef /*DiagnosticArgument*/ bridgedArguments,
     CharSourceRange highlight,
     BridgedArrayRef /*DiagnosticInfo::FixIt*/ bridgedFixIts) {
+  auto *D = getDiagnosticEngine(bridgedEngine);
 
   auto diagID = static_cast<DiagID>(bridgedDiagID);
   SmallVector<DiagnosticArgument, 2> arguments;
   for (auto arg : getArrayRef<DiagnosticArgument>(bridgedArguments)) {
     arguments.push_back(arg);
   }
-  auto inflight = engine.diagnose(loc, diagID, arguments);
+  auto inflight = D->diagnose(loc, diagID, arguments);
 
   // Add highlight.
   if (highlight.isValid()) {
@@ -42,3 +52,8 @@ void DiagnosticEngine_diagnose(
     inflight.fixItReplaceChars(range.getStart(), range.getEnd(), text);
   }
 }
+
+bool DiagnosticEngine_hadAnyError(BridgedDiagnosticEngine bridgedEngine) {
+  auto *D = getDiagnosticEngine(bridgedEngine);
+  return D->hadAnyError();
+}

lib/Parse/Lexer.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Parse/Lexer.h"
+#include "swift/AST/BridgingUtils.h"
 #include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/Identifier.h"
 #include "swift/Basic/LangOptions.h"
@@ -2084,7 +2085,7 @@ const char *Lexer::tryScanRegexLiteral(const char *TokStart, bool MustBeRegex,
   //   recovered from.
   auto *Ptr = TokStart;
   CompletelyErroneous = regexLiteralLexingFn(
-      &Ptr, BufferEnd, MustBeRegex, Diags);
+      &Ptr, BufferEnd, MustBeRegex, getBridgedOptionalDiagnosticEngine(Diags));
 
   // If we didn't make any lexing progress, this isn't a regex literal and we
   // should fallback to lexing as something else.

lib/Parse/ParseRegex.cpp

@@ -14,6 +14,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/AST/BridgingUtils.h"
+#include "swift/AST/DiagnosticsParse.h"
 #include "swift/Basic/BridgingUtils.h"
 #include "swift/Parse/Parser.h"
 
@@ -42,7 +44,8 @@ ParserResult<Expr> Parser::parseExprRegexLiteral() {
       regexLiteralParsingFn(regexText.str().c_str(), &version,
                             /*captureStructureOut*/ capturesBuf.data(),
                             /*captureStructureSize*/ capturesBuf.size(),
-                            /*diagBaseLoc*/ Tok.getLoc(), Diags);
+                            /*diagBaseLoc*/ Tok.getLoc(),
+                            getBridgedDiagnosticEngine(&Diags));
   auto loc = consumeToken();
   SourceMgr.recordRegexLiteralStartLoc(loc);