[ConstraintSystem] Adjust handling of incorrect member references on protocol metatypes

Since it's now possible to refer to static members declared on a protocol
metatype if result type conforms to the protocol we need to adjust failure
detection to identify that conformance failure means and invalid reference
in certain situations.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -5962,6 +5962,27 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       }
     }
 
+    if (path.back().is<LocatorPathElt::MemberRefBase>()) {
+      path.pop_back();
+
+      auto *memberLoc = getConstraintLocator(anchor, path);
+      if (auto overload = findSelectedOverloadFor(memberLoc)) {
+        const auto &choice = overload->choice;
+        assert(choice.isDecl());
+
+        auto *decl = choice.getDecl();
+        auto nameRef = choice.getFunctionRefKind() == FunctionRefKind::Compound
+                           ? decl->createNameRef()
+                           : DeclNameRef(decl->getBaseName());
+
+        auto *fix = AllowTypeOrInstanceMember::create(
+            *this, MetatypeType::get(protocolTy, getASTContext()), decl,
+            nameRef, memberLoc);
+
+        return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
+      }
+    }
+
     // If this is an implicit Hashable conformance check generated for each
     // index argument of the keypath subscript component, we could just treat
     // it as though it conforms.

lib/Sema/ConstraintSystem.cpp

@@ -1606,17 +1606,27 @@ ConstraintSystem::getTypeOfMemberReference(
 
   Type selfObjTy = openedParams.front().getPlainType()->getMetatypeInstanceType();
   if (outerDC->getSelfProtocolDecl()) {
+    // For a protocol, substitute the base object directly. We don't need a
+    // conformance constraint because we wouldn't have found the declaration
+    // if it didn't conform.
+    addConstraint(ConstraintKind::Bind, baseOpenedTy, selfObjTy,
+                  getConstraintLocator(locator));
+
     if (isStaticMemberRefOnProtocol) {
-      // If this is a static member reference on a protocol metatype
-      // we need to make sure that base type, we yet to infer from a
-      // result type of the member, does indeed conform to `Self`.
-      addSelfConstraint(*this, baseOpenedTy, selfObjTy, locator);
-    } else {
-      // For a protocol, substitute the base object directly. We don't need a
-      // conformance constraint because we wouldn't have found the declaration
-      // if it didn't conform.
-      addConstraint(ConstraintKind::Bind, baseOpenedTy, selfObjTy,
-                    getConstraintLocator(locator));
+      // 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);

test/decl/enum/enumtest.swift

@@ -36,7 +36,9 @@ func test1a() -> unionSearchFlags {
 
 func test1b(_ b : Bool) {
   _ = 123
-  _ = .description == 1 // expected-error {{cannot infer contextual base in reference to member 'description'}}
+  _ = .description == 1
+  // expected-error@-1 {{instance member 'description' cannot be used on type 'Int'}}
+  // expected-error@-2 {{member 'description' in 'Int' produces result of type 'String', but context expects 'Int'}}
 }
 
 enum MaybeInt {