Extend candidate missing conformance checking to other types of requirements so that we check superclass and same type requirements in the same way.

Author: gregomni

include/swift/AST/DiagnosticsSema.def

@@ -1814,8 +1814,9 @@ NOTE(protocol_witness_kind_conflict,none,
      "a subscript}0", (RequirementKind))
 NOTE(protocol_witness_type_conflict,none,
      "candidate has non-matching type %0%1", (Type, StringRef))
-NOTE(protocol_witness_missing_conformance,none,
-     "candidate would match if %0 conformed to %1", (Type, Type))
+NOTE(protocol_witness_missing_requirement,none,
+     "candidate would match if %0 %select{conformed to|subclassed|"
+     "was the same type as}2 %1", (Type, Type, unsigned))
 
 NOTE(protocol_witness_optionality_conflict,none,
      "candidate %select{type has|result type has|parameter type has|"

lib/Sema/CSFix.h

@@ -75,6 +75,11 @@ enum class FixKind : uint8_t {
   /// Skip same-type generic requirement constraint,
   /// and assume that types are equal.
   SkipSameTypeRequirement,
+
+  /// Skip superclass generic requirement constraint,
+  /// and assume that types are related.
+  SkipSuperclassRequirement,
+
 };
 
 class ConstraintFix {
@@ -311,6 +316,9 @@ class SkipSameTypeRequirement final : public ConstraintFix {
 
   bool diagnose(Expr *root, bool asNote = false) const override;
 
+  Type lhsType() { return LHS; }
+  Type rhsType() { return RHS; }
+
   static SkipSameTypeRequirement *create(ConstraintSystem &cs, Type lhs,
                                          Type rhs, ConstraintLocator *locator);
 };
@@ -322,8 +330,8 @@ class SkipSuperclassRequirement final : public ConstraintFix {
 
   SkipSuperclassRequirement(ConstraintSystem &cs, Type lhs, Type rhs,
                             ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::SkipSameTypeRequirement, locator), LHS(lhs),
-        RHS(rhs) {}
+      : ConstraintFix(cs, FixKind::SkipSuperclassRequirement, locator),
+        LHS(lhs), RHS(rhs) {}
 
 public:
   std::string getName() const override {
@@ -332,6 +340,9 @@ class SkipSuperclassRequirement final : public ConstraintFix {
 
   bool diagnose(Expr *root, bool asNote = false) const override;
 
+  Type subclassType() { return LHS; }
+  Type superclassType() { return RHS; }
+
   static SkipSuperclassRequirement *
   create(ConstraintSystem &cs, Type lhs, Type rhs, ConstraintLocator *locator);
 };

lib/Sema/CSSimplify.cpp

@@ -5038,7 +5038,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
     return result;
   }
 
-  case FixKind::SkipSameTypeRequirement: {
+  case FixKind::SkipSameTypeRequirement:
+  case FixKind::SkipSuperclassRequirement: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -845,26 +845,58 @@ swift::matchWitness(TypeChecker &tc,
 
     // If the types would match but for some other missing conformance, find and
     // call that out.
-    if (solution && conformance && solution->Fixes.size() == 1 &&
-        solution->Fixes.front()->getKind() == FixKind::AddConformance) {
-      auto fix = (MissingConformance *)solution->Fixes.front();
-      auto type = fix->getNonConformingType();
-      auto protocolType = fix->getProtocol()->getDeclaredType();
+    if (solution && conformance && solution->Fixes.size() == 1) {
+      auto fix = solution->Fixes.front();
+      Type type, missingType;
+      RequirementKind requirementKind;
+      switch (fix->getKind()) {
+      case FixKind::AddConformance: {
+        auto missingConform = (MissingConformance *)fix;
+        requirementKind = RequirementKind::Conformance;
+        type = missingConform->getNonConformingType();
+        missingType = missingConform->getProtocol()->getDeclaredType();
+        break;
+      }
+      case FixKind::SkipSameTypeRequirement: {
+        requirementKind = RequirementKind::SameType;
+        auto requirementFix = (SkipSameTypeRequirement *)fix;
+        type = requirementFix->lhsType();
+        missingType = requirementFix->rhsType();
+        break;
+      }
+      case FixKind::SkipSuperclassRequirement: {
+        requirementKind = RequirementKind::Superclass;
+        auto requirementFix = (SkipSuperclassRequirement *)fix;
+        type = requirementFix->subclassType();
+        missingType = requirementFix->superclassType();
+        break;
+      }
+      default:
+        return RequirementMatch(witness, MatchKind::TypeConflict, witnessType);
+      }
+
+      auto missingRequirementMatch = [&](Type type) -> RequirementMatch {
+        Requirement requirement(requirementKind, type, missingType);
+        return RequirementMatch(witness, MatchKind::MissingRequirement,
+                                requirement);
+      };
+
       if (auto memberTy = type->getAs<DependentMemberType>())
-        return RequirementMatch(witness, MatchKind::MissingConformance, type,
-                                protocolType);
+        return missingRequirementMatch(type);
 
       type = type->mapTypeOutOfContext();
       if (auto typeParamTy = type->getAs<GenericTypeParamType>())
         if (auto env = conformance->getGenericEnvironment())
           if (auto assocType = env->mapTypeIntoContext(typeParamTy))
-            return RequirementMatch(witness, MatchKind::MissingConformance,
-                                    assocType, protocolType);
-      if (type->isEqual(conformance->getType())) {
+            return missingRequirementMatch(assocType);
+
+      auto reqSubMap = reqEnvironment.getRequirementToSyntheticMap();
+      Type selfTy = proto->getSelfInterfaceType().subst(reqSubMap);
+      if (type->isEqual(selfTy) /*type->isEqual(conformance->getType())*/) {
+        type = conformance->getType();
         if (auto agt = type->getAs<AnyGenericType>())
           type = agt->getDecl()->getDeclaredInterfaceType();
-        return RequirementMatch(witness, MatchKind::MissingConformance, type,
-                                protocolType);
+        return missingRequirementMatch(type);
       }
     }
 
@@ -2051,9 +2083,10 @@ diagnoseMatch(ModuleDecl *module, NormalProtocolConformance *conformance,
     break;
   }
 
-  case MatchKind::MissingConformance:
-    diags.diagnose(match.Witness, diag::protocol_witness_missing_conformance,
-                   match.WitnessType, match.SecondType);
+  case MatchKind::MissingRequirement:
+    diags.diagnose(match.Witness, diag::protocol_witness_missing_requirement,
+                   match.WitnessType, match.MissingRequirement->getSecondType(),
+                   (unsigned)match.MissingRequirement->getKind());
     break;
 
   case MatchKind::ThrowsConflict:

lib/Sema/TypeCheckProtocol.h

@@ -168,8 +168,8 @@ enum class MatchKind : uint8_t {
   /// \brief The types conflict.
   TypeConflict,
 
-  /// \brief The witness would match with an additional conformance.
-  MissingConformance,
+  /// \brief The witness would match if an additional requirement were met.
+  MissingRequirement,
 
   /// The witness throws, but the requirement does not.
   ThrowsConflict,
@@ -355,17 +355,15 @@ struct RequirementMatch {
            "Should (or should not) have witness type");
   }
 
-  RequirementMatch(ValueDecl *witness, MatchKind kind,
-                   Type witnessType, Type secondType,
+  RequirementMatch(ValueDecl *witness, MatchKind kind, Requirement requirement,
                    Optional<RequirementEnvironment> env = None,
                    ArrayRef<OptionalAdjustment> optionalAdjustments = {})
-    : Witness(witness), Kind(kind), WitnessType(witnessType),
-      SecondType(secondType), ReqEnv(std::move(env)),
-      OptionalAdjustments(optionalAdjustments.begin(),
-                          optionalAdjustments.end())
-  {
-      assert(hasWitnessType() && hasSecondType() &&
-             "Should have witness type and second type");
+      : Witness(witness), Kind(kind), WitnessType(requirement.getFirstType()),
+        MissingRequirement(requirement), ReqEnv(std::move(env)),
+        OptionalAdjustments(optionalAdjustments.begin(),
+                            optionalAdjustments.end()) {
+    assert(hasWitnessType() && hasRequirement() &&
+           "Should have witness type and requirement");
   }
 
   /// \brief The witness that matches the (implied) requirement.
@@ -377,8 +375,8 @@ struct RequirementMatch {
   /// \brief The type of the witness when it is referenced.
   Type WitnessType;
 
-  /// \brief Explanatory second type.
-  Type SecondType;
+  /// \brief Requirement not met.
+  Optional<Requirement> MissingRequirement;
 
   /// \brief The requirement environment to use for the witness thunk.
   Optional<RequirementEnvironment> ReqEnv;
@@ -401,7 +399,7 @@ struct RequirementMatch {
     case MatchKind::WitnessInvalid:
     case MatchKind::KindConflict:
     case MatchKind::TypeConflict:
-    case MatchKind::MissingConformance:
+    case MatchKind::MissingRequirement:
     case MatchKind::StaticNonStaticConflict:
     case MatchKind::SettableConflict:
     case MatchKind::PrefixNonPrefixConflict:
@@ -424,7 +422,7 @@ struct RequirementMatch {
     case MatchKind::ExactMatch:
     case MatchKind::RenamedMatch:
     case MatchKind::TypeConflict:
-    case MatchKind::MissingConformance:
+    case MatchKind::MissingRequirement:
     case MatchKind::OptionalityConflict:
       return true;
 
@@ -446,10 +444,8 @@ struct RequirementMatch {
     llvm_unreachable("Unhandled MatchKind in switch.");
   }
 
-  /// \brief Determine whether this requirement match has a second type.
-  bool hasSecondType() {
-    return Kind == MatchKind::MissingConformance;
-  }
+  /// \brief Determine whether this requirement match has a requirement.
+  bool hasRequirement() { return Kind == MatchKind::MissingRequirement; }
 
   swift::Witness getWitness(ASTContext &ctx) const;
 };

test/decl/protocol/conforms/self.swift

@@ -61,12 +61,7 @@ class SeriousClass {}
 
 extension HasDefault where Self : SeriousClass {
   func foo() {}
-  // expected-note@-1 {{candidate has non-matching type '<Self> () -> ()'}}
-
-  // FIXME: the above diangostic is from trying to check conformance for
-  // 'SillyClass' and not 'SeriousClass'. Evidently name lookup finds members
-  // from all constrained extensions, and then if any don't have a matching
-  // generic signature, diagnostics doesn't really know what to do about it.
+  // expected-note@-1 {{candidate would match if 'SillyClass' subclassed 'SeriousClass'}}
 }
 
 extension SeriousClass : HasDefault {}

test/decl/protocol/req/missing_conformance.swift

@@ -80,3 +80,21 @@ protocol P8 {
 struct B : P8 { // expected-error {{type 'B' does not conform to protocol 'P8'}}
     func g(t: (Int, String)) {} // expected-note {{candidate can not infer 'T' = '(Int, String)' because '(Int, String)' is not a nominal type and so can't conform to 'P7'}}
 }
+
+protocol P9 {
+    func foo() // expected-note {{protocol requires function 'foo()' with type '() -> ()'; do you want to add a stub?}}
+}
+class C2 {}
+extension P9 where Self : C2 {
+    func foo() {} // expected-note {{candidate would match if 'C3' subclassed 'C2'}}
+}
+class C3 : P9 {} // expected-error {{type 'C3' does not conform to protocol 'P9'}}
+
+protocol P10 {
+    associatedtype A
+    func bar() // expected-note {{protocol requires function 'bar()' with type '() -> ()'; do you want to add a stub?}}
+}
+extension P10 where A == Int {
+    func bar() {} // expected-note {{candidate would match if 'A' was the same type as 'Int'}}
+}
+struct S2<A> : P10 {} // expected-error {{type 'S2<A>' does not conform to protocol 'P10'}}

test/decl/protocol/req/unsatisfiable.swift

@@ -10,7 +10,7 @@ protocol P {
 
 extension P {
   func f<T: P>(_: T) where T.A == Self.A, T.A == Self.B { }
-  // expected-note@-1 {{candidate has non-matching type '<Self, T> (T) -> ()'}}
+  // expected-note@-1 {{candidate would match if 'X' was the same type as 'X.B' (aka 'Int')}}
 }
 
 struct X : P { // expected-error {{type 'X' does not conform to protocol 'P'}}