[Diagnostics] Implement a tailored diagnostic for invalid static member refs on protocol metatypes

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -1902,6 +1902,9 @@ ERROR(type_does_not_conform_owner,none,
 ERROR(type_does_not_conform_in_decl_ref,none,
       "referencing %0 %1 on %2 requires that %3 conform to %4",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))
+ERROR(type_does_not_conform_in_member_ref_on_protocol_type,none,
+      "cannot reference %0 %1 on %2 with non-conforming result type %3",
+      (DescriptiveDeclKind, DeclName, Type, Type))
 ERROR(type_does_not_conform_anyobject_in_decl_ref,none,
       "referencing %0 %1 on %2 requires that %3 be a class type",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))

include/swift/Sema/CSFix.h

@@ -2313,24 +2313,24 @@ class AllowUnsupportedRuntimeCheckedCast final
 };
 
 class AllowInvalidStaticMemberRefOnProtocolMetatype final
-  : public ConstraintFix {
-  Type BaseType;
+    : public ConstraintFix {
+  Type ResultType;
 
   AllowInvalidStaticMemberRefOnProtocolMetatype(ConstraintSystem &cs,
-                                                Type baseType,
+                                                Type resultType,
                                                 ConstraintLocator *locator)
-    : ConstraintFix(cs,
-                    FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype,
-                    locator),
-      BaseType(baseType) {}
+      : ConstraintFix(cs,
+                      FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype,
+                      locator),
+        ResultType(resultType) {}
 
   public:
   std::string getName() const override {
     return "allow invalid static member reference on a protocol metatype";
   }
 
   static AllowInvalidStaticMemberRefOnProtocolMetatype *
-  create(ConstraintSystem &cs, Type baseType, ConstraintLocator *locator);
+  create(ConstraintSystem &cs, Type resultType, ConstraintLocator *locator);
 };
 
 } // end namespace constraints

lib/Sema/CSDiagnostics.cpp

@@ -7189,6 +7189,26 @@ bool MemberMissingExplicitBaseTypeFailure::diagnoseAsError() {
               .fixItInsert(UME->getDotLoc(), baseTypeName);
         });
   }
+
+  return true;
+}
+
+bool InvalidMemberRefOnProtocolMetatype::diagnoseAsError() {
+  auto *locator = getLocator();
+  auto overload = getOverloadChoiceIfAvailable(locator);
+  if (!overload)
+    return false;
+
+  auto *member = overload->choice.getDeclOrNull();
+  assert(member);
+
+  auto *DC = member->getDeclContext()->getSelfProtocolDecl();
+  auto protocolTy = DC->getDeclaredInterfaceType();
+
+  emitDiagnostic(diag::type_does_not_conform_in_member_ref_on_protocol_type,
+                 member->getDescriptiveKind(), member->getName(),
+                 MetatypeType::get(protocolTy), ResultType);
+  emitDiagnosticAt(member, diag::decl_declared_here, member->getName());
   return true;
 }
 

lib/Sema/CSDiagnostics.h

@@ -2472,6 +2472,30 @@ class UnsupportedRuntimeCheckedCastFailure final
   bool diagnoseAsError() override;
 };
 
+/// Diagnose situations when static member reference has invalid result
+/// type which disqualifies it from being used on a protocol metatype base.
+///
+/// \code
+/// protocol Foo {
+///   static var bar: Int
+/// }
+///
+/// _ = Foo.bar
+/// \endcode
+///
+/// `bar` can't be referenced from `P.Protocol` base because its result type
+/// `Int` doesn't conform to `Foo`.
+class InvalidMemberRefOnProtocolMetatype final : public FailureDiagnostic {
+  Type ResultType;
+
+public:
+  InvalidMemberRefOnProtocolMetatype(const Solution &solution, Type resultType,
+                                     ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), ResultType(resultType) {}
+
+  bool diagnoseAsError() override;
+};
+
 } // end namespace constraints
 } // end namespace swift
 

lib/Sema/CSFix.cpp

@@ -1941,20 +1941,14 @@ bool AllowUnsupportedRuntimeCheckedCast::diagnose(const Solution &solution,
 
 bool AllowInvalidStaticMemberRefOnProtocolMetatype::diagnose(
     const Solution &solution, bool asNote) const {
-  auto *locator = getLocator();
-  auto overload = solution.getOverloadChoice(locator);
-
-  auto *member = overload.choice.getDeclOrNull();
-  assert(member);
-
-  AllowTypeOrInstanceMemberFailure failure(solution, BaseType, member,
-                                           member->createNameRef(), locator);
+  InvalidMemberRefOnProtocolMetatype failure(solution, ResultType,
+                                             getLocator());
   return failure.diagnose(asNote);
 }
 
 AllowInvalidStaticMemberRefOnProtocolMetatype *
 AllowInvalidStaticMemberRefOnProtocolMetatype::create(
-    ConstraintSystem &cs, Type baseType, ConstraintLocator *locator) {
+    ConstraintSystem &cs, Type resultType, ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      AllowInvalidStaticMemberRefOnProtocolMetatype(cs, baseType, locator);
+      AllowInvalidStaticMemberRefOnProtocolMetatype(cs, resultType, locator);
 }