[SR-11183] There should be a way to disambiguate methods/properties/nested types with the same name in the same type defined in extensions in different modules

[swift-ci]

Previous ID	SR-11183
Radar	rdar://problem/17275821
Original Reporter	broadway_lamb (JIRA User)
Type	Bug

Additional Detail from JIRA

Votes	2
Component/s	Compiler
Labels	Bug
Assignee	None
Priority	Medium

md5: 88bc464882feb2ff1ad6082004a35c49

relates to:

• SR-1842 Introduce syntax for explicitly invoking extension methods.

Issue Description:

Right now if two modules extend a type with a method/property with the same name, there's no way to refer to any of them in a client module:

// Module A
extension Int {
    public struct Nested {
        public init() {}
    }
    public func whatModuleIsThis() -> String { "A" }
}

// Module B
extension Int {
    public struct Nested {
        public init() {}
    }
    public func whatModuleIsThis() -> String { "B" }
}

// Module C
import A
import B

func ambiguous(_ n: Int) -> String {
    // error: Ambiguous type name 'Nested' in 'Int'
    return n.whatModuleIsThis() + String(describing: Int.Nested())
}

I couldn't find a bug for this, so I figured I should create one.

I'd like to work on supporting this in the compiler, and then pitch a syntax for disambiguation, with a working implementation.

[swift-ci]

Comment by Sergej Jaskiewicz (JIRA)

I've created a PR that prepares some ground for this feature.

#26186

[belkadan]

Some syntax spitballing from our Radar:

[1, 2, 3].MyModule::myMethod
[1, 2, 3].(MyModule.myMethod)
[1, 2, 3].`MyModule.myMethod`
[1, 2, 3].MyModule#myMethod
[1, 2, 3].myMethod@MyModule

[swift-ci]

Comment by Sergej Jaskiewicz (JIRA)

@belkadan I had in mind the first option with :: and it looks good to me, but I'd also want to discuss this one:

[1, 2, 3].(MyModule)myMethod

This has the advantage of more precise code completion: as soon as we see an lparen following a period, we can suggest only module names like we do when completing an import declaration, but, unlike the second option in your list, the module parens are not too close to call parens, and we save one period. Compare:

[1, 2, 3].(MyModule.myMethod)()
[1, 2, 3].(MyModule)myMethod()

I actually have a prototype implementation of this solution locally but want to also implement the one with a double colon so that everybody could check out both variants and play with them.

[belkadan]

I find it hard to read, but it's as valid an option as anything else. I'm sure we're going to get plenty of bikeshedding on the forums.

(I do remember people talking about .(foo) as shorthand for .init(foo), but that was no more real syntax than this is.)