Fix SILDebugScopes for closures expanded from an expression macro.

An expression macro can expand not just to code inside the function, but also to
a closure. Such a closure needs to be treated similar to any functions generated
from a freestanding macro: Its instructions should have locations that point
straight into the macro buffer. Instructions that are expanded into the same
function as the macro expansion can be represented using inline locations
pointing back to the macro expansion, but this is not an option for top-level
function declaration.

#65484
rdar://108618562

Author: adrian-prantl

lib/SILGen/SILGenFunction.cpp

@@ -232,8 +232,16 @@ struct MacroInfo {
 };
 }
 
+static DeclContext *getInnermostFunctionContext(DeclContext *DC) {
+  for (; DC; DC = DC->getParent())
+    if (DC->getContextKind() == DeclContextKind::AbstractFunctionDecl)
+      return DC;
+  return nullptr;
+}
+
 /// Return location of the macro expansion and the macro name.
-static MacroInfo getMacroInfo(GeneratedSourceInfo &Info) {
+static MacroInfo getMacroInfo(GeneratedSourceInfo &Info,
+                              DeclContext *FunctionDC) {
   MacroInfo Result(Info.generatedSourceRange.getStart(),
                    Info.originalSourceRange.getStart());
   if (!Info.astNode)
@@ -252,6 +260,13 @@ static MacroInfo getMacroInfo(GeneratedSourceInfo &Info) {
       Result.ExpansionLoc = RegularLocation(decl);
       Result.Name = mangler.mangleMacroExpansion(decl);
     }
+    // If the parent function of the macro expansion expression is not the
+    // current function, then the macro expanded to a closure or nested
+    // function. As far as the generated SIL is concerned this is the same as a
+    // function generated from a freestanding macro expansion.
+    DeclContext *MacroContext = getInnermostFunctionContext(Info.declContext);
+    if (MacroContext != FunctionDC)
+      Result.Freestanding = true;
     break;
   }
   case GeneratedSourceInfo::FreestandingDeclMacroExpansion: {
@@ -295,7 +310,7 @@ const SILDebugScope *SILGenFunction::getMacroScope(SourceLoc SLoc) {
   // declaration that isn't part of a real function. By not handling them here,
   // source locations will still point into the macro expansion buffer, but
   // debug info doesn't know what macro that buffer was expanded from.
-  auto Macro = getMacroInfo(*GeneratedSourceInfo);
+  auto Macro = getMacroInfo(*GeneratedSourceInfo, FunctionDC);
   if (Macro.Freestanding)
     return nullptr;
 

test/Macros/macro_expand_closure.swift

@@ -6,11 +6,26 @@
 // RUN: %target-codesign %t/main
 // RUN: %target-run %t/main | %FileCheck %s
 
+
+// Debug info SIL testing
+// RUN: %target-swift-frontend -swift-version 5 -emit-sil -enable-experimental-feature FreestandingMacros -load-plugin-library %t/%target-library-name(MacroDefinition) %s -module-name MacroUser -o - -g | %FileCheck --check-prefix CHECK-SIL %s
+
+
 @freestanding(expression) public macro multiStatement() -> Int = #externalMacro(module: "MacroDefinition", type: "MultiStatementClosure")
 
 func multiStatementInference() -> Int {
   #multiStatement()
 }
 
+// The closure intruduced by the macro expansion should not contain any inline
+// locations, but instead point directly into the macro buffer.
+// CHECK-SIL: sil_scope [[S0:[0-9]+]] { loc "@__swiftmacro_9MacroUser23multiStatementInferenceSiyF0cD0fMf_.swift":1:1 parent @$s9MacroUser23multiStatementInferenceSiyFSiyXEfU_
+// CHECK-SIL: sil_scope [[S1:[0-9]+]] { loc "@__swiftmacro_9MacroUser23multiStatementInferenceSiyF0cD0fMf_.swift":2:7 parent [[S0]] }
+// CHECK-SIL: sil_scope [[S2:[0-9]+]] { loc "@__swiftmacro_9MacroUser23multiStatementInferenceSiyF0cD0fMf_.swift":2:14 parent [[S1]] }
+
+// CHECK-SIL: sil {{.*}} @$s9MacroUser23multiStatementInferenceSiyFSiyXEfU_
+// CHECK-SIL-NOT: return
+// CHECK-SIL: %0 = integer_literal $Builtin.Int64, 10, loc "@__swiftmacro_9MacroUser23multiStatementInferenceSiyF0cD0fMf_.swift":2:14, scope [[S2]]
+
 // CHECK: 10
 print(multiStatementInference())