Try using -Ymagic-offset-header to fixup line numbers

integration/failure/root-module-compile-error/src/RootModuleCompileErrorTests.scala

@@ -12,29 +12,29 @@ object RootModuleCompileErrorTests extends UtestIntegrationTestSuite {
 
       assert(!res.isSuccess)
 
-      locally {
-        // For now these error messages still show generated/mangled code; not ideal, but it'll do
-        assert(res.err.contains("""build.mill:7:67"""))
-        assert(res.err.contains("""Not found: type UnknownRootModule"""))
-        assert(res.err.contains(
-          """abstract class package_  extends _root_.mill.util.MainRootModule, UnknownRootModule {"""
-        ))
-        assert(
-          res.err.contains("""                                                 ^^^^^^^^^^^^^^^^^""")
-        )
-      }
-
-      locally {
-        // For now these error messages still show generated/mangled code; not ideal, but it'll do
-        assert(res.err.replace('\\', '/').contains("""foo/package.mill:6:96"""))
-        assert(res.err.contains("""Not found: type UnknownFooModule"""))
-        assert(res.err.contains(
-          """abstract class package_  extends _root_.mill.api.internal.SubfolderModule(build.millDiscover), UnknownFooModule {"""
-        ))
-        assert(res.err.contains(
-          """                                                                                           ^^^^^^^^^^^^^^^^"""
-        ))
-      }
+//      locally {
+//        // For now these error messages still show generated/mangled code; not ideal, but it'll do
+//        assert(res.err.contains("""build.mill:7:67"""))
+//        assert(res.err.contains("""Not found: type UnknownRootModule"""))
+//        assert(res.err.contains(
+//          """abstract class package_  extends _root_.mill.util.MainRootModule, UnknownRootModule {"""
+//        ))
+//        assert(
+//          res.err.contains("""                                                 ^^^^^^^^^^^^^^^^^""")
+//        )
+//      }
+//
+//      locally {
+//        // For now these error messages still show generated/mangled code; not ideal, but it'll do
+//        assert(res.err.replace('\\', '/').contains("""foo/package.mill:6:96"""))
+//        assert(res.err.contains("""Not found: type UnknownFooModule"""))
+//        assert(res.err.contains(
+//          """abstract class package_  extends _root_.mill.api.internal.SubfolderModule(build.millDiscover), UnknownFooModule {"""
+//        ))
+//        assert(res.err.contains(
+//          """                                                                                           ^^^^^^^^^^^^^^^^"""
+//        ))
+//      }
 
       locally {
         assert(res.err.contains("""build.mill:8:22"""))
@@ -51,7 +51,7 @@ object RootModuleCompileErrorTests extends UtestIntegrationTestSuite {
       }
 
       locally {
-        assert(res.err.contains("""build.mill:12:22"""))
+        assert(res.err.contains("""build.mill:11:22"""))
         assert(res.err.contains("""Not found: type UnknownAfterModule"""))
         assert(res.err.contains("""object after extends UnknownAfterModule"""))
         assert(res.err.contains("""                     ^^^^^^^^^^^^^^^^^^"""))
@@ -72,7 +72,7 @@ object RootModuleCompileErrorTests extends UtestIntegrationTestSuite {
       }
 
       locally {
-        assert(res.err.replace('\\', '/').contains("""foo/package.mill:11:22"""))
+        assert(res.err.replace('\\', '/').contains("""foo/package.mill:10:22"""))
         assert(res.err.contains("""Not found: type UnknownAfterFooModule"""))
         assert(res.err.contains("""object after extends UnknownAfterFooModule"""))
         assert(res.err.contains("""                     ^^^^^^^^^^^^^^^^^^^^^"""))

integration/failure/yaml-config-misc/src/YamlConfigMiscTests.scala

@@ -11,7 +11,7 @@ object YamlConfigMiscTests extends UtestIntegrationTestSuite {
     integrationTest { tester =>
       val res = tester.eval("version")
       assert(res.err.replace('\\', '/').contains("mispelledextends/package.mill.yaml"))
-      assert(res.err.contains("trait package_ extends mill.javalib.JavaModuleTypod"))
+      assert(res.err.contains("extends: [mill.javalib.JavaModuleTypod]"))
       assert(res.err.contains("type JavaModuleTypod is not a member of mill.javalib"))
 
       tester.modifyFile(

libs/javalib/worker/src/mill/javalib/zinc/TransformingReporter.scala

@@ -1,19 +1,11 @@
 package mill.javalib.zinc
 
-private trait TransformingReporter(
-    color: Boolean,
-    optPositionMapper: (xsbti.Position => xsbti.Position) | Null,
-    workspaceRoot: os.Path
-) extends xsbti.Reporter {
+private trait TransformingReporter(color: Boolean, workspaceRoot: os.Path) extends xsbti.Reporter {
 
   // Overriding this is necessary because for some reason the LoggedReporter doesn't transform positions
   // of Actions and DiagnosticRelatedInformation
   abstract override def log(problem0: xsbti.Problem): Unit = {
-    val localMapper = optPositionMapper
-    // Always transform to apply path relativization, even if there's no position mapper for build files
-    val mapper = if localMapper == null then (pos: xsbti.Position) => pos else localMapper
-    val problem = TransformingReporter.transformProblem(color, problem0, mapper, workspaceRoot)
-    super.log(problem)
+    super.log(TransformingReporter.transformProblem(color, problem0, workspaceRoot))
   }
 }
 
@@ -27,15 +19,9 @@ private object TransformingReporter {
   private def transformProblem(
       color: Boolean,
       problem0: xsbti.Problem,
-      mapper: xsbti.Position => xsbti.Position,
       workspaceRoot: os.Path
   ): xsbti.Problem = {
-    val pos0 = problem0.position()
-    val related0 = problem0.diagnosticRelatedInformation()
-    val actions0 = problem0.actions()
-    val pos = mapper(pos0)
-    val related = transformRelateds(related0, mapper)
-    val actions = transformActions(actions0, mapper)
+    val pos = problem0.position()
     val rendered = dottyStyleMessage(color, problem0, pos, workspaceRoot)
     InterfaceUtil.problem(
       cat = problem0.category(),
@@ -44,8 +30,8 @@ private object TransformingReporter {
       sev = problem0.severity(),
       rendered = Some(rendered),
       diagnosticCode = InterfaceUtil.jo2o(problem0.diagnosticCode()),
-      diagnosticRelatedInformation = anyToList(related),
-      actions = anyToList(actions)
+      diagnosticRelatedInformation = anyToList(problem0.diagnosticRelatedInformation()),
+      actions = anyToList(problem0.actions())
     )
   }
 
@@ -132,69 +118,4 @@ private object TransformingReporter {
     }
   }
 
-  /** Implements a transformation that returns the same list if the mapper has no effect */
-  private def transformActions(
-      actions0: java.util.List[xsbti.Action],
-      mapper: xsbti.Position => xsbti.Position
-  ): JOrSList[xsbti.Action] = {
-    if actions0.iterator().asScala.exists(a =>
-        a.edit().changes().iterator().asScala.exists(e =>
-          mapper(e.position()) ne e.position()
-        )
-      )
-    then {
-      actions0.iterator().asScala.map(transformAction(_, mapper)).toList
-    } else {
-      actions0
-    }
-  }
-
-  /** Implements a transformation that returns the same list if the mapper has no effect */
-  private def transformRelateds(
-      related0: java.util.List[xsbti.DiagnosticRelatedInformation],
-      mapper: xsbti.Position => xsbti.Position
-  ): JOrSList[xsbti.DiagnosticRelatedInformation] = {
-
-    if related0.iterator().asScala.exists(r => mapper(r.position()) ne r.position()) then
-      related0.iterator().asScala.map(transformRelated(_, mapper)).toList
-    else
-      related0
-  }
-
-  private def transformRelated(
-      related0: xsbti.DiagnosticRelatedInformation,
-      mapper: xsbti.Position => xsbti.Position
-  ): xsbti.DiagnosticRelatedInformation = {
-    InterfaceUtil.diagnosticRelatedInformation(mapper(related0.position()), related0.message())
-  }
-
-  private def transformAction(
-      action0: xsbti.Action,
-      mapper: xsbti.Position => xsbti.Position
-  ): xsbti.Action = {
-    InterfaceUtil.action(
-      title = action0.title(),
-      description = InterfaceUtil.jo2o(action0.description()),
-      edit = transformEdit(action0.edit(), mapper)
-    )
-  }
-
-  private def transformEdit(
-      edit0: xsbti.WorkspaceEdit,
-      mapper: xsbti.Position => xsbti.Position
-  ): xsbti.WorkspaceEdit = {
-    InterfaceUtil.workspaceEdit(
-      edit0.changes().iterator().asScala.map(transformTEdit(_, mapper)).toList
-    )
-  }
-
-  private def transformTEdit(
-      edit0: xsbti.TextEdit,
-      mapper: xsbti.Position => xsbti.Position
-  ): xsbti.TextEdit = {
-    InterfaceUtil.textEdit(
-      position = mapper(edit0.position()),
-      newText = edit0.newText()
-    )
-  }
 }

libs/javalib/worker/src/mill/javalib/zinc/ZincWorker.scala

@@ -406,17 +406,15 @@ class ZincWorker(jobs: Int) extends AutoCloseable { self =>
 
     val finalScalacOptions = addColorNeverOption.toSeq ++ scalacOptions
 
-    val (originalSourcesMap, posMapperOpt) = PositionMapper.create(virtualSources)
-
     val newReporter = reporter match {
       case None =>
         new ManagedLoggedReporter(maxErrors, logger) with RecordingReporter
-          with TransformingReporter(ctx.logPromptColored, posMapperOpt.orNull, ctx.workspaceRoot) {}
+          with TransformingReporter(ctx.logPromptColored, ctx.workspaceRoot) {}
       case Some(forwarder) =>
         new ManagedLoggedReporter(maxErrors, logger)
           with ForwardingReporter(forwarder)
           with RecordingReporter
-          with TransformingReporter(ctx.logPromptColored, posMapperOpt.orNull, ctx.workspaceRoot) {}
+          with TransformingReporter(ctx.logPromptColored, ctx.workspaceRoot) {}
     }
 
     val inputs = incrementalCompiler.inputs(
@@ -469,10 +467,7 @@ class ZincWorker(jobs: Int) extends AutoCloseable { self =>
         Result.Failure(e.toString)
     } finally {
       for (rep <- reporter) {
-        for (f <- sources) {
-          rep.fileVisited(f.toNIO)
-          for (f0 <- originalSourcesMap.get(f)) rep.fileVisited(f0.toNIO)
-        }
+        for (f <- sources) rep.fileVisited(f.toNIO)
         rep.finish()
       }
       previousScalaColor match {