[SourceKit/CursorInfo] Mark dynamic calls

bnbarham · bnbarham · commit 19f23130d0ae · 2021-03-20T13:57:01.000+10:00
Adds two new fields to the cursor info response:
  1. is_dynamic: whether a call is dynamic
  2. receivers: receivers of the call (USRs)

Users of the CursorInfo request can use "is_dynamic" to decide whether
to lookup overrides or not, and then the "receivers" as the starting
point of the lookup.

Resolves rdar://75385900
diff --git a/include/swift/IDE/Utils.h b/include/swift/IDE/Utils.h
@@ -164,6 +164,11 @@ struct ResolvedCursorInfo {
   Type ContainerType;
   Stmt *TrailingStmt = nullptr;
   Expr *TrailingExpr = nullptr;
+  /// If this is a call, whether it is "dynamic", see ide::isDynamicCall.
+  bool IsDynamic = false;
+  /// If this is a call, the types of the base (multiple in the case of
+  /// protocol composition).
+  SmallVector<NominalTypeDecl *, 1> ReceiverTypes;
 
   ResolvedCursorInfo() = default;
   ResolvedCursorInfo(SourceFile *SF) : SF(SF) {}
@@ -174,12 +179,9 @@ struct ResolvedCursorInfo {
       lhs.Loc.getOpaquePointerValue() == rhs.Loc.getOpaquePointerValue();
   }
 
-  void setValueRef(ValueDecl *ValueD,
-                   TypeDecl *CtorTyRef,
-                   ExtensionDecl *ExtTyRef,
-                   bool IsRef,
-                   Type Ty,
-                   Type ContainerType) {
+  void setValueRef(ValueDecl *ValueD, TypeDecl *CtorTyRef,
+                   ExtensionDecl *ExtTyRef, bool IsRef,
+                   Type Ty, Type ContainerType) {
     Kind = CursorInfoKind::ValueRef;
     this->ValueD = ValueD;
     this->CtorTyRef = CtorTyRef;
diff --git a/lib/IDE/IDERequests.cpp b/lib/IDE/IDERequests.cpp
@@ -60,6 +60,7 @@ class CursorInfoResolver : public SourceEntityWalker {
   ResolvedCursorInfo CursorInfo;
   Type ContainerType;
   Expr *OutermostCursorExpr;
+  llvm::SmallVector<Expr*, 8> ExprStack;
 
 public:
   explicit CursorInfoResolver(SourceFile &SrcFile) :
@@ -99,8 +100,8 @@ SourceManager &CursorInfoResolver::getSourceMgr() const
 }
 
 bool CursorInfoResolver::tryResolve(ValueDecl *D, TypeDecl *CtorTyRef,
-                                 ExtensionDecl *ExtTyRef, SourceLoc Loc,
-                                 bool IsRef, Type Ty) {
+                                    ExtensionDecl *ExtTyRef, SourceLoc Loc,
+                                    bool IsRef, Type Ty) {
   if (!D->hasName())
     return false;
 
@@ -116,6 +117,14 @@ bool CursorInfoResolver::tryResolve(ValueDecl *D, TypeDecl *CtorTyRef,
       }
     }
   }
+
+  if (isBeingCalled(ExprStack)) {
+    if (Expr *BaseE = getBase(ExprStack)) {
+      CursorInfo.IsDynamic = isDynamicCall(BaseE, D);
+      ide::getReceiverType(BaseE, CursorInfo.ReceiverTypes);
+    }
+  }
+
   CursorInfo.setValueRef(D, CtorTyRef, ExtTyRef, IsRef, Ty, ContainerType);
   return true;
 }
@@ -254,6 +263,8 @@ bool CursorInfoResolver::walkToExprPre(Expr *E) {
   if (!OutermostCursorExpr && isCursorOn(E, LocToResolve))
     OutermostCursorExpr = E;
 
+  ExprStack.push_back(E);
+
   return true;
 }
 
@@ -266,6 +277,8 @@ bool CursorInfoResolver::walkToExprPost(Expr *E) {
     return false;
   }
 
+  ExprStack.pop_back();
+
   return true;
 }
 
