Alternatively, make export method synthetic & handle that

dwijnand · dwijnand · commit 6aadd94b6fbf · 2024-01-19T22:09:09.000Z
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -341,11 +341,6 @@ 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
diff --git a/compiler/src/dotty/tools/dotc/interactive/SourceTree.scala b/compiler/src/dotty/tools/dotc/interactive/SourceTree.scala
@@ -42,12 +42,7 @@ case class SourceTree(tree: tpd.Import | tpd.NameTree, source: SourceFile) {
               (treeSpan.end - nameLength, treeSpan.end)
           Span(start, end, start)
         }
-        // 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)
+        source.atSpan(position)
       }
     case _ =>
       NoSourcePosition
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1247,7 +1247,7 @@ class Namer { typer: Typer =>
                   (EmptyFlags, mbrInfo)
               var flagMask = RetainedExportFlags
               if sym.isTerm then flagMask |= HasDefaultParams | NoDefaultParams
-              var mbrFlags = Exported | Method | Final | maybeStable | sym.flags & flagMask
+              var mbrFlags = Exported | Synthetic | Method | Final | maybeStable | sym.flags & flagMask
               if sym.is(ExtensionMethod) || pathMethod.exists then
                 mbrFlags |= ExtensionMethod
               val forwarderName = checkNoConflict(alias, isPrivate = false, span)
diff --git a/presentation-compiler/src/main/dotty/tools/pc/MetalsInteractive.scala b/presentation-compiler/src/main/dotty/tools/pc/MetalsInteractive.scala
@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.core.Symbols.*
-import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.interactive.SourceTree
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.util.SourcePosition
@@ -109,14 +109,15 @@ 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
-    @tailrec def go(path: List[Tree]): List[(Symbol, Type)] = path match
+    path match
       // For a named arg, find the target `DefDef` and jump to the param
       case NamedArg(name, _) :: Apply(fn, _) :: _ =>
         val funSym = fn.symbol
@@ -204,8 +205,24 @@ object MetalsInteractive:
             Nil
 
       case path @ head :: tail =>
-        if head.symbol.is(Synthetic) then
-          go(tail)
+        if head.symbol.is(Exported) then
+          head.symbol.info match
+            case TypeAlias(target: NamedType) =>
+              val ss = target.symbol.sourceSymbol // exported type
+              List((ss, ss.info))
+            case info => info.finalResultType match
+              case target: NamedType =>
+                val ss = target.symbol.sourceSymbol // exported term
+                List((ss, ss.info))
+              case _ =>
+                enclosingSymbolsWithExpressionType(tail, pos, indexed, skipCheckOnName)
+        else if head.symbol.is(Synthetic) then
+          enclosingSymbolsWithExpressionType(
+            tail,
+            pos,
+            indexed,
+            skipCheckOnName
+          )
         else if head.symbol != NoSymbol then
           if skipCheckOnName ||
             MetalsInteractive.isOnName(
@@ -219,24 +236,21 @@ object MetalsInteractive:
            * https://github.com/lampepfl/dotty/issues/15937
            */
           else if head.isInstanceOf[TypeTree] then
-            go(tail)
+            enclosingSymbolsWithExpressionType(tail, pos, indexed)
           else Nil
         else
           val recovered = recoverError(head, indexed)
           if recovered.isEmpty then
-            go(tail)
+            enclosingSymbolsWithExpressionType(
+              tail,
+              pos,
+              indexed,
+              skipCheckOnName
+            )
           else recovered.map(sym => (sym, sym.info))
         end if
       case Nil => Nil
-    end go
-    go(path).map { (sym, tp) =>
-      if sym.is(Synthetic) && sym.name == StdNames.nme.apply then
-        (sym, tp) // return synthetic apply, rather than the apply's owner
-      else if sym.isClassConstructor && sym.isPrimaryConstructor then
-        (sym, tp) // return the class constructor, rather than the class (so skip trait constructors)
-      else
-        (sym.sourceSymbol, tp)
-    }
+    end match
   end enclosingSymbolsWithExpressionType
 
   import dotty.tools.pc.utils.MtagsEnrichments.*
diff --git a/tests/neg/export-leaks.check b/tests/neg/export-leaks.check
@@ -0,0 +1,12 @@
+-- [E006] Not Found Error: tests/neg/export-leaks.scala:24:13 ----------------------------------------------------------
+24 |    val t1 = bar // error: Not found: bar
+   |             ^^^
+   |             Not found: bar
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/export-leaks.scala:25:13 ----------------------------------------------------------
+25 |    val t2 = foo // error: Not found: foo
+   |             ^^^
+   |             Not found: foo
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/export-leaks.scala b/tests/neg/export-leaks.scala
@@ -6,10 +6,20 @@ object Signature {
   object O1 {
     private[Signature] def bar: T = ???
   }
-  export O1._ // error: non-private method bar refers to private type T
+  export O1._
 
   object O2 {
     private[Signature] val foo: T = ???
   }
-  export O2._ // error: non-private method foo refers to private type T
-}
+  export O2._
+
+  object PosTest:
+    def main(args: Array[String]): Unit =
+      val t1 = bar // ok
+      val t2 = foo // ok
+}
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val t1 = bar // error: Not found: bar
+    val t2 = foo // error: Not found: foo
diff --git a/tests/neg/exports.check b/tests/neg/exports.check
@@ -7,16 +7,21 @@
    |                     ^^^^^^^^^^^^^^
    |                     no eligible member scanAll at this.scanUnit
    |                     this.scanUnit.scanAll cannot be exported because it is not accessible
--- Error: tests/neg/exports.scala:25:21 --------------------------------------------------------------------------------
-25 |    export printUnit.bitmap         // error: no eligible member
-   |                     ^
-   |                     non-private given instance bitmap in class Copier refers to private value printUnit
-   |                     in its type signature => object Copier.this.printUnit.bitmap
+-- [E120] Naming Error: tests/neg/exports.scala:28:8 -------------------------------------------------------------------
+28 |    def status: List[String] = printUnit.status ++ scanUnit.status // error: double definition w/ printUnit.status
+   |        ^
+   |        Double definition:
+   |        final def status: List[String] in class Copier at line 23 and
+   |        def status: List[String] in class Copier at line 28
+   |        have the same type after erasure.
+   |
+   |        Consider adding a @targetName annotation to one of the conflicting definitions
+   |        for disambiguation.
 -- [E120] Naming Error: tests/neg/exports.scala:23:33 ------------------------------------------------------------------
 23 |    export printUnit.{stat => _, _} // error: double definition
    |                                 ^
    |                                 Double definition:
-   |                                 def status: List[String] in class Copier at line 28 and
+   |                                 final def status: List[String] in class Copier at line 24 and
    |                                 final def status: List[String] in class Copier at line 23
    |                                 have the same type after erasure.
    |
@@ -26,22 +31,12 @@
 24 |    export scanUnit._               // error: double definition
    |                    ^
    |                    Double definition:
-   |                    final def status: List[String] in class Copier at line 23 and
+   |                    final def status: List[String] in class Copier at line 26 and
    |                    final def status: List[String] in class Copier at line 24
    |                    have the same type after erasure.
    |
    |                    Consider adding a @targetName annotation to one of the conflicting definitions
    |                    for disambiguation.
--- [E120] Naming Error: tests/neg/exports.scala:26:21 ------------------------------------------------------------------
-26 |    export printUnit.status         // error: double definition
-   |                     ^
-   |                     Double definition:
-   |                     final def status: List[String] in class Copier at line 24 and
-   |                     final def status: List[String] in class Copier at line 26
-   |                     have the same type after erasure.
-   |
-   |                     Consider adding a @targetName annotation to one of the conflicting definitions
-   |                     for disambiguation.
 -- Error: tests/neg/exports.scala:35:24 --------------------------------------------------------------------------------
 35 |    export this.{concat => ++}   // error: no eligible member
    |                 ^^^^^^^^^^^^
@@ -52,12 +47,6 @@
    |               ^^^
    |               no eligible member foo at this.foo
    |               this.foo.foo cannot be exported because it is already a member of class Foo
--- [E120] Naming Error: tests/neg/exports.scala:46:15 ------------------------------------------------------------------
-46 |    export bar._  // error: double definition
-   |               ^
-   |               Double definition:
-   |               val bar: Bar in class Baz at line 45 and
-   |               final def bar: (Baz.this.bar.bar : => (Baz.this.bar.baz.bar : Bar)) in class Baz at line 46
 -- [E083] Type Error: tests/neg/exports.scala:57:11 --------------------------------------------------------------------
 57 |    export printer.*  // error: not stable
    |           ^^^^^^^
diff --git a/tests/neg/exports.scala b/tests/neg/exports.scala
@@ -22,10 +22,10 @@
     export scanUnit.{scanAll => foo} // error: no eligible member
     export printUnit.{stat => _, _} // error: double definition
     export scanUnit._               // error: double definition
-    export printUnit.bitmap         // error: no eligible member
-    export printUnit.status         // error: double definition
+    export printUnit.bitmap
+    export printUnit.status
 
-    def status: List[String] = printUnit.status ++ scanUnit.status
+    def status: List[String] = printUnit.status ++ scanUnit.status // error: double definition w/ printUnit.status
   }
 
   trait IterableOps[+A, +CC[_], +C] {
@@ -43,7 +43,7 @@
 
   class Baz {
     val bar: Bar = new Bar
-    export bar._  // error: double definition
+    export bar._
   }
   class Bar {
     val baz: Baz = new Baz

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