[ConstraintSystem] Implement new rule for static member lookup in generic contexts

Instead of requiring result type of the member to conform to declaring protocol,
as originally proposed by SE-0299, let's instead require `Self` to be bound to
some concrete type in extension that declares a static member.

This would make sure that:

1. Members are only visible on a particular type;
2. There is no ambiguity regarding what base of the member chain is going to be.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -5539,6 +5539,11 @@ bool hasExplicitResult(ClosureExpr *closure);
 void performSyntacticDiagnosticsForTarget(
     const SolutionApplicationTarget &target, bool isExprStmt);
 
+/// Given a member of a protocol, check whether `Self` type of that
+/// protocol is contextually bound to some concrete type via same-type
+/// generic requirement and if so return that type or null type otherwise.
+Type getConcreteReplacementForProtocolSelfType(ValueDecl *member);
+
 } // end namespace constraints
 
 template<typename ...Args>

lib/Sema/CSSimplify.cpp

@@ -6852,9 +6852,10 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
       /* We're OK */
     } else if (hasStaticMembers && baseObjTy->is<MetatypeType>() &&
                instanceTy->isExistentialType()) {
-      // Static member lookup on protocol metatype requires that result type
-      // of a selected member to conform to protocol this method is being
-      // referred from.
+      // Static member lookup on protocol metatype in generic context
+      // requires `Self` of the protocol to be bound to some concrete
+      // type via same-type requirement, otherwise it would be
+      // impossible to find a witness for this member.
 
       // Cannot instantiate a protocol or reference a member on
       // protocol composition type.
@@ -6865,40 +6866,13 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
         return;
       }
 
