Add information aobut internal class name to SMAP

Author: Kordyjan

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -281,7 +281,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
                   superClass, interfaceNames.toArray)
 
       if (emitSource) {
-        sourceMap = sourceMapFor(cunit)
+        sourceMap = sourceMapFor(cunit)(s => classBTypeFromSymbol(s).internalName)
         cnode.visitSource(cunit.source.file.name, sourceMap.debugExtension.orNull)
       }
 

compiler/src/dotty/tools/backend/jvm/InlinedSourceMaps.scala

@@ -6,11 +6,11 @@ import dotc.CompilationUnit
 import dotc.ast.tpd._
 import dotc.util.{ SourcePosition, SourceFile }
 import dotc.core.Contexts._
+import dotc.core.Symbols.Symbol
 import dotc.report
 import dotc.typer.Inliner.InliningPosition
 import collection.mutable
 
-import scala.collection.mutable.StringBuilder
 
 object InlinedSourceMaps:
   private case class Request(targetPos: SourcePosition, origPos: SourcePosition, firstFakeLine: Int)
@@ -61,17 +61,26 @@ object InlinedSourceMaps:
         b ++= "*E\n"
   end Stratum
 
-  def sourceMapFor(cunit: CompilationUnit)(using Context): InlinedSourceMap =
+  def sourceMapFor(cunit: CompilationUnit)(internalNameProvider: Symbol => String)(using Context): InlinedSourceMap =
     val requests = mutable.ListBuffer.empty[Request]
     var lastLine = cunit.tpdTree.sourcePos.endLine
+    var internalNames = Map.empty[SourceFile, String]
 
     class RequestCollector(enclosingFile: SourceFile) extends TreeTraverser:
       override def traverse(tree: Tree)(using Context): Unit =
         if tree.source != enclosingFile && tree.source != cunit.source then
           tree.getAttachment(InliningPosition) match
-            case Some(targetPos) =>
+            case Some(InliningPosition(targetPos, cls)) =>
               val firstFakeLine = allocate(tree.sourcePos)
               requests += Request(targetPos, tree.sourcePos, firstFakeLine)
+              cls match
+                case Some(symbol) if !internalNames.isDefinedAt(tree.source) =>
+                  internalNames += (tree.source -> internalNameProvider(symbol))
+                  // We are skipping any internal name info if we already have one stored in our map
+                  // because a debugger will use internal name only to localize matching source.
+                  // Both old and new internal names are associated with the same source file
+                  // so it doesn't matter if internal name is not matching used symbol.
+                case _ => ()
               RequestCollector(tree.source).traverseChildren(tree)
             case None =>
               // Not exactly sure in which cases it is happening. Should we report warning?
@@ -85,17 +94,24 @@ object InlinedSourceMaps:
       line
 
     RequestCollector(cunit.source).traverse(cunit.tpdTree)
-    InlinedSourceMap(cunit, requests.toList)
+    InlinedSourceMap(cunit, requests.toList, internalNames)
   end sourceMapFor
 
-  class InlinedSourceMap private[InlinedSourceMaps] (cunit: CompilationUnit, requests: List[Request])(using Context):
+  class InlinedSourceMap private[InlinedSourceMaps] (
+    cunit: CompilationUnit,
+    requests: List[Request],
+    internalNames: Map[SourceFile, String])(using Context):
+
     def debugExtension: Option[String] = Option.when(requests.nonEmpty) {
       val scalaStratum =
         val files = cunit.source :: requests.map(_.origPos.source).distinct.filter(_ != cunit.source)
         val mappings = requests.map { case Request(_, origPos, firstFakeLine) =>
           Mapping(origPos.startLine, files.indexOf(origPos.source) + 1, origPos.lines.length, firstFakeLine, 1)
         }
-        Stratum("Scala", files.zipWithIndex.map { case (f, n) => File(n + 1, f.name, None) }, Mapping(0, 1, cunit.tpdTree.sourcePos.lines.length, 0, 1) +: mappings)
+        Stratum("Scala",
+          files.zipWithIndex.map { case (f, n) => File(n + 1, f.name, internalNames.get(f)) },
+          Mapping(0, 1, cunit.tpdTree.sourcePos.lines.length, 0, 1) +: mappings
+        )
 
       val debugStratum =
         val mappings = requests.map { case Request(targetPos, origPos, firstFakeLine) =>

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -37,7 +37,8 @@ import quoted.QuoteUtils
 object Inliner {
   import tpd._
 
-  val InliningPosition = new Property.StickyKey[SourcePosition]
+  object InliningPosition extends Property.StickyKey[InliningPosition]
+  case class InliningPosition(sourcePos: SourcePosition, topLevelSymbol: Option[Symbol])
 
   /** `sym` is an inline method with a known body to inline.
    */
@@ -226,12 +227,15 @@ object Inliner {
 
   /** Replace `Inlined` node by a block that contains its bindings and expansion */
   def dropInlined(inlined: Inlined)(using Context): Tree =
-    // In case that bindings are present we are adding SourcePosition attachement both to the resulting block and to the expansion
+    val topLevelClass = Some(inlined.call.symbol.topLevelClass).filter(_.exists)
+    val inliningPosition = InliningPosition(inlined.sourcePos, topLevelClass)
+
+    // In case that bindings are present we are adding InliningPosition attachement both to the resulting block and to the expansion
     // as in some cases the block is removed in one of later phases and attachment is lost.
     val tree1 =
       if inlined.bindings.isEmpty then inlined.expansion
-      else cpy.Block(inlined)(inlined.bindings, inlined.expansion.withAttachment(InliningPosition, inlined.sourcePos))
-    tree1.withAttachment(InliningPosition, inlined.sourcePos)
+      else cpy.Block(inlined)(inlined.bindings, inlined.expansion.withAttachment(InliningPosition, inliningPosition))
+    tree1.withAttachment(InliningPosition, inliningPosition)
 
   /** Leave only a call trace consisting of
    *  - a reference to the top-level class from which the call was inlined,