Merge pull request swiftlang#32562 from AnthonyLatsis/stub-filter

Sema: Filter out conflicting requirements when printing stubs

Author: AnthonyLatsis

lib/Sema/TypeCheckProtocol.cpp

@@ -2963,6 +2963,59 @@ printProtocolStubFixitString(SourceLoc TypeLoc, ProtocolConformance *Conf,
     });
 }
 
+/// Filter the given array of protocol requirements and produce a new vector
+/// containing the non-conflicting requirements to be implemented by the given
+/// \c Adoptee type.
+static llvm::SmallVector<ValueDecl *, 4>
+filterProtocolRequirements(ArrayRef<ValueDecl *> Reqs, Type Adoptee) {
+  llvm::SmallVector<ValueDecl *, 4> Filtered;
+  if (Reqs.empty()) {
+    return Filtered;
+  }
+
+  const auto getProtocolSubstitutionMap = [&](ValueDecl *Req) {
+    auto *const PD = cast<ProtocolDecl>(Req->getDeclContext());
+    return SubstitutionMap::getProtocolSubstitutions(
+        PD, Adoptee, ProtocolConformanceRef(PD));
+  };
+
+  llvm::SmallDenseMap<DeclName, llvm::SmallVector<ValueDecl *, 2>, 4>
+      DeclsByName;
+  for (auto *const Req : Reqs) {
+    if (DeclsByName.find(Req->getName()) == DeclsByName.end()) {
+      DeclsByName[Req->getName()] = {Req};
+      Filtered.push_back(Req);
+      continue;
+    }
+
+    auto OverloadTy = Req->getOverloadSignatureType();
+    if (OverloadTy) {
+      OverloadTy =
+          OverloadTy.subst(getProtocolSubstitutionMap(Req))->getCanonicalType();
+    }
+    if (llvm::any_of(DeclsByName[Req->getName()], [&](ValueDecl *OtherReq) {
+          auto OtherOverloadTy = OtherReq->getOverloadSignatureType();
+          if (OtherOverloadTy) {
+            OtherOverloadTy =
+                OtherOverloadTy.subst(getProtocolSubstitutionMap(OtherReq))
+                    ->getCanonicalType();
+          }
+          return conflicting(Req->getASTContext(), Req->getOverloadSignature(),
+                             OverloadTy, OtherReq->getOverloadSignature(),
+                             OtherOverloadTy,
+                             /*wouldConflictInSwift5*/ nullptr,
+                             /*skipProtocolExtensionCheck*/ true);
+        })) {
+      continue;
+    }
+
+    DeclsByName[Req->getName()].push_back(Req);
+    Filtered.push_back(Req);
+  }
+
+  return Filtered;
+}
+
 void ConformanceChecker::
 diagnoseMissingWitnesses(MissingWitnessDiagnosisKind Kind) {
   auto LocalMissing = getLocalMissingWitness();
@@ -2971,12 +3024,10 @@ diagnoseMissingWitnesses(MissingWitnessDiagnosisKind Kind) {
   if (LocalMissing.empty())
     return;
 
-  SourceLoc ComplainLoc = Loc;
-  bool EditorMode = getASTContext().LangOpts.DiagnosticsEditorMode;
-  llvm::SetVector<ValueDecl*> MissingWitnesses(GlobalMissingWitnesses.begin(),
-                                               GlobalMissingWitnesses.end());
-  auto InsertFixitCallback = [ComplainLoc, EditorMode, MissingWitnesses]
-      (NormalProtocolConformance *Conf) {
+  const auto InsertFixit = [](NormalProtocolConformance *Conf,
+                              SourceLoc ComplainLoc, bool EditorMode,
+                              llvm::SmallVector<ValueDecl *, 4>
+                                  MissingWitnesses) {
     DeclContext *DC = Conf->getDeclContext();
     // The location where to insert stubs.
     SourceLoc FixitLocation;
@@ -2996,9 +3047,8 @@ diagnoseMissingWitnesses(MissingWitnessDiagnosisKind Kind) {
     llvm::SetVector<ValueDecl*> NoStubRequirements;
 
     // Print stubs for all known missing witnesses.
-    printProtocolStubFixitString(TypeLoc, Conf,
-                                 MissingWitnesses.getArrayRef(),
-                                 FixIt, NoStubRequirements);
+    printProtocolStubFixitString(TypeLoc, Conf, MissingWitnesses, FixIt,
+                                 NoStubRequirements);
     auto &Diags = DC->getASTContext().Diags;
 
     // If we are in editor mode, squash all notes into a single fixit.
@@ -3072,27 +3122,33 @@ diagnoseMissingWitnesses(MissingWitnessDiagnosisKind Kind) {
     }
   };
 
+  const bool IsEditorMode = Context.LangOpts.DiagnosticsEditorMode;
   switch (Kind) {
   case MissingWitnessDiagnosisKind::ErrorFixIt: {
+    const auto MissingWitnesses = filterProtocolRequirements(
+        GlobalMissingWitnesses.getArrayRef(), Adoptee);
     if (SuppressDiagnostics) {
       // If the diagnostics are suppressed, we register these missing witnesses
       // for later revisiting.
       Conformance->setInvalid();
-      getASTContext().addDelayedMissingWitnesses(
-          Conformance, MissingWitnesses.getArrayRef());
+      getASTContext().addDelayedMissingWitnesses(Conformance, MissingWitnesses);
     } else {
-      diagnoseOrDefer(LocalMissing[0], true, InsertFixitCallback);
+      diagnoseOrDefer(
+          LocalMissing[0], true, [&](NormalProtocolConformance *Conf) {
+            InsertFixit(Conf, Loc, IsEditorMode, std::move(MissingWitnesses));
+          });
     }
     clearGlobalMissingWitnesses();
     return;
   }
   case MissingWitnessDiagnosisKind::ErrorOnly: {
-    diagnoseOrDefer(LocalMissing[0], true,
-                    [](NormalProtocolConformance *Conf) {});
+    diagnoseOrDefer(LocalMissing[0], true, [](NormalProtocolConformance *) {});
     return;
   }
   case MissingWitnessDiagnosisKind::FixItOnly:
-    InsertFixitCallback(Conformance);
+    InsertFixit(Conformance, Loc, IsEditorMode,
+                filterProtocolRequirements(GlobalMissingWitnesses.getArrayRef(),
+                                           Adoptee));
     clearGlobalMissingWitnesses();
     return;
   }

test/decl/protocol/conforms/fixit_stub_editor.swift

@@ -3,18 +3,31 @@
 
 // RUN: %target-swift-frontend -typecheck %s -I %t -verify -diagnostics-editor-mode
 
+protocol P0_A { associatedtype T }
+protocol P0_B { associatedtype T }
+
+class C0: P0_A, P0_B {} // expected-error{{type 'C0' does not conform to protocol 'P0_A'}} expected-error{{type 'C0' does not conform to protocol 'P0_B'}} expected-note{{do you want to add protocol stubs?}}{{23-23=\n    typealias T = <#type#>\n}}
+
 protocol P1 {
   @available(*, deprecated)
   func foo1()
   func foo2()
+  func foo3(arg: Int, arg2: String)
+  func foo4<T: P1>(_: T)
 }
 
 protocol P2 {
   func bar1()
   func bar2()
+
+  func foo2()
+  func foo3(arg: Int, arg2: String)
+  func foo3(arg: Int, arg2: Int)
+  func foo4<T: P1>(_: T)
+  func foo4<T: P2>(_: T)
 }
 
-class C1 : P1, P2 {} // expected-error{{type 'C1' does not conform to protocol 'P1'}} expected-error{{type 'C1' does not conform to protocol 'P2'}} expected-note{{do you want to add protocol stubs?}}{{20-20=\n    func foo1() {\n        <#code#>\n    \}\n\n    func foo2() {\n        <#code#>\n    \}\n\n    func bar1() {\n        <#code#>\n    \}\n\n    func bar2() {\n        <#code#>\n    \}\n}}
+class C1 : P1, P2 {} // expected-error{{type 'C1' does not conform to protocol 'P1'}} expected-error{{type 'C1' does not conform to protocol 'P2'}} expected-note{{do you want to add protocol stubs?}}{{20-20=\n    func foo1() {\n        <#code#>\n    \}\n\n    func foo2() {\n        <#code#>\n    \}\n\n    func foo3(arg: Int, arg2: String) {\n        <#code#>\n    \}\n\n    func foo4<T>(_: T) where T : P1 {\n        <#code#>\n    \}\n\n    func bar1() {\n        <#code#>\n    \}\n\n    func bar2() {\n        <#code#>\n    \}\n\n    func foo3(arg: Int, arg2: Int) {\n        <#code#>\n    \}\n}}
 
 protocol P3 {
   associatedtype T1
@@ -23,13 +36,29 @@ protocol P3 {
 }
 
 protocol P4 : P3 {
+  associatedtype T1
   associatedtype T4 = T1
   associatedtype T5 = T2
   associatedtype T6 = T3
 }
 
 class C2 : P4 {} // expected-error{{type 'C2' does not conform to protocol 'P4'}} expected-error{{type 'C2' does not conform to protocol 'P3'}} expected-note{{do you want to add protocol stubs?}}{{16-16=\n    typealias T1 = <#type#>\n\n    typealias T2 = <#type#>\n\n    typealias T3 = <#type#>\n}}
 
+protocol P5 {
+  func foo1()
+  func foo2(arg: Int, arg2: String)
+  func foo3<T: P3>(_: T)
+}
+
+protocol P6: P5 {
+  func foo1()
+  func foo2(arg: Int, arg2: String)
+  func foo2(arg: Int, arg2: Int)
+  func foo3<T: P3>(_: T)
+  func foo3<T: P4>(_: T)
+}
+
+class C3 : P6 {} // expected-error{{type 'C3' does not conform to protocol 'P5'}} expected-error{{type 'C3' does not conform to protocol 'P6'}} expected-note{{do you want to add protocol stubs?}}{{16-16=\n    func foo1() {\n        <#code#>\n    \}\n\n    func foo2(arg: Int, arg2: String) {\n        <#code#>\n    \}\n\n    func foo2(arg: Int, arg2: Int) {\n        <#code#>\n    \}\n\n    func foo3<T>(_: T) where T : P3 {\n        <#code#>\n    \}\n}}
 
 // =============================================================================
 // Test how we print stubs for mutating and non-mutating requirements.