Add support for nested ASTScopes inside of macro expansions. … @adrian-prantl

include/swift/AST/ASTScope.h

@@ -413,6 +413,7 @@ class ASTSourceFileScope final : public ASTScopeImpl {
   NullablePtr<const void> addressForPrinting() const override { return SF; }
 
   ASTContext &getASTContext() const override;
+  bool ignoreInDebugInfo() const override { return true; }
 
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;

lib/IRGen/IRGenDebugInfo.cpp

@@ -2171,6 +2171,14 @@ void IRGenDebugInfoImpl::setCurrentLoc(IRBuilder &Builder,
   assert(parentScopesAreSane(DS) && "parent scope sanity check failed");
   auto DL = llvm::DILocation::get(IGM.getLLVMContext(), L.line, L.column, Scope,
                                   InlinedAt);
+#ifndef NDEBUG
+  {
+    llvm::DILocalScope *Scope = DL->getInlinedAtScope();
+    llvm::DISubprogram *SP = Scope->getSubprogram();
+    llvm::Function *F = Builder.GetInsertBlock()->getParent();
+    assert((!F || SP->describes(F)) && "location points to different function");
+  }
+#endif
   Builder.SetCurrentDebugLocation(DL);
 }
 

lib/SILGen/SILGenFunction.cpp

@@ -57,7 +57,7 @@ SILGenFunction::SILGenFunction(SILGenModule &SGM, SILFunction &F,
   SourceLoc SLoc = F.getLocation().getSourceLoc();
   if (SF && SLoc) {
     FnASTScope = ast_scope::ASTScopeImpl::findStartingScopeForLookup(SF, SLoc);
-    ScopeMap.insert({FnASTScope, F.getDebugScope()});
+    ScopeMap.insert({{FnASTScope, nullptr}, F.getDebugScope()});
   }
 }
 
@@ -215,47 +215,49 @@ const SILDebugScope *SILGenFunction::getOrCreateScope(SourceLoc SLoc) {
   if (!astScope->getParent())
     return nullptr;
 
-  const SILDebugScope *Scope = getOrCreateScope(astScope);
+  const SILDebugScope *Scope = getOrCreateScope(astScope, F.getDebugScope());
   assert(Scope && "failed to construct SILDebugScope from ASTScope");
   return Scope;
 }
 
 namespace {
 struct MacroInfo {
-  MacroInfo(SourceLoc SLoc) : Loc(SLoc) {}
-  RegularLocation Loc;
-  std::string Name;
+  MacroInfo(SourceLoc SLoc, SourceLoc ExpansionSLoc)
+      : SLoc(SLoc), ExpansionSLoc(ExpansionSLoc) {}
+  SourceLoc SLoc;
+  SourceLoc ExpansionSLoc;
+  RegularLocation ExpansionLoc = RegularLocation((Decl*)nullptr);
+  std::string Name = "__unknown_macro__";
   bool Freestanding = false;
 };
 }
 
+/// Return location of the macro expansion and the macro name.
 static MacroInfo getMacroInfo(GeneratedSourceInfo &Info) {
-  SourceLoc MacroSLoc = Info.generatedSourceRange.getStart();
-  MacroInfo Result(MacroSLoc);
-  Result.Name = "__unknown_macro__";
+  MacroInfo Result(Info.generatedSourceRange.getStart(),
+                   Info.originalSourceRange.getStart());
   if (!Info.astNode)
     return Result;
-
   // Keep this in sync with ASTMangler::appendMacroExpansionContext().
   Mangle::ASTMangler mangler;
   switch (Info.kind) {
   case GeneratedSourceInfo::ExpressionMacroExpansion: {
     auto parent = ASTNode::getFromOpaqueValue(Info.astNode);
     if (auto expr =
             cast_or_null<MacroExpansionExpr>(parent.dyn_cast<Expr *>())) {
-      Result.Loc = RegularLocation(expr);
+      Result.ExpansionLoc = RegularLocation(expr);
       Result.Name = mangler.mangleMacroExpansion(expr);
     } else {
       auto decl = cast<MacroExpansionDecl>(parent.get<Decl *>());
-      Result.Loc = RegularLocation(decl);
+      Result.ExpansionLoc = RegularLocation(decl);
       Result.Name = mangler.mangleMacroExpansion(decl);
     }
     break;
   }
   case GeneratedSourceInfo::FreestandingDeclMacroExpansion: {
     auto expansion = cast<MacroExpansionDecl>(
         ASTNode::getFromOpaqueValue(Info.astNode).get<Decl *>());
-    Result.Loc = RegularLocation(expansion);
+    Result.ExpansionLoc = RegularLocation(expansion);
     Result.Name = mangler.mangleMacroExpansion(expansion);
     Result.Freestanding = true;
     break;
@@ -268,7 +270,7 @@ static MacroInfo getMacroInfo(GeneratedSourceInfo &Info) {
     auto decl = ASTNode::getFromOpaqueValue(Info.astNode).get<Decl *>();
     auto attr = Info.attachedMacroCustomAttr;
     if (auto *macroDecl = decl->getResolvedMacro(attr)) {
-      Result.Loc = RegularLocation(macroDecl);
+      Result.ExpansionLoc = RegularLocation(macroDecl);
       Result.Name = macroDecl->getBaseName().userFacingName();
       Result.Freestanding = true;
     }
@@ -297,61 +299,67 @@ const SILDebugScope *SILGenFunction::getMacroScope(SourceLoc SLoc) {
   if (Macro.Freestanding)
     return nullptr;
 
-  SourceLoc OrigSLoc = GeneratedSourceInfo->originalSourceRange.getStart();
-  if (!OrigSLoc)
-    return nullptr;
-
+  const SILDebugScope *TopLevelScope;
   auto It = InlinedScopeMap.find(BufferID);
   if (It != InlinedScopeMap.end())
-    return It->second;
+    TopLevelScope = It->second;
+  else {
+    // Recursively create one inlined function + scope per layer of generated
+    // sources.  Chains of Macro expansions are representad as flat
+    // function-level scopes.
+    SILGenFunctionBuilder B(SGM);
+    auto &ASTContext = SGM.M.getASTContext();
+    auto ExtInfo = SILFunctionType::ExtInfo::getThin();
+    auto FunctionType = SILFunctionType::get(
+        nullptr, ExtInfo, SILCoroutineKind::None,
+        ParameterConvention::Direct_Unowned, /*Params*/ {},
+        /*yields*/
+        {},
+        /*Results*/ {}, None, SubstitutionMap(), SubstitutionMap(), ASTContext);
+    StringRef MacroName = ASTContext.getIdentifier(Macro.Name).str();
+    RegularLocation MacroLoc(Macro.SLoc);
+    // Use the ExpansionLoc as the location so IRGenDebugInfo can extract the
+    // human-readable macro name from the MacroExpansionDecl.
+    SILFunction *MacroFn = B.getOrCreateFunction(
+        Macro.ExpansionLoc, MacroName,
+        SILLinkage::DefaultForDeclaration, FunctionType, IsNotBare,
+        IsNotTransparent, IsNotSerialized, IsNotDynamic, IsNotDistributed,
+        IsNotRuntimeAccessible);
+    // At the end of the chain ExpansionLoc should be a macro expansion node.
+    const SILDebugScope *InlinedAt = nullptr;
+    const SILDebugScope *ExpansionScope = getOrCreateScope(Macro.ExpansionSLoc);
+
+    // Inject an extra scope to hold the inlined call site.
+    if (ExpansionScope)
+      InlinedAt = new (SGM.M)
+          SILDebugScope(Macro.ExpansionLoc, nullptr, ExpansionScope,
+                        ExpansionScope->InlinedCallSite);
+
+    TopLevelScope =
+        new (SGM.M) SILDebugScope(MacroLoc, MacroFn, nullptr, InlinedAt);
+
+    InlinedScopeMap.insert({BufferID, TopLevelScope});
+  }
 
-  // Recursively create one inlined function + scope per layer of generated
-  // sources.  Chains of Macro expansions are representad as flat function-level
-  // scopes.
-  SILGenFunctionBuilder B(SGM);
-  auto &ASTContext = SGM.M.getASTContext();
-  auto ExtInfo = SILFunctionType::ExtInfo::getThin();
-  auto FunctionType = SILFunctionType::get(
-      nullptr, ExtInfo, SILCoroutineKind::None,
-      ParameterConvention::Direct_Unowned, /*Params*/ {},
-      /*yields*/
-      {},
-      /*Results*/ {}, None, SubstitutionMap(), SubstitutionMap(), ASTContext);
-  StringRef MacroName = ASTContext.getIdentifier(Macro.Name).str();
-
-  SILFunction *MacroFn = B.getOrCreateFunction(
-      Macro.Loc, MacroName, SILLinkage::DefaultForDeclaration, FunctionType,
-      IsNotBare, IsNotTransparent, IsNotSerialized, IsNotDynamic,
-      IsNotDistributed, IsNotRuntimeAccessible);
-  // At the end of the chain OrigSLoc should be a macro expansion node.
-  const SILDebugScope *InlinedAt = nullptr;
-  const SILDebugScope *OrigScope = getOrCreateScope(OrigSLoc);
-  RegularLocation OrigLoc(OrigSLoc);
-  // Inject an extra scope to hold the inlined call site.
-  if (OrigScope)
-    InlinedAt = new (SGM.M)
-        SILDebugScope(Macro.Freestanding ? Macro.Loc : OrigLoc, nullptr,
-                      OrigScope, OrigScope->InlinedCallSite);
-
-  const SILDebugScope *Scope =
-      new (SGM.M) SILDebugScope(Macro.Loc, MacroFn, nullptr, InlinedAt);
-
-  InlinedScopeMap.insert({BufferID, Scope});
-  return Scope;
+  // Create the scope hierarchy inside the macro expansion.
+  auto *MacroAstScope =
+      ast_scope::ASTScopeImpl::findStartingScopeForLookup(SF, Macro.SLoc);
+  return getOrCreateScope(MacroAstScope, TopLevelScope,
+                          TopLevelScope->InlinedCallSite);
 }
 
 const SILDebugScope *
-SILGenFunction::getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope) {
-  const SILDebugScope *FnScope = F.getDebugScope();
-
+SILGenFunction::getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope,
+                                 const SILDebugScope *FnScope,
+                                 const SILDebugScope *InlinedAt) {
   if (!ASTScope)
     return FnScope;
 
   // Top-level function scope?
   if (ASTScope == FnASTScope)
     return FnScope;
 
-  auto It = ScopeMap.find(ASTScope);
+  auto It = ScopeMap.find({ASTScope, InlinedAt});
   if (It != ScopeMap.end())
     return It->second;
 
@@ -374,20 +382,21 @@ SILGenFunction::getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope) {
     //        Since the arguments to Constructor aren't marked as implicit,
     //        argument b is in the scope of v, but the call to Constructor
     //        isn't, which correctly triggers the scope hole verifier.
-    return B.getCurrentDebugScope();
+    auto *CurScope = B.getCurrentDebugScope();
+    return CurScope->InlinedCallSite != InlinedAt ? FnScope : CurScope;
   }
 
   // Collapse BraceStmtScopes whose parent is a .*BodyScope.
   if (auto Parent = ASTScope->getParent().getPtrOrNull())
     if (Parent->getSourceRangeOfThisASTNode() ==
         ASTScope->getSourceRangeOfThisASTNode())
-      return getOrCreateScope(Parent);
+      return getOrCreateScope(Parent, FnScope, InlinedAt);
 
   // The calls to defer closures have cleanup source locations pointing to the
   // defer. Reparent them into the current debug scope.
   auto *AncestorScope = ASTScope->getParent().getPtrOrNull();
   while (AncestorScope && AncestorScope != FnASTScope &&
-         !ScopeMap.count(AncestorScope)) {
+         !ScopeMap.count({AncestorScope, InlinedAt})) {
     if (auto *FD = dyn_cast_or_null<FuncDecl>(
           AncestorScope->getDeclIfAny().getPtrOrNull())) {
       if (cast<DeclContext>(FD) != FunctionDC)
@@ -404,10 +413,16 @@ SILGenFunction::getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope) {
   };
 
   const SILDebugScope *Parent =
-      getOrCreateScope(ASTScope->getParent().getPtrOrNull());
-  RegularLocation Loc(ASTScope->getSourceRangeOfThisASTNode().Start);
-  SILScope = new (SGM.M) SILDebugScope(Loc, &F, Parent);
-  ScopeMap.insert({ASTScope, SILScope});
+    getOrCreateScope(ASTScope->getParent().getPtrOrNull(), FnScope, InlinedAt);
+  SourceLoc SLoc = ASTScope->getSourceRangeOfThisASTNode().Start;
+  RegularLocation Loc(SLoc);
+  SILScope = new (SGM.M)
+      SILDebugScope(Loc, FnScope->getParentFunction(), Parent, InlinedAt);
+  ScopeMap.insert({{ASTScope, InlinedAt}, SILScope});
+
+  assert(SILScope->getParentFunction() == &F &&
+         "inlinedAt points to other function");
+
   return SILScope;
 }
 

lib/SILGen/SILGenFunction.h

@@ -367,8 +367,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   using ASTScopeTy = ast_scope::ASTScopeImpl;
   const ASTScopeTy *FnASTScope = nullptr;
   /// Caches one SILDebugScope for each ASTScope.
-  llvm::SmallDenseMap<const ASTScopeTy *, const SILDebugScope *, 16> ScopeMap;
-  /// Caches one inline SILDebugScope for each macro BufferID.
+  llvm::SmallDenseMap<std::pair<const ASTScopeTy *, const SILDebugScope *>,
+                      const SILDebugScope *, 16>
+      ScopeMap;
+  /// Caches one toplevel inline SILDebugScope for each macro BufferID.
   llvm::SmallDenseMap<unsigned, const SILDebugScope *, 16> InlinedScopeMap;
 
   /// The cleanup depth and BB for when the operand of a
@@ -720,7 +722,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   const SILDebugScope *getOrCreateScope(SourceLoc SLoc);
   const SILDebugScope *getMacroScope(SourceLoc SLoc);
   const SILDebugScope *
-  getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope);
+  getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope,
+                   const SILDebugScope *FnScope,
+                   const SILDebugScope *InlinedAt = nullptr);
 
 public:
   /// Enter the debug scope for \p Loc, creating it if necessary.

test/Macros/macro_expand.swift

@@ -98,9 +98,9 @@ struct Bad {}
 func testFileID(a: Int, b: Int) {
   // CHECK: MacroUser/macro_expand.swift
   print("Result is \(#customFileID)")
-  // CHECK-SIL: sil_scope [[SRC_SCOPE:[0-9]+]] { loc "{{.*}}macro_expand.swift":[[@LINE-3]]
+  // CHECK-SIL: sil_scope [[SRC_SCOPE:[0-9]+]] { loc "{{.*}}macro_expand.swift":[[@LINE-3]]:6 parent {{.*}}testFileID
   // CHECK-SIL: sil_scope [[EXPANSION_SCOPE:[0-9]+]] { loc "{{.*}}macro_expand.swift":[[@LINE-2]]:22 parent [[SRC_SCOPE]]
-  // CHECK-SIL: sil_scope [[MACRO_SCOPE:[0-9]+]] { loc "{{.*}}":[[@LINE-3]]:22 parent @$s9MacroUser10testFileID1a1bySi_SitF06customdE0fMf_ {{.*}} inlined_at [[EXPANSION_SCOPE]] }
+  // CHECK-SIL: sil_scope [[MACRO_SCOPE:[0-9]+]] { loc "@__swiftmacro{{.*}}":1:1 parent @$s9MacroUser10testFileID1a1bySi_SitF06customdE0fMf_ {{.*}} inlined_at [[EXPANSION_SCOPE]] }
   // CHECK-SIL: string_literal utf8 "MacroUser/macro_expand.swift", loc "@__swiftmacro_9MacroUser10testFileID1a1bySi_SitF06customdE0fMf_.swift":1:1, scope [[MACRO_SCOPE]]
   // CHECK-IR-DAG: !DISubprogram(name: "customFileID", linkageName: "$s9MacroUser10testFileID1a1bySi_SitF06customdE0fMf_"