Ambiguous implicits due to export

[soronpo]

AFAIK, this bug only appears across packages. Export to an outer package that reflects into an inner package causes implicit ambiguity.

Compiler version

v3.0.0

Minimized code

Complete minimized project at:
https://github.com/soronpo/dottybug/tree/export_ambiguous_implicits
Outer.scala

package outer
export inner.Foo
export Foo.Bar

Inner.scala

package outer
package inner

sealed trait Foo
object Foo:
  trait TC[T]
  given ofFoo[T <: Foo]: TC[T] = ???
  trait Bar extends Foo

import Foo.TC
//Adding import Foo.Bar resolves the issue
val badSummon = summon[TC[Bar]] //error here

Output

[error] 13 |val badSummon = summon[TC[Bar]]                                                                                                                                                                                                    
[error]    |                               ^                                                                                                                                                                                                   
[error]    |                               ambiguous implicit arguments: both given instance ofFoo in object Foo and given instance ofFoo in object Foo match type outer.inner.Foo.TC[outer.Bar] of parameter x of method summon in object Predef  

Expectation

No error.

[odersky]

I fixed it so that it becomes clearer what goes on. The new error message is:

-- Error: Inner.scala:12:31 ----------------------------------------------------
12 |val badSummon = summon[TC[Bar]] //error here
   |                               ^
   |ambiguous implicit arguments: both outer.inner.Foo.ofFoo and outer.Foo.ofFoo match type outer.inner.Foo.TC[outer.Bar] of parameter x of method summon in object Predef

Should we try to further analyze the two paths to realize they are the same in the end? It's not clear IMO. First, it's probably not so easy. Second, if we allow export paths to have side effects, it will actually matter which of the two implicits is picked, so the compiler is right to flag this as an ambiguity.

[soronpo]

Should we try to further analyze the two paths to realize they are the same in the end?

IMO, yes. I've been playing around with Scala 3, and exports help me bring selected organized API into the same scope. But companion implicits leak through and appear they exist in different places although they are clearly not.