diff --git a/lib/IDE/Utils.cpp b/lib/IDE/Utils.cpp
@@ -1214,33 +1214,41 @@ Expr *swift::ide::getBase(ArrayRef<Expr *> ExprStack) {
 
   Expr *CurrentE = ExprStack.back();
   Expr *ParentE = getContainingExpr(ExprStack, 1);
+  Expr *Base = nullptr;
   if (auto DSE = dyn_cast_or_null<DotSyntaxCallExpr>(ParentE))
-    return DSE->getBase();
+    Base = DSE->getBase();
   else if (auto MRE = dyn_cast<MemberRefExpr>(CurrentE))
-    return MRE->getBase();
+    Base = MRE->getBase();
   else if (auto SE = dyn_cast<SubscriptExpr>(CurrentE))
-    return SE->getBase();
-  return nullptr;
-}
-
-static bool isSuperRefExpr(Expr *E) {
-  if (!E)
-    return false;
-  if (isa<SuperRefExpr>(E))
-    return true;
-  if (auto LoadE = dyn_cast<LoadExpr>(E))
-    return isSuperRefExpr(LoadE->getSubExpr());
-  return false;
+    Base = SE->getBase();
+
+  if (Base) {
+    while (auto ICE = dyn_cast<ImplicitConversionExpr>(Base))
+      Base = ICE->getSubExpr();
+    // DotSyntaxCallExpr with getBase() == CurrentE (ie. the current call is
+    // the base of another expression)
+    if (Base == CurrentE)
+      return nullptr;
+  }
+  return Base;
 }
 
 bool swift::ide::isDynamicCall(Expr *Base, ValueDecl *D) {
   auto TyD = D->getDeclContext()->getSelfNominalTypeDecl();
   if (!TyD)
     return false;
-  if (isa<StructDecl>(TyD) || isa<EnumDecl>(TyD))
+
+  if (isa<StructDecl>(TyD) || isa<EnumDecl>(TyD) || D->isFinal())
     return false;
-  if (isSuperRefExpr(Base))
+
+  // super.method()
+  // TODO: Should be dynamic if `D` is marked as dynamic and @objc, but in
+  //       that case we really need to change the role the index outputs as
+  //       well - the overrides we'd want to include are from the type of
+  //       super up to `D`
+  if (Base->isSuperExpr())
     return false;
+
   // `SomeType.staticOrClassMethod()`
   if (isa<TypeExpr>(Base))
     return false;
@@ -1270,6 +1278,8 @@ void swift::ide::getReceiverType(Expr *Base,
     ReceiverTy = LVT->getObjectType();
   else if (auto MetaT = ReceiverTy->getAs<MetatypeType>())
     ReceiverTy = MetaT->getInstanceType();
+  else if (auto SelfT = ReceiverTy->getAs<DynamicSelfType>())
+    ReceiverTy = SelfT->getSelfType();
 
   // TODO: Handle generics and composed protocols
   if (auto OpenedTy = ReceiverTy->getAs<OpenedArchetypeType>())
diff --git a/test/SourceKit/CursorInfo/cursor_dynamic.swift b/test/SourceKit/CursorInfo/cursor_dynamic.swift
@@ -0,0 +1,142 @@
+protocol ProtoA {
+  func method()
+  static func staticMethod()
+}
+
+class ClassB: ProtoA {
+  let immutableMember: Int = 1
+  var mutableMember: Int = 1
+  func method() {}
+  static func staticMethod() {}
+  class func classMethod() {}
+  final func finalMethod() {}
+}
+
+class ClassC: ClassB {}
+
+class ClassD: ClassC {
+  override var mutableMember: Int {
+    get {
+      return super.mutableMember
+    }
+    set {
+      super.mutableMember = newValue + 1
+    }
+  }
+
+  override func method() {
+    super.method()
+  }
+
+  override class func classMethod() {}
+}
+
+struct StructE: ProtoA {
+  func method() {}
+
+  static func staticMethod() {}
+}
+
+func direct() {
+  ClassB.staticMethod()
+  ClassB.classMethod()
+  ClassD.classMethod()
+  StructE.staticMethod()
+}
+
+func protoCalls(p: ProtoA) {
+  p.method()
+  type(of: p).staticMethod()
+}
+
+func classCalls(c: ClassC) {
+  _ = c.immutableMember
+  _ = c.mutableMember
+  c.mutableMember = 1
+  c.method()
+  type(of: c).staticMethod()
+  type(of: c).classMethod()
+  c.finalMethod()
+}
+
+func structCalls(e: StructE) {
+  e.method()
+  type(of: e).staticMethod()
+}
+
+// RUN: %sourcekitd-test -req=cursor -pos=28:11 %s -- %s | %FileCheck -check-prefix=CHECK-SUPER %s
+// CHECK-SUPER: s:14cursor_dynamic6ClassBC6methodyyF
+// CHECK-SUPER-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=41:10 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSSTATIC %s
+// CHECK-CLASSSTATIC: s:14cursor_dynamic6ClassBC12staticMethodyyFZ
+// CHECK-CLASSSTATIC-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=42:10 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSCLASS %s
+// CHECK-CLASSCLASS: s:14cursor_dynamic6ClassBC11classMethodyyFZ
+// CHECK-CLASSCLASS-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=43:10 %s -- %s | %FileCheck -check-prefix=CHECK-SUBCLASSCLASS %s
+// CHECK-SUBCLASSCLASS: s:14cursor_dynamic6ClassDC11classMethodyyFZ
+// CHECK-SUBCLASSCLASS-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=44:11 %s -- %s | %FileCheck -check-prefix=CHECK-STRUCTSTATIC %s
+// CHECK-STRUCTSTATIC: s:14cursor_dynamic7StructEV12staticMethodyyFZ
+// CHECK-STRUCTSTATIC-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=48:5 %s -- %s | %FileCheck -check-prefix=CHECK-PROTOMETHOD %s
+// CHECK-PROTOMETHOD: s:14cursor_dynamic6ProtoAP6methodyyF
+// CHECK-PROTOMETHOD: DYNAMIC
+// CHECK-PROTOMETHOD: RECEIVERS BEGIN
+// CHECK-PROTOMETHOD-NEXT: s:14cursor_dynamic6ProtoAP
+// CHECK-PROTOMETHOD-NEXT: RECEIVERS END
+
+// RUN: %sourcekitd-test -req=cursor -pos=49:15 %s -- %s | %FileCheck -check-prefix=CHECK-PROTOTOSTATIC %s
+// CHECK-PROTOTOSTATIC: s:14cursor_dynamic6ProtoAP12staticMethodyyFZ
+// CHECK-PROTOTOSTATIC: DYNAMIC
+// CHECK-PROTOSTATIC: RECEIVERS BEGIN
+// CHECK-PROTOSTATIC-NEXT: s:14cursor_dynamic6ProtoAP
+// CHECK-PROTOSTATIC-NEXT: RECEIVERS END
+
+// RUN: %sourcekitd-test -req=cursor -pos=53:9 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSIMMEMBER %s
+// CHECK-CLASSIMMEMBER: s:14cursor_dynamic6ClassBC15immutableMemberSivp
+// rdar://75645572 should include getter without dynamic (or maybe we just skip returning in that case
+// since it would only be used to find overrides)
+
+// RUN: %sourcekitd-test -req=cursor -pos=54:9 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSMEMBERREAD %s
+// CHECK-CLASSMEMBERREAD: s:14cursor_dynamic6ClassBC13mutableMemberSivp
+// rdar://75645572 should include getter with dynamic
+
+// RUN: %sourcekitd-test -req=cursor -pos=55:5 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSMEMBERWRITE %s
+// CHECK-CLASSMEMBERWRITE: s:14cursor_dynamic6ClassBC13mutableMemberSivp
+// rdar://75645572 should include setter with dynamic
+
+// RUN: %sourcekitd-test -req=cursor -pos=56:5 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSMETHOD %s
+// CHECK-CLASSMETHOD: s:14cursor_dynamic6ClassBC6methodyyF
+// CHECK-CLASSMETHOD: DYNAMIC
+// CHECK-CLASSMETHOD: RECEIVERS BEGIN
+// CHECK-CLASSMETHOD-NEXT: s:14cursor_dynamic6ClassCC
+// CHECK-CLASSMETHOD-NEXT: RECEIVERS END
+
+// RUN: %sourcekitd-test -req=cursor -pos=57:15 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSTOSTATIC %s
+// CHECK-CLASSTOSTATIC: s:14cursor_dynamic6ClassBC12staticMethodyyFZ
+// CHECK-CLASSTOSTATIC-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=58:15 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSTOCLASS %s
+// CHECK-CLASSTOCLASS: s:14cursor_dynamic6ClassBC11classMethodyyFZ
+// CHECK-CLASSTOCLASS: DYNAMIC
+// CHECK-CLASSTOCLASS: RECEIVERS BEGIN
+// CHECK-CLASSTOCLASS-NEXT: s:14cursor_dynamic6ClassCC
+// CHECK-CLASSTOCLASS-NEXT: RECEIVERS END
+
+// RUN: %sourcekitd-test -req=cursor -pos=59:5 %s -- %s | %FileCheck -check-prefix=CHECK-CLASSFINAL %s
+// CHECK-CLASSFINAL: s:14cursor_dynamic6ClassBC11finalMethodyyF
+// CHECK-CLASSFINAL-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=63:5 %s -- %s | %FileCheck -check-prefix=CHECK-STRUCTMETHOD %s
+// CHECK-STRUCTMETHOD: s:14cursor_dynamic7StructEV6methodyyF
+// CHECK-STRUCTMETHOD-NOT: DYNAMIC
+
+// RUN: %sourcekitd-test -req=cursor -pos=64:15 %s -- %s | %FileCheck -check-prefix=CHECK-STRUCTTOSTATIC %s
+// CHECK-STRUCTTOSTATIC: s:14cursor_dynamic7StructEV12staticMethodyyFZ
+// CHECK-STRUCTOTSTATIC-NOT: DYNAMIC
diff --git a/test/SourceKit/Indexing/index_forbid_typecheck.swift.response b/test/SourceKit/Indexing/index_forbid_typecheck.swift.response
@@ -89,7 +89,6 @@
               key.line: 5,
               key.column: 20,
               key.receiver_usr: "s:16forbid_typecheck6ClsSecC",
-              key.is_dynamic: 1,
               key.is_implicit: 1
             }
           ]
