Better error messages when no export aliases exist

Author: odersky

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -944,19 +944,20 @@ class Namer { typer: Typer =>
         val path = typedAheadExpr(expr, AnySelectionProto)
         checkLegalImportPath(path)
 
-        def needsForwarder(sym: Symbol) =
-          sym.is(ImplicitOrImplied) == exp.impliedOnly &&
-          sym.isAccessibleFrom(path.tpe) &&
-          !sym.isConstructor &&
-          !sym.is(ModuleClass) &&
-          !sym.is(Bridge) &&
-          !cls.derivesFrom(sym.owner)
+        def whyNoForwarder(mbr: SingleDenotation): String = {
+          val sym = mbr.symbol
+          if (sym.is(ImplicitOrImplied) != exp.impliedOnly) s"is ${if (exp.impliedOnly) "not " else ""}implied"
+          else if (!sym.isAccessibleFrom(path.tpe)) "is not accessible"
+          else if (sym.isConstructor || sym.is(ModuleClass) || sym.is(Bridge)) "_"
+          else if (cls.derivesFrom(sym.owner)) i"is already a member of $cls"
+          else ""
+        }
 
         /** Add a forwarder with name `alias` or its type name equivalent to `mbr`,
          *  provided `mbr` is accessible and of the right implicit/non-implicit kind.
          */
-        def addForwarder(alias: TermName, mbr: SingleDenotation, span: Span): Unit =
-          if (needsForwarder(mbr.symbol)) {
+        def addForwarder(alias: TermName, mbr: SingleDenotation, span: Span): Unit = {
+          if (whyNoForwarder(mbr) == "") {
 
             /** The info of a forwarder to type `ref` which has info `info`
              */
@@ -998,12 +999,19 @@ class Namer { typer: Typer =>
               }
             buf += forwarderDef.withSpan(span)
           }
+        }
 
         def addForwardersNamed(name: TermName, alias: TermName, span: Span): Unit = {
+          val size = buf.size
           val mbrs = List(name, name.toTypeName).flatMap(path.tpe.member(_).alternatives)
-          if (mbrs.isEmpty)
-            ctx.error(i"no accessible member $name at $path", ctx.source.atSpan(span))
           mbrs.foreach(addForwarder(alias, _, span))
+          if (buf.size == size) {
+            val reason = mbrs.map(whyNoForwarder).dropWhile(_ == "-") match {
+              case Nil => ""
+              case why :: _ => i"\n$path.$name cannot be exported because it $why"
+            }
+            ctx.error(i"""no eligible member $name at $path$reason""", ctx.source.atSpan(span))
+          }
         }
 
         def addForwardersExcept(seen: List[TermName], span: Span): Unit =

tests/neg/exports.check

@@ -0,0 +1,24 @@
+[991..997] in exports.scala
+no eligible member concat at this
+this.concat cannot be exported because it is already a member of trait IterableOps
+<647..647> in exports.scala
+Double definition:
+final def status: => List[String] in class Copier at line 23 and
+final def status: => List[String] in class Copier at line 24
+have the same type after erasure.
+<596..596> in exports.scala
+Double definition:
+def status: => List[String] in class Copier at line 28 and
+final def status: => List[String] in class Copier at line 23
+have the same type after erasure.
+[785..791] in exports.scala
+no eligible member status at this.printUnit
+this.printUnit.status cannot be exported because it is not implied
+[712..718] in exports.scala
+no eligible member bitmap at this.printUnit
+this.printUnit.bitmap cannot be exported because it is implied
+[518..525] in exports.scala
+no eligible member scanAll at this.scanUnit
+this.scanUnit.scanAll cannot be exported because it is not accessible
+[452..458] in exports.scala
+no eligible member scanIt at this.scanUnit

tests/neg/exports.scala

@@ -0,0 +1,37 @@
+  class BitMap
+  class InkJet
+
+  class Printer {
+    type PrinterType
+    def print(bits: BitMap): Unit = ???
+    def status: List[String] = ???
+    implied bitmap for BitMap
+  }
+
+  class Scanner {
+    def scan(): BitMap = ???
+    private def scanAll: BitMap = ???
+    def status: List[String] = ???
+  }
+
+  class Copier {
+    private val printUnit = new Printer { type PrinterType = InkJet }
+    private val scanUnit = new Scanner
+
+    export scanUnit.scanIt          // error: no eligible member
+    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 implied printUnit.status // error: no eligible member
+
+    def status: List[String] = printUnit.status ++ scanUnit.status
+  }
+
+trait IterableOps[+A, +CC[_], +C] {
+
+  def concat[B >: A](other: List[B]): CC[B]
+
+  export this.{concat => ++}   // error: no eligible member
+
+}