additions: copy tests from metals version: 41e96ee33f82 , create diff utils, implement test framework

Author: rochala

compiler/src/dotty/tools/dotc/util/DiffUtil.scala

@@ -70,7 +70,9 @@ object DiffUtil {
    *         differences are highlighted.
    */
   def mkColoredLineDiff(expected: Seq[String], actual: Seq[String]): String = {
-    val expectedSize = EOF.length max expected.maxBy(_.length).length
+    val longestExpected = expected.map(_.length).maxOption.getOrElse(0)
+    val longestActual = actual.map(_.length).maxOption.getOrElse(0)
+    val expectedSize = EOF.length max longestActual max longestExpected
     actual.padTo(expected.length, "").zip(expected.padTo(actual.length, "")).map { case (act, exp) =>
       mkColoredLineDiff(exp, act, expectedSize)
     }.mkString(System.lineSeparator)
@@ -101,11 +103,75 @@ object DiffUtil {
         case Deleted(str) => deleted(str)
       }.mkString
 
+    (expectedDiff, actualDiff)
     val pad = " " * 0.max(expectedSize - expected.length)
 
     expectedDiff + pad + "  |  " + actualDiff
   }
 
+  private def ensureLineSeparator(str: String): String =
+    if str.endsWith(System.lineSeparator) then
+      str
+    else
+      str + System.lineSeparator
+
+  /**
+   * Returns a colored diffs by comparison of lines instead of tokens.
+   * It will automatically group subsequential pairs of `Insert` and `Delete`
+   * in order to improve the readability
+   *
+   * @param expected The expected lines
+   * @param actual   The actual lines
+   * @return A string with colored diffs between `expected` and `actual` grouped whenever possible
+   */
+  def mkColoredHorizontalLineDiff(expected: String, actual: String): String = {
+    val indent = 2
+    val tab = " " * indent
+    val insertIndent = "+" ++ (" " * (indent - 1))
+    val deleteIndent = "-" ++ (" " * (indent - 1))
+
+    if actual.isEmpty then
+      (expected.linesIterator.map(line => added(insertIndent + line)).toList :+ deleted("--- EMPTY OUTPUT ---"))
+        .map(ensureLineSeparator).mkString
+    else if expected.isEmpty then
+      (added("--- NO VALUE EXPECTED ---") +: actual.linesIterator.map(line => deleted(deleteIndent + line)).toList)
+        .map(ensureLineSeparator).mkString
+    else
+      lazy val diff = {
+        val expectedTokens = expected.linesWithSeparators.toArray
+        val actualTokens = actual.linesWithSeparators.toArray
+        hirschberg(actualTokens, expectedTokens)
+      }.toList
+
+      val transformedDiff = diff.flatMap {
+        case Modified(original, str) => Seq(
+          Inserted(ensureLineSeparator(original)), Deleted(ensureLineSeparator(str))
+        )
+        case other => Seq(other)
+      }
+
+      val zipped = transformedDiff zip transformedDiff.drop(1)
+
+      val (acc, inserts, deletions) = zipped.foldLeft((Seq[Patch](), Seq[Inserted](), Seq[Deleted]())): (acc, patches) =>
+        val (currAcc, inserts, deletions) = acc
+        patches match
+          case (currentPatch: Inserted, nextPatch: Deleted) =>
+            (currAcc, inserts :+ currentPatch, deletions)
+          case (currentPatch: Deleted, nextPatch: Inserted) =>
+            (currAcc, inserts, deletions :+ currentPatch)
+          case (currentPatch, nextPatch) =>
+            (currAcc :++ inserts :++ deletions :+ currentPatch, Seq.empty, Seq.empty)
+
+      val stackedDiff = acc :++ inserts :++ deletions :+ diff.last
+
+      stackedDiff.collect {
+        case Unmodified(str) => tab + str
+        case Inserted(str) => added(insertIndent + str)
+        case Deleted(str) => deleted(deleteIndent + str)
+      }.map(ensureLineSeparator).mkString
+
+  }
+
   def mkColoredCodeDiff(code: String, lastCode: String, printDiffDel: Boolean): String = {
     val tokens = splitTokens(code, Nil).toArray
     val lastTokens = splitTokens(lastCode, Nil).toArray

presentation-compiler/test/dotty/tools/pc/base/BaseAutoImportsSuite.scala

@@ -0,0 +1,73 @@
+package dotty.tools.pc.base
+
+import dotty.tools.pc.utils.TextEdits
+
+import java.nio.file.Paths
+import scala.meta.internal.jdk.CollectionConverters.*
+import scala.meta.internal.metals.CompilerOffsetParams
+import scala.meta.pc.AutoImportsResult
+
+trait BaseAutoImportsSuite extends BaseCodeActionSuite:
+
+  val isExtensionMethods: Boolean = false
+
+  def check(
+      original: String,
+      expected: String
+  ): Unit =
+    val imports = getAutoImports(original, "A.scala")
+    val obtained = imports.map(_.packageName()).mkString("\n")
+    assertNoDiff(expected, obtained)
+
+  def checkEdit(
+      original: String,
+      expected: String,
+      selection: Int = 0,
+      filename: String = "A.scala"
+  ): Unit =
+    checkEditSelection(filename, original, expected, selection)
+
+  def checkAmmoniteEdit(
+      original: String,
+      expected: String,
+      selection: Int = 0
+  ): Unit =
+    checkEditSelection(
+      "script.amm.sc.scala",
+      original,
+      expected,
+      selection
+    )
+
+  def checkEditSelection(
+      filename: String,
+      original: String,
+      expected: String,
+      selection: Int
+  ): Unit =
+    val imports = getAutoImports(original, filename)
+    if (imports.size <= selection) fail("Obtained no expected imports")
+    val edits = imports(selection).edits().asScala.toList
+    val (code, _, _) = params(original)
+    val obtained = TextEdits.applyEdits(code, edits)
+
+    assertNoDiff(expected, obtained)
+
+  def getAutoImports(
+      original: String,
+      filename: String
+  ): List[AutoImportsResult] =
+    val (code, symbol, offset) = params(original)
+    val result = presentationCompiler
+      .autoImports(
+        symbol,
+        CompilerOffsetParams(
+          Paths.get(filename).toUri(),
+          code,
+          offset,
+          cancelToken
+        ),
+        isExtensionMethods
+      )
+      .get()
+    result.asScala.toList

presentation-compiler/test/dotty/tools/pc/base/BaseCodeActionSuite.scala

@@ -0,0 +1,28 @@
+package dotty.tools.pc.base
+
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+import scala.collection.immutable
+import scala.meta.internal.metals.EmptyCancelToken
+import scala.meta.pc.CancelToken
+
+abstract class BaseCodeActionSuite extends BasePCSuite:
+
+  def cancelToken: CancelToken = EmptyCancelToken
+
+  def params(
+      code: String
+  ): (String, String, Int) =
+    val filename = "test.scala"
+    val targetRegex = "<<(.+)>>".r
+    val target = targetRegex.findAllMatchIn(code).toList match
+      case immutable.Nil => fail("Missing <<target>>")
+      case t :: immutable.Nil => t.group(1)
+      case _ => fail("Multiple <<targets>> found")
+    val code2 = code.replace("<<", "").replace(">>", "")
+    val offset = code.indexOf("<<") + target.length()
+    val file = tmp.resolve(filename)
+    Files.write(file, code2.getBytes(StandardCharsets.UTF_8))
+
+    testingWorkspaceSearch.inputs.update(filename, code)
+    (code2, target, offset)