Merge pull request #62405 from DougGregor/macro-diagnostics

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -132,7 +132,6 @@ namespace swift {
   class IndexSubset;
   struct SILAutoDiffDerivativeFunctionKey;
   struct InterfaceSubContextDelegate;
-  class CompilerPlugin;
 
   enum class KnownProtocolKind : uint8_t;
 

include/swift/AST/CASTBridging.h

@@ -86,13 +86,49 @@ typedef struct {
   // FIXME: Handle Layout Requirements
 } BridgedRequirementRepr;
 
+/// Diagnostic severity when reporting diagnostics.
+typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagnosticSeverity : long {
+  BridgedFatalError,
+  BridgedError,
+  BridgedWarning,
+  BridgedRemark,
+  BridgedNote,
+} BridgedDiagnosticSeverity;
+
+typedef void* BridgedDiagnostic;
+
 #ifdef __cplusplus
 extern "C" {
 
 #define _Bool bool
 
 #endif
 
+// Diagnostics
+
+/// Create a new diagnostic with the given severity, location, and diagnostic
+/// text.
+///
+/// \returns a diagnostic instance that can be extended with additional
+/// information and then must be finished via \c SwiftDiagnostic_finish.
+BridgedDiagnostic SwiftDiagnostic_create(
+    void *diagnosticEngine, BridgedDiagnosticSeverity severity,
+    void *_Nullable sourceLoc,
+    const uint8_t *_Nullable text, long textLen);
+
+/// Highlight a source range as part of the diagnostic.
+void SwiftDiagnostic_highlight(
+    BridgedDiagnostic diag, void *_Nullable startLoc, void *_Nullable endLoc);
+
+/// Add a Fix-It to replace a source range as part of the diagnostic.
+void SwiftDiagnostic_fixItReplace(
+    BridgedDiagnostic diag,
+    void *_Nullable replaceStartLoc, void *_Nullable replaceEndLoc,
+    const uint8_t *_Nullable newText, long newTextLen);
+
+/// Finish the given diagnostic and emit it.
+void SwiftDiagnostic_finish(BridgedDiagnostic diag);
+
 BridgedIdentifier SwiftASTContext_getIdentifier(void *ctx,
                                                 const uint8_t *_Nullable str,
                                                 long len);

include/swift/AST/CompilerPlugin.h

@@ -8282,11 +8282,12 @@ class MissingMemberDecl : public Decl {
 
 /// Provides a declaration of a macro.
 ///
+/// Macros are declared within the source code with the `macro` introducer.
+///
 /// Macros are defined externally via conformances to the 'Macro' type
 /// that is part of swift-syntax, and are introduced into the compiler via
-/// various mechanisms (built-in macros are linked in directly, plugin macros
-/// are introduced via compiler plugins, and so on). They have no explicit
-/// representation in the source code, but are still declarations.
+/// various mechanisms (e.g., in-process macros provided as builtins or
+/// loaded via shared library, and so on).
 class MacroDecl : public GenericContext, public ValueDecl {
 public:
   /// The location of the 'macro' keyword.

include/swift/AST/Decl.h

@@ -214,5 +214,15 @@ REMARK(remark_save_cache, none,
 ERROR(unknown_attribute,none,
       "unknown attribute '%0'", (StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: bridged diagnostics
+//------------------------------------------------------------------------------
+
+NOTE(bridged_note, none, "%0", (StringRef))
+WARNING(bridged_warning, none,"%0", (StringRef))
+ERROR(bridged_error, none, "%0", (StringRef))
+ERROR(bridged_fatal_error, Fatal, "%0", (StringRef))
+REMARK(bridged_remark, none, "%0", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsCommon.def

@@ -333,9 +333,6 @@ IDENTIFIER(unsafe)
 // The singleton instance of TupleTypeDecl in the Builtin module
 IDENTIFIER(TheTupleType)
 
-// Macros / compiler plugins
-IDENTIFIER_(CompilerPluginSupport)
-
 #undef IDENTIFIER
 #undef IDENTIFIER_
 #undef IDENTIFIER_WITH_NAME

include/swift/AST/KnownIdentifiers.def

@@ -116,9 +116,6 @@ PROTOCOL(AsyncIteratorProtocol)
 
 PROTOCOL(FloatingPoint)
 
-// Compiler Plugins
-PROTOCOL_(CompilerPlugin)
-
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByDictionaryLiteral, "Dictionary", false)

include/swift/AST/KnownProtocols.def

@@ -22,8 +22,6 @@
 
 namespace swift {
 
-class CompilerPlugin;
-
 /// Provides the definition of a macro.
 struct MacroDefinition {
     /// The kind of macro, which determines how it can be used in source code.
@@ -34,12 +32,9 @@ struct MacroDefinition {
 
     /// Describes how the macro is implemented.
   enum class ImplementationKind: uint8_t {
-      /// The macro is built-in to the compiler, linked against the same
-      /// underlying syntax tree libraries.
-    Builtin,
-
-      /// The macro was defined in a compiler plugin.
-    Plugin,
+    /// The macro is in the same process as the compiler, whether built-in or
+    /// loaded via a compiler plugin.
+    InProcess,
   };
 
 public:
@@ -55,39 +50,22 @@ struct MacroDefinition {
 public:
   static MacroDefinition forInvalid() {
     return MacroDefinition{
-      Kind::Expression, ImplementationKind::Builtin, nullptr
+      Kind::Expression, ImplementationKind::InProcess, nullptr
     };
   }
 
-  static MacroDefinition forBuiltin(Kind kind, void *opaqueHandle) {
-    return MacroDefinition{kind, ImplementationKind::Builtin, opaqueHandle};
-  }
-
-  static MacroDefinition forCompilerPlugin(Kind kind, CompilerPlugin *plugin) {
-    return MacroDefinition{kind, ImplementationKind::Plugin, plugin};
+  static MacroDefinition forInProcess(Kind kind, void *opaqueHandle) {
+    return MacroDefinition{kind, ImplementationKind::InProcess, opaqueHandle};
   }
 
   bool isInvalid() const { return opaqueHandle == nullptr; }
 
   explicit operator bool() const { return !isInvalid(); }
 
-  void *getAsBuiltin() const {
+  void *getAsInProcess() const {
     switch (implKind) {
-    case ImplementationKind::Builtin:
+    case ImplementationKind::InProcess:
       return opaqueHandle;
-
-    case ImplementationKind::Plugin:
-      return nullptr;
-    }
-  }
-
-  CompilerPlugin *getAsCompilerPlugin() const {
-    switch (implKind) {
-    case ImplementationKind::Builtin:
-      return nullptr;
-
-    case ImplementationKind::Plugin:
-      return (CompilerPlugin *)opaqueHandle;
     }
   }
 };

include/swift/AST/MacroDefinition.h

@@ -19,7 +19,6 @@
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
 #include "swift/AST/ClangModuleLoader.h"
-#include "swift/AST/CompilerPlugin.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsFrontend.h"
@@ -1125,9 +1124,6 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::UnsafeCxxRandomAccessIterator:
     M = getLoadedModule(Id_Cxx);
     break;
-  case KnownProtocolKind::CompilerPlugin:
-    M = getLoadedModule(Id_CompilerPluginSupport);
-    break;
   default:
     M = getStdlibModule();
     break;