Add [fixit] to suggest Self.member instead of Proto.member

Protocol types cannot provide an implementation of their members — when
one is looked up on a protocol in that protocol’s context, we can
suggest using the dynamic `Self` type.

```
extension StaticP {
  func bar() {
    _ = StaticP.foo(a:)  // suggest `Self.foo(a:)`
  }
}
```

Author: joewillsher

lib/Sema/CSDiag.cpp

@@ -2358,10 +2358,22 @@ diagnoseUnviableLookupResults(MemberLookupResult &result, Type baseObjTy,
     case MemberLookupResult::UR_TypeMemberOnInstance:
       if (instanceTy->isExistentialType() && baseObjTy->is<AnyMetatypeType>()) {
         // If the base of the lookup is an existential metatype, emit an
-        // error specific to that
-        diagnose(loc, diag::could_not_use_type_member_on_existential,
-                 baseObjTy, memberName)
-          .highlight(baseRange).highlight(nameLoc.getSourceRange());
+        // error saying the lookup cannot be on a protocol metatype
+        auto Diag = diagnose(loc, diag::could_not_use_type_member_on_existential,
+                             baseObjTy, memberName);
+        Diag.highlight(baseRange).highlight(nameLoc.getSourceRange());
+
+        // See through function decl context
+        if (auto parent = CS->DC->getParent())
+        // If we are in an protocol extension of 'Proto' and we see
+        // 'Proto.static', suggest 'Self.static'
+        if (auto extensionContext = parent->getAsProtocolExtensionContext()) {
+          if (extensionContext->getDeclaredType()->getCanonicalType()
+              == instanceTy->getCanonicalType()) {
+            Diag.fixItReplace(baseRange, "Self");
+          }
+        }
+
       } else {
         // Otherwise the static member lookup was invalid because it was
         // called on an instance

test/Constraints/members.swift

@@ -304,6 +304,15 @@ func staticExistential(_ p: P.Type, pp: P.Protocol) {
   let _: P! = id(p.returnSelfIUOStatic(true))
 }
 
+protocol StaticP {
+  static func foo(a: Int)
+}
+extension StaticP {
+  func bar() {
+    _ = StaticP.foo(a:) // expected-error{{static member 'foo(a:)' cannot be used on protocol metatype 'StaticP.Protocol'}} {{9-16=Self}}
+  }
+}
+
 func existentialClassP(_ p: ClassP) {
   // Instance member of existential)
   let _: (Int) -> () = id(p.bas)