Merge pull request swiftlang#36508 from bnbarham/static-dynamic-flag

[SourceKit/CursorInfo] Mark dynamic calls

Author: bnbarham

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;
@@ -621,6 +623,23 @@ ClangNode extensionGetClangNode(const ExtensionDecl *ext);
 /// or a curry thunk, etc.
 std::pair<Type, ConcreteDeclRef> getReferencedDecl(Expr *expr);
 
+/// Whether the last expression in \p ExprStack is being called.
+bool isBeingCalled(ArrayRef<Expr*> ExprStack);
+
+/// The base of the last expression in \p ExprStack (which may look up the
+/// stack in eg. the case of a `DotSyntaxCallExpr`).
+Expr *getBase(ArrayRef<Expr *> ExprStack);
+
+/// Assuming that we have a call, returns whether or not it is "dynamic" based
+/// on its base expression and decl of the callee. Note that this is not
+/// Swift's "dynamic" modifier (`ValueDecl::isDynamic`), but rathar "can call a
+/// function in a conformance/subclass".
+bool isDynamicCall(Expr *Base, ValueDecl *D);
+
+/// Adds the resolved nominal types of \p Base to \p Types.
+void getReceiverType(Expr *Base,
+                     SmallVectorImpl<NominalTypeDecl *> &Types);
+
 } // namespace ide
 } // namespace swift
 

lib/IDE/IDERequests.cpp

@@ -59,11 +59,12 @@ class CursorInfoResolver : public SourceEntityWalker {
   SourceLoc LocToResolve;
   ResolvedCursorInfo CursorInfo;
   Type ContainerType;
-  llvm::SmallVector<Expr*, 4> TrailingExprStack;
+  Expr *OutermostCursorExpr;
+  llvm::SmallVector<Expr*, 8> ExprStack;
 
 public:
   explicit CursorInfoResolver(SourceFile &SrcFile) :
-    SrcFile(SrcFile), CursorInfo(&SrcFile) {}
+    SrcFile(SrcFile), CursorInfo(&SrcFile), OutermostCursorExpr(nullptr) {}
   ResolvedCursorInfo resolve(SourceLoc Loc);
   SourceManager &getSourceMgr() const;
 private:
@@ -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;
 }
@@ -221,44 +230,55 @@ bool CursorInfoResolver::visitDeclReference(ValueDecl *D,
   return !tryResolve(D, CtorTyRef, ExtTyRef, Range.getStart(), /*IsRef=*/true, T);
 }
 
