Fix export go-to-definition

Author: dwijnand

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -341,6 +341,11 @@ object Symbols extends SymUtils {
       }
       else if (denot.isPrimaryConstructor)
         denot.owner.sourceSymbol
+      else if denot.is(Exported) then
+        denot.info.finalResultType match
+          case TypeAlias(target: NamedType) => target.symbol.sourceSymbol // exported type
+          case target: NamedType            => target.symbol.sourceSymbol // exported term
+          case info                         => this
       else this
 
     /** The position of this symbol, or NoSpan if the symbol was not loaded

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

@@ -42,7 +42,12 @@ case class SourceTree(tree: tpd.Import | tpd.NameTree, source: SourceFile) {
               (treeSpan.end - nameLength, treeSpan.end)
           Span(start, end, start)
         }
-        source.atSpan(position)
+        // Don't widen the span, only narrow.
+        // E.g. The star in a wildcard export is 1 character,
+        // and that is the span of the type alias that results from it
+        // but the name may very well be larger, which we don't want.
+        val span1 = if treeSpan.contains(position) then position else treeSpan
+        source.atSpan(span1)
       }
     case _ =>
       NoSourcePosition

presentation-compiler/src/main/dotty/tools/pc/MetalsInteractive.scala

@@ -109,15 +109,14 @@ object MetalsInteractive:
    * Returns the list of tuple enclosing symbol and
    * the symbol's expression type if possible.
    */
-  @tailrec
   def enclosingSymbolsWithExpressionType(
       path: List[Tree],
       pos: SourcePosition,
       indexed: IndexedContext,
       skipCheckOnName: Boolean = false
   ): List[(Symbol, Type)] =
     import indexed.ctx
-    path match
+    @tailrec def go(path: List[Tree]): List[(Symbol, Type)] = path match
       // For a named arg, find the target `DefDef` and jump to the param
       case NamedArg(name, _) :: Apply(fn, _) :: _ =>
         val funSym = fn.symbol
@@ -206,12 +205,7 @@ object MetalsInteractive:
 
       case path @ head :: tail =>
         if head.symbol.is(Synthetic) then
-          enclosingSymbolsWithExpressionType(
-            tail,
-            pos,
-            indexed,
-            skipCheckOnName
-          )
+          go(tail)
         else if head.symbol != NoSymbol then
           if skipCheckOnName ||
             MetalsInteractive.isOnName(
@@ -225,21 +219,17 @@ object MetalsInteractive:
            * https://github.com/lampepfl/dotty/issues/15937
            */
           else if head.isInstanceOf[TypeTree] then
-            enclosingSymbolsWithExpressionType(tail, pos, indexed)
+            go(tail)
           else Nil
         else
           val recovered = recoverError(head, indexed)
           if recovered.isEmpty then
-            enclosingSymbolsWithExpressionType(
-              tail,
-              pos,
-              indexed,
-              skipCheckOnName
-            )
+            go(tail)
           else recovered.map(sym => (sym, sym.info))
         end if
       case Nil => Nil
-    end match
+    end go
+    go(path).map((sym, tp) => (sym.sourceSymbol, tp))
   end enclosingSymbolsWithExpressionType
 
   import dotty.tools.pc.utils.MtagsEnrichments.*

presentation-compiler/test/dotty/tools/pc/tests/definition/PcDefinitionSuite.scala

@@ -199,6 +199,24 @@ class PcDefinitionSuite extends BasePcDefinitionSuite:
          |""".stripMargin
     )
 
+  @Test def `export` =
+    check(
+      """object enumerations:
+        |  trait <<SymbolKind>>
+        |  trait CymbalKind
+        |
+        |object all:
+        |  export enumerations.*
+        |
+        |@main def hello =
+        |  import all.SymbolKind
+        |  import enumerations.CymbalKind
+        |
+        |  val x = new Symbo@@lKind {}
+        |  val y = new CymbalKind {}
+        |""".stripMargin
+    )
+
   @Test def `named-arg-local` =
     check(
       """|