mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
65ef8020de
Now that arguments are marked up with whether they have a default or not, clients may not need the extra call (that has no default arguments). Add an option to allow not adding this item. Resolves rdar://85526214.
136 lines
4.4 KiB
C++
136 lines
4.4 KiB
C++
//===--- CodeCompletionCache.h - Routines for code completion caching -----===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 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_CODE_COMPLETIONCACHE_H
|
|
#define SWIFT_IDE_CODE_COMPLETIONCACHE_H
|
|
|
|
#include "swift/Basic/ThreadSafeRefCounted.h"
|
|
#include "swift/IDE/CodeCompletion.h"
|
|
#include "llvm/ADT/Hashing.h"
|
|
#include "llvm/ADT/IntrusiveRefCntPtr.h"
|
|
#include "llvm/Support/Chrono.h"
|
|
#include <system_error>
|
|
|
|
namespace swift {
|
|
namespace ide {
|
|
|
|
struct CodeCompletionCacheImpl;
|
|
class OnDiskCodeCompletionCache;
|
|
|
|
/// In-memory per-module code completion result cache.
|
|
///
|
|
/// These results persist between multiple code completion requests and can be
|
|
/// used with different ASTContexts.
|
|
class CodeCompletionCache {
|
|
std::unique_ptr<CodeCompletionCacheImpl> Impl;
|
|
OnDiskCodeCompletionCache *nextCache;
|
|
|
|
public:
|
|
/// Cache key.
|
|
struct Key {
|
|
std::string ModuleFilename;
|
|
std::string ModuleName;
|
|
std::vector<std::string> AccessPath;
|
|
bool ResultsHaveLeadingDot;
|
|
bool ForTestableLookup;
|
|
bool ForPrivateImportLookup;
|
|
bool AddInitsInToplevel;
|
|
bool AddCallWithNoDefaultArgs;
|
|
bool Annotated;
|
|
|
|
friend bool operator==(const Key &LHS, const Key &RHS) {
|
|
return LHS.ModuleFilename == RHS.ModuleFilename &&
|
|
LHS.ModuleName == RHS.ModuleName &&
|
|
LHS.AccessPath == RHS.AccessPath &&
|
|
LHS.ResultsHaveLeadingDot == RHS.ResultsHaveLeadingDot &&
|
|
LHS.ForTestableLookup == RHS.ForTestableLookup &&
|
|
LHS.ForPrivateImportLookup == RHS.ForPrivateImportLookup &&
|
|
LHS.AddInitsInToplevel == RHS.AddInitsInToplevel &&
|
|
LHS.AddCallWithNoDefaultArgs == RHS.AddCallWithNoDefaultArgs &&
|
|
LHS.Annotated == RHS.Annotated;
|
|
}
|
|
};
|
|
|
|
struct Value : public llvm::ThreadSafeRefCountedBase<Value> {
|
|
llvm::sys::TimePoint<> ModuleModificationTime;
|
|
CodeCompletionResultSink Sink;
|
|
};
|
|
using ValueRefCntPtr = llvm::IntrusiveRefCntPtr<Value>;
|
|
|
|
CodeCompletionCache(OnDiskCodeCompletionCache *nextCache = nullptr);
|
|
~CodeCompletionCache();
|
|
|
|
static ValueRefCntPtr createValue();
|
|
Optional<ValueRefCntPtr> get(const Key &K);
|
|
void set(const Key &K, ValueRefCntPtr V) { setImpl(K, V, /*setChain*/ true); }
|
|
|
|
private:
|
|
void setImpl(const Key &K, ValueRefCntPtr V, bool setChain);
|
|
};
|
|
|
|
/// On-disk per-module code completion result cache.
|
|
///
|
|
/// These results persist between multiple code completion requests and can be
|
|
/// used with different ASTContexts.
|
|
class OnDiskCodeCompletionCache {
|
|
std::string cacheDirectory;
|
|
|
|
public:
|
|
using Key = CodeCompletionCache::Key;
|
|
using Value = CodeCompletionCache::Value;
|
|
using ValueRefCntPtr = CodeCompletionCache::ValueRefCntPtr;
|
|
|
|
OnDiskCodeCompletionCache(Twine cacheDirectory);
|
|
~OnDiskCodeCompletionCache();
|
|
|
|
Optional<ValueRefCntPtr> get(const Key &K);
|
|
std::error_code set(const Key &K, ValueRefCntPtr V);
|
|
|
|
static Optional<ValueRefCntPtr> getFromFile(StringRef filename);
|
|
};
|
|
|
|
struct RequestedCachedModule {
|
|
CodeCompletionCache::Key Key;
|
|
const ModuleDecl *TheModule;
|
|
bool OnlyTypes;
|
|
bool OnlyPrecedenceGroups;
|
|
};
|
|
|
|
} // end namespace ide
|
|
} // end namespace swift
|
|
|
|
namespace llvm {
|
|
template<>
|
|
struct DenseMapInfo<swift::ide::CodeCompletionCache::Key> {
|
|
using KeyTy = swift::ide::CodeCompletionCache::Key;
|
|
static inline KeyTy getEmptyKey() {
|
|
return KeyTy{"", "", {}, false, false, false, false, false, false};
|
|
}
|
|
static inline KeyTy getTombstoneKey() {
|
|
return KeyTy{"", "", {}, true, false, false, false, false, false};
|
|
}
|
|
static unsigned getHashValue(const KeyTy &Val) {
|
|
return llvm::hash_combine(
|
|
Val.ModuleFilename, Val.ModuleName,
|
|
llvm::hash_combine_range(Val.AccessPath.begin(), Val.AccessPath.end()),
|
|
Val.ResultsHaveLeadingDot, Val.ForTestableLookup,
|
|
Val.ForPrivateImportLookup, Val.AddInitsInToplevel,
|
|
Val.AddCallWithNoDefaultArgs, Val.Annotated);
|
|
}
|
|
static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
};
|
|
} // end namespace llvm
|
|
|
|
#endif // SWIFT_IDE_CODE_COMPLETIONCACHE_H
|