-      Type resultTy;
-
-      if (isa<AbstractFunctionDecl>(decl)) {
-        auto refTy =
-            decl->getInterfaceType()->castTo<AnyFunctionType>()->getResult();
-        resultTy = refTy->castTo<FunctionType>()->getResult();
-      } else if (isa<SubscriptDecl>(decl)) {
-        resultTy =
-            decl->getInterfaceType()->castTo<AnyFunctionType>()->getResult();
+      if (getConcreteReplacementForProtocolSelfType(decl)) {
+        result.addViable(candidate);
       } else {
-        resultTy = decl->getInterfaceType();
-      }
-
-      if (auto *fnType = resultTy->getAs<FunctionType>())
-        resultTy = fnType->getResult();
-
-      // No reason to suggest that `Void` doesn't conform to some protocol.
-      if (resultTy->isVoid()) {
         result.addUnviable(candidate,
                            MemberLookupResult::UR_TypeMemberOnInstance);
-        return;
-      }
-
-      // If result is not a concrete type which could conform to the
-      // expected protocol, this method is only viable for diagnostics.
-      if (resultTy->isExistentialType() || resultTy->is<AnyFunctionType>() ||
-          resultTy->is<TupleType>() || resultTy->is<AnyMetatypeType>()) {
-        result.addUnviable(
-            candidate,
-            MemberLookupResult::UR_InvalidStaticMemberOnProtocolMetatype);
-        return;
       }
 
-      result.addViable(candidate);
       return;
     } else {
       if (!hasStaticMembers) {

lib/Sema/ConstraintSystem.cpp

@@ -1589,19 +1589,12 @@ ConstraintSystem::getTypeOfMemberReference(
     // reference e.g. it might be incorrect initializer call
     // or result type is invalid.
     if (!(shouldAttemptFixes() && hasFixFor(getConstraintLocator(locator)))) {
-      // Member type with Self applied.
-      auto refTy = openedType->castTo<FunctionType>()->getResult();
-      // If member is a function type, let's use its result type
-      // since it could be either a static method or a property
-      // which returns a function type.
-      if (auto *funcTy = refTy->getAs<FunctionType>())
-        baseOpenedTy = funcTy->getResult();
-      else
-        baseOpenedTy = refTy;
-
-      // It should be possible to form optional chains which start
-      // from a protocol metatype.
-      baseOpenedTy = baseOpenedTy->lookThroughAllOptionalTypes();
+      if (auto concreteSelf =
+              getConcreteReplacementForProtocolSelfType(value)) {
+        // Concrete type replacing `Self` could be generic, so we need
+        // to make sure that it's opened before use.
+        baseOpenedTy = openType(concreteSelf, replacements);
+      }
     }
   } else if (baseObjTy->isExistentialType()) {
     auto openedArchetype = OpenedArchetypeType::get(baseObjTy);
@@ -4540,6 +4533,23 @@ bool constraints::hasExplicitResult(ClosureExpr *closure) {
                            ClosureHasExplicitResultRequest{closure}, false);
 }
 
+Type constraints::getConcreteReplacementForProtocolSelfType(ValueDecl *member) {
+  auto *DC = member->getDeclContext();
+
+  if (!DC->getSelfProtocolDecl())
+    return Type();
+
+  GenericSignature signature;
+  if (auto *genericContext = member->getAsGenericContext()) {
+    signature = genericContext->getGenericSignature();
+  } else {
+    signature = DC->getGenericSignatureOfContext();
+  }
+
+  auto selfTy = DC->getProtocolSelfType();
+  return signature->getConcreteType(selfTy);
+}
+
 static bool isOperator(Expr *expr, StringRef expectedName) {
   auto name = getOperatorName(expr);
   return name ? name->is(expectedName) : false;

test/Constraints/static_members_on_protocol_metatype.swift renamed to test/Constraints/static_members_on_protocol_in_generic_context.swift

@@ -11,7 +11,7 @@ struct G<T> : P {
   var other: G<T> { fatalError() }
 }
 
-extension P {
+extension P where Self == S {
   static var property: S { S() }
 
   static var iuoProp: S! { S() }
@@ -25,15 +25,17 @@ extension P {
     return S()
   }
 
-  static func genericFn<T>(_: T) -> G<T> {
-    return G<T>()
-  }
-
   static subscript(_: Int) -> S {
     get { S() }
   }
+}
+
+extension P {
+  static func genericFn<T>(_: T) -> G<T> where Self == G<T> {
+    return G<T>()
+  }
 
-  static subscript<T>(t t: T) -> G<T> {
+  static subscript<T>(t t: T) -> G<T> where Self == G<T> {
     get { G<T>() }
   }
 }
@@ -107,7 +109,7 @@ protocol Q {}
 
 func test_combo<T: P & Q>(_: T) {} // expected-note 2 {{where 'T' = 'G<Int>'}}
 
-extension Q {
+extension Q where Self == S {
   static var otherProperty: S { S() }
 
   static func otherMethod() -> S {
@@ -136,14 +138,16 @@ test_combo(.genericFn(42)) // expected-error {{global function 'test_combo' requ
 /* Invalid result types */
 
 extension P {
-  static var invalidProp: Int { 42 } // expected-note 3 {{'invalidProp' declared here}}
-  static var selfProp: Self { fatalError() }
-  static func invalidMethod() -> Int { 42 } // expected-note 3 {{'invalidMethod()' declared here}}
-  static func generic<T>(_: T) -> T { fatalError() } // expected-note 3 {{'generic' declared here}}
-  static func genericWithReqs<T: Collection, Q>(_: T) -> Q where T.Element == Q { // expected-note {{in call to function 'genericWithReqs'}} expected-note 2 {{'genericWithReqs' declared here}} expected-note 3 {{required by static method 'genericWithReqs' where 'T' = '()'}}
+  static func generic<T>(_: T) -> T where Self == T { fatalError() } // expected-note 3 {{'generic' declared here}}
+  static func genericWithReqs<T: Collection, Q>(_: T) -> Q where T.Element == Q, Self == Q { // expected-note {{in call to function 'genericWithReqs'}} expected-note 2 {{'genericWithReqs' declared here}} expected-note 3 {{required by static method 'genericWithReqs' where 'T' = '()'}}
     fatalError()
   }
+}
 
+extension P {
+  static var invalidProp: Int { 42 } // expected-note 3 {{'invalidProp' declared here}}
+  static var selfProp: Self { fatalError() }
+  static func invalidMethod() -> Int { 42 } // expected-note 3 {{'invalidMethod()' declared here}}
   static subscript(q q: String) -> Int { get { 42 } }
 }