[ConstraintSystem] Filtering for static member lookup on protocol metatypes

Detect and filter some of the overload choices which can't possibly
match because their result type cannot conform to the expected protocol.

Author: xedin

lib/Sema/CSApply.cpp

@@ -1189,24 +1189,10 @@ namespace {
         // Here `P.foo` would be replaced with `S.foo`
         if (!isExistentialMetatype && baseTy->is<ProtocolType>() &&
             member->isStatic()) {
-          auto refKind = choice.getFunctionRefKind();
-          Type baseTy;
-
-          bool isMethod = isa<AbstractFunctionDecl>(member);
-          switch (refKind) {
-          case FunctionRefKind::Compound:
-          case FunctionRefKind::Unapplied:
-          case FunctionRefKind::SingleApply: {
-            baseTy = isMethod ? openedType->castTo<FunctionType>()->getResult()
-                              : openedType;
-            break;
-          }
-
-          case FunctionRefKind::DoubleApply: {
-            llvm_unreachable("not implemented yet");
-          }
-          }
-
+          Type baseTy =
+              simplifyType(openedType->is<FunctionType>()
+                               ? openedType->castTo<FunctionType>()->getResult()
+                               : openedType);
           base = TypeExpr::createImplicitHack(base->getLoc(), baseTy, context);
           cs.cacheType(base);
         }

lib/Sema/CSSimplify.cpp

@@ -5511,19 +5511,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
         }
       }
     }
-
-    if (elt->is<LocatorPathElt::UnresolvedMemberChainResult>()) {
-      if (type1->is<ProtocolType>() && !type2->isTypeVariableOrMember()) {
-        auto result = simplifyConformsToConstraint(
-            type2, type1, ConstraintKind::ConformsTo,
-            locator.withPathElement(LocatorPathElt::TypeParameterRequirement(
-                0, RequirementKind::Conformance)),
-            subflags);
-
-        return result == SolutionKind::Error ? getTypeMatchFailure(locator)
-                                             : getTypeMatchSuccess();
-      }
-    }
   }
 
   if (kind == ConstraintKind::BindParam) {
@@ -6839,7 +6826,50 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
                     ->hasTypeParameter()) {
 
       /* We're OK */
+    } else if (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.
+      assert(hasStaticMembers);
+
+      Type resultTy;
+
+      // Cannot instantiate a protocol or reference a member on
+      // protocol composition type.
+      if (isa<ConstructorDecl>(decl) ||
+          instanceTy->is<ProtocolCompositionType>()) {
+        result.addUnviable(candidate,
+                           MemberLookupResult::UR_TypeMemberOnInstance);
+        return;
+      }
+
+      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();
+      } else {
+        resultTy = decl->getInterfaceType();
+      }
 
+      if (auto *fnType = resultTy->getAs<FunctionType>())
+        resultTy = fnType->getResult();
+
+      // If result is not a concrete type which could conform to the
+      // expected protocol, this method is only viable for diagnostics.
+      if (!(resultTy->is<NominalType>() || resultTy->is<BoundGenericType>()) ||
+          resultTy->isExistentialType()) {
+        result.addUnviable(
+            candidate,
+            MemberLookupResult::UR_InvalidStaticMemberOnProtocolMetatype);
+        return;
+      }
+
+      result.addViable(candidate);
+      return;
     } else {
       if (!hasStaticMembers) {
         result.addUnviable(candidate,
@@ -7980,6 +8010,24 @@ ConstraintSystem::simplifyUnresolvedMemberChainBaseConstraint(
     return SolutionKind::Unsolved;
   }
 
+  if (baseTy->is<ProtocolType>()) {
+    auto *baseExpr =
+        castToExpr<UnresolvedMemberChainResultExpr>(locator.getAnchor())
+            ->getChainBase();
+    auto *memberLoc =
+        getConstraintLocator(baseExpr, ConstraintLocator::UnresolvedMember);
+
+    auto *memberRef = findResolvedMemberRef(memberLoc);
+    assert(memberRef);
+
+    if (memberRef->isStatic()) {
+      return simplifyConformsToConstraint(
+          resultTy, baseTy, ConstraintKind::ConformsTo,
+          getConstraintLocator(memberLoc, ConstraintLocator::MemberRefBase),
+          flags);
+    }
+  }
+
   return matchTypes(baseTy, resultTy, ConstraintKind::Equal, flags, locator);
 }
 

lib/Sema/ConstraintSystem.cpp

@@ -1577,22 +1577,15 @@ ConstraintSystem::getTypeOfMemberReference(
   Type baseOpenedTy = baseObjTy;
 
   if (isStaticMemberRefOnProtocol) {
-    auto refTy = openedType->castTo<FunctionType>();
-    switch (functionRefKind) {
-    // Either variable or use of method as a value
-    case FunctionRefKind::Unapplied:
-    case FunctionRefKind::SingleApply:
-    case FunctionRefKind::Compound: {
-      baseOpenedTy =
-          isa<AbstractFunctionDecl>(value)
-              ? refTy->getResult()->castTo<FunctionType>()->getResult()
-              : refTy->getResult();
-      break;
-    }
-
-    case FunctionRefKind::DoubleApply:
-      llvm_unreachable("not implemented yet");
-    }
+    // 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;
   } else if (baseObjTy->isExistentialType()) {
     auto openedArchetype = OpenedArchetypeType::get(baseObjTy);
     OpenedExistentialTypes.push_back(
@@ -1611,23 +1604,6 @@ ConstraintSystem::getTypeOfMemberReference(
     // if it didn't conform.
     addConstraint(ConstraintKind::Bind, baseOpenedTy, selfObjTy,
                   getConstraintLocator(locator));
-
-    if (isStaticMemberRefOnProtocol) {
-      // Since base is a protocol metatype we could use to make sure that
-      // self type inferred from result of the member does indeed conform
-      // to the expected protocol.
-      //
-      // Delay solving this constraint until after member choice has
-      // been completely resolved by the constraint system, so that
-      // conformance failure has access to a referenced declaration.
-      auto *constraint = Constraint::create(
-          *this, ConstraintKind::ConformsTo, selfObjTy, baseObjTy,
-          getConstraintLocator(
-              locator.withPathElement(ConstraintLocator::MemberRefBase)));
-
-      addUnsolvedConstraint(constraint);
-      activateConstraint(constraint);
-    }
   } else if (!isDynamicResult) {
     addSelfConstraint(*this, baseOpenedTy, selfObjTy, locator);
   }