[SR-3145] Compiler reports ambiguous type inference when not ambiguous

[swift-ci]

Previous ID	SR-3145
Radar	None
Original Reporter	ellneal (JIRA User)
Type	Bug

Environment

Swift 3.0.1 Xcode 8.1 (8B62) macOS 10.12.1

Additional Detail from JIRA

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

md5: b543b9861b9acc9be7a5739c0a9e33f8

Issue Description:

I'm prefacing this by saying that I know this is an overly complicated example, but I think the compiler is wrong in saying that this is ambiguous.

class Root { }

protocol Generic {
    associatedtype RootType: Root
    var root: RootType { get }
}

extension Generic where Self: Root {
    var root: Self {
        return self
    }
}

class Leaf: Root { }

protocol Specialised { }
extension Specialised where Self: Generic {
    var root: Leaf {
        get {
            return Leaf()
        }
    }
}

class Implementation: Generic, Specialised {
    // errors:
    //   Ambiguous inference of associated type 'RootType': 'Leaf' vs. 'Implementation'
    //   Matching requirement 'root' to this declaration inferred associated type to 'Leaf'
    //   Matching requirement 'root' to this declaration inferred associated type to 'Implementation'
}

I believe that if Implementation also inherited from Root this would be ambiguous, but not in the current state (as far as I can tell).

[swift-ci]

Comment by Ell Neal (JIRA)

It's worth noting that if I remove the generic constraint from Generic (and therefore the Self requirement in the first extension), the compiler resolves correctly:

class Root { }

protocol Generic {
    var root: Root { get }
}

extension Generic where Self: Root {
    var root: Root {
        return self
    }
}

class Leaf: Root {}

protocol Specialised { }
extension Specialised where Self: Generic {
    var root: Root {
        get {
            return Leaf()
        }
    }
}

class Implementation: Generic, Specialised {
    // no errors!
}

[swift-ci]

Comment by Ell Neal (JIRA)

Probably even more interesting, I can resolve this with only one change:

class Root { }

protocol Generic {
    associatedtype RootType: Root
    var root: RootType { get }
}

extension Generic where Self: Root {
    var root: Root { // don't use Self here, use Root instead
        return self
    }
}

class Leaf: Root { }

protocol Specialised { }
extension Specialised where Self: Generic {
    var root: Leaf {
        get {
            return Leaf()
        }
    }
}

class Implementation: Generic, Specialised {
    // no errors!
}

[belkadan]

I'm not seeing this as ambiguous on master. @DougGregor, @slavapestov, did anything change here?

[DougGregor]

We've been cleaning up there area of the type checker on master; I don't know which specific issue addressed this.

[swift-ci]

Comment by Raphael (JIRA)

I think this is the same or a very similar issue:

protocol A {
    associatedtype T: Hashable
}

extension Array where Element: A {
    func foo() {
        var bar = [Element.T: [Element]]() // error here
    }
}

Apparently, the compiler can not infer the type of `bar`. However, adding a type alias resolves it:

extension Array where Element: A {
    typealias T = Element.T

    func foo() {
        var bar = [T: [Element]]()
    }
}

[belkadan]

I think this last one is just SR-349.