parameters();
+}
diff --git a/pc/interfaces/src/main/java/scala/meta/pc/SymbolIndexer.java b/pc/interfaces/src/main/java/scala/meta/pc/SymbolIndexer.java
new file mode 100644
index 00000000000..37b04ac9296
--- /dev/null
+++ b/pc/interfaces/src/main/java/scala/meta/pc/SymbolIndexer.java
@@ -0,0 +1,5 @@
+package scala.meta.pc;
+
+public interface SymbolIndexer {
+ void visit(String symbol, SymbolVisitor visitor);
+}
diff --git a/pc/interfaces/src/main/java/scala/meta/pc/SymbolSearch.java b/pc/interfaces/src/main/java/scala/meta/pc/SymbolSearch.java
new file mode 100644
index 00000000000..f692e49bcad
--- /dev/null
+++ b/pc/interfaces/src/main/java/scala/meta/pc/SymbolSearch.java
@@ -0,0 +1,11 @@
+package scala.meta.pc;
+
+public interface SymbolSearch {
+ Result search(String query,
+ String buildTargetIdentifier,
+ SymbolSearchVisitor visitor);
+ enum Result {
+ COMPLETE,
+ INCOMPLETE
+ }
+}
diff --git a/pc/interfaces/src/main/java/scala/meta/pc/SymbolSearchVisitor.java b/pc/interfaces/src/main/java/scala/meta/pc/SymbolSearchVisitor.java
new file mode 100644
index 00000000000..865f2e8d4aa
--- /dev/null
+++ b/pc/interfaces/src/main/java/scala/meta/pc/SymbolSearchVisitor.java
@@ -0,0 +1,18 @@
+package scala.meta.pc;
+
+import org.eclipse.lsp4j.Range;
+import org.eclipse.lsp4j.SymbolKind;
+
+import java.nio.file.Path;
+
+public abstract class SymbolSearchVisitor {
+
+ abstract public boolean shouldVisitPackage(String pkg);
+ abstract public int visitClassfile(String pkg, String filename);
+
+ abstract public boolean shouldVisitPath(Path path);
+ abstract public int visitWorkspaceSymbol(Path path, String symbol, SymbolKind kind, Range range);
+
+ abstract public boolean isCancelled();
+
+}
diff --git a/pc/interfaces/src/main/java/scala/meta/pc/SymbolVisitor.java b/pc/interfaces/src/main/java/scala/meta/pc/SymbolVisitor.java
new file mode 100644
index 00000000000..e331301df5a
--- /dev/null
+++ b/pc/interfaces/src/main/java/scala/meta/pc/SymbolVisitor.java
@@ -0,0 +1,5 @@
+package scala.meta.pc;
+
+public abstract class SymbolVisitor {
+ public abstract void visitSymbol(SymbolDocumentation symbol);
+}
diff --git a/test-workspace/src/main/scala/example/User.scala b/test-workspace/src/main/scala/example/User.scala
index dc0973af7f8..2b0859e7818 100644
--- a/test-workspace/src/main/scala/example/User.scala
+++ b/test-workspace/src/main/scala/example/User.scala
@@ -1,12 +1,5 @@
-package example
+package myexample
-import java.nio.file.Paths
-
-case class User(
- name: String,
- age: Int
-)
-
-object User {
- val path = Paths.get("build.sbt")
+object A {
+ Iterator.empty.map(e => e)
}
diff --git a/tests/cross/src/main/scala/tests/BaseCompletionSuite.scala b/tests/cross/src/main/scala/tests/BaseCompletionSuite.scala
new file mode 100644
index 00000000000..866aedfa0b0
--- /dev/null
+++ b/tests/cross/src/main/scala/tests/BaseCompletionSuite.scala
@@ -0,0 +1,72 @@
+package tests
+
+import scala.collection.JavaConverters._
+import scala.meta.internal.metals.CompilerOffsetParams
+import scala.meta.pc.CompletionItems
+import scala.meta.internal.metals.PCEnrichments._
+
+abstract class BaseCompletionSuite extends BasePCSuite {
+
+ def checkLength(
+ name: String,
+ original: String,
+ expected: Int,
+ compat: Map[String, Int] = Map.empty
+ ): Unit = {
+ test(name) {
+ val (code, offset) = params(original)
+ val result = pc.complete(CompilerOffsetParams("A.scala", code, offset))
+ assertEquals(
+ result.getItems.size(),
+ getExpected(expected, compat)
+ )
+ }
+ }
+
+ private def resolvedCompletions(
+ params: CompilerOffsetParams
+ ): CompletionItems = {
+ val result = pc.complete(params)
+ val newItems = result.getItems.asScala.map { item =>
+ val symbol = item.data.get.symbol
+ pc.completionItemResolve(item, symbol)
+ }
+ result.setItems(newItems.asJava)
+ result
+ }
+
+ def check(
+ name: String,
+ original: String,
+ expected: String,
+ includeDocs: Boolean = false,
+ includeCommitCharacter: Boolean = false,
+ compat: Map[String, String] = Map.empty
+ )(implicit filename: sourcecode.File, line: sourcecode.Line): Unit = {
+ test(name) {
+ val (code, offset) = params(original)
+ val result =
+ resolvedCompletions(CompilerOffsetParams("A.scala", code, offset))
+ val out = new StringBuilder()
+ result.getItems.asScala.sortBy(_.getSortText).foreach { item =>
+ val label =
+ if (item.getInsertText == null) item.getLabel else item.getInsertText
+ val commitCharacter =
+ if (includeCommitCharacter)
+ item.getCommitCharacters.asScala.mkString(" (commit: '", " ", "')")
+ else ""
+ val documentation = doc(item.getDocumentation)
+ if (includeDocs && documentation.nonEmpty) {
+ out.append("> ").append(documentation).append("\n")
+ }
+ out
+ .append(label)
+ .append(item.getDetail)
+ .append(commitCharacter)
+ .append("\n")
+ }
+ assertNoDiff(out.toString(), getExpected(expected, compat))
+ }
+ }
+
+}
diff --git a/tests/cross/src/main/scala/tests/BasePCSuite.scala b/tests/cross/src/main/scala/tests/BasePCSuite.scala
new file mode 100644
index 00000000000..b01abd5ba89
--- /dev/null
+++ b/tests/cross/src/main/scala/tests/BasePCSuite.scala
@@ -0,0 +1,97 @@
+package tests
+
+import com.geirsson.coursiersmall.CoursierSmall
+import com.geirsson.coursiersmall.Dependency
+import com.geirsson.coursiersmall.Settings
+import java.net.URLClassLoader
+import java.nio.file.Path
+import java.nio.file.Paths
+import org.eclipse.lsp4j.MarkupContent
+import org.eclipse.lsp4j.jsonrpc.messages.{Either => JEither}
+import scala.collection.JavaConverters._
+import scala.meta.internal.metals.ClasspathSearch
+import scala.meta.internal.metals.JdkSources
+import scala.meta.internal.metals.MetalsSymbolIndexer
+import scala.meta.internal.mtags.OnDemandSymbolIndex
+import scala.meta.internal.pc.ScalaPresentationCompiler
+import scala.meta.io.AbsolutePath
+import scala.util.Properties
+
+abstract class BasePCSuite extends BaseSuite {
+ val scalaLibrary: Seq[Path] =
+ this.getClass.getClassLoader
+ .asInstanceOf[URLClassLoader]
+ .getURLs
+ .iterator
+ .filter(_.getPath.contains("scala-library"))
+ .map(url => Paths.get(url.toURI))
+ .toSeq
+ def extraClasspath: List[Path] = Nil
+ val myclasspath: List[Path] = extraClasspath ++ scalaLibrary.toList
+ val index = OnDemandSymbolIndex()
+ val indexer = new MetalsSymbolIndexer(index)
+ val search = new SimpleSymbolSearch(
+ ClasspathSearch.fromClasspath(myclasspath, _ => 0)
+ )
+ val pc = new ScalaPresentationCompiler()
+ .withIndexer(indexer)
+ .withSearch(search)
+ .newInstance("", myclasspath.asJava, Nil.asJava)
+
+ def indexJDK(): Unit = {
+ index.addSourceJar(JdkSources().get)
+ }
+ def indexScalaLibrary(): Unit = {
+ val sources = CoursierSmall.fetch(
+ new Settings()
+ .withClassifiers(List("sources"))
+ .withDependencies(
+ List(
+ new Dependency(
+ "org.scala-lang",
+ "scala-library",
+ BuildInfoVersions.scala212
+ )
+ )
+ )
+ )
+ sources.foreach { jar =>
+ index.addSourceJar(AbsolutePath(jar))
+ }
+ }
+
+ override def beforeAll(): Unit = {
+ indexJDK()
+ indexScalaLibrary()
+ }
+ override def afterAll(): Unit = {
+ pc.shutdown()
+ }
+ def params(code: String): (String, Int) = {
+ val code2 = code.replaceAllLiterally("@@", "")
+ val offset = code.indexOf("@@")
+ if (offset < 0) {
+ fail("missing @@")
+ }
+ search.source = code2
+ (code2, offset)
+ }
+ def doc(e: JEither[String, MarkupContent]): String = {
+ if (e == null) ""
+ else if (e.isLeft) {
+ " " + e.getLeft
+ } else {
+ " " + e.getRight.getValue
+ }
+ }.trim
+ private def scalaVersion: String =
+ Properties.versionNumberString
+ private def scalaBinary: String =
+ scalaVersion.split("\\.").take(2).mkString(".")
+ def getExpected[T](default: T, compat: Map[String, T]): T = {
+ compat
+ .get(scalaBinary)
+ .orElse(compat.get(scalaVersion))
+ .getOrElse(default)
+ }
+}
diff --git a/tests/cross/src/main/scala/tests/BaseSignatureHelpSuite.scala b/tests/cross/src/main/scala/tests/BaseSignatureHelpSuite.scala
new file mode 100644
index 00000000000..bb413111589
--- /dev/null
+++ b/tests/cross/src/main/scala/tests/BaseSignatureHelpSuite.scala
@@ -0,0 +1,68 @@
+package tests
+
+import scala.collection.JavaConverters._
+import scala.meta.internal.metals.CompilerOffsetParams
+
+abstract class BaseSignatureHelpSuite extends BasePCSuite {
+ def checkDoc(name: String, code: String, expected: String): Unit = {
+ check(name, code, expected, includeDocs = true)
+ }
+ def check(
+ name: String,
+ original: String,
+ expected: String,
+ includeDocs: Boolean = false,
+ compat: Map[String, String] = Map.empty
+ ): Unit = {
+ test(name) {
+ val (code, offset) = params(original)
+ val result =
+ pc.signatureHelp(CompilerOffsetParams("A.scala", code, offset))
+ val out = new StringBuilder()
+ if (result != null) {
+ result.getSignatures.asScala.zipWithIndex.foreach {
+ case (signature, i) =>
+ if (includeDocs) {
+ val sdoc = doc(signature.getDocumentation)
+ if (sdoc.nonEmpty) {
+ out.append(sdoc).append("\n")
+ }
+ }
+ out
+ .append(signature.getLabel)
+ .append("\n")
+ if (result.getActiveSignature == i && result.getActiveParameter != null) {
+ val param = signature.getParameters.get(result.getActiveParameter)
+ val column = signature.getLabel.indexOf(param.getLabel)
+ if (column < 0) {
+ fail(s"""invalid parameter label
+ | param.label : ${param.getLabel}
+ | signature.label: ${signature.getLabel}
+ |""".stripMargin)
+ }
+ val indent = " " * column
+ out
+ .append(indent)
+ .append("^" * param.getLabel.length)
+ .append("\n")
+ signature.getParameters.asScala.foreach { param =>
+ val pdoc = doc(param.getDocumentation)
+ .stripPrefix("```scala\n")
+ .stripSuffix("\n```")
+ .replaceAllLiterally("\n```\n", " ")
+ if (includeDocs && pdoc.nonEmpty) {
+ out
+ .append(" @param ")
+ .append(param.getLabel.replaceFirst(":.*", ""))
+ .append(" ")
+ .append(pdoc)
+ .append("\n")
+ }
+ }
+ }
+ }
+ }
+ assertNoDiff(out.toString(), getExpected(expected, compat))
+ }
+ }
+}
diff --git a/tests/cross/src/main/scala/tests/SimpleSymbolSearch.scala b/tests/cross/src/main/scala/tests/SimpleSymbolSearch.scala
new file mode 100644
index 00000000000..1b3b389118a
--- /dev/null
+++ b/tests/cross/src/main/scala/tests/SimpleSymbolSearch.scala
@@ -0,0 +1,28 @@
+package tests
+
+import java.nio.file.Paths
+import scala.meta.inputs.Input
+import scala.meta.internal.metals.ClasspathSearch
+import scala.meta.internal.metals.SemanticdbDefinition
+import scala.meta.internal.metals.WorkspaceSymbolQuery
+import scala.meta.pc.SymbolSearch
+import scala.meta.pc.SymbolSearchVisitor
+
+class SimpleSymbolSearch(classpath: ClasspathSearch) extends SymbolSearch {
+ var source = ""
+ val path = Paths.get("A.scala")
+ override def search(
+ textQuery: String,
+ buildTargetIdentifier: String,
+ visitor: SymbolSearchVisitor
+ ): SymbolSearch.Result = {
+ val query = WorkspaceSymbolQuery.exact(textQuery)
+ SemanticdbDefinition.foreach(Input.VirtualFile("A.scala", source)) { defn =>
+ if (query.matches(defn.info)) {
+ val c = defn.toCached
+ visitor.visitWorkspaceSymbol(path, c.symbol, c.kind, c.range)
+ }
+ }
+ classpath.search(query, visitor)
+ }
+}
diff --git a/tests/cross/src/test/scala/tests/pc/CompletionDocSuite.scala b/tests/cross/src/test/scala/tests/pc/CompletionDocSuite.scala
new file mode 100644
index 00000000000..81982ead984
--- /dev/null
+++ b/tests/cross/src/test/scala/tests/pc/CompletionDocSuite.scala
@@ -0,0 +1,262 @@
+package tests.pc
+
+import tests.BaseCompletionSuite
+
+object CompletionDocSuite extends BaseCompletionSuite {
+
+ check(
+ "java",
+ """
+ |object A {
+ | "".substrin@@
+ |}
+ """.stripMargin,
+ """|substring(beginIndex: Int): String
+ |substring(beginIndex: Int, endIndex: Int): String
+ |""".stripMargin
+ )
+
+ check(
+ "java2",
+ """
+ |object A {
+ | String.join@@
+ |}
+ """.stripMargin,
+ """|join(delimiter: CharSequence, elements: CharSequence*): String
+ |join(delimiter: CharSequence, elements: Iterable[_ <: CharSequence]): String
+ |""".stripMargin
+ )
+
+ check(
+ "java3",
+ """
+ |import scala.collection.JavaConverters._
+ |object A {
+ | new java.util.HashMap[String, Int]().entrySet.asScala.foreach { entry =>
+ | entry.setV@@
+ | }
+ |}
+ """.stripMargin,
+ """|setValue(value: Int): Int
+ |""".stripMargin
+ )
+ check(
+ "java4",
+ """
+ |object A {
+ | java.util.Collections.singletonLis@@
+ |}
+ """.stripMargin,
+ """|singletonList[T](o: T): List[T]
+ |""".stripMargin
+ )
+ check(
+ "java5",
+ """
+ |object A {
+ | java.util.OptionalInt@@
+ |}
+ """.stripMargin,
+ """|> A container object which may or may not contain a {@code int} value.
+ |If a value is present, {@code isPresent()} will return {@code true} and
+ |{@code getAsInt()} will return the value.
+ |
+ |Additional methods that depend on the presence or absence of a contained
+ |value are provided, such as {@link #orElse(int) orElse()}
+ |(return a default value if value not present) and
+ |{@link #ifPresent(java.util.function.IntConsumer) ifPresent()} (execute a block
+ |of code if the value is present).
+ |
+ |
This is a value-based
+ |class; use of identity-sensitive operations (including reference equality
+ |({@code ==}), identity hash code, or synchronization) on instances of
+ |{@code OptionalInt} may have unpredictable results and should be avoided.
+ |OptionalInt java.util
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala",
+ """
+ |object A {
+ | val source: io.Source = ???
+ | source.reportWarn@@
+ |}
+ """.stripMargin,
+ """|reportWarning(pos: Int, msg: String, out: PrintStream = Console.out): Unit
+ |""".stripMargin
+ )
+
+ check(
+ "scala1",
+ """
+ |object A {
+ | List(1).iterator.sliding@@
+ |}
+ """.stripMargin,
+ """|sliding[B >: Int](size: Int, step: Int = 1): Iterator[Int]#GroupedIterator[B]
+ |""".stripMargin
+ )
+
+ check(
+ "scala2",
+ """
+ |object A {
+ | println@@
+ |}
+ """.stripMargin,
+ """|> Prints a newline character on the default output.
+ |println(): Unit
+ |> Prints out an object to the default output, followed by a newline character.
+ |println(x: Any): Unit
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala3",
+ """
+ |object A {
+ | Predef@@
+ |}
+ """.stripMargin,
+ """|DeprecatedPredef scala
+ |> The `Predef` object provides definitions that are accessible in all Scala
+ | compilation units without explicit qualification.
+ |Predef scala
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala4",
+ """
+ |object A {
+ | scala.collection.Iterator@@
+ |}
+ """.stripMargin,
+ """|> Explicit instantiation of the `Iterator` trait to reduce class file size in subclasses.
+ |AbstractIterator scala.collection
+ |> Buffered iterators are iterators which provide a method `head`
+ | that inspects the next element without discarding it.
+ |BufferedIterator scala.collection
+ |> ### class Iterator
+ |Iterators are data structures that allow to iterate over a sequence
+ | of elements.
+ |
+ |### object Iterator
+ |The `Iterator` object provides various functions for creating specialized iterators.
+ |Iterator scala.collection
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala5",
+ """
+ |object A {
+ | scala.concurrent.ExecutionContext.Implicits.global@@
+ |}
+ """.stripMargin,
+ """|> The implicit global `ExecutionContext`.
+ |global: ExecutionContext
+ |""".stripMargin,
+ includeDocs = true,
+ compat = Map(
+ "2.11" -> """|> The implicit global `ExecutionContext`.
+ |global: ExecutionContextExecutor
+ |""".stripMargin
+ )
+ )
+ check(
+ "scala6",
+ """
+ |object A {
+ | scala.util.Try@@
+ |}
+ """.stripMargin,
+ """|> The `Try` type represents a computation that may either result in an exception, or return a
+ |successfully computed value.
+ |Try scala.util
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala7",
+ """
+ |object A {
+ | scala.collection.mutable.StringBuilder@@
+ |}
+ """.stripMargin,
+ """|> A builder for mutable sequence of characters.
+ |StringBuilder scala.collection.mutable
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala8",
+ """
+ |object A {
+ | scala.Vector@@
+ |}
+ """.stripMargin,
+ """|> ### class Vector
+ |Vector is a general-purpose, immutable data structure.
+ |
+ |### object Vector
+ |Companion object to the Vector class
+ |Vector scala.collection.immutable
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala9",
+ """
+ |object A {
+ | new Catch@@
+ |}
+ """.stripMargin,
+ """|> A container class for catch/finally logic.
+ |scala.util.control.Exception.Catch scala.util.control.Exception
+ |""".stripMargin,
+ includeDocs = true
+ )
+
+ check(
+ "scala10",
+ """
+ |object A {
+ | scala.util.Failure@@
+ |}
+ """.stripMargin,
+ """|Failure scala.util
+ |""".stripMargin,
+ includeDocs = true
+ )
+ check(
+ "scala11",
+ """
+ |object A {
+ | new scala.util.DynamicVariable@@
+ |}
+ """.stripMargin,
+ """|> `DynamicVariables` provide a binding mechanism where the current
+ | value is found through dynamic scope, but where access to the
+ | variable itself is resolved through static scope.
+ |DynamicVariable scala.util
+ |""".stripMargin,
+ includeDocs = true
+ )
+
+ check(
+ "local",
+ """
+ |object A {
+ | locally {
+ | val myNumbers = Vector(1)
+ | myNumbers@@
+ | }
+ |}
+ """.stripMargin,
+ """|myNumbers: Vector[Int]
+ |""".stripMargin
+ )
+}
diff --git a/tests/cross/src/test/scala/tests/pc/CompletionSuite.scala b/tests/cross/src/test/scala/tests/pc/CompletionSuite.scala
new file mode 100644
index 00000000000..c1dab6d1721
--- /dev/null
+++ b/tests/cross/src/test/scala/tests/pc/CompletionSuite.scala
@@ -0,0 +1,455 @@
+package tests.pc
+
+import tests.BaseCompletionSuite
+
+object CompletionSuite extends BaseCompletionSuite {
+ override def beforeAll(): Unit = {
+ indexJDK()
+ }
+
+ // The following method tests too many results so we only assert the total number of results
+ // to catch at least regressions. It's OK to update the expected number, but at least double check
+ // the output makes sense before doing so.
+ checkLength(
+ "open",
+ """
+ |object Local {
+ | @@
+ |}""".stripMargin,
+ 457,
+ compat = Map("2.11" -> 456)
+ )
+
+ check(
+ "scope",
+ """
+ |object A {
+ | Lis@@
+ |}""".stripMargin,
+ """|List scala.collection.immutable
+ |java.awt.List java.awt
+ |java.util.List java.util
+ |scala.collection.immutable.ListMap scala.collection.immutable
+ |scala.collection.mutable.ListMap scala.collection.mutable
+ |scala.collection.immutable.ListSet scala.collection.immutable
+ |java.awt.peer.ListPeer java.awt.peer
+ |org.w3c.dom.NameList org.w3c.dom
+ |org.w3c.dom.NodeList org.w3c.dom
+ |java.util.ArrayList java.util
+ |org.w3c.dom.stylesheets.MediaList org.w3c.dom.stylesheets
+ |""".stripMargin
+ )
+
+ check(
+ "member",
+ """
+ |object A {
+ | List.emp@@
+ |}""".stripMargin,
+ """
+ |empty[A]: List[A]
+ |""".stripMargin
+ )
+
+ check(
+ "extension",
+ """
+ |object A {
+ | "".stripSu@@
+ |}""".stripMargin,
+ """|stripSuffix(suffix: String): String
+ |""".stripMargin
+ )
+
+ check(
+ "tparam",
+ """
+ |class Foo[A] {
+ | def identity[B >: A](a: B): B = a
+ |}
+ |object Foo {
+ | new Foo[Int].ident@@
+ |}""".stripMargin,
+ """|identity[B >: Int](a: B): B
+ |""".stripMargin
+ )
+
+ check(
+ "tparam1",
+ """
+ |class Foo[A] {
+ | def identity(a: A): A = a
+ |}
+ |object Foo {
+ | new Foo[Int].ident@@
+ |}""".stripMargin,
+ """|identity(a: Int): Int
+ |""".stripMargin
+ )
+ check(
+ "tparam2",
+ """
+ |object A {
+ | Map.empty[Int, String].getOrEl@@
+ |}""".stripMargin,
+ """|getOrElse[V1 >: String](key: Int, default: => V1): V1
+ |""".stripMargin,
+ compat = Map(
+ "2.11" -> "getOrElse[B1 >: String](key: Int, default: => B1): B1"
+ )
+ )
+
+ check(
+ "cursor",
+ """
+ |object A {
+ | val default = 1
+ | def@@
+ |}""".stripMargin,
+ """|default: Int
+ |""".stripMargin
+ )
+
+ check(
+ "dot",
+ """
+ |object A {
+ | List.@@
+ |}""".stripMargin,
+ """|apply[A](xs: A*): List[A]
+ |canBuildFrom[A]: CanBuildFrom[List.Coll,A,List[A]]
+ |empty[A]: List[A]
+ |newBuilder[A]: Builder[A,List[A]]
+ |GenericCanBuildFrom scala.collection.generic.GenTraversableFactory
+ |ReusableCBF: List.GenericCanBuildFrom[Nothing]
+ |concat[A](xss: Traversable[A]*): List[A]
+ |fill[A](n1: Int, n2: Int)(elem: => A): List[List[A]]
+ |fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): List[List[List[A]]]
+ |fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): List[List[List[List[A]]]]
+ |fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): List[List[List[List[List[A]]]]]
+ |fill[A](n: Int)(elem: => A): List[A]
+ |iterate[A](start: A, len: Int)(f: A => A): List[A]
+ |range[T](start: T, end: T)(implicit evidence$1: Integral[T]): List[T]
+ |range[T](start: T, end: T, step: T)(implicit evidence$2: Integral[T]): List[T]
+ |tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): List[List[A]]
+ |tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): List[List[List[A]]]
+ |tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): List[List[List[List[A]]]]
+ |tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): List[List[List[List[List[A]]]]]
+ |tabulate[A](n: Int)(f: Int => A): List[A]
+ |unapplySeq[A](x: List[A]): Some[List[A]]
+ |->[B](y: B): (A, B)
+ |+(other: String): String
+ |ensuring(cond: A => Boolean): A
+ |ensuring(cond: A => Boolean, msg: => Any): A
+ |ensuring(cond: Boolean): A
+ |ensuring(cond: Boolean, msg: => Any): A
+ |formatted(fmtstr: String): String
+ |asInstanceOf[T0]: T0
+ |equals(obj: Any): Boolean
+ |getClass(): Class[_]
+ |hashCode(): Int
+ |isInstanceOf[T0]: Boolean
+ |synchronized[T0](x$1: T0): T0
+ |toString(): String
+ |""".stripMargin
+ )
+
+ check(
+ "implicit-class",
+ """
+ |object A {
+ | implicit class XtensionMethod(a: Int) {
+ | def increment = a + 1
+ | }
+ | Xtension@@
+ |}""".stripMargin,
+ """|XtensionMethod(a: Int): A.XtensionMethod
+ |""".stripMargin
+ )
+
+ check(
+ "fuzzy",
+ """
+ |object A {
+ | def userService = 1
+ | uService@@
+ |}""".stripMargin,
+ """|userService: Int
+ |""".stripMargin
+ )
+
+ check(
+ "fuzzy1",
+ """
+ |object A {
+ | new PBuil@@
+ |}""".stripMargin,
+ """|ProcessBuilder java.lang
+ |scala.sys.process.ProcessBuilder scala.sys.process
+ |java.security.cert.CertPathBuilder java.security.cert
+ |java.security.cert.CertPathBuilderSpi java.security.cert
+ |scala.sys.process.ProcessBuilderImpl scala.sys.process
+ |java.security.cert.CertPathBuilderResult java.security.cert
+ |java.security.cert.PKIXBuilderParameters java.security.cert
+ |java.security.cert.CertPathBuilderException java.security.cert
+ |java.security.cert.PKIXCertPathBuilderResult java.security.cert
+ |""".stripMargin
+ )
+
+ check(
+ "companion",
+ """
+ |import scala.collection.concurrent._
+ |object A {
+ | TrieMap@@
+ |}""".stripMargin,
+ """|TrieMap scala.collection.concurrent
+ |scala.collection.parallel.mutable.ParTrieMap scala.collection.parallel.mutable
+ |scala.collection.immutable.HashMap.HashTrieMap scala.collection.immutable.HashMap
+ |scala.collection.parallel.mutable.ParTrieMapCombiner scala.collection.parallel.mutable
+ |scala.collection.parallel.mutable.ParTrieMapSplitter scala.collection.parallel.mutable
+ |scala.collection.concurrent.TrieMapSerializationEnd scala.collection.concurrent
+ |""".stripMargin
+ )
+
+ check(
+ "pkg",
+ """
+ |import scala.collection.conc@@
+ |""".stripMargin,
+ """|concurrent scala.collection
+ |""".stripMargin
+ )
+
+ check(
+ "import",
+ """
+ |import JavaCon@@
+ |""".stripMargin,
+ """|scala.collection.JavaConverters scala.collection
+ |scala.collection.JavaConversions scala.collection
+ |scala.concurrent.JavaConversions scala.concurrent
+ |scala.collection.convert.AsJavaConverters scala.collection.convert
+ |""".stripMargin,
+ compat = Map(
+ "2.11" -> """|scala.collection.JavaConverters scala.collection
+ |scala.collection.JavaConversions scala.collection
+ |scala.concurrent.JavaConversions scala.concurrent
+ |""".stripMargin
+ )
+ )
+
+ check(
+ "import1",
+ """
+ |import Paths@@
+ |""".stripMargin,
+ """|java.nio.file.Paths java.nio.file
+ |""".stripMargin
+ )
+
+ check(
+ "import2",
+ """
+ |import Catch@@
+ |""".stripMargin,
+ """|scala.util.control.Exception.Catch scala.util.control.Exception
+ |""".stripMargin
+ )
+
+ check(
+ "import3",
+ """
+ |import Path@@
+ |""".stripMargin,
+ """|java.nio.file.Path java.nio.file
+ |java.nio.file.Paths java.nio.file
+ |java.awt.geom.Path2D java.awt.geom
+ |java.security.cert.CertPath java.security.cert
+ |java.awt.font.LayoutPath java.awt.font
+ |java.awt.geom.GeneralPath java.awt.geom
+ |java.nio.file.PathMatcher java.nio.file
+ |org.w3c.dom.xpath.XPathResult org.w3c.dom.xpath
+ |java.awt.geom.PathIterator java.awt.geom
+ |org.w3c.dom.xpath.XPathEvaluator org.w3c.dom.xpath
+ |org.w3c.dom.xpath.XPathException org.w3c.dom.xpath
+ |""".stripMargin
+ )
+
+ check(
+ "accessible",
+ """
+ |package a
+ |import MetaData@@
+ |""".stripMargin,
+ """|java.sql.DatabaseMetaData java.sql
+ |java.sql.ParameterMetaData java.sql
+ |java.sql.ResultSetMetaData java.sql
+ |""".stripMargin
+ )
+
+ check(
+ "source",
+ """
+ |package a
+ |object Main {
+ | import Inner@@
+ |}
+ |object Outer {
+ | class Inner
+ |}
+ |""".stripMargin,
+ """|a.Outer.Inner a.Outer
+ |""".stripMargin
+ )
+
+ check(
+ "duplicate",
+ """
+ |package a
+ |object Main {
+ | import a.Outer.Inner
+ | import Inner@@
+ |}
+ |object Outer {
+ | class Inner
+ |}
+ |""".stripMargin,
+ ""
+ )
+
+ check(
+ "duplicate2",
+ """
+ |package a
+ |import java.nio.file.Files
+ |
+ |final class AbsolutePath private (val underlying: String) extends AnyVal {
+ | def syntax: String = Files@@
+ |}
+ |
+ |object Outer {
+ | object Files
+ |}
+ |""".stripMargin,
+ """Files java.nio.file
+ |a.Outer.Files a.Outer
+ |""".stripMargin
+ )
+
+ check(
+ "commit",
+ """
+ |package a
+ |
+ |object Main{
+ | Map.emp@@
+ |}
+ |""".stripMargin,
+ """|empty[K, V]: Map[K,V] (commit: '.')
+ |""".stripMargin,
+ includeCommitCharacter = true,
+ compat = Map(
+ "2.11" -> "empty[A, B]: Map[A,B] (commit: '.')"
+ )
+ )
+
+ check(
+ "numeric-sort",
+ """
+ |package a
+ |
+ |object Main{
+ | scala.Function@@
+ |}
+ |""".stripMargin,
+ // assert that we don't sort lexicographically: Function1, Function11, ..., Function2, ...
+ """|Function scala
+ |Function0 scala
+ |Function1 scala
+ |Function2 scala
+ |Function3 scala
+ |Function4 scala
+ |Function5 scala
+ |Function6 scala
+ |Function7 scala
+ |Function8 scala
+ |Function9 scala
+ |Function10 scala
+ |Function11 scala
+ |Function12 scala
+ |Function13 scala
+ |Function14 scala
+ |Function15 scala
+ |Function16 scala
+ |Function17 scala
+ |Function18 scala
+ |Function19 scala
+ |Function20 scala
+ |Function21 scala
+ |Function22 scala
+ |PartialFunction scala
+ |""".stripMargin
+ )
+
+ check(
+ "sam",
+ """
+ |object A {
+ | new java.util.ArrayList[String]().forEach(p => p.toChar@@)
+ |}
+ """.stripMargin,
+ """|toCharArray(): Array[Char]
+ |""".stripMargin,
+ compat = Map(
+ "2.11" -> "" // SAM was introduced in Scala 2.12
+ )
+ )
+
+ check(
+ "implicit",
+ """
+ |object A {
+ | Array.concat@@
+ |}
+ """.stripMargin,
+ """|concat[T](xss: Array[T]*)(implicit evidence$8: ClassTag[T]): Array[T]
+ |""".stripMargin
+ )
+ check(
+ "bounds",
+ """
+ |object A {
+ | java.nio.file.Files.readAttributes@@
+ |}
+ """.stripMargin,
+ """|readAttributes(path: Path, attributes: String, options: LinkOption*): Map[String,Object]
+ |readAttributes[A <: BasicFileAttributes](path: Path, type: Class[A], options: LinkOption*): A
+ |""".stripMargin
+ )
+
+ check(
+ "local",
+ """
+ |object A {
+ | locally {
+ | val thisIsLocal = 1
+ | thisIsLoc@@
+ | }
+ |}
+ """.stripMargin,
+ """|thisIsLocal: Int
+ |""".stripMargin
+ )
+ check(
+ "singleton",
+ """
+ |class A {
+ | def incrementThisType(): this.type = x
+ | incrementThisType@@
+ |}
+ """.stripMargin,
+ """|incrementThisType(): A.this.type (with underlying type A)
+ |""".stripMargin
+ )
+}
diff --git a/tests/cross/src/test/scala/tests/pc/SignatureHelpDocSuite.scala b/tests/cross/src/test/scala/tests/pc/SignatureHelpDocSuite.scala
new file mode 100644
index 00000000000..52a12afbb7a
--- /dev/null
+++ b/tests/cross/src/test/scala/tests/pc/SignatureHelpDocSuite.scala
@@ -0,0 +1,201 @@
+package tests.pc
+
+import tests.BaseSignatureHelpSuite
+
+object SignatureHelpDocSuite extends BaseSignatureHelpSuite {
+ checkDoc(
+ "curry",
+ """
+ |object a {
+ | Option(1).fold("")(_ => @@)
+ |}
+ """.stripMargin,
+ """|Returns the result of applying $f to this $option's
+ | value if the $option is nonempty.
+ |fold[B](ifEmpty: => B)(f: Int => B): B
+ | ^^^^^^^^^^^
+ | @param ifEmpty `.
+ | @param f Int => ??? to this $option's
+ |""".stripMargin
+ )
+
+ checkDoc(
+ "curry2",
+ """
+ |object a {
+ | Option(1).fold("@@")
+ |}
+ """.stripMargin,
+ """|Returns the result of applying $f to this $option's
+ | value if the $option is nonempty.
+ |fold[B](ifEmpty: => B)(f: Int => B): B
+ | ^^^^^^^^^^^^^
+ | @param ifEmpty String `.
+ | @param f to this $option's
+ |""".stripMargin
+ )
+ checkDoc(
+ "curry3",
+ """
+ |object a {
+ | List(1).foldLeft(0) {
+ | case @@
+ | }
+ |}
+ """.stripMargin,
+ """|
+ |foldLeft[B](z: B)(op: (B, Int) => B): B
+ | ^^^^^^^^^^^^^^^^^
+ | @param op (Int, Int) => Int
+ |""".stripMargin
+ )
+ checkDoc(
+ "curry4",
+ """
+ |object a {
+ | def curry(a: Int, b: Int)(c: Int) = a
+ | curry(1)(3@@)
+ |}
+ """.stripMargin,
+ """|
+ |curry(a: Int, b: Int)(c: Int): Int
+ | ^^^^^^
+ |""".stripMargin
+ )
+ checkDoc(
+ "canbuildfrom",
+ """
+ |object a {
+ | List(1).map(x => @@)
+ |}
+ """.stripMargin,
+ """|
+ |map[B, That](f: Int => B)(implicit bf: CanBuildFrom[List[Int],B,That]): That
+ | ^^^^^^^^^^^
+ | @param f Int => ???
+ |""".stripMargin
+ )
+ checkDoc(
+ "too-many",
+ """
+ |object a {
+ | Option(1, 2, @@2)
+ |}
+ """.stripMargin,
+ // FIXME: https://github.com/scalameta/metals/issues/518
+ // The expected output is broken here.
+ """|An Option factory which creates Some(x) if the argument is not null,
+ | and None if it is null.
+ |apply[A](x: A): Option[A]
+ | ^^^^
+ | @param A n Option factory which creates Some(x) if the argument is not null,
+ | @param x (Int, Int, Int) ) if the argument is not null,
+ |""".stripMargin
+ )
+ checkDoc(
+ "java5",
+ """
+ |object a {
+ | java.util.Collections.singleton(@@)
+ |}
+ """.stripMargin,
+ """| Returns an immutable set containing only the specified object.
+ |The returned set is serializable.
+ |singleton[T](o: T): Set[T]
+ | ^^^^
+ | @param T the class of the objects in the set
+ | @param o o the sole object to be stored in the returned set.
+ |""".stripMargin
+ )
+ checkDoc(
+ "default",
+ """
+ |object A {
+ | new scala.util.control.Exception.Catch(@@)
+ |}
+ """.stripMargin,
+ """|A container class for catch/finally logic.
+ |(pf: Exception.Catcher[T], fin: Option[Exception.Finally] = None, rethrow: Throwable => Boolean = shouldRethrow): Exception.Catch[T]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ | @param pf Partial function used when applying catch logic to determine result value
+ | @param fin ally logic.
+ | @param rethrow if you want to probably
+ |""".stripMargin
+ )
+ check(
+ "java",
+ """
+ |object a {
+ | new java.io.File(@@)
+ |}
+ """.stripMargin,
+ """|(uri: URI): File
+ |(parent: File, child: String): File
+ |(parent: String, child: String): File
+ |(pathname: String): File
+ |""".stripMargin
+ )
+ check(
+ "java2",
+ """
+ |object a {
+ | "".substring(1@@)
+ |}
+ """.stripMargin,
+ """|substring(beginIndex: Int, endIndex: Int): String
+ |substring(beginIndex: Int): String
+ | ^^^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "java3",
+ """
+ |object a {
+ | String.valueOf(1@@)
+ |}
+ """.stripMargin,
+ """|valueOf(d: Double): String
+ |valueOf(f: Float): String
+ |valueOf(l: Long): String
+ |valueOf(i: Int): String
+ | ^^^^^^
+ |valueOf(c: Char): String
+ |valueOf(b: Boolean): String
+ |valueOf(data: Array[Char], offset: Int, count: Int): String
+ |valueOf(data: Array[Char]): String
+ |valueOf(obj: Any): String
+ |""".stripMargin
+ )
+ check(
+ "java4",
+ """
+ |object a {
+ | String.valueOf(@@)
+ |}
+ """.stripMargin,
+ """|valueOf(d: Double): String
+ | ^^^^^^^^^
+ |valueOf(f: Float): String
+ |valueOf(l: Long): String
+ |valueOf(i: Int): String
+ |valueOf(c: Char): String
+ |valueOf(b: Boolean): String
+ |valueOf(data: Array[Char]): String
+ |valueOf(obj: Any): String
+ |""".stripMargin
+ )
+ checkDoc(
+ "ctor2",
+ """
+ |object a {
+ | new Some(10@@)
+ |}
+ """.stripMargin,
+ """|Class `Some[A]` represents existing values of type
+ | `A`.
+ |(value: Int): Some[Int]
+ | ^^^^^^^^^^
+ | @param value s of type
+ |""".stripMargin
+ )
+}
diff --git a/tests/cross/src/test/scala/tests/pc/SignatureHelpSuite.scala b/tests/cross/src/test/scala/tests/pc/SignatureHelpSuite.scala
new file mode 100644
index 00000000000..9c7d979bb75
--- /dev/null
+++ b/tests/cross/src/test/scala/tests/pc/SignatureHelpSuite.scala
@@ -0,0 +1,368 @@
+package tests.pc
+
+import tests.BaseSignatureHelpSuite
+
+object SignatureHelpSuite extends BaseSignatureHelpSuite {
+ override def beforeAll(): Unit = ()
+ check(
+ "method",
+ """
+ |object a {
+ | assert(true, ms@@)
+ |}
+ """.stripMargin,
+ """|assert(assertion: Boolean, message: => Any): Unit
+ | ^^^^^^^^^^^^^^^
+ |assert(assertion: Boolean): Unit
+ |""".stripMargin
+ )
+ check(
+ "empty",
+ """
+ |object a {
+ | assert(@@)
+ |}
+ """.stripMargin,
+ """|assert(assertion: Boolean, message: => Any): Unit
+ |assert(assertion: Boolean): Unit
+ | ^^^^^^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "erroneous",
+ """
+ |object a {
+ | Option(1).fold("")(_ => a@@)
+ |}
+ """.stripMargin,
+ """|fold[B](ifEmpty: => B)(f: Int => B): B
+ | ^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "canbuildfrom2",
+ """
+ |object a {
+ | List(1).map(@@)
+ |}
+ """.stripMargin,
+ """|map[B, That](f: Int => B)(implicit bf: CanBuildFrom[List[Int],B,That]): That
+ | ^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "ctor",
+ """
+ |object a {
+ | new scala.util.Random(@@)
+ |}
+ """.stripMargin,
+ """|(): Random
+ |(seed: Int): Random
+ |(seed: Long): Random
+ |(self: java.util.Random): Random
+ |""".stripMargin
+ )
+ check(
+ "ctor1",
+ """
+ |object a {
+ | new ProcessBuilder(@@)
+ |}
+ """.stripMargin,
+ """|(x$1: String*): ProcessBuilder
+ |(x$1: List[String]): ProcessBuilder
+ |""".stripMargin
+ )
+ check(
+ "ctor2",
+ """
+ |object a {
+ | new Some(10@@)
+ |}
+ """.stripMargin,
+ """|(value: Int): Some[Int]
+ | ^^^^^^^^^^
+ |""".stripMargin,
+ compat = Map(
+ "2.11" ->
+ """|(x: Int): Some[Int]
+ | ^^^^^^
+ |""".stripMargin
+ )
+ )
+
+ check(
+ "apply",
+ """
+ |object a {
+ | def apply(a: Int): Int = a
+ | def apply(b: String): String = b
+ | a(""@@)
+ |}
+ """.stripMargin,
+ """|apply(b: String): String
+ | ^^^^^^^^^
+ |apply(a: Int): Int
+ |""".stripMargin
+ )
+ check(
+ "partial",
+ """
+ |object a {
+ | Option(1).collect {
+ | case@@
+ | }
+ |}
+ """.stripMargin,
+ """|collect[B](pf: PartialFunction[Int,B]): Option[B]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "nested",
+ """
+ |object a {
+ | List(Option(1@@))
+ |}
+ """.stripMargin,
+ """|apply[A](x: A): Option[A]
+ | ^^^^
+ |""".stripMargin
+ )
+ check(
+ "nested2",
+ """
+ |object a {
+ | List(Opt@@ion(1))
+ |}
+ """.stripMargin,
+ """|apply[A](xs: A*): List[A]
+ | ^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "nested3",
+ """
+ |object a {
+ | List(Option(@@))
+ |}
+ """.stripMargin,
+ """|apply[A](x: A): Option[A]
+ |""".stripMargin
+ )
+ check(
+ "vararg",
+ """
+ |object a {
+ | List(1, 2@@
+ |}
+ """.stripMargin,
+ """|apply[A](xs: A*): List[A]
+ | ^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "tparam",
+ """
+ |object a {
+ | identity[I@@]
+ |}
+ """.stripMargin,
+ """|identity[A](x: A): A
+ | ^
+ |""".stripMargin
+ )
+ check(
+ "tparam2",
+ """
+ |object a {
+ | Option.empty[I@@]
+ |}
+ """.stripMargin,
+ """|empty[A]: Option[A]
+ | ^
+ |""".stripMargin
+ )
+ check(
+ "tparam3",
+ """
+ |object a {
+ | Option[I@@]
+ |}
+ """.stripMargin,
+ """|apply[A](x: A): Option[A]
+ | ^
+ |""".stripMargin
+ )
+ check(
+ "tparam4",
+ """
+ |object a {
+ | Map.empty[I@@]
+ |}
+ """.stripMargin,
+ """|empty[K, V]: Map[K,V]
+ | ^
+ |""".stripMargin,
+ compat = Map(
+ "2.11" ->
+ """|empty[A, B]: Map[A,B]
+ | ^
+ |""".stripMargin
+ )
+ )
+ check(
+ "tparam5",
+ """
+ |object a {
+ | List[String](1).lengthCompare(@@)
+ |}
+ """.stripMargin,
+ """|lengthCompare(len: Int): Int
+ | ^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "error1",
+ """
+ |object a {
+ | Map[Int](1 @@-> "").map {
+ | }
+ |}
+ """.stripMargin,
+ ""
+ )
+ check(
+ "for",
+ """
+ |object a {
+ | for {
+ | i <- Option(1)
+ | j < 1.to(i)
+ | if i > j
+ | k@@ = i + j
+ | l <- j.to(k)
+ | } yield l
+ |}
+ """.stripMargin,
+ """|flatMap[B](f: Int => Option[B]): Option[B]
+ | ^^^^^^^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+
+ check(
+ "bounds",
+ """
+ |object a {
+ | Map.empty[Int, String].applyOrElse(1@@)
+ |}
+ """.stripMargin,
+ """|applyOrElse[K1 <: Int, V1 >: String](x: K1, default: K1 => V1): V1
+ | ^^^^^
+ |""".stripMargin,
+ compat = Map(
+ "2.11" ->
+ """|applyOrElse[A1 <: Int, B1 >: String](x: A1, default: A1 => B1): B1
+ | ^^^^^
+ |""".stripMargin
+ )
+ )
+
+ check(
+ "error",
+ """
+ |object a {
+ | Map[Int](1 @@-> "").map {
+ | }
+ |}
+ """.stripMargin,
+ ""
+ )
+
+ check(
+ "named",
+ """
+ |case class User(name: String = "John", age: Int = 42)
+ |object A {
+ | User(age = 1, @@)
+ |}
+ """.stripMargin,
+ """|apply(, ): User
+ | ^^^^^^^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "named1",
+ """
+ |case class User(name: String = "John", age: Int = 42)
+ |object A {
+ | User(name = "", @@)
+ |}
+ """.stripMargin,
+ """|apply(name: String = {}, age: Int = {}): User
+ | ^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "named2",
+ """
+ |object A {
+ | def user(name: String, age: Int) = age
+ | user(na@@me = "", age = 42)
+ |}
+ """.stripMargin,
+ """|user(name: String, age: Int): Int
+ | ^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "named3",
+ """
+ |object A {
+ | def user(name: String, age: Int): Int = age
+ | def user(name: String, age: Int, street: Int): Int = age
+ | def x = user(str@@eet = 42, name = "", age = 2)
+ |}
+ """.stripMargin,
+ """|user(name: String, age: Int, street: Int): Int
+ | ^^^^^^^^^^^^
+ |user(name: String, age: Int): Int
+ |""".stripMargin
+ )
+ check(
+ "short-name",
+ """
+ |object A {
+ | new scala.util.control.Exception.Catch(@@)
+ |}
+ """.stripMargin,
+ """|(pf: Exception.Catcher[T], fin: Option[Exception.Finally] = {}, rethrow: Throwable => Boolean = {}): Exception.Catch[T]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "short-name1",
+ """
+ |object A {
+ | new java.util.HashMap[String, Int]().computeIfAbsent(@@)
+ |}
+ """.stripMargin,
+ """|computeIfAbsent(x$1: String, x$2: Function[_ >: String, _ <: Int]): Int
+ | ^^^^^^^^^^^
+ |""".stripMargin
+ )
+ check(
+ "curry5",
+ """
+ |object a {
+ | def curry(a: Int)(c: Int) = a
+ | curry(1)(3@@)
+ |}
+ """.stripMargin,
+ """|
+ |curry(a: Int)(c: Int): Int
+ | ^^^^^^
+ |""".stripMargin
+ )
+}
diff --git a/tests/input/src/main/java/example/JavaClass.java b/tests/input/src/main/java/example/JavaClass.java
index 8211e757f87..10c6eaafec6 100644
--- a/tests/input/src/main/java/example/JavaClass.java
+++ b/tests/input/src/main/java/example/JavaClass.java
@@ -2,6 +2,9 @@
public class JavaClass {
+ private JavaClass() {
+
+ }
public JavaClass(int d) {
this.d = d;
}
diff --git a/tests/unit/src/main/scala/tests/BaseSuite.scala b/tests/mtest/src/main/scala/tests/BaseSuite.scala
similarity index 97%
rename from tests/unit/src/main/scala/tests/BaseSuite.scala
rename to tests/mtest/src/main/scala/tests/BaseSuite.scala
index 9ae141058d6..9453d60c440 100644
--- a/tests/unit/src/main/scala/tests/BaseSuite.scala
+++ b/tests/mtest/src/main/scala/tests/BaseSuite.scala
@@ -4,7 +4,6 @@ import scala.concurrent.Await
import scala.concurrent.Future
import scala.concurrent.duration.Duration
import scala.language.experimental.macros
-import scala.meta.internal.metals.MetalsLogger
import scala.meta.io.AbsolutePath
import scala.reflect.ClassTag
import utest.TestSuite
@@ -23,7 +22,6 @@ import utest.ufansi.Str
*
*/
class BaseSuite extends TestSuite {
- MetalsLogger.updateDefaultFormat()
System.setProperty("metals.testing", "true")
def isAppveyor: Boolean = "True" == System.getenv("APPVEYOR")
def beforeAll(): Unit = ()
@@ -95,9 +93,11 @@ class BaseSuite extends TestSuite {
override def exceptionStackFrameHighlighter(
s: StackTraceElement
): Boolean = {
+ s.getClassName.startsWith("scala.meta.internal.pc.") ||
s.getClassName.startsWith("scala.meta.internal.mtags.") ||
s.getClassName.startsWith("scala.meta.internal.metals.") ||
s.getClassName.startsWith("scala.meta.metals.") ||
+ s.getClassName.startsWith("scala.meta.pc.") ||
(s.getClassName.startsWith("tests") &&
!s.getClassName.startsWith("tests.DiffAssertions") &&
!s.getClassName.startsWith("tests.MegaSuite"))
diff --git a/tests/unit/src/main/scala/tests/DiffAssertions.scala b/tests/mtest/src/main/scala/tests/DiffAssertions.scala
similarity index 100%
rename from tests/unit/src/main/scala/tests/DiffAssertions.scala
rename to tests/mtest/src/main/scala/tests/DiffAssertions.scala
diff --git a/tests/unit/src/main/scala/tests/TestFailedException.scala b/tests/mtest/src/main/scala/tests/TestFailedException.scala
similarity index 100%
rename from tests/unit/src/main/scala/tests/TestFailedException.scala
rename to tests/mtest/src/main/scala/tests/TestFailedException.scala
diff --git a/tests/slow/src/test/scala/tests/ClasspathSymbolRegressionSuite.scala b/tests/slow/src/test/scala/tests/ClasspathSymbolRegressionSuite.scala
index f26868139b6..6b819983ac4 100644
--- a/tests/slow/src/test/scala/tests/ClasspathSymbolRegressionSuite.scala
+++ b/tests/slow/src/test/scala/tests/ClasspathSymbolRegressionSuite.scala
@@ -33,24 +33,11 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
)
check(
"Map.Entry",
- """|com.esotericsoftware.kryo.util.IntMap#Entry Class
+ """|com.esotericsoftware.kryo.util.IdentityMap#Entry Class
+ |com.esotericsoftware.kryo.util.IntMap#Entry Class
|com.esotericsoftware.kryo.util.ObjectMap#Entry Class
- |com.google.common.collect.Maps#EntryFunction Class
- |com.google.common.collect.Maps#EntrySet Class
- |com.google.common.collect.Maps#EntryTransformer Interface
- |com.google.common.collect.Maps#FilteredEntryBiMap Class
- |com.google.common.collect.Maps#FilteredEntryMap Class
- |com.google.common.collect.Maps#FilteredEntryMap#EntrySet Class
- |com.google.common.collect.Maps#FilteredEntryNavigableMap Class
- |com.google.common.collect.Maps#FilteredEntrySortedMap Class
- |com.google.common.collect.Maps#UnmodifiableEntrySet Class
|com.twitter.util.tunable.TunableMap.Entry Class
- |java.util.EnumMap#EntryIterator Class
- |java.util.EnumMap#EntryIterator#Entry Class
- |java.util.EnumMap#EntrySet Class
- |java.util.HashMap#EntryIterator Class
- |java.util.HashMap#EntrySet Class
- |java.util.HashMap#EntrySpliterator Class
+ |io.netty.util.collection.IntObjectMap#PrimitiveEntry Interface
|java.util.Map#Entry Interface
|java.util.TreeMap#AscendingSubMap#AscendingEntrySetView Class
|java.util.TreeMap#DescendingSubMap#DescendingEntrySetView Class
@@ -62,15 +49,12 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
|java.util.TreeMap#NavigableSubMap#EntrySetView Class
|java.util.TreeMap#NavigableSubMap#SubMapEntryIterator Class
|java.util.TreeMap#PrivateEntryIterator Class
- |jersey.repackaged.com.google.common.collect.Maps#EntryFunction Class
- |jersey.repackaged.com.google.common.collect.Maps#EntrySet Class
- |jersey.repackaged.com.google.common.collect.Maps#EntryTransformer Interface
- |jersey.repackaged.com.google.common.collect.Maps#FilteredEntryBiMap Class
- |jersey.repackaged.com.google.common.collect.Maps#FilteredEntryMap Class
- |jersey.repackaged.com.google.common.collect.Maps#FilteredEntryMap#EntrySet Class
- |jersey.repackaged.com.google.common.collect.Maps#FilteredEntryNavigableMap Class
- |jersey.repackaged.com.google.common.collect.Maps#FilteredEntrySortedMap Class
- |jersey.repackaged.com.google.common.collect.Maps#UnmodifiableEntrySet Class
+ |java.util.WeakHashMap#Entry Class
+ |java.util.WeakHashMap#EntryIterator Class
+ |java.util.WeakHashMap#EntrySet Class
+ |java.util.WeakHashMap#EntrySpliterator Class
+ |org.apache.commons.collections.ReferenceMap#Entry Class
+ |org.apache.commons.collections.ReferenceMap#EntryIterator Class
|org.apache.commons.lang.IntHashMap#Entry Class
|""".stripMargin
)
@@ -98,6 +82,11 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
|com.google.common.io.Files#FileByteSink Class
|com.google.common.io.Files#FileByteSource Class
|com.google.common.io.Files#FilePredicate Class
+ |com.google.protobuf.compiler.PluginProtos#CodeGeneratorResponse#File Class
+ |com.google.protobuf.compiler.PluginProtos#CodeGeneratorResponse#FileOrBuilder Interface
+ |com.google.protobuf.compiler.plugin.CodeGeneratorResponse.File Class
+ |com.google.protobuf.compiler.plugin.CodeGeneratorResponse.File Object
+ |com.google.protobuf.compiler.plugin.CodeGeneratorResponse.File.FileLens Class
|com.twitter.io.Files Object
|io.buoyant.config.types.File Class
|io.buoyant.config.types.FileDeserializer Class
@@ -105,16 +94,13 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
|java.io.File Class
|java.nio.file.Files Class
|java.nio.file.Files#FileTypeDetectors Class
- |javax.annotation.processing.Filer Interface
- |org.apache.hadoop.io.file.tfile.TFile Class
- |org.apache.hadoop.io.file.tfile.TFile#TFileIndex Class
- |org.apache.hadoop.io.file.tfile.TFile#TFileIndexEntry Class
- |org.apache.hadoop.io.file.tfile.TFile#TFileMeta Class
|org.apache.hadoop.mapred.IFile Class
|org.apache.hadoop.record.compiler.JFile Class
|org.apache.jute.compiler.JFile Class
|org.apache.parquet.Files Class
- |scala.meta.internal.io.FileIO Object
+ |scala.meta.inputs.Input.Stream.SerializationProxy#File Class
+ |scala.meta.inputs.Input.Stream.SerializationProxy#File Object
+ |scala.meta.inputs.Input.Stream.SerializationProxy#File.SerializationProxy#VirtualFile Class
|scala.reflect.io.File Class
|scala.reflect.io.File Object
|sourcecode.File Class
@@ -129,7 +115,6 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
|java.nio.file.Files Class
|org.apache.hadoop.mapred.MROutputFiles Class
|org.apache.hadoop.mapred.YarnOutputFiles Class
- |org.apache.hadoop.mapreduce.JobSubmissionFiles Class
|org.apache.ivy.ant.IvyCacheFileset Class
|org.apache.parquet.Files Class
|org.apache.spark.SparkFiles Object
@@ -137,22 +122,24 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
|org.apache.spark.sql.execution.streaming.FileStreamSource.SeenFilesMap Class
|org.glassfish.jersey.server.internal.scanning.FilesScanner Class
|scala.meta.internal.io.ListFiles Class
+ |scala.tools.nsc.interactive.CompilerControl#FilesDeletedItem Class
|""".stripMargin
)
check(
"Implicits",
- """|com.fasterxml.jackson.module.scala.util.Implicits Object
+ """|akka.stream.extra.Implicits Object
+ |akka.stream.scaladsl.GraphDSL.Implicits Object
+ |com.fasterxml.jackson.module.scala.util.Implicits Object
|fastparse.core.Implicits Object
|kafka.javaapi.Implicits Object
- |kafka.javaapi.MetadataListImplicits Object
|kafka.utils.Implicits Object
|org.apache.spark.sql.LowPrioritySQLImplicits Interface
|org.apache.spark.sql.SQLImplicits Class
|org.json4s.Implicits Interface
- |scala.LowPriorityImplicits Class
|scala.collection.convert.ToJavaImplicits Interface
|scala.collection.convert.ToScalaImplicits Interface
+ |scala.concurrent.ExecutionContext.Implicits Object
|scala.math.Fractional.ExtraImplicits Interface
|scala.math.Fractional.Implicits Object
|scala.math.Integral.ExtraImplicits Interface
@@ -163,9 +150,9 @@ object ClasspathSymbolRegressionSuite extends BaseWorkspaceSymbolSuite {
|scala.math.Ordering.ExtraImplicits Interface
|scala.math.Ordering.Implicits Object
|scala.meta.internal.fastparse.core.Implicits Object
- |scala.sys.process.ProcessImplicits Interface
|scala.tools.nsc.interpreter.Power#LowPriorityPrettifier#AnyPrettifier.Implicits1 Interface
|scala.tools.nsc.interpreter.Power#LowPriorityPrettifier#AnyPrettifier.Implicits2 Interface
+ |scala.tools.nsc.interpreter.StdReplVals#ReplImplicits Class
|scala.tools.nsc.typechecker.Implicits Interface
|scala.tools.nsc.typechecker.ImplicitsStats Object
|""".stripMargin
diff --git a/tests/slow/src/test/scala/tests/CompletionCrossSlowSuite.scala b/tests/slow/src/test/scala/tests/CompletionCrossSlowSuite.scala
new file mode 100644
index 00000000000..5a1f530fe82
--- /dev/null
+++ b/tests/slow/src/test/scala/tests/CompletionCrossSlowSuite.scala
@@ -0,0 +1,10 @@
+package tests
+
+import scala.meta.internal.metals.{BuildInfo => V}
+
+object CompletionCrossSlowSuite
+ extends BaseCompletionSlowSuite("completion-cross") {
+ testAsync("basic-211") {
+ basicTest(V.scala211)
+ }
+}
diff --git a/tests/unit/src/main/scala/tests/BaseCompletionSlowSuite.scala b/tests/unit/src/main/scala/tests/BaseCompletionSlowSuite.scala
new file mode 100644
index 00000000000..4c62e629406
--- /dev/null
+++ b/tests/unit/src/main/scala/tests/BaseCompletionSlowSuite.scala
@@ -0,0 +1,83 @@
+package tests
+
+import scala.concurrent.Future
+
+abstract class BaseCompletionSlowSuite(name: String)
+ extends BaseSlowSuite(name) {
+ def assertCompletion(
+ query: String,
+ expected: String,
+ project: Char = 'a'
+ )(implicit file: sourcecode.File, line: sourcecode.Line): Future[Unit] = {
+ val filename = s"$project/src/main/scala/$project/${project.toUpper}.scala"
+ server.completion(filename, query).map { completion =>
+ assertNoDiff(completion, expected)
+ }
+ }
+
+ def basicTest(scalaVersion: String): Future[Unit] = {
+ cleanWorkspace()
+ for {
+ _ <- server.initialize(
+ s"""/metals.json
+ |{
+ | "a": { "scalaVersion": "${scalaVersion}" }
+ |}
+ |/a/src/main/scala/a/A.scala
+ |package a
+ |object A {
+ | val x = "".substrin
+ | Stream
+ | TrieMap
+ | locally {
+ | val myLocalVariable = Array("")
+ | myLocalVariable
+ | val source = ""
+ | }
+ |}
+ |""".stripMargin
+ )
+ _ <- server.didOpen("a/src/main/scala/a/A.scala")
+ _ = assertNotEmpty(client.workspaceDiagnostics)
+ _ <- assertCompletion(
+ "substrin@@",
+ """|substring(beginIndex: Int): String
+ |substring(beginIndex: Int, endIndex: Int): String
+ |""".stripMargin
+ )
+ _ <- assertCompletion(
+ "Stream@@",
+ """|Stream scala.collection.immutable
+ |Stream java.util.stream
+ |IntStream java.util.stream
+ |LogStream java.rmi.server
+ |BaseStream java.util.stream
+ |LongStream java.util.stream
+ |StreamView scala.collection.immutable
+ |InputStream java.io
+ |PrintStream java.io
+ |DoubleStream java.util.stream
+ |OutputStream java.io
+ |StreamBuilder scala.collection.immutable.Stream
+ |StreamHandler java.util.logging
+ |StreamCanBuildFrom scala.collection.immutable.Stream
+ |""".stripMargin
+ )
+ _ <- assertCompletion(
+ "TrieMap@@",
+ """|TrieMap scala.collection.concurrent
+ |ParTrieMap scala.collection.parallel.mutable
+ |HashTrieMap scala.collection.immutable.HashMap
+ |ParTrieMapCombiner scala.collection.parallel.mutable
+ |ParTrieMapSplitter scala.collection.parallel.mutable
+ |TrieMapSerializationEnd scala.collection.concurrent
+ |""".stripMargin
+ )
+ _ <- assertCompletion(
+ " myLocalVariable@@",
+ """|myLocalVariable: Array[String]
+ |""".stripMargin
+ )
+ } yield ()
+ }
+}
diff --git a/tests/unit/src/main/scala/tests/BaseSlowSuite.scala b/tests/unit/src/main/scala/tests/BaseSlowSuite.scala
index c19f5303586..7c682b9dba8 100644
--- a/tests/unit/src/main/scala/tests/BaseSlowSuite.scala
+++ b/tests/unit/src/main/scala/tests/BaseSlowSuite.scala
@@ -9,6 +9,7 @@ import scala.meta.internal.metals.BloopProtocol
import scala.meta.internal.metals.Buffers
import scala.meta.internal.metals.ExecuteClientCommandConfig
import scala.meta.internal.metals.Icons
+import scala.meta.internal.metals.MetalsLogger
import scala.meta.internal.metals.MetalsServerConfig
import scala.meta.internal.metals.RecursivelyDelete
import scala.meta.internal.metals.Time
@@ -20,6 +21,7 @@ import scala.util.control.NonFatal
* Full end to end integration tests against a full metals language server.
*/
abstract class BaseSlowSuite(suiteName: String) extends BaseSuite {
+ MetalsLogger.updateDefaultFormat()
def protocol: BloopProtocol = BloopProtocol.auto
def icons: Icons = Icons.default
def userConfig: UserConfiguration = UserConfiguration()
diff --git a/tests/unit/src/main/scala/tests/Library.scala b/tests/unit/src/main/scala/tests/Library.scala
index dcca1226fec..119148da645 100644
--- a/tests/unit/src/main/scala/tests/Library.scala
+++ b/tests/unit/src/main/scala/tests/Library.scala
@@ -3,6 +3,8 @@ package tests
import com.geirsson.coursiersmall.CoursierSmall
import com.geirsson.coursiersmall.Dependency
import com.geirsson.coursiersmall.Settings
+import scala.meta.internal.metals.JdkSources
+import scala.meta.internal.metals.PackageIndex
import scala.meta.io.AbsolutePath
import scala.meta.io.Classpath
@@ -13,6 +15,12 @@ case class Library(
)
object Library {
+ def jdk: Library =
+ Library(
+ "JDK",
+ Classpath(PackageIndex.bootClasspath),
+ Classpath(JdkSources().get :: Nil)
+ )
def all: List[Library] = {
val settings = new Settings()
.withDependencies(
@@ -27,6 +35,11 @@ object Library {
"akka-testkit_2.12",
"2.5.9"
),
+ new Dependency(
+ "com.typesafe.akka",
+ "akka-stream_2.12",
+ "2.5.9"
+ ),
new Dependency(
"org.apache.spark",
"spark-sql_2.11",
diff --git a/tests/unit/src/main/scala/tests/MetalsTestEnrichments.scala b/tests/unit/src/main/scala/tests/MetalsTestEnrichments.scala
index 516593cbeee..51ade30d0ad 100644
--- a/tests/unit/src/main/scala/tests/MetalsTestEnrichments.scala
+++ b/tests/unit/src/main/scala/tests/MetalsTestEnrichments.scala
@@ -11,6 +11,7 @@ import org.eclipse.lsp4j.TextDocumentIdentifier
import org.eclipse.lsp4j.TextDocumentPositionParams
import org.eclipse.{lsp4j => l}
import scala.collection.mutable.ArrayBuffer
+import scala.meta.internal.metals.CachedSymbolInformation
import scala.meta.internal.metals.JdkSources
import scala.meta.internal.metals.Memory
import scala.meta.internal.metals.MetalsEnrichments._
@@ -45,11 +46,11 @@ object MetalsTestEnrichments {
if source.isScalaOrJava
} {
val input = source.toInput
- val symbols = ArrayBuffer.empty[String]
+ val symbols = ArrayBuffer.empty[CachedSymbolInformation]
SemanticdbDefinition.foreach(input) {
- case SemanticdbDefinition(info, _, _) =>
+ case defn @ SemanticdbDefinition(info, _, _) =>
if (WorkspaceSymbolProvider.isRelevantKind(info.kind)) {
- symbols += info.symbol
+ symbols += defn.toCached
}
}
wsp.didChange(source, symbols)
diff --git a/tests/unit/src/main/scala/tests/SimpleJavaSymbolIndexer.scala b/tests/unit/src/main/scala/tests/SimpleJavaSymbolIndexer.scala
new file mode 100644
index 00000000000..638553b90c6
--- /dev/null
+++ b/tests/unit/src/main/scala/tests/SimpleJavaSymbolIndexer.scala
@@ -0,0 +1,24 @@
+package tests
+
+import java.net.URLClassLoader
+import java.nio.charset.StandardCharsets
+import scala.meta.inputs.Input
+import scala.meta.internal.io.InputStreamIO
+import scala.meta.internal.metals.JavaSymbolIndexer
+import scala.meta.internal.mtags.Symbol
+import scala.meta.io.AbsolutePath
+import scala.meta.pc.SymbolIndexer
+import scala.meta.pc.SymbolVisitor
+
+class SimpleJavaSymbolIndexer(jars: List[AbsolutePath]) extends SymbolIndexer {
+ val classpath = new URLClassLoader(jars.map(_.toURI.toURL).toArray, null)
+ override def visit(symbol: String, visitor: SymbolVisitor): Unit = {
+ val filename = Symbol(symbol).toplevel.value.stripSuffix("#") + ".java"
+ val in = classpath.getResourceAsStream(filename)
+ if (in != null) {
+ val text = new String(InputStreamIO.readBytes(in), StandardCharsets.UTF_8)
+ new JavaSymbolIndexer(Input.VirtualFile(filename, text))
+ .visit(symbol, visitor)
+ }
+ }
+}
diff --git a/tests/unit/src/main/scala/tests/TestingServer.scala b/tests/unit/src/main/scala/tests/TestingServer.scala
index bcf8d9c3970..4fa110883eb 100644
--- a/tests/unit/src/main/scala/tests/TestingServer.scala
+++ b/tests/unit/src/main/scala/tests/TestingServer.scala
@@ -12,6 +12,7 @@ import java.util
import java.util.Collections
import java.util.concurrent.ScheduledExecutorService
import org.eclipse.lsp4j.ClientCapabilities
+import org.eclipse.lsp4j.CompletionParams
import scala.meta.internal.metals.PositionSyntax._
import org.eclipse.lsp4j.DidChangeConfigurationParams
import org.eclipse.lsp4j.DidChangeTextDocumentParams
@@ -329,6 +330,31 @@ final class TestingServer(
}
}
+ def completion(
+ filename: String,
+ query: String
+ ): Future[String] = {
+ val path = toPath(filename)
+ val input = path.toInputFromBuffers(buffers)
+ val offset = query.indexOf("@@")
+ if (offset < 0) sys.error("missing @@")
+ val start = input.text.indexOf(query.substring(0, offset))
+ if (start < 0) sys.error(s"missing '$query'")
+ val point = start + offset
+ val pos = m.Position.Range(input, point, point)
+ val params =
+ new CompletionParams(path.toTextDocumentIdentifier, pos.toLSP.getStart)
+ for {
+ completion <- server.completion(params).asScala
+ } yield {
+ val items =
+ completion.getItems.asScala.map(server.completionItemResolveSync)
+ items.iterator
+ .map(item => item.getLabel + item.getDetail)
+ .mkString("\n")
+ }
+ }
+
def references(
filename: String,
substring: String
diff --git a/tests/unit/src/main/scala/tests/TestingWorkspaceSymbolProvider.scala b/tests/unit/src/main/scala/tests/TestingWorkspaceSymbolProvider.scala
index caf7eab663c..a2fb69645a0 100644
--- a/tests/unit/src/main/scala/tests/TestingWorkspaceSymbolProvider.scala
+++ b/tests/unit/src/main/scala/tests/TestingWorkspaceSymbolProvider.scala
@@ -14,7 +14,7 @@ object TestingWorkspaceSymbolProvider {
buildTargets: BuildTargets = new BuildTargets,
statistics: StatisticsConfig = StatisticsConfig.default,
index: OnDemandSymbolIndex = OnDemandSymbolIndex(),
- isReferencedPackage: String => Boolean = _ => false
+ isReferencedPackage: String => Int = _ => 0
): WorkspaceSymbolProvider = {
new WorkspaceSymbolProvider(
workspace = workspace,
diff --git a/tests/unit/src/test/resources/mtags/example/JavaClass.java b/tests/unit/src/test/resources/mtags/example/JavaClass.java
index 20d84541171..2b9234dfc0a 100644
--- a/tests/unit/src/test/resources/mtags/example/JavaClass.java
+++ b/tests/unit/src/test/resources/mtags/example/JavaClass.java
@@ -2,6 +2,9 @@
public class JavaClass/*example.JavaClass#*/ {
+ private JavaClass() {
+
+ }
public JavaClass/*example.JavaClass#``().*/(int d) {
this.d = d;
}
diff --git a/tests/unit/src/test/resources/semanticdb/example/JavaThenScala.scala b/tests/unit/src/test/resources/semanticdb/example/JavaThenScala.scala
index 79811ad2236..955b8d0d582 100644
--- a/tests/unit/src/test/resources/semanticdb/example/JavaThenScala.scala
+++ b/tests/unit/src/test/resources/semanticdb/example/JavaThenScala.scala
@@ -1,5 +1,5 @@
package example
class JavaThenScala/*example.JavaThenScala#*/ {
- new JavaClass/*example.JavaClass#*//*example.JavaClass#``().*/(42)
+ new JavaClass/*example.JavaClass#*//*example.JavaClass#``(+1).*/(42)
}
diff --git a/tests/unit/src/test/resources/workspace-symbol/example/JavaClass.java b/tests/unit/src/test/resources/workspace-symbol/example/JavaClass.java
index bcf94411764..fb8ed41a0ad 100644
--- a/tests/unit/src/test/resources/workspace-symbol/example/JavaClass.java
+++ b/tests/unit/src/test/resources/workspace-symbol/example/JavaClass.java
@@ -2,6 +2,9 @@
public class JavaClass/*example.JavaClass#*/ {
+ private JavaClass() {
+
+ }
public JavaClass(int d) {
this.d = d;
}
diff --git a/tests/unit/src/test/scala/tests/BspCli.scala b/tests/unit/src/test/scala/tests/BspCli.scala
index f01e07b694d..2bb97b875a3 100644
--- a/tests/unit/src/test/scala/tests/BspCli.scala
+++ b/tests/unit/src/test/scala/tests/BspCli.scala
@@ -53,8 +53,12 @@ object BspCli {
val config = MetalsServerConfig.default
val icons = Icons.none
val time = Time.system
- val statusBar: StatusBar =
- new StatusBar(() => loggingLangaugeClient, time, ProgressTicks.none)
+ val statusBar = new StatusBar(
+ () => loggingLangaugeClient,
+ time,
+ ProgressTicks.none,
+ icons
+ )
val embedded = new Embedded(icons, statusBar, () => UserConfiguration())
val server = new BloopServers(
sh,
diff --git a/tests/unit/src/test/scala/tests/CompletionSlowSuite.scala b/tests/unit/src/test/scala/tests/CompletionSlowSuite.scala
new file mode 100644
index 00000000000..d1b428415d8
--- /dev/null
+++ b/tests/unit/src/test/scala/tests/CompletionSlowSuite.scala
@@ -0,0 +1,55 @@
+package tests
+
+import scala.meta.internal.metals.{BuildInfo => V}
+
+object CompletionSlowSuite extends BaseCompletionSlowSuite("completion") {
+
+ testAsync("basic-212") {
+ basicTest(V.scala212)
+ }
+
+ testAsync("workspace") {
+ cleanWorkspace()
+ for {
+ _ <- server.initialize(
+ """/metals.json
+ |{
+ | "b": {},
+ | "c": {},
+ | "a": { "dependsOn": ["c"] }
+ |}
+ |/b/src/main/scala/b/DefinedInB.scala
+ |package b
+ |object DefinedInB {
+ |}
+ |/c/src/main/scala/c/DefinedInC.scala
+ |package c
+ |object DefinedInC {
+ |}
+ |/a/src/main/scala/a/DefinedInA.scala
+ |package a
+ |object Outer {
+ | class DefinedInA
+ |}
+ |/a/src/main/scala/a/A.scala
+ |package a
+ |object Main {
+ | // DefinedIn
+ |}
+ |""".stripMargin
+ )
+ _ <- server.didOpen("a/src/main/scala/a/A.scala")
+ _ = assertEmpty(client.workspaceDiagnostics)
+ _ <- server.didChange("a/src/main/scala/a/A.scala")(
+ _.replaceAllLiterally("// ", "")
+ )
+ // assert that "DefinedInB" does not appear in results
+ _ <- assertCompletion(
+ "DefinedIn@@",
+ """|DefinedInA a.Outer
+ |DefinedInC c
+ |""".stripMargin
+ )
+ } yield ()
+ }
+}
diff --git a/tests/unit/src/test/scala/tests/CompressionSuite.scala b/tests/unit/src/test/scala/tests/CompressionSuite.scala
index 2631ec53463..60262addebe 100644
--- a/tests/unit/src/test/scala/tests/CompressionSuite.scala
+++ b/tests/unit/src/test/scala/tests/CompressionSuite.scala
@@ -6,7 +6,7 @@ object CompressionSuite extends BaseSuite {
def checkRoundtrip(a: String): Unit = {
val nonempty = a.trim.linesIterator.map(_.trim).filterNot(_.isEmpty).toArray
test(nonempty.headOption.getOrElse("")) {
- val compressed = Compression.compress(nonempty)
+ val compressed = Compression.compress(nonempty.iterator)
val decompressed = Compression.decompress(compressed)
assertNoDiff(decompressed.mkString("\n"), nonempty.mkString("\n"))
}
diff --git a/tests/unit/src/test/scala/tests/DidFocusSlowSuite.scala b/tests/unit/src/test/scala/tests/DidFocusSlowSuite.scala
index 36dded20e87..f84f43789ba 100644
--- a/tests/unit/src/test/scala/tests/DidFocusSlowSuite.scala
+++ b/tests/unit/src/test/scala/tests/DidFocusSlowSuite.scala
@@ -11,6 +11,7 @@ object DidFocusSlowSuite extends BaseSlowSuite("did-focus") {
super.utestBeforeEach(path)
}
testAsync("is-compiled") {
+ cleanWorkspace()
for {
_ <- server.initialize(
"""
diff --git a/tests/unit/src/test/scala/tests/FilenameLength.scala b/tests/unit/src/test/scala/tests/FilenameLength.scala
new file mode 100644
index 00000000000..18291033545
--- /dev/null
+++ b/tests/unit/src/test/scala/tests/FilenameLength.scala
@@ -0,0 +1,15 @@
+package tests
+
+import scala.meta.internal.metals.Fuzzy
+
+object FilenameLength extends BaseSuite {
+ def check(filename: String, expected: String): Unit = {
+ test(expected) {
+ val obtained = Fuzzy.nameLength(filename)
+ assertNoDiff(obtained.toString, expected.length.toString)
+ }
+ }
+
+ check("Path.class", "Path")
+ check("Polygon$PolygonPathIterator.class", "PolygonPathIterator")
+}
diff --git a/tests/unit/src/test/scala/tests/FuzzySuite.scala b/tests/unit/src/test/scala/tests/FuzzySuite.scala
index fd668dc3dc7..842bb32b913 100644
--- a/tests/unit/src/test/scala/tests/FuzzySuite.scala
+++ b/tests/unit/src/test/scala/tests/FuzzySuite.scala
@@ -54,9 +54,9 @@ object FuzzySuite extends BaseSuite {
.toSeq
.map(_.toString)
.sorted
- val isPrefix = Fuzzy.bloomFilterSymbolStrings(Seq(in))
+ val isPrefix = Fuzzy.bloomFilterSymbolStrings(Seq(in)).map(_.toString)
assertNoDiff(obtained.mkString("\n"), expected)
- val allWords = Fuzzy.bloomFilterQueryStrings(in)
+ val allWords = Fuzzy.bloomFilterQueryStrings(in).map(_.toString)
val isNotPrefix = allWords.filterNot(isPrefix)
assert(isNotPrefix.isEmpty)
}
diff --git a/tests/unit/src/test/scala/tests/StatusBarSuite.scala b/tests/unit/src/test/scala/tests/StatusBarSuite.scala
index 61fc7d361dd..1747b86569c 100644
--- a/tests/unit/src/test/scala/tests/StatusBarSuite.scala
+++ b/tests/unit/src/test/scala/tests/StatusBarSuite.scala
@@ -3,13 +3,15 @@ package tests
import scala.concurrent.Promise
import scala.meta.internal.io.PathIO
import scala.meta.internal.metals.Buffers
+import scala.meta.internal.metals.Icons
import scala.meta.internal.metals.ProgressTicks
import scala.meta.internal.metals.StatusBar
object StatusBarSuite extends BaseSuite {
val time = new FakeTime
val client = new TestingClient(PathIO.workingDirectory, Buffers())
- var status: StatusBar = new StatusBar(() => client, time, ProgressTicks.dots)
+ var status =
+ new StatusBar(() => client, time, ProgressTicks.dots, Icons.default)
override def utestBeforeEach(path: Seq[String]): Unit = {
client.statusParams.clear()
status.cancel()