Comments and some useful prints added

Author: Tetchki

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

@@ -282,6 +282,8 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
       if (emitSource) {
         sourceMap = sourceMapFor(cunit)(s => classBTypeFromSymbol(s).internalName)
+        // debugExtension is the ScalaDebug Stratum
+        // println(s"sourceMap for ${claszSymbol.fullName} = ${sourceMap.debugExtension}")
         cnode.visitSource(cunit.source.file.name, sourceMap.debugExtension.orNull)
       }
 
@@ -564,7 +566,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
             lnn.line = nr
           case _ =>
             mnode.visitLineNumber(nr, currProgramPoint())
-
+    
     def lineNumber(tree: Tree): Unit = {
       if !emitLines || !tree.span.exists then return;
       if tree.source != cunit.source then

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

@@ -85,6 +85,8 @@ object InlinedSourceMaps:
     val requests = mutable.ListBuffer.empty[(SourcePosition, SourcePosition)]
     var internalNames = Map.empty[SourceFile, String]
 
+    // Collect all inlined calls in the compilation unit
+
     class RequestCollector(enclosingFile: SourceFile) extends TreeTraverser:
       override def traverse(tree: Tree)(using Context): Unit =
         if tree.source != enclosingFile && tree.source != cunit.source then
@@ -95,6 +97,7 @@ object InlinedSourceMaps:
               cls match
                 case Some(symbol) if !internalNames.isDefinedAt(tree.source) =>
                   internalNames += (tree.source -> internalNameProvider(symbol))
+                  //println(s"Internal name for ${tree.source} is ${internalNames(tree.source)}")
                   // 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
@@ -107,17 +110,30 @@ object InlinedSourceMaps:
         else traverseChildren(tree)
     end RequestCollector
 
+    // Create the mapping from the real source files to the real and virtual lines
+
     // Don't generate mappings for the quotes compiled at runtime by the staging compiler
     if cunit.source.file.isVirtual then InlinedSourceMap(cunit, Nil, Map.empty[SourceFile, String])
     else
-      var lastLine = cunit.tpdTree.sourcePos.endLine
+      var lastLine = cunit.tpdTree.sourcePos.endLine // Last line of the source file
+      //println(s"lastLine = $lastLine")
       def allocate(origPos: SourcePosition): Int =
-        val line = lastLine + 1
+        val line = lastLine + 1 // Add an empty line. Why ?
         lastLine += origPos.lines.length
+        //println(s"LastLine = $lastLine, line = $line")
         line
 
       RequestCollector(cunit.source).traverse(cunit.tpdTree)
       val allocated = requests.sortBy(_._1.start).map(r => Request(r._1, r._2, allocate(r._2)))
+      // targetPos.startLine is the line in the source file where the inlined call is located
+      // origPos.startLine is the line in the source file where the inlined is defined
+      // firstFakeLine is the first virtual line of the inline
+      /*allocated.foreach { case Request(targetPos, origPos, firstFakeLine) =>
+        println(s"targetPos = ${targetPos.startLine}, origPos = ${origPos.startLine}, firstFakeLine = $firstFakeLine")
+      }*/
+      // internalNames is a map from source file to the internal name of the class that contains the inlined code
+      // Map(local/Macro_1.scala -> Macro_1$package$)
+      //println(s"internalNames = $internalNames")
       InlinedSourceMap(cunit, allocated.toList, internalNames)
   end sourceMapFor
 
@@ -126,10 +142,13 @@ object InlinedSourceMaps:
     requests: List[Request],
     internalNames: Map[SourceFile, String])(using Context):
 
+    // Generate the Scala Stratum and the ScalaDebug Stratum from the map created in sourceMapFor
+
     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) =>
+          //println(s" origPos = ${origPos.startLine}, files.indexOf(origPos.source) + 1 = ${files.indexOf(origPos.source) + 1}, origPos.lines.length = ${origPos.lines.length}, firstFakeLine = $firstFakeLine")
           Mapping(origPos.startLine, files.indexOf(origPos.source) + 1, origPos.lines.length, firstFakeLine, 1)
         }
         Stratum("Scala",

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -249,9 +249,15 @@ object Inlines:
 
   /** Replace `Inlined` node by a block that contains its bindings and expansion */
   def dropInlined(inlined: Inlined)(using Context): Tree =
+    //println(i"inlined : ${inlined.show}")
+    //println(i"inlined is empty : ${inlined.call.isEmpty}")
     val topLevelClass = Option.when(!inlined.call.isEmpty)(inlined.call.symbol.topLevelClass)
+    //println(i"topLevelClass : ${topLevelClass}")
     val inliningPosition = InliningPosition(inlined.sourcePos, topLevelClass)
+    //println(i"inliningPosition : ${inliningPosition}")
     val withPos = inlined.expansion.withAttachment(InliningPosition, inliningPosition)
+    //println(i"withPos : ${withPos}")
+    //println(i"inlined.bindings : ${inlined.bindings}")
     if inlined.bindings.isEmpty then withPos else cpy.Block(inlined)(inlined.bindings, withPos)
 
   /** Leave only a call trace consisting of

compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala

@@ -66,7 +66,7 @@ class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase
   private def ensurePrivateAccessible(d: SymDenotation)(using Context) =
     if (isVCPrivateParamAccessor(d))
       d.ensureNotPrivate.installAfter(thisPhase)
-    else if (d.is(PrivateTerm) && !d.owner.is(Package) && d.owner != ctx.owner.lexicallyEnclosingClass && !d.is(InlineProxy) && !d.is(Synthetic)) {
+    else if (d.is(PrivateTerm) && !d.owner.is(Package) && d.owner != ctx.owner.lexicallyEnclosingClass && !d.is(InlineProxy)) {
       // Paths `p1` and `p2` are similar if they have a common suffix that follows
       // possibly different directory paths. That is, their common suffix extends
       // in both cases either to the start of the path or to a file separator character.