Merge pull request swiftlang#30389 from benlangmuir/index-caf

[index] Add implicit callAsFunction reference to index

Author: benlangmuir

include/swift/IDE/SourceEntityWalker.h

@@ -120,6 +120,16 @@ class SourceEntityWalker {
                                        ReferenceMetaData Data,
                                        bool IsOpenBracket);
 
+  /// This method is called when a ValueDecl for a callAsFunction decl is
+  /// referenced in source. If it returns false, the remaining traversal is
+  /// terminated and returns failure.
+  ///
+  /// \param D the referenced decl.
+  /// \param Range the source range of the source reference.
+  /// \param Data whether this is a read, write or read/write access, etc.
+  virtual bool visitCallAsFunctionReference(ValueDecl *D, CharSourceRange Range,
+                                            ReferenceMetaData Data);
+
   /// This method is called for each keyword argument in a call expression.
   /// If it returns false, the remaining traversal is terminated and returns
   /// failure.

lib/IDE/SourceEntityWalker.cpp

@@ -78,6 +78,8 @@ class SemaAnnotator : public ASTWalker {
 
   bool passSubscriptReference(ValueDecl *D, SourceLoc Loc,
                               ReferenceMetaData Data, bool IsOpenBracket);
+  bool passCallAsFunctionReference(ValueDecl *D, SourceLoc Loc,
+                                   ReferenceMetaData Data);
 
   bool passCallArgNames(Expr *Fn, TupleExpr *TupleE);
 
@@ -271,6 +273,18 @@ std::pair<bool, Expr *> SemaAnnotator::walkToExprPre(Expr *E) {
     }
   }
 
+  if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
+    auto *FD = dyn_cast<FuncDecl>(DRE->getDecl());
+    // Handle implicit callAsFunction reference. An explicit reference will be
+    // handled by the usual DeclRefExpr case below.
+    if (DRE->isImplicit() && FD && FD->isCallAsFunctionMethod()) {
+      ReferenceMetaData data(SemaReferenceKind::DeclMemberRef, OpAccess);
+      if (!passCallAsFunctionReference(FD, DRE->getLoc(), data))
+        return {false, nullptr};
+      return {true, E};
+    }
+  }
+
   if (!isa<InOutExpr>(E) &&
       !isa<LoadExpr>(E) &&
       !isa<OpenExistentialExpr>(E) &&
@@ -643,6 +657,17 @@ bool SemaAnnotator::passSubscriptReference(ValueDecl *D, SourceLoc Loc,
   return Continue;
 }
 
+bool SemaAnnotator::passCallAsFunctionReference(ValueDecl *D, SourceLoc Loc,
+                                                ReferenceMetaData Data) {
+  CharSourceRange Range =
+      Loc.isValid() ? CharSourceRange(Loc, 1) : CharSourceRange();
+
+  bool Continue = SEWalker.visitCallAsFunctionReference(D, Range, Data);
+  if (!Continue)
+    Cancelled = true;
+  return Continue;
+}
+
 bool SemaAnnotator::
 passReference(ValueDecl *D, Type Ty, DeclNameLoc Loc, ReferenceMetaData Data) {
   return passReference(D, Ty, Loc.getBaseNameLoc(), Loc.getSourceRange(), Data);
@@ -792,6 +817,12 @@ bool SourceEntityWalker::visitSubscriptReference(ValueDecl *D,
              : true;
 }
 
+bool SourceEntityWalker::visitCallAsFunctionReference(ValueDecl *D,
+                                                      CharSourceRange Range,
+                                                      ReferenceMetaData Data) {
+  return true;
+}
+
 bool SourceEntityWalker::visitCallArgName(Identifier Name,
                                           CharSourceRange Range,
                                           ValueDecl *D) {

lib/Index/Index.cpp

@@ -495,6 +495,13 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
     return finishSourceEntity(Info.symInfo, Info.roles);
   }
 
+  bool visitCallAsFunctionReference(ValueDecl *D, CharSourceRange Range,
+                                    ReferenceMetaData Data) override {
+    // Index implicit callAsFunction reference.
+    return visitDeclReference(D, Range, /*CtorTyRef*/ nullptr,
+                              /*ExtTyRef*/ nullptr, Type(), Data);
+  }
+
   Decl *getParentDecl() const {
     if (!EntitiesStack.empty())
       return EntitiesStack.back().D;

test/Index/index_callasfunction.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-ide-test -print-indexed-symbols -source-filename %s | %FileCheck %s
+
+struct Adder {
+    var base: Int
+    func callAsFunction(_ x: Int) -> Int {
+// CHECK: [[@LINE-1]]:10 | instance-method/Swift | callAsFunction(_:) | [[callAsFunc1:.*]] | Def
+        return base + x
+    }
+    func callAsFunction(x: Int, y: Int) -> Int {
+// CHECK: [[@LINE-1]]:10 | instance-method/Swift | callAsFunction(x:y:) | [[callAsFunc2:.*]] | Def
+        return base + x + y
+    }
+}
+
+let add3 = Adder(base: 3)
+// CHECK: [[@LINE-1]]:5 | variable/Swift | add3 | [[add3:.*]] | Def
+let global = 1
+
+add3(global)
+// CHECK: [[@LINE-1]]:1 | variable/Swift | add3 | [[add3]] | Ref,Read |
+// CHECK: [[@LINE-2]]:1 | instance-method/Swift | callAsFunction(_:) | [[callAsFunc1]] | Ref,Call,RelRec | rel: 1
+// CHECK:   RelRec | struct/Swift | Adder |
+// CHECK: [[@LINE-4]]:6 | variable/Swift | global | {{.*}} | Ref,Read |
+
+add3(x: 10, y: 11)
+// CHECK: [[@LINE-1]]:1 | variable/Swift | add3 | [[add3]] | Ref,Read |
+// CHECK: [[@LINE-2]]:1 | instance-method/Swift | callAsFunction(x:y:) | [[callAsFunc2]] | Ref,Call,RelRec | rel: 1
+// CHECK:   RelRec | struct/Swift | Adder |