+static bool isCursorOn(Expr *E, SourceLoc Loc) {
+  if (E->isImplicit())
+    return false;
+
+  bool IsCursorOnLoc = E->getStartLoc() == Loc;
+  // Handle cursor placement after `try` in (ForceTry|OptionalTry)Expr
+  if (auto *FTE = dyn_cast<ForceTryExpr>(E)) {
+    IsCursorOnLoc |= FTE->getExclaimLoc() == Loc;
+  }
+  if (auto *OTE = dyn_cast<OptionalTryExpr>(E)) {
+    IsCursorOnLoc |= OTE->getQuestionLoc() == Loc;
+  }
+  return IsCursorOnLoc;
+}
+
 bool CursorInfoResolver::walkToExprPre(Expr *E) {
-  if (!isDone()) {
-    if (auto SAE = dyn_cast<SelfApplyExpr>(E)) {
-      if (SAE->getFn()->getStartLoc() == LocToResolve) {
-        ContainerType = SAE->getBase()->getType();
-      }
-    } else if (auto ME = dyn_cast<MemberRefExpr>(E)) {
-      SourceLoc MemberLoc = ME->getNameLoc().getBaseNameLoc();
-      if (MemberLoc.isValid() && MemberLoc == LocToResolve) {
-        ContainerType = ME->getBase()->getType();
-      }
-    }
-    auto IsProperCursorLocation = E->getStartLoc() == LocToResolve;
-    // Handle cursor placement after `try` in ForceTry and OptionalTry Expr.
-    auto CheckLocation = [&IsProperCursorLocation, this](SourceLoc Loc) {
-      IsProperCursorLocation = Loc == LocToResolve || IsProperCursorLocation;
-    };
-    if (auto *FTE = dyn_cast<ForceTryExpr>(E)) {
-      CheckLocation(FTE->getExclaimLoc());
+  if (isDone())
+    return true;
+
+  if (auto SAE = dyn_cast<SelfApplyExpr>(E)) {
+    if (SAE->getFn()->getStartLoc() == LocToResolve) {
+      ContainerType = SAE->getBase()->getType();
     }
-    if (auto *OTE = dyn_cast<OptionalTryExpr>(E)) {
-      CheckLocation(OTE->getQuestionLoc());
+  } else if (auto ME = dyn_cast<MemberRefExpr>(E)) {
+    SourceLoc MemberLoc = ME->getNameLoc().getBaseNameLoc();
+    if (MemberLoc.isValid() && MemberLoc == LocToResolve) {
+      ContainerType = ME->getBase()->getType();
     }
-    // Keep track of trailing expressions.
-    if (!E->isImplicit() && IsProperCursorLocation)
-      TrailingExprStack.push_back(E);
   }
+
+  if (!OutermostCursorExpr && isCursorOn(E, LocToResolve))
+    OutermostCursorExpr = E;
+
+  ExprStack.push_back(E);
+
   return true;
 }
 
 bool CursorInfoResolver::walkToExprPost(Expr *E) {
   if (isDone())
     return false;
-  if (!TrailingExprStack.empty() && TrailingExprStack.back() == E) {
-    // We return the outtermost expression in the token info.
-    CursorInfo.setTrailingExpr(TrailingExprStack.front());
+
+  if (OutermostCursorExpr && isCursorOn(E, LocToResolve)) {
+    CursorInfo.setTrailingExpr(OutermostCursorExpr);
     return false;
   }
+
+  ExprStack.pop_back();
+
   return true;
 }
 

lib/IDE/Utils.cpp

@@ -1181,3 +1181,111 @@ std::pair<Type, ConcreteDeclRef> swift::ide::getReferencedDecl(Expr *expr) {
 
   return std::make_pair(exprTy, refDecl);
 }
+
+bool swift::ide::isBeingCalled(ArrayRef<Expr *> ExprStack) {
+  if (ExprStack.empty())
+    return false;
+
+  Expr *Target = ExprStack.back();
+  auto UnderlyingDecl = getReferencedDecl(Target).second;
+  for (Expr *E: reverse(ExprStack)) {
+    auto *AE = dyn_cast<ApplyExpr>(E);
+    if (!AE || AE->isImplicit())
+      continue;
+    if (isa<ConstructorRefCallExpr>(AE) && AE->getArg() == Target)
+      return true;
+    if (isa<SelfApplyExpr>(AE))
+      continue;
+    if (getReferencedDecl(AE->getFn()).second == UnderlyingDecl)
+      return true;
+  }
+  return false;
+}
+
+static Expr *getContainingExpr(ArrayRef<Expr *> ExprStack, size_t index) {
+  if (ExprStack.size() > index)
+    return ExprStack.end()[-std::ptrdiff_t(index + 1)];
+  return nullptr;
+}
+
+Expr *swift::ide::getBase(ArrayRef<Expr *> ExprStack) {
+  if (ExprStack.empty())
+    return nullptr;
+
+  Expr *CurrentE = ExprStack.back();
+  Expr *ParentE = getContainingExpr(ExprStack, 1);
+  Expr *Base = nullptr;
+  if (auto DSE = dyn_cast_or_null<DotSyntaxCallExpr>(ParentE))
+    Base = DSE->getBase();
+  else if (auto MRE = dyn_cast<MemberRefExpr>(CurrentE))
+    Base = MRE->getBase();
+  else if (auto SE = dyn_cast<SubscriptExpr>(CurrentE))
+    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) || D->isFinal())
+    return false;
+
+  // 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;
+
+  // `type(of: foo).staticOrClassMethod()`, not "dynamic" if the instance type
+  // is a struct/enum or if it is a class and the function is a static method
+  // (rather than a class method).
+  if (auto IT = Base->getType()->getAs<MetatypeType>()) {
+    auto InstanceType = IT->getInstanceType();
+    if (InstanceType->getStructOrBoundGenericStruct() ||
+        InstanceType->getEnumOrBoundGenericEnum())
+      return false;
+    if (InstanceType->getClassOrBoundGenericClass() && D->isFinal())
+      return false;
+  }
+
+  return true;
+}
+
+void swift::ide::getReceiverType(Expr *Base,
+                                 SmallVectorImpl<NominalTypeDecl *> &Types) {
+  Type ReceiverTy = Base->getType();
+  if (!ReceiverTy)
+    return;
+
+  if (auto LVT = ReceiverTy->getAs<LValueType>())
+    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>())
+    ReceiverTy = OpenedTy->getOpenedExistentialType();
+
+  if (auto TyD = ReceiverTy->getAnyNominal()) {
+    Types.push_back(TyD);
+  }
+}