Index: Record override-of relationship between a decl in protocol extension and the protocol requirements it can provide default implementations for. (#8418)

Author: nkcsgexi

include/swift/Sema/IDETypeChecking.h

@@ -49,6 +49,15 @@ namespace swift {
   void collectDefaultImplementationForProtocolMembers(ProtocolDecl *PD,
                         llvm::SmallDenseMap<ValueDecl*, ValueDecl*> &DefaultMap);
 
+  /// \brief Collect all the protocol requirements that a given declaration can
+  ///   provide default implementations for. VD is a declaration in extension
+  ///   declaration. Scratch is the buffer to collect those protocol
+  ///   requirements.
+  ///
+  /// \returns the slice of Scratch
+  ArrayRef<ValueDecl*> canDeclProvideDefaultImplementationFor(ValueDecl* VD,
+                                  llvm::SmallVectorImpl<ValueDecl*> &Scractch);
+
   /// \brief Given an unresolved member E and its parent P, this function tries
   /// to infer the type of E.
   /// \returns true on success, false on error.

lib/IDE/CMakeLists.txt

@@ -9,6 +9,7 @@ add_swift_library(swiftIDE STATIC
   SwiftSourceDocInfo.cpp
   SyntaxModel.cpp
   Utils.cpp
+  IDETypeChecking.cpp
   LINK_LIBRARIES
     swiftFrontend
     swiftClangImporter

lib/IDE/IDETypeChecking.cpp

@@ -0,0 +1,88 @@
+//===--- IDETypeChecking.cpp ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/Identifier.h"
+#include "swift/AST/Decl.h"
+#include "swift/AST/Types.h"
+#include "swift/Sema/IDETypeChecking.h"
+
+using namespace swift;
+
+ArrayRef<ValueDecl*> swift::
+canDeclProvideDefaultImplementationFor(ValueDecl* VD,
+                                llvm::SmallVectorImpl<ValueDecl*> &Scractch) {
+
+  // Skip decls that don't have valid names.
+  if (!VD->getFullName())
+    return {};
+
+  // Check if VD is from a protocol extension.
+  auto P = VD->getDeclContext()->getAsProtocolExtensionContext();
+  if (!P)
+    return {};
+
+  // Look up all decls in the protocol's inheritance chain for the ones with
+  // the same name with VD.
+  ResolvedMemberResult LookupResult =
+    resolveValueMember(*P->getInnermostDeclContext(),
+                       P->getDeclaredInterfaceType(), VD->getFullName());
+
+  for (auto Mem : LookupResult.getMemberDecls(InterestedMemberKind::All)) {
+    if (auto Pro = dyn_cast<ProtocolDecl>(Mem->getDeclContext())) {
+      if (Mem->isProtocolRequirement() &&
+          Mem->getInterfaceType()->isEqual(VD->getInterfaceType())) {
+        // We find a protocol requirement VD can provide default
+        // implementation for.
+        Scractch.push_back(Mem);
+      }
+    }
+  }
+  return Scractch;
+}
+
+void swift::
+collectDefaultImplementationForProtocolMembers(ProtocolDecl *PD,
+                    llvm::SmallDenseMap<ValueDecl*, ValueDecl*> &DefaultMap) {
+  Type BaseTy = PD->getDeclaredInterfaceType();
+  DeclContext *DC = PD->getInnermostDeclContext();
+  auto HandleMembers = [&](DeclRange Members) {
+    for (Decl *D : Members) {
+      ValueDecl *VD = dyn_cast<ValueDecl>(D);
+
+      // Skip non-value decl.
+      if (!VD)
+        continue;
+
+      // Skip decls with empty names, e.g. setter/getters for properties.
+      if (VD->getName().empty())
+        continue;
+
+      ResolvedMemberResult Result = resolveValueMember(*DC, BaseTy,
+                                                       VD->getFullName());
+      assert(Result);
+      for (auto *Default : Result.getMemberDecls(InterestedMemberKind::All)) {
+        if (PD == Default->getDeclContext()->getAsProtocolExtensionContext()) {
+          DefaultMap.insert({Default, VD});
+        }
+      }
+    }
+  };
+
+  // Collect the default implementations for the members in this given protocol.
+  HandleMembers(PD->getMembers());
+
+  // Collect the default implementations for the members in the inherited
+  // protocols.
+  for (auto* IP : PD->getInheritedProtocols())
+    HandleMembers(IP->getMembers());
+}

lib/Index/Index.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/USRGeneration.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/StringExtras.h"
+#include "swift/Sema/IDETypeChecking.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -596,6 +597,17 @@ bool IndexSwiftASTWalker::startEntityDecl(ValueDecl *D) {
     if (addRelation(Info, (SymbolRoleSet) SymbolRole::RelationOverrideOf, Overridden))
       return false;
   }
+
+  {
+    // Collect the protocol requirements this decl can provide default
+    // implementations to, and record them as overriding.
+    llvm::SmallVector<ValueDecl*, 2> Buffer;
+    for (auto Req : canDeclProvideDefaultImplementationFor(D, Buffer)) {
+      if (addRelation(Info, (SymbolRoleSet) SymbolRole::RelationOverrideOf, Req))
+        return false;
+    }
+  }
+
   // FIXME: This is quite expensive and not worth the cost for indexing purposes
   // of system modules. Revisit if this becomes more efficient.
   if (!isSystemModule) {

lib/Sema/TypeChecker.cpp

@@ -1002,46 +1002,3 @@ TypeChecker::getDeclTypeCheckingSemantics(ValueDecl *decl) {
   }
   return DeclTypeCheckingSemantics::Normal;
 }
-
-void swift::
-collectDefaultImplementationForProtocolMembers(ProtocolDecl *PD,
-                    llvm::SmallDenseMap<ValueDecl*, ValueDecl*> &DefaultMap) {
-  Type BaseTy = PD->getDeclaredInterfaceType();
-  DeclContext *DC = PD->getInnermostDeclContext();
-  std::unique_ptr<TypeChecker> CreatedTC;
-  auto *TC = static_cast<TypeChecker*>(DC->getASTContext().getLazyResolver());
-  if (!TC) {
-    CreatedTC.reset(new TypeChecker(DC->getASTContext()));
-    TC = CreatedTC.get();
-  }
-  auto HandleMembers = [&](DeclRange Members) {
-    for (Decl *D : Members) {
-      ValueDecl *VD = dyn_cast<ValueDecl>(D);
-
-      // Skip non-value decl.
-      if (!VD)
-        continue;
-
-      // Skip decls with empty names, e.g. setter/getters for properties.
-      if (VD->getName().empty())
-        continue;
-
-      ResolvedMemberResult Result = resolveValueMember(*DC, BaseTy,
-                                                       VD->getFullName());
-      assert(Result);
-      for (auto *Default : Result.getMemberDecls(InterestedMemberKind::All)) {
-        if (PD == Default->getDeclContext()->getAsProtocolExtensionContext()) {
-          DefaultMap.insert({Default, VD});
-        }
-      }
-    }
-  };
-
-  // Collect the default implementations for the members in this given protocol.
-  HandleMembers(PD->getMembers());
-
-  // Collect the default implementations for the members in the inherited
-  // protocols.
-  for (auto* IP : PD->getInheritedProtocols())
-    HandleMembers(IP->getMembers());
-}

test/Index/roles.swift

@@ -333,3 +333,28 @@ func containing() {
     }
   }
 }
+
+protocol ProtRoot {
+  func fooCommon()
+  func foo1()
+  func foo2()
+}
+
+protocol ProtDerived : ProtRoot {
+  func fooCommon()
+  func bar1()
+  func bar2()
+}
+
+extension ProtDerived {
+  func fooCommon() {}
+  // CHECK: 350:8 | instance-method/Swift | fooCommon() | s:14swift_ide_test11ProtDerivedPAAE9fooCommonyyF | Def,RelChild,RelOver | rel: 2
+  // CHECK-NEXT: RelOver | instance-method/Swift | fooCommon() | s:14swift_ide_test11ProtDerivedP9fooCommonyyF
+
+  func foo1() {}
+  // FIXME: This should override foo1 from ProtRoot.
+
+  func bar1() {}
+  // CHECK: 357:8 | instance-method/Swift | bar1() | s:14swift_ide_test11ProtDerivedPAAE4bar1yyF | Def,RelChild,RelOver | rel: 2
+  // CHECK-NEXT: RelOver | instance-method/Swift | bar1() | s:14swift_ide_test11ProtDerivedP4bar1yyF
+}