[IDE] Implement completion-like cursor info for ValueDecls

This brings up the ability to compute cursor info results using the completion-like type checking paradigm, which an reuse ASTContexts and doesn’t need to type check the entire file.

For now, the new implementation only supports cursor info on `ValueDecl`s (not on references) because they were easiest to implement. More cursor info kinds are coming soon.

At the moment, we only run the new implementation in a verification mode: It is only invoked in assert toolchains and when run, we check that the results are equivalent to the old implementation. Once more cursor info kinds are implemented and if the SourceKit stress tester doesn’t find any verification issues, we can enable the new implementation, falling back to the old implementation if the new one didn’t produce any results.

Author: ahoppen

include/swift/IDE/CursorInfo.h

@@ -0,0 +1,40 @@
+//===--- CursorInfo.h --- ---------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2019 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_IDE_CURSORINFO_H
+#define SWIFT_IDE_CURSORINFO_H
+
+#include "swift/AST/Type.h"
+#include "swift/Basic/LLVM.h"
+#include "swift/IDE/Utils.h"
+
+namespace swift {
+class CodeCompletionCallbacksFactory;
+
+namespace ide {
+
+/// An abstract base class for consumers of context info results.
+class CursorInfoConsumer {
+public:
+  virtual ~CursorInfoConsumer() {}
+  virtual void handleResults(const ResolvedCursorInfo &) = 0;
+};
+
+/// Create a factory for code completion callbacks.
+CodeCompletionCallbacksFactory *
+makeCursorInfoCallbacksFactory(CursorInfoConsumer &Consumer,
+                               SourceLoc RequestedLoc);
+
+} // namespace ide
+} // namespace swift
+
+#endif // SWIFT_IDE_CURSORINFO_H

include/swift/IDETool/CompletionInstance.h

@@ -19,6 +19,7 @@
 #include "swift/IDE/CodeCompletionResult.h"
 #include "swift/IDE/CodeCompletionResultSink.h"
 #include "swift/IDE/ConformingMethodList.h"
+#include "swift/IDE/CursorInfo.h"
 #include "swift/IDE/ImportDepth.h"
 #include "swift/IDE/SwiftCompletionInfo.h"
 #include "swift/IDE/TypeContextInfo.h"
@@ -78,6 +79,14 @@ struct ConformingMethodListResults {
   bool DidReuseAST;
 };
 
+/// The results returned from \c CompletionInstance::conformingMethodList.
+struct CursorInfoResults {
+  /// The actual results. If \c nullptr, no results were found.
+  const ResolvedCursorInfo *Result;
+  /// Whether an AST was reused for the completion.
+  bool DidReuseAST;
+};
+
 /// Manages \c CompilerInstance for completion like operations.
 class CompletionInstance {
   struct Options {
@@ -192,6 +201,14 @@ class CompletionInstance {
       std::shared_ptr<std::atomic<bool>> CancellationFlag,
       llvm::function_ref<void(CancellableResult<ConformingMethodListResults>)>
           Callback);
+
+  void cursorInfo(
+      swift::CompilerInvocation &Invocation, llvm::ArrayRef<const char *> Args,
+      llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem,
+      llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
+      DiagnosticConsumer *DiagC,
+      std::shared_ptr<std::atomic<bool>> CancellationFlag,
+      llvm::function_ref<void(CancellableResult<CursorInfoResults>)> Callback);
 };
 
 } // namespace ide

lib/IDE/CMakeLists.txt

