[Caching] Support swift style diagnostics for swift caching

Add support for swift style diagnostics for swift caching. This includes
pre-populate the GeneratedSourceInfo with macro name so it doesn't need
to infer from an ASTNode, which the caching mechanism cannot preserve.

Still leave the default diagnostic style to LLVM style because replaying
swift style diagnostics is still very slow and including parsing source
file using swift-syntax.

rdar://128615572

Author: cachemeifyoucan

include/swift/AST/DiagnosticEngine.h

@@ -1687,10 +1687,6 @@ namespace swift {
     const StringRef Message;
   };
 
-/// Retrieve the macro name for a generated source info that represents
-/// a macro expansion.
-DeclName getGeneratedSourceInfoMacroName(const GeneratedSourceInfo &info);
-
 } // end namespace swift
 
 #endif

include/swift/Basic/SourceManager.h

@@ -69,6 +69,10 @@ class GeneratedSourceInfo {
   /// The custom attribute for an attached macro.
   CustomAttr *attachedMacroCustomAttr = nullptr;
 
+  /// MacroDecl name if the generated source is coming from macro expansion,
+  /// otherwise empty string.
+  std::string macroName = "";
+
   /// The name of the source file on disk that was created to hold the
   /// contents of this file for external clients.
   StringRef onDiskBufferCopyFileName = StringRef();

lib/AST/DiagnosticEngine.cpp

@@ -1463,6 +1463,37 @@ DiagnosticEngine::diagnosticInfoForDiagnostic(const Diagnostic &diagnostic) {
       diagnostic.isChildNote());
 }
 
