Small improvements to workspace/symbol

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -317,14 +317,6 @@ object Interactive {
     else
       namedTrees(trees, include, matchSymbol(_, sym, include))
 
-  /** Find named trees with a non-empty position whose name contains `nameSubstring` in `trees`.
-   */
-  def namedTrees(trees: List[SourceTree], nameSubstring: String)
-   (implicit ctx: Context): List[SourceTree] = {
-    val predicate: NameTree => Boolean = _.name.toString.contains(nameSubstring)
-    namedTrees(trees, Include.empty, predicate)
-  }
-
   /** Find named trees with a non-empty position satisfying `treePredicate` in `trees`.
    *
    *  @param includeReferences  If true, include references and not just definitions

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -22,6 +22,7 @@ import core._, core.Decorators.{sourcePos => _, _}
 import Comments._, Constants._, Contexts._, Flags._, Names._, NameOps._, Symbols._, SymDenotations._, Trees._, Types._
 import classpath.ClassPathEntries
 import reporting._, reporting.diagnostic.{Message, MessageContainer, messages}
+import transform.SymUtils.decorateSymbol
 import typer.Typer
 import util.{Set => _, _}
 import interactive._, interactive.InteractiveDriver._
@@ -456,8 +457,12 @@ class DottyLanguageServer extends LanguageServer
     implicit val ctx = driver.currentCtx
 
     val uriTrees = driver.openedTrees(uri)
+    val predicate = (tree: NameTree) => {
+      val sym = tree.symbol
+      sym.exists && !sym.isLocal && !sym.isPrimaryConstructor && !sym.is(Synthetic)
+    }
 
-    val defs = Interactive.namedTrees(uriTrees, Include.empty, _ => true)
+    val defs = Interactive.namedTrees(uriTrees, Include.empty, predicate)
     (for {
       d <- defs if !isWorksheetWrapper(d)
       info <- symbolInfo(d.tree.symbol, d.namePos, positionMapperFor(d.source))
@@ -466,12 +471,14 @@ class DottyLanguageServer extends LanguageServer
 
   override def symbol(params: WorkspaceSymbolParams) = computeAsync { cancelToken =>
     val query = params.getQuery
+    def predicate(implicit ctx: Context): NameTree => Boolean =
+      tree => tree.symbol.exists && !tree.symbol.isLocal && tree.name.toString.contains(query)
 
     drivers.values.toList.flatMap { driver =>
       implicit val ctx = driver.currentCtx
 
-      val trees = driver.allTrees
-      val defs = Interactive.namedTrees(trees, nameSubstring = query)
+      val trees = driver.sourceTreesContaining(query)
+      val defs = Interactive.namedTrees(trees, Include.empty, predicate)
       defs.flatMap(d => symbolInfo(d.tree.symbol, d.namePos, positionMapperFor(d.source)))
     }.asJava
   }

language-server/test/dotty/tools/languageserver/DocumentSymbolTest.scala

@@ -38,4 +38,10 @@ class DocumentSymbolTest {
       .documentSymbol(m1, (m1 to m2).symInfo("Foo", SymbolKind.Module),
                           (m3 to m4).symInfo("Foo", SymbolKind.Class))
   }
+
+  @Test def documentSymbolSynthetic: Unit = {
+    code"""case class ${m1}Foo${m2}(${m3}x${m4}: Int)""".withSource
+      .documentSymbol(m1, (m1 to m2).symInfo("Foo", SymbolKind.Class),
+                          (m3 to m4).symInfo("x", SymbolKind.Field, "Foo"))
+  }
 }

language-server/test/dotty/tools/languageserver/SymbolTest.scala

@@ -39,4 +39,26 @@ class SymbolTest {
       .symbol("Foo", (m1 to m2).symInfo("Foo", SymbolKind.Module),
                      (m3 to m4).symInfo("Foo", SymbolKind.Class))
   }
+
+  @Test def multipleProjects0: Unit = {
+    val p0 = Project.withSources(
+      code"""class ${m1}Foo${m2}"""
+    )
+
+    val p1 = Project.dependingOn(p0).withSources(
+      code"""class ${m3}Bar${m4} extends Foo"""
+    )
+
+    withProjects(p0, p1)
+      .symbol("Foo", (m1 to m2).symInfo("Foo", SymbolKind.Class))
+  }
+
+  @Test def noLocalSymbols: Unit = {
+    code"""object O {
+             def foo = {
+               val hello = 0
+             }
+           }""".withSource
+      .symbol("hello")
+  }
 }