@@ -18,6 +18,7 @@ add_swift_host_library(swiftIDE STATIC
   CompletionLookup.cpp
   CompletionOverrideLookup.cpp
   ConformingMethodList.cpp
+  CursorInfo.cpp
   ExprCompletion.cpp
   ExprContextAnalysis.cpp
   Formatting.cpp

lib/IDE/CursorInfo.cpp

@@ -0,0 +1,278 @@
+//===--- CursorInfo.cpp ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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/IDE/CursorInfo.h"
+#include "ExprContextAnalysis.h"
+#include "swift/AST/ASTDemangler.h"
+#include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/NameLookup.h"
+#include "swift/AST/USRGeneration.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
+#include "swift/Parse/CodeCompletionCallbacks.h"
+#include "swift/Sema/ConstraintSystem.h"
+#include "swift/Sema/IDETypeChecking.h"
+#include "clang/AST/Attr.h"
+#include "clang/AST/Decl.h"
+#include "clang/Basic/Module.h"
+
+using namespace swift;
+using namespace swift::constraints;
+using namespace ide;
+
+namespace {
+
+// MARK: - Utilities
+
+void typeCheckDeclAndParentClosures(ValueDecl *VD) {
+  // We need to type check any parent closures because their types are
+  // encoded in the USR of ParentContexts in the cursor info response.
+  auto DC = VD->getDeclContext();
+  while (DC->getParent()) {
+    if (auto Closure = dyn_cast<AbstractClosureExpr>(DC)) {
+      if (Closure->getType().isNull()) {
+        typeCheckASTNodeAtLoc(
+            TypeCheckASTNodeAtLocContext::declContext(DC->getParent()),
+            Closure->getLoc());
+      }
+    }
+    DC = DC->getParent();
+  }
+
+  typeCheckASTNodeAtLoc(
+      TypeCheckASTNodeAtLocContext::declContext(VD->getDeclContext()),
+      VD->getLoc());
+}
+
+// MARK: - NodeFinderResults
+
+enum class NodeFinderResultKind { Decl };
+
+class NodeFinderResult {
+  NodeFinderResultKind Kind;
+
+protected:
+  NodeFinderResult(NodeFinderResultKind Kind) : Kind(Kind) {}
+
+public:
+  NodeFinderResultKind getKind() const { return Kind; }
+};
+
+class NodeFinderDeclResult : public NodeFinderResult {
+  ValueDecl *ValueD;
+
+public:
+  NodeFinderDeclResult(ValueDecl *ValueD)
+      : NodeFinderResult(NodeFinderResultKind::Decl), ValueD(ValueD) {}
+
+  ValueDecl *getDecl() const { return ValueD; }
+
+  static bool classof(const NodeFinderResult *Res) {
+    return Res->getKind() == NodeFinderResultKind::Decl;
+  }
+};
+
+// MARK: - NodeFinder
+
+/// Walks the AST, looking for a node at \c LocToResolve. While walking the
+/// AST, also gathers information about shorthand shadows.
+class NodeFinder : ASTWalker {
+  SourceFile &SrcFile;
+  SourceLoc LocToResolve;
+
+  /// As we are walking the tree, this variable is updated to the last seen
+  /// DeclContext.
+  SmallVector<DeclContext *> DeclContextStack;
+
+  /// The found node.
+  std::unique_ptr<NodeFinderResult> Result;
+
+  /// If a decl shadows another decl using shorthand syntax (`[foo]` or
+  /// `if let foo {`), this maps the re-declared variable to the one that is
+  /// being shadowed.
+  /// The transitive closure of shorthand shadowed decls should be reported as
+  /// additional results in cursor info.
+  llvm::DenseMap<ValueDecl *, ValueDecl *> ShorthandShadowedDecls;
+
+public:
+  NodeFinder(SourceFile &SrcFile, SourceLoc LocToResolve)
+      : SrcFile(SrcFile), LocToResolve(LocToResolve),
+        DeclContextStack({&SrcFile}) {}
+
+  void resolve() { SrcFile.walk(*this); }
+
+  std::unique_ptr<NodeFinderResult> takeResult() { return std::move(Result); }
+
+  /// Get the declarations that \p ShadowingDecl shadows using shorthand shadow
+  /// syntax.
+  SmallVector<ValueDecl *, 2>
+  getShorthandShadowedDecls(ValueDecl *ShadowingDecl) {
+    SmallVector<ValueDecl *, 2> Result;
+    auto ShorthandShadowedDecl = ShorthandShadowedDecls[ShadowingDecl];
+    while (ShorthandShadowedDecl) {
+      Result.push_back(ShorthandShadowedDecl);
+      ShorthandShadowedDecl = ShorthandShadowedDecls[ShorthandShadowedDecl];
+    }
+    return Result;
+  }
+
+private:
+  SourceManager &getSourceMgr() const {
+    return SrcFile.getASTContext().SourceMgr;
+  }
+
+  /// The decl context that is currently being walked.
+  DeclContext *getCurrentDeclContext() { return DeclContextStack.back(); }
+
+  bool rangeContainsLocToResolve(SourceRange Range) const {
+    return Range.contains(LocToResolve);
+  }
+
+  PreWalkAction walkToDeclPre(Decl *D) override {
+    if (!rangeContainsLocToResolve(D->getSourceRangeIncludingAttrs())) {
+      return PreWalkAction::SkipChildren;
+    }
+
+    if (auto *newDC = dyn_cast<DeclContext>(D)) {
+      DeclContextStack.push_back(newDC);
+    }
+
+    if (D->getLoc() != LocToResolve) {
+      return Action::Continue();
+    }
+
+    if (auto VD = dyn_cast<ValueDecl>(D)) {
+      if (VD->hasName()) {
+        assert(Result == nullptr);
+        Result = std::make_unique<NodeFinderDeclResult>(VD);
+        return Action::Stop();
+      }
+    }
+
+    return Action::Continue();
+  }
+
+  PostWalkAction walkToDeclPost(Decl *D) override {
+    if (auto *newDC = dyn_cast<DeclContext>(D)) {
+      assert(DeclContextStack.back() == newDC);
+      DeclContextStack.pop_back();
+    }
+    return Action::Continue();
+  }
+
+  PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
+    if (auto closure = dyn_cast<ClosureExpr>(E)) {
+      DeclContextStack.push_back(closure);
+    }
+
+    if (auto CaptureList = dyn_cast<CaptureListExpr>(E)) {
+      for (auto ShorthandShadows :
+           getShorthandShadows(CaptureList, getCurrentDeclContext())) {
+        assert(ShorthandShadowedDecls.count(ShorthandShadows.first) == 0);
+        ShorthandShadowedDecls[ShorthandShadows.first] =
+            ShorthandShadows.second;
+      }
+    }
+
+    return Action::Continue(E);
+  }
+
+  PostWalkResult<Expr *> walkToExprPost(Expr *E) override {
+    if (auto *closure = dyn_cast<ClosureExpr>(E)) {
+      assert(DeclContextStack.back() == closure);
+      DeclContextStack.pop_back();
+    }
+    return Action::Continue(E);
+  }
+
+  PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
+    if (auto CondStmt = dyn_cast<LabeledConditionalStmt>(S)) {
+      for (auto ShorthandShadow :
+           getShorthandShadows(CondStmt, getCurrentDeclContext())) {
+        assert(ShorthandShadowedDecls.count(ShorthandShadow.first) == 0);
+        ShorthandShadowedDecls[ShorthandShadow.first] = ShorthandShadow.second;
+      }
+    }
+    return Action::Continue(S);
+  }
+};
+
+// MARK: - CursorInfoDoneParsingCallback
+
+class CursorInfoDoneParsingCallback : public CodeCompletionCallbacks {
+  CursorInfoConsumer &Consumer;
+  SourceLoc RequestedLoc;
+
+public:
+  CursorInfoDoneParsingCallback(Parser &P, CursorInfoConsumer &Consumer,
+                                SourceLoc RequestedLoc)
+      : CodeCompletionCallbacks(P), Consumer(Consumer),
+        RequestedLoc(RequestedLoc) {}
+
+  std::unique_ptr<ResolvedCursorInfo>
+  getDeclResult(NodeFinderDeclResult *DeclResult, SourceFile *SrcFile,
+                NodeFinder &Finder) const {
+    typeCheckDeclAndParentClosures(DeclResult->getDecl());
+    auto CursorInfo = std::make_unique<ResolvedValueRefCursorInfo>(
+        ResolvedCursorInfo(SrcFile), DeclResult->getDecl(),
+        /*CtorTyRef=*/nullptr,
+        /*ExtTyRef=*/nullptr, /*IsRef=*/false, /*Ty=*/Type(),
+        /*ContainerType=*/Type());
+    CursorInfo->setLoc(RequestedLoc);
+    CursorInfo->setShorthandShadowedDecls(
+        Finder.getShorthandShadowedDecls(DeclResult->getDecl()));
+    return CursorInfo;
+  }
+
+  void doneParsing(SourceFile *SrcFile) override {
+    if (!SrcFile) {
+      return;
+    }
+    NodeFinder Finder(*SrcFile, RequestedLoc);
+    Finder.resolve();
+    auto Result = Finder.takeResult();
+    if (!Result) {
+      return;
+    }
+    std::unique_ptr<ResolvedCursorInfo> CursorInfo;
+    switch (Result->getKind()) {
+    case NodeFinderResultKind::Decl:
+      CursorInfo = getDeclResult(cast<NodeFinderDeclResult>(Result.get()),
+                                 SrcFile, Finder);
+      break;
+    }
+    if (Result) {
+      Consumer.handleResults(*CursorInfo);
+    }
+  }
+};
+
+} // anonymous namespace.
+
+CodeCompletionCallbacksFactory *
+swift::ide::makeCursorInfoCallbacksFactory(CursorInfoConsumer &Consumer,
+                                           SourceLoc RequestedLoc) {
+  class CursorInfoCallbacksFactoryImpl : public CodeCompletionCallbacksFactory {
+    CursorInfoConsumer &Consumer;
+    SourceLoc RequestedLoc;
+
+  public:
+    CursorInfoCallbacksFactoryImpl(CursorInfoConsumer &Consumer,
+                                   SourceLoc RequestedLoc)
+        : Consumer(Consumer), RequestedLoc(RequestedLoc) {}
+
+    CodeCompletionCallbacks *createCodeCompletionCallbacks(Parser &P) override {
+      return new CursorInfoDoneParsingCallback(P, Consumer, RequestedLoc);
+    }
+  };
+
+  return new CursorInfoCallbacksFactoryImpl(Consumer, RequestedLoc);
+}