[IDE] Report ambiguous cursor info results

Author: ahoppen

lib/IDE/CursorInfo.cpp

@@ -225,7 +225,8 @@ class NodeFinder : ASTWalker {
     switch (E->getKind()) {
     case ExprKind::DeclRef:
     case ExprKind::UnresolvedDot:
-    case ExprKind::UnresolvedDeclRef: {
+    case ExprKind::UnresolvedDeclRef:
+    case ExprKind::OverloadedDeclRef: {
       assert(Result == nullptr);
       Result =
           std::make_unique<NodeFinderExprResult>(E, getCurrentDeclContext());
@@ -273,13 +274,33 @@ class CursorInfoTypeCheckSolutionCallback : public TypeCheckCompletionCallback {
   };
 
 private:
-  /// The expression for which we want to provide cursor info results.
-  Expr *ResolveExpr;
+  /// The source file and location to resolve.
+  /// Note that we cannot store the expression to resolve directly because an
+  /// \c UnresolvedDeclRefExpr might be replaced by an \c OverloadedDeclRefExpr
+  /// and thus the constraint system solution doesn't know about the
+  /// \c UnresolvedDeclRefExpr. Instead, we find the expression to resolve in
+  /// the source file again after expression pre-check has run.
+  SourceFile &SrcFile;
+  SourceLoc ResolveLoc;
 
   SmallVector<CursorInfoDeclReference, 1> Results;
 
+  Expr *getExprToResolve() {
+    NodeFinder Finder(SrcFile, ResolveLoc);
+    Finder.resolve();
+    auto Result = Finder.takeResult();
+    if (!Result || Result->getKind() != NodeFinderResultKind::Expr) {
+      return nullptr;
+    }
+    return cast<NodeFinderExprResult>(Result.get())->getExpr();
+  }
+
   void sawSolutionImpl(const Solution &S) override {
     auto &CS = S.getConstraintSystem();
+    auto ResolveExpr = getExprToResolve();
+    if (!ResolveExpr) {
+      return;
+    }
 
     auto Locator = CS.getConstraintLocator(ResolveExpr);
     auto CalleeLocator = S.getCalleeLocator(Locator);
@@ -303,8 +324,8 @@ class CursorInfoTypeCheckSolutionCallback : public TypeCheckCompletionCallback {
   }
 
 public:
-  CursorInfoTypeCheckSolutionCallback(Expr *ResolveExpr)
-      : ResolveExpr(ResolveExpr) {}
+  CursorInfoTypeCheckSolutionCallback(SourceFile &SrcFile, SourceLoc ResolveLoc)
+      : SrcFile(SrcFile), ResolveLoc(ResolveLoc) {}
 
   ArrayRef<CursorInfoDeclReference> getResults() const { return Results; }
 };
@@ -325,7 +346,7 @@ class CursorInfoDoneParsingCallback : public IDEInspectionCallbacks {
   getDeclResult(NodeFinderDeclResult *DeclResult, SourceFile *SrcFile,
                 NodeFinder &Finder) const {
     typeCheckDeclAndParentClosures(DeclResult->getDecl());
-    return new ResolvedValueRefCursorInfo(
+    auto CursorInfo = new ResolvedValueRefCursorInfo(
         SrcFile, RequestedLoc, DeclResult->getDecl(),
         /*CtorTyRef=*/nullptr,
         /*ExtTyRef=*/nullptr, /*IsRef=*/false, /*Ty=*/Type(),
@@ -345,7 +366,7 @@ class CursorInfoDoneParsingCallback : public IDEInspectionCallbacks {
     DeclContext *DC = ExprResult->getDeclContext();
 
     // Type check the statemnt containing E and listen for solutions.
-    CursorInfoTypeCheckSolutionCallback Callback(E);
+    CursorInfoTypeCheckSolutionCallback Callback(*SrcFile, RequestedLoc);
     llvm::SaveAndRestore<TypeCheckCompletionCallback *> CompletionCollector(
         DC->getASTContext().SolutionCallback, &Callback);
     typeCheckASTNodeAtLoc(TypeCheckASTNodeAtLocContext::declContext(DC),

lib/Sema/TypeCheckConstraints.cpp

@@ -416,7 +416,11 @@ TypeChecker::typeCheckTarget(SolutionApplicationTarget &target,
   // Construct a constraint system from this expression.
   ConstraintSystemOptions csOptions = ConstraintSystemFlags::AllowFixes;
 
-  if (DiagnosticSuppression::isEnabled(Context.Diags))
+  /// If we have a SolutionCallback, we are inspecting constraint system
+  /// solutions directly and thus also want to receive ambiguous solutions.
+  /// Hence, don't set SuppressDiagnsostics to salvage the constraint system.
+  if (DiagnosticSuppression::isEnabled(Context.Diags) &&
+      !Context.SolutionCallback)
     csOptions |= ConstraintSystemFlags::SuppressDiagnostics;
 
   if (options.contains(TypeCheckExprFlags::LeaveClosureBodyUnchecked))

test/SourceKit/CursorInfo/cursor_ambiguous.swift

@@ -0,0 +1,17 @@
+func testAmbiguousFunctionReference() {
+  func foo(a: Int) {}
+  func foo(a: String) {}
+
+  // RUN: %sourcekitd-test -req=cursor -pos=%(line + 1):7 %s -- %s | %FileCheck %s
+  _ = foo
+
+  // RUN: %sourcekitd-test -req=cursor -pos=%(line + 1):7 %s -- %s | %FileCheck %s
+  _ = foo(a: UInt(1))
+}
+
+// CHECK: source.lang.swift.ref.function.free (2:8-2:19)
+// CHECK: <Declaration>func foo(a: <Type usr="s:Si">Int</Type>)</Declaration>
+// CHECK: SECONDARY SYMBOLS BEGIN
+// CHECK: source.lang.swift.ref.function.free (3:8-3:22)
+// CHECK: <Declaration>func foo(a: <Type usr="s:SS">String</Type>)</Declaration>
+// CHECK: SECONDARY SYMBOLS END

test/SourceKit/Refactoring/basic.swift

@@ -170,7 +170,7 @@ func hasCallToAsyncAlternative(c: ConvertAsync) {
 // RUN: %sourcekitd-test -req=cursor -pos=117:16  -cursor-action %s -- %s | %FileCheck %s -check-prefix=CHECK-GLOBAL
 // RUN: %sourcekitd-test -req=cursor -pos=117:17  -cursor-action %s -- %s | %FileCheck %s -check-prefix=CHECK-GLOBAL
 
-// RUN: %sourcekitd-test -req=cursor -pos=35:10 -end-pos=35:16 -cursor-action %s -- %s | %FileCheck %s -check-prefix=CHECK-RENAME-EXTRACT
+// RUN: %sourcekitd-test -req=cursor -pos=35:10 -end-pos=35:16 -cursor-action %s -- %s | %FileCheck %s -check-prefix=CHECK-RENAME
 
 // RUN: %sourcekitd-test -req=cursor -pos=54:10 -end-pos=54:22 -cursor-action %s -- %s | %FileCheck %s -check-prefix=CHECK-LOCAL
 // RUN: %sourcekitd-test -req=cursor -pos=54:12 -end-pos=54:22 -cursor-action %s -- %s | %FileCheck %s -check-prefix=CHECK-SELF-RENAME1
@@ -231,6 +231,8 @@ func hasCallToAsyncAlternative(c: ConvertAsync) {
 // CHECK-LOCAL-NOT: Global Rename
 // CHECK-LOCAL: ACTIONS END
 
+// CHECK-RENAME: Global Rename
+
 // CHECK-RENAME-EXTRACT: Global Rename
 // CHECK-RENAME-EXTRACT: Extract Method
 

tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp

@@ -2015,7 +2015,8 @@ void SwiftLangSupport::getCursorInfo(
   std::unique_ptr<llvm::MemoryBuffer> UnresolvedInputFile =
       getASTManager()->getMemoryBuffer(RealInputFilePath, fileSystem,
                                        InputFileError);
-  if (UnresolvedInputFile) {
+  // The solver-based implementation doesn't support range based cursor info.
+  if (UnresolvedInputFile && Length == 0) {
     auto SolverBasedReceiver = [&](const RequestResult<CursorInfoData> &Res) {
       SolverBasedProducedResult = true;
       Receiver(Res);