swift-mirror/lib/IDE/CodeCompletionConsumer.cpp

//===--- CodeCompletionConsumer.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/CodeCompletionConsumer.h"
#include "swift/IDE/CodeCompletionCache.h"

using namespace swift;
using namespace swift::ide;

static MutableArrayRef<CodeCompletionResult *> copyCodeCompletionResults(
    CodeCompletionResultSink &targetSink, CodeCompletionCache::Value &source,
    CodeCompletionFilter filter, const ExpectedTypeContext *TypeContext,
    const DeclContext *DC, bool CanCurrDeclContextHandleAsync) {
  assert(filter && "Should never have an empty filter");

  // We will be adding foreign results (from another sink) into TargetSink.
  // TargetSink should have an owning pointer to the allocator that keeps the
  // results alive.
  targetSink.ForeignAllocators.push_back(source.Allocator);
  auto startSize = targetSink.Results.size();

  CodeCompletionMacroRoles expectedMacroRoles = getCompletionMacroRoles(filter);
  std::function<bool(const ContextFreeCodeCompletionResult *)>
      shouldIncludeResult =
          [filter, expectedMacroRoles](
              const ContextFreeCodeCompletionResult *R) -> bool {
    if (R->getKind() != CodeCompletionResultKind::Declaration)
      return false;

    switch (R->getAssociatedDeclKind()) {
    case CodeCompletionDeclKind::EnumElement:
    case CodeCompletionDeclKind::Constructor:
    case CodeCompletionDeclKind::Destructor:
    case CodeCompletionDeclKind::Subscript:
    case CodeCompletionDeclKind::StaticMethod:
    case CodeCompletionDeclKind::InstanceMethod:
    case CodeCompletionDeclKind::PrefixOperatorFunction:
    case CodeCompletionDeclKind::PostfixOperatorFunction:
    case CodeCompletionDeclKind::InfixOperatorFunction:
    case CodeCompletionDeclKind::FreeFunction:
    case CodeCompletionDeclKind::StaticVar:
    case CodeCompletionDeclKind::InstanceVar:
    case CodeCompletionDeclKind::LocalVar:
    case CodeCompletionDeclKind::GlobalVar:
      return filter.contains(CodeCompletionFilterFlag::Expr);

    case CodeCompletionDeclKind::Module:
    case CodeCompletionDeclKind::Class:
    case CodeCompletionDeclKind::Actor:
    case CodeCompletionDeclKind::Struct:
    case CodeCompletionDeclKind::Enum:
    case CodeCompletionDeclKind::Protocol:
    case CodeCompletionDeclKind::TypeAlias:
    case CodeCompletionDeclKind::AssociatedType:
    case CodeCompletionDeclKind::GenericTypeParam:
      return filter.contains(CodeCompletionFilterFlag::Type);

    case CodeCompletionDeclKind::PrecedenceGroup:
      return filter.contains(CodeCompletionFilterFlag::PrecedenceGroup);

    case CodeCompletionDeclKind::Macro:
      return (bool)(R->getMacroRoles() & expectedMacroRoles);
    }

    llvm_unreachable("Unhandled associated decl kind");
  };

  USRBasedTypeContext USRTypeContext(TypeContext, source.USRTypeArena);

  for (auto contextFreeResult : source.Results) {
    if (!shouldIncludeResult(contextFreeResult)) {
      continue;
    }
    auto contextualResult = new (*targetSink.Allocator) CodeCompletionResult(
        *contextFreeResult, SemanticContextKind::OtherModule,
        CodeCompletionFlair(),
        /*numBytesToErase=*/0, TypeContext, DC, &USRTypeContext,
        CanCurrDeclContextHandleAsync, ContextualNotRecommendedReason::None);
    targetSink.Results.push_back(contextualResult);
  }

  return llvm::makeMutableArrayRef(targetSink.Results.data() + startSize,
                                   targetSink.Results.size() - startSize);
}

void SimpleCachingCodeCompletionConsumer::handleResultsAndModules(
    CodeCompletionContext &context,
    ArrayRef<RequestedCachedModule> requestedModules,
    const ExpectedTypeContext *TypeContext, const DeclContext *DC,
    bool CanCurrDeclContextHandleAsync) {

  // Use the current SourceFile as the DeclContext so that we can use it to
  // perform qualified lookup, and to get the correct visibility for
  // @testable imports. Also it cannot use 'DC' since it would apply decl
  // context changes to cached results.
  const SourceFile *SF = DC->getParentSourceFile();

  for (auto &R : requestedModules) {
    // FIXME(thread-safety): lock the whole AST context.  We might load a
    // module.
    llvm::Optional<CodeCompletionCache::ValueRefCntPtr> V =
        context.Cache.get(R.Key);
    if (!V.has_value()) {
      // No cached results found. Fill the cache.
      V = context.Cache.createValue();
      // Temporary sink in which we gather the result. The cache value retains
      // the sink's allocator.
      CodeCompletionResultSink Sink;
      Sink.annotateResult = context.getAnnotateResult();
      Sink.addInitsToTopLevel = context.getAddInitsToTopLevel();
      Sink.enableCallPatternHeuristics = context.getCallPatternHeuristics();
      Sink.includeObjectLiterals = context.includeObjectLiterals();
      Sink.addCallWithNoDefaultArgs = context.addCallWithNoDefaultArgs();
      Sink.setProduceContextFreeResults((*V)->USRTypeArena);
      lookupCodeCompletionResultsFromModule(Sink, R.TheModule, R.Key.AccessPath,
                                            R.Key.ResultsHaveLeadingDot, SF);
      (*V)->Allocator = Sink.Allocator;
      auto &CachedResults = (*V)->Results;
      CachedResults.reserve(Sink.Results.size());
      // Instead of copying the context free results out of the sink's allocator
      // retain the sink's entire allocator (which also includes the contextual
      // properities) and simply store pointers to the context free results that
      // back the contextual results.
      for (auto Result : Sink.Results) {
        assert(
            Result->getContextFreeResult().getResultType().isBackedByUSRs() &&
            "Results stored in the cache should have their result types backed "
            "by a USR because the cache might outlive the ASTContext the "
            "results were created from.");
        CachedResults.push_back(&Result->getContextFreeResult());
      }
      context.Cache.set(R.Key, *V);
    }
    assert(V.has_value());
    auto newItems = copyCodeCompletionResults(context.getResultSink(), **V,
                                              R.Filter, TypeContext, DC,
                                              CanCurrDeclContextHandleAsync);
    postProcessCompletionResults(newItems, context.CodeCompletionKind, DC,
                                 &context.getResultSink());
  }

  handleResults(context);
}