+static DeclName
+getGeneratedSourceInfoMacroName(const GeneratedSourceInfo &info) {
+  ASTNode expansionNode = ASTNode::getFromOpaqueValue(info.astNode);
+  switch (info.kind) {
+#define MACRO_ROLE(Name, Description)                                          \
+  case GeneratedSourceInfo::Name##MacroExpansion:
+#include "swift/Basic/MacroRoles.def"
+    {
+      if (auto customAttr = info.attachedMacroCustomAttr) {
+        // FIXME: How will we handle deserialized custom attributes like this?
+        auto declRefType = cast<DeclRefTypeRepr>(customAttr->getTypeRepr());
+        return declRefType->getNameRef().getFullName();
+      }
+
+      if (auto expansionExpr = dyn_cast_or_null<MacroExpansionExpr>(
+              expansionNode.dyn_cast<Expr *>())) {
+        return expansionExpr->getMacroName().getFullName();
+      }
+
+      auto expansionDecl =
+          cast<MacroExpansionDecl>(expansionNode.get<Decl *>());
+      return expansionDecl->getMacroName().getFullName();
+    }
+
+  case GeneratedSourceInfo::PrettyPrinted:
+  case GeneratedSourceInfo::ReplacedFunctionBody:
+  case GeneratedSourceInfo::DefaultArgument:
+    return DeclName();
+  }
+}
+
 std::vector<Diagnostic>
 DiagnosticEngine::getGeneratedSourceBufferNotes(SourceLoc loc) {
   // The set of child notes we're building up.
@@ -1674,35 +1705,3 @@ EncodedDiagnosticMessage::EncodedDiagnosticMessage(StringRef S)
     : Message(Lexer::getEncodedStringSegment(S, Buf, /*IsFirstSegment=*/true,
                                              /*IsLastSegment=*/true,
                                              /*IndentToStrip=*/~0U)) {}
-
-DeclName
-swift::getGeneratedSourceInfoMacroName(const GeneratedSourceInfo &info) {
-  ASTNode expansionNode = ASTNode::getFromOpaqueValue(info.astNode);
-  switch (info.kind) {
-#define MACRO_ROLE(Name, Description)  \
-    case GeneratedSourceInfo::Name##MacroExpansion:
-#include "swift/Basic/MacroRoles.def"
-  {
-    DeclName macroName;
-    if (auto customAttr = info.attachedMacroCustomAttr) {
-      // FIXME: How will we handle deserialized custom attributes like this?
-      auto declRefType = cast<DeclRefTypeRepr>(customAttr->getTypeRepr());
-      return declRefType->getNameRef().getFullName();
-    }
-
-    if (auto expansionExpr = dyn_cast_or_null<MacroExpansionExpr>(
-            expansionNode.dyn_cast<Expr *>())) {
-      return expansionExpr->getMacroName().getFullName();
-    }
-
-    auto expansionDecl =
-        cast<MacroExpansionDecl>(expansionNode.get<Decl *>());
-      return expansionDecl->getMacroName().getFullName();
-  }
-
-  case GeneratedSourceInfo::PrettyPrinted:
-  case GeneratedSourceInfo::ReplacedFunctionBody:
-  case GeneratedSourceInfo::DefaultArgument:
-      return DeclName();
-  }
-}

lib/Frontend/CachedDiagnostics.cpp

@@ -16,11 +16,11 @@
 
 #include "swift/Frontend/CachedDiagnostics.h"
 
+#include "swift/AST/DiagnosticBridge.h"
 #include "swift/AST/DiagnosticConsumer.h"
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/SourceManager.h"
-#include "swift/Frontend/CachingUtils.h"
 #include "swift/Frontend/Frontend.h"
 #include "swift/Frontend/FrontendInputsAndOutputs.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
@@ -101,6 +101,7 @@ struct SerializedGeneratedFileInfo {
   unsigned FileID;
   SerializedCharSourceRange OriginalRange;
   SerializedCharSourceRange GeneratedRange;
+  std::string MacroName;
 };
 
 struct DiagnosticSerializer {
@@ -285,6 +286,7 @@ struct MappingTraits<SerializedGeneratedFileInfo> {
     io.mapRequired("FileID", Info.FileID);
     io.mapRequired("OriginalRange", Info.OriginalRange);
     io.mapRequired("GeneratedRange", Info.GeneratedRange);
+    io.mapOptional("MacroName", Info.MacroName, "");
   }
 };
 
@@ -353,7 +355,7 @@ unsigned DiagnosticSerializer::getFileIDFromBufferID(SourceManager &SM,
       [&](const GeneratedSourceInfo &Info) -> SerializedGeneratedFileInfo {
     return {(uint8_t)Info.kind, CurrentFileID,
             convertSourceRange(SM, Info.originalSourceRange),
-            convertSourceRange(SM, Info.generatedSourceRange)};
+            convertSourceRange(SM, Info.generatedSourceRange), Info.macroName};
   };
   if (Info) {
     auto GI = convertGeneratedFileInfo(*Info);
@@ -567,6 +569,7 @@ llvm::Error DiagnosticSerializer::deserializeGeneratedFileInfo(
   if (!GeneratedRange)
     return GeneratedRange.takeError();
   Info.generatedSourceRange = *GeneratedRange;
+  Info.macroName = GI.MacroName;
   SrcMgr.setGeneratedSourceInfo(ID->second, Info);
   return llvm::Error::success();
 }

lib/Frontend/CompilerInvocation.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/SILOptions.h"
+#include "swift/Basic/DiagnosticOptions.h"
 #include "swift/Frontend/Frontend.h"
 
 #include "ArgsToFrontendOptionsConverter.h"
@@ -2228,8 +2229,12 @@ static bool ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
       Args.hasFlag(OPT_color_diagnostics,
                    OPT_no_color_diagnostics,
                    /*Default=*/llvm::sys::Process::StandardErrHasColors());
-  // If no style options are specified, default to Swift style.
-  Opts.PrintedFormattingStyle = DiagnosticOptions::FormattingStyle::Swift;
+  // If no style options are specified, default to Swift style, unless it is
+  // under swift caching, which llvm style is preferred because LLVM style
+  // replays a lot faster.
+  Opts.PrintedFormattingStyle = Args.hasArg(OPT_cache_compile_job)
+                                    ? DiagnosticOptions::FormattingStyle::LLVM
+                                    : DiagnosticOptions::FormattingStyle::Swift;
   if (const Arg *arg = Args.getLastArg(OPT_diagnostic_style)) {
     StringRef contents = arg->getValue();
     if (contents == "llvm") {
@@ -2242,9 +2247,6 @@ static bool ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
       return true;
     }
   }
-  // Swift style is not fully supported in cached mode yet.
-  if (Args.hasArg(OPT_cache_compile_job))
-    Opts.PrintedFormattingStyle = DiagnosticOptions::FormattingStyle::LLVM;
 
   for (const Arg *arg: Args.filtered(OPT_emit_macro_expansion_files)) {
     StringRef contents = arg->getValue();

lib/Sema/TypeCheckMacros.cpp

@@ -985,6 +985,21 @@ createMacroSourceFile(std::unique_ptr<llvm::MemoryBuffer> buffer,
   GeneratedSourceInfo::Kind generatedSourceKind =
       getGeneratedSourceInfoKind(role);
 
+  /// Retrieve the macro name for a generated source info that represents
+  /// a macro expansion.
+  llvm::SmallString<64> macroName;
+  if (attr)
+    cast<DeclRefTypeRepr>(attr->getTypeRepr())
+        ->getNameRef()
+        .getFullName()
+        .getString(macroName);
+  else if (auto expansionExpr =
+               dyn_cast_or_null<MacroExpansionExpr>(target.dyn_cast<Expr *>()))
+    expansionExpr->getMacroName().getFullName().getString(macroName);
+  else if (auto expansionDecl =
+               dyn_cast_or_null<MacroExpansionDecl>(target.get<Decl *>()))
+    expansionDecl->getMacroName().getFullName().getString(macroName);
+
   // Create a new source buffer with the contents of the expanded macro.
   unsigned macroBufferID = sourceMgr.addNewSourceBuffer(std::move(buffer));
   auto macroBufferRange = sourceMgr.getRangeForBuffer(macroBufferID);
@@ -993,7 +1008,9 @@ createMacroSourceFile(std::unique_ptr<llvm::MemoryBuffer> buffer,
                                  macroBufferRange,
                                  target.getOpaqueValue(),
                                  dc,
-                                 attr};
+                                 attr,
+                                 macroName.c_str()
+  };
   sourceMgr.setGeneratedSourceInfo(macroBufferID, sourceInfo);
 
   // Create a source file to hold the macro buffer. This is automatically

test/CAS/cached_diagnostics_macro.swift

@@ -0,0 +1,60 @@
+// REQUIRES: swift_swift_parser
+
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+// RUN: %host-build-swift -swift-version 5 -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %t/macro.swift
+
+// RUN: %target-swift-frontend -typecheck -module-load-mode prefer-serialized -module-name MyApp -module-cache-path %t/clang-module-cache -O \
+// RUN:   -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import \
+// RUN:   %t/main.swift -swift-version 5 -external-plugin-path %t#%swift-plugin-server 2> %t/diag1.txt
+
+// RUN: %target-swift-frontend -scan-dependencies -module-load-mode prefer-serialized -module-name MyApp -module-cache-path %t/clang-module-cache -O \
+// RUN:   -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import \
+// RUN:   %t/main.swift -o %t/deps.json -swift-version 5 -cache-compile-job -cas-path %t/cas -external-plugin-path %t#%swift-plugin-server
+
+// RUN: %S/Inputs/SwiftDepsExtractor.py %t/deps.json MyApp casFSRootID > %t/fs.casid
+// RUN: llvm-cas -cas %t/cas -ls-tree-recursive @%t/fs.casid | %FileCheck %s --check-prefix=FS
+
+// FS: MacroDefinition
+// RUN: %S/Inputs/BuildCommandExtractor.py %t/deps.json clang:SwiftShims > %t/SwiftShims.cmd
+// RUN: %swift_frontend_plain @%t/SwiftShims.cmd
+
+// RUN: %S/Inputs/BuildCommandExtractor.py %t/deps.json MyApp > %t/MyApp.cmd
+// RUN: %{python} %S/Inputs/GenerateExplicitModuleMap.py %t/deps.json > %t/map.json
+// RUN: llvm-cas --cas %t/cas --make-blob --data %t/map.json > %t/map.casid
+
+// RUN: %target-swift-frontend -diagnostic-style=swift \
+// RUN:   -emit-module -o %t/Test.swiftmodule -cache-compile-job -cas-path %t/cas \
+// RUN:   -swift-version 5 -disable-implicit-swift-modules \
+// RUN:   -external-plugin-path %t#%swift-plugin-server \
+// RUN:   -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import \
+// RUN:   -module-name MyApp -explicit-swift-module-map-file @%t/map.casid -O \
+// RUN:   %t/main.swift @%t/MyApp.cmd -serialize-diagnostics-path %t/Test.diag 2> %t/diag2.txt
+
+// RUN: diff %t/diag1.txt %t/diag2.txt
+
+//--- macro.swift
+import SwiftDiagnostics
+import SwiftOperators
+import SwiftSyntax
+import SwiftSyntaxBuilder
+@_spi(ExperimentalLanguageFeature) import SwiftSyntaxMacros
+
+public struct CallDeprecatedMacro: ExpressionMacro {
+   public static func expansion(
+     of macro: some FreestandingMacroExpansionSyntax,
+     in context: some MacroExpansionContext
+   ) throws -> ExprSyntax {
+     return "testDeprecated()"
+  }
+}
+
+//--- main.swift
+@freestanding(expression) macro myWarning(_ message: String) = #externalMacro(module: "MacroDefinition", type: "CallDeprecatedMacro")
+
+@available(*, deprecated)
+func testDeprecated() {}
+
+func testDiscardableStringify(x: Int) {
+  #myWarning("this is a warning")
+}