Merge pull request swiftlang#31032 from bitjammer/acgarland/rdar-61459287-no-members-for-defaultimplementations-of-requirements

[SymbolGraph] Don't emit memberOf for default implementations or requ…

Author: bitjammer

lib/SymbolGraphGen/SymbolGraph.cpp

@@ -69,6 +69,50 @@ PrintOptions SymbolGraph::getDeclarationFragmentsPrintOptions() const {
   return Opts;
 }
 
+bool
+SymbolGraph::isRequirementOrDefaultImplementation(const ValueDecl *VD) const {
+  const auto *DC = VD->getDeclContext();
+
+  if (isa<ProtocolDecl>(DC) && VD->isProtocolRequirement()) {
+    return true;
+  }
+
+  // At this point, VD is either a default implementation of a requirement
+  // or a freestanding implementation from a protocol extension without
+  // a corresponding requirement.
+
+  auto *Proto = dyn_cast_or_null<ProtocolDecl>(DC->getSelfNominalTypeDecl());
+  if (!Proto) {
+    return false;
+  }
+
+  /// Try to find a member of the owning protocol with the same name
+  /// that is a requirement.
+  auto FoundRequirementMemberNamed = [](DeclName Name,
+                                        ProtocolDecl *Proto) -> bool {
+    for (const auto *Member : Proto->lookupDirect(Name)) {
+      if (isa<ProtocolDecl>(Member->getDeclContext()) &&
+          Member->isProtocolRequirement()) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  if (FoundRequirementMemberNamed(VD->getFullName(), Proto)) {
+    return true;
+  }
+  for (auto *Inherited : Proto->getInheritedProtocols()) {
+    if (FoundRequirementMemberNamed(VD->getFullName(), Inherited)) {
+      return true;
+    }
+  }
+
+  // Couldn't find any requirement members of a protocol by this name.
+  // It's not a requirement or default implementation of a requirement.
+  return false;
+}
+
 // MARK: - Symbols (Nodes)
 
 void SymbolGraph::recordNode(Symbol S) {
@@ -102,15 +146,26 @@ void SymbolGraph::recordEdge(Symbol Source,
 }
 
 void SymbolGraph::recordMemberRelationship(Symbol S) {
-  auto *DC = S.getSymbolDecl()->getDeclContext();
+  const auto *DC = S.getSymbolDecl()->getDeclContext();
   switch (DC->getContextKind()) {
     case DeclContextKind::GenericTypeDecl:
     case DeclContextKind::ExtensionDecl:
     case swift::DeclContextKind::EnumElementDecl:
+      /*
+       If this symbol is itself a protocol requirement, or
+       is a default implementation of a protocol requirement,
+       don't record a memberOf relationship.
+
+       This is to allow distinguishing between requirements,
+       default implementations of requirements, and just other
+       things added to protocols in extensions not related to their
+       requirements.
+       */
+      if (isRequirementOrDefaultImplementation(S.getSymbolDecl())) {
+        return;
+      }
       return recordEdge(S,
-          Symbol(this,
-                 S.getSymbolDecl()->getDeclContext()->getSelfNominalTypeDecl(),
-                 nullptr),
+                        Symbol(this, DC->getSelfNominalTypeDecl(), nullptr),
                         RelationshipKind::MemberOf());
     case swift::DeclContextKind::AbstractClosureExpr:
     case swift::DeclContextKind::Initializer:

lib/SymbolGraphGen/SymbolGraph.h

@@ -202,6 +202,10 @@ struct SymbolGraph {
   /// Returns `true` if the declaration should be included as a node
   /// in the graph.
   bool canIncludeDeclAsNode(const Decl *D) const;
+
+  /// Returns `true` if the declaration is a requirement of a protocol
+  /// or is a default implementation of a protocol
+  bool isRequirementOrDefaultImplementation(const ValueDecl *VD) const;
 };
 
 } // end namespace symbolgraphgen

test/SymbolGraph/Relationships/DefaultImplementationOf/Basic.swift

@@ -16,3 +16,6 @@ extension P {
 // CHECK: "kind": "defaultImplementationOf",
 // CHECK-NEXT: "source": "s:23DefaultImplementationOf1PPAAE1xSivp",
 // CHECK-NEXT: "target": "s:23DefaultImplementationOf1PP1xSivp"
+
+// Since x is a default implementation of a requirement, we don't consider this to be a "member".
+// CHECK-NOT: memberOf

test/SymbolGraph/Relationships/DefaultImplementationOf/Indirect.swift

@@ -4,7 +4,6 @@
 // RUN: %FileCheck %s --input-file %t/Indirect.symbols.json
 
 public protocol P {
-  associatedtype Thing
   func foo()
 }
 
@@ -15,3 +14,6 @@ extension Q {
 }
 
 // CHECK-DAG: "kind": "defaultImplementationOf",{{[[:space:]]*}}"source": "s:8Indirect1QPAAE3fooyyF",{{[[:space:]]*}}"target": "s:8Indirect1PP3fooyyF"
+
+// Since foo is a default implementation of a requirment, we don't consider this to be a "member"
+// CHECK-NOT: memberOf

test/SymbolGraph/Relationships/MemberOf.swift

@@ -0,0 +1,11 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -module-name Basic -emit-module -emit-module-path %t/
+// RUN: %target-swift-symbolgraph-extract -module-name Basic -I %t -pretty-print -output-dir %t
+// RUN: %FileCheck %s --input-file %t/Basic.symbols.json 
+public struct S {
+  public var x: Int
+}
+
+// CHECK: "kind": "memberOf"
+// CHECK-NEXT: "source": "s:5Basic1SV1xSivp"
+// CHECK-NEXT: "target": "s:5Basic1SV"

test/SymbolGraph/Relationships/MemberOf/Basic.swift

@@ -0,0 +1,27 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -module-name ProtocolMemberWithoutRequirement -emit-module -emit-module-path %t/
+// RUN: %target-swift-symbolgraph-extract -module-name ProtocolMemberWithoutRequirement -I %t -pretty-print -output-dir %t
+// RUN: %FileCheck %s --input-file %t/ProtocolMemberWithoutRequirement.symbols.json
+
+public protocol P {}
+
+extension P {
+  public func foo() {}
+}
+public protocol Q : P {}
+
+extension Q {
+  public func bar() {}
+}
+
+// foo is a member of P.
+// CHECK-DAG: "kind": "memberOf",{{[[:space:]]*}}"source": "s:32ProtocolMemberWithoutRequirement1PPAAE3fooyyF",{{[[:space:]]*}}"target": "s:32ProtocolMemberWithoutRequirement1PP"
+
+// bar is a member of Q.
+// CHECK-DAG: "kind": "memberOf",{{[[:space:]]*}}"source": "s:32ProtocolMemberWithoutRequirement1QPAAE3baryyF",{{[[:space:]]*}}"target": "s:32ProtocolMemberWithoutRequirement1QP"
+
+// foo is not a requirement of P nor a default implementation for any requirement.
+// Neither is bar for Q.
+// CHECK-NOT: requirementOf
+// CHECK-NOT: defaultImplementationOf 
+

test/SymbolGraph/Relationships/MemberOf/ProtocolMemberWithoutRequirement.swift

@@ -10,3 +10,4 @@ public protocol P {
 // CHECK: "kind": "requirementOf"
 // CHECK-NEXT: "source": "s:10ConformsTo1PP1xSivp"
 // CHECK-NEXT: "target": "s:10ConformsTo1PP"
+// CHECK-NOT: defaultImplementationOf