3

If I'm understanding this revision correctly, this proposal derives the base type for the implicit member expression entirely from the type of Self in the same-type constraint, and not at all from the particular member—is that correct?

I.e., would this now be allowed?

protocol P {}
struct S: P {}
struct R: P {}

extension P where Self == S {
  static var r: R { R() }
}

extension R {
  var s: S { S() }
}

test<T: P>(_: T) {}

test(.r.s) // Ok

Also, does this proposal use the semantics mentioned in the previous review thread?

?

I.e., what gets printed in this example?

protocol P {}
struct S: P {}

extension P where Self == S {
  static var s: S {
    print("s via P")
    return S()
  }
}

extension S {
  static var s: S {
    print("s via S")
    return S()
  }
}

test<T: P>(_: T) {}

test(.s) // ?

IMO this revision results in more explainable behavior, and is more inline with existing inference rules in similar positions (such as the examples @Joe_Groff posted here).

If the example above prints "s via P" then I'm fully on board with this revision.

If the example above would print "s via S" then I remain concerned about the ability of a declaration guide type-checking that does not appear in the final expression. The author of P would not, for instance, be able to remove P.s by deprecating the declaration for a time and then deleting it, because they could not be sure that all clients depending on the declaration would actually see the deprecation warning before removal.