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

To differentiate between freestanding extensions of protocols and matching
default implementations with their requirements. Otherwise, it's difficult to
filter out "duplicate" entries for protocols.

rdar://61459287

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