diff --git a/tools/SourceKit/include/SourceKit/Core/LangSupport.h b/tools/SourceKit/include/SourceKit/Core/LangSupport.h
@@ -431,8 +431,13 @@ struct CursorInfoData {
   /// Stores the Symbol Graph title, kind, and USR of the parent contexts of the
   /// symbol under the cursor.
   ArrayRef<ParentInfo> ParentContexts;
+  /// For calls this lists the USRs of the receiver types (multiple only in the
+  /// case that the base is a protocol composition).
+  ArrayRef<StringRef> ReceiverUSRs;
 
   bool IsSystem = false;
+  bool IsDynamic = false;
+
   llvm::Optional<unsigned> ParentNameOffset;
 };
 
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
@@ -834,7 +834,6 @@ static bool passCursorInfoForDecl(SourceFile* SF,
   }
   unsigned DeclEnd = SS.size();
 
-
   SmallVector<symbolgraphgen::PathComponent, 4> PathComponents;
   unsigned SymbolGraphBegin = SS.size();
   if (SymbolGraph) {
@@ -949,6 +948,14 @@ static bool passCursorInfoForDecl(SourceFile* SF,
     RelDeclsStream.endPiece();
   });
 
+  DelayedStringRetriever ReceiverUSRsStream(SS);
+  for (auto *ReceiverTy : TheTok.ReceiverTypes) {
+    ReceiverUSRsStream.startPiece();
+    if (SwiftLangSupport::printUSR(ReceiverTy, OS))
+      ReceiverUSRsStream.startPiece();
+    ReceiverUSRsStream.endPiece();
+  }
+
   ASTContext &Ctx = VD->getASTContext();
 
   ClangImporter *Importer = static_cast<ClangImporter*>(
@@ -1026,6 +1033,9 @@ static bool passCursorInfoForDecl(SourceFile* SF,
   SmallVector<StringRef, 4> AnnotatedRelatedDecls;
   RelDeclsStream.retrieve([&](StringRef S) { AnnotatedRelatedDecls.push_back(S); });
 
+  SmallVector<StringRef, 4> ReceiverUSRs;
+  ReceiverUSRsStream.retrieve([&](StringRef S) { ReceiverUSRs.push_back(S); });
+
   SmallVector<RefactoringInfo, 4> RefactoringInfoBuffer;
   for (unsigned I = 0, N = RefactoringIds.size(); I < N; I ++) {
     RefactoringInfoBuffer.push_back({RefactoringIds[I], RefactoringNameOS[I],
@@ -1065,6 +1075,8 @@ static bool passCursorInfoForDecl(SourceFile* SF,
   Info.ParentNameOffset = getParamParentNameOffset(VD, CursorLoc);
   Info.SymbolGraph = SymbolGraphJSON;
   Info.ParentContexts = llvm::makeArrayRef(Parents);
+  Info.IsDynamic = TheTok.IsDynamic;
+  Info.ReceiverUSRs = ReceiverUSRs;
   Receiver(RequestResult<CursorInfoData>::fromResult(Info));
   return true;
 }
diff --git a/tools/SourceKit/tools/sourcekitd-test/sourcekitd-test.cpp b/tools/SourceKit/tools/sourcekitd-test/sourcekitd-test.cpp
diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp
diff --git a/utils/gyb_sourcekit_support/UIDs.py b/utils/gyb_sourcekit_support/UIDs.py

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,7 @@ class CursorInfoResolver : public SourceEntityWalker {`
`60`	`60`	`ResolvedCursorInfo CursorInfo;`
`61`	`61`	`Type ContainerType;`
`62`	`62`	`Expr *OutermostCursorExpr;`
	`63`	`+ llvm::SmallVector<Expr*, 8> ExprStack;`
`63`	`64`
`64`	`65`	`public:`
`65`	`66`	`explicit CursorInfoResolver(SourceFile &SrcFile) :`
`@@ -99,8 +100,8 @@ SourceManager &CursorInfoResolver::getSourceMgr() const`
`99`	`100`	`}`
`100`	`101`
`101`	`102`	`bool CursorInfoResolver::tryResolve(ValueDecl D, TypeDecl CtorTyRef,`
`102`		`- ExtensionDecl *ExtTyRef, SourceLoc Loc,`
`103`		`- bool IsRef, Type Ty) {`
	`103`	`+ ExtensionDecl *ExtTyRef, SourceLoc Loc,`
	`104`	`+ bool IsRef, Type Ty) {`
`104`	`105`	`if (!D->hasName())`
`105`	`106`	`return false;`
`106`	`107`
`@@ -116,6 +117,14 @@ bool CursorInfoResolver::tryResolve(ValueDecl D, TypeDecl CtorTyRef,`
`116`	`117`	`}`
`117`	`118`	`}`
`118`	`119`	`}`
	`120`	`+`
	`121`	`+ if (isBeingCalled(ExprStack)) {`
	`122`	`+ if (Expr *BaseE = getBase(ExprStack)) {`
	`123`	`+ CursorInfo.IsDynamic = isDynamicCall(BaseE, D);`
	`124`	`+ ide::getReceiverType(BaseE, CursorInfo.ReceiverTypes);`
	`125`	`+ }`
	`126`	`+ }`
	`127`	`+`
`119`	`128`	`CursorInfo.setValueRef(D, CtorTyRef, ExtTyRef, IsRef, Ty, ContainerType);`
`120`	`129`	`return true;`
`121`	`130`	`}`
`@@ -254,6 +263,8 @@ bool CursorInfoResolver::walkToExprPre(Expr *E) {`
`254`	`263`	`if (!OutermostCursorExpr && isCursorOn(E, LocToResolve))`
`255`	`264`	`OutermostCursorExpr = E;`
`256`	`265`
	`266`	`+ ExprStack.push_back(E);`
	`267`	`+`
`257`	`268`	`return true;`
`258`	`269`	`}`
`259`	`270`
`@@ -266,6 +277,8 @@ bool CursorInfoResolver::walkToExprPost(Expr *E) {`
`266`	`277`	`return false;`
`267`	`278`	`}`
`268`	`279`
	`280`	`+ ExprStack.pop_back();`
	`281`	`+`
`269`	`282`	`return true;`
`270`	`283`	`}`
`271`	`284`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,6 @@`
`89`	`89`	`key.line: 5,`
`90`	`90`	`key.column: 20,`
`91`	`91`	`key.receiver_usr: "s:16forbid_typecheck6ClsSecC",`
`92`		`- key.is_dynamic: 1,`
`93`	`92`	`key.is_implicit: 1`
`94`	`93`	`}`
`95`	`94`	`]`