Note that you really do need two files to see the regression.

@swift-ci create

I'm able to reproduce this with one file:

    struct X<T> { }

    extension X {
      func f(_: T) { }

      subscript(_: T) -> Int { return 0 }
    }

    extension X {
      func f(_: Y) { }

      subscript(_: Y) -> Int { return 0 }
    }

    struct Y { }

    func test(xy: X<Y>, y: Y) {
      _ = xy.f(y)   // okay: picks second declaration

      _ = xy[y]     // error: ambiguous subscript
    }

On master, the difference here is that the constraint optimizer is causing us to only consider the second "f", but the constraint optimizer doesn't kick in for subscripts, so it gets kicked over to partial ordering of declarations... and these are considered ambiguous by the partial ordering rules on master.

Back in Swift 3, these two subscript declarations were ordered, although it seems like they shouldn't be: the second is not actually more specialized than the first. Had the second been written as:

    extension X where T == Y {
      func f(_: Y) { }

      subscript(_: Y) -> Int { return 0 }
    }

then it's clearly more specialized.

I don't see a good way to emulate the old behavior without inventing a new overloading rule. The partial-ordering code has literally not changed, but the type checker itself is more accurately representing the language semantics.