SwiftEditor.cpp

//===--- SwiftEditor.cpp --------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include"SwiftASTManager.h"
#include"SwiftEditorDiagConsumer.h"
#include"SwiftLangSupport.h"
#include"SourceKit/Core/Context.h"
#include"SourceKit/Core/NotificationCenter.h"
#include"SourceKit/Support/FileSystemProvider.h"
#include"SourceKit/Support/ImmutableTextBuffer.h"
#include"SourceKit/Support/Logging.h"
#include"SourceKit/Support/Tracing.h"
#include"SourceKit/Support/UIdent.h"

#include"swift/AST/ASTPrinter.h"
#include"swift/AST/ASTVisitor.h"
#include"swift/AST/ASTWalker.h"
#include"swift/AST/DiagnosticsClangImporter.h"
#include"swift/AST/DiagnosticsParse.h"
#include"swift/AST/DiagnosticsFrontend.h"
#include"swift/AST/DiagnosticsSIL.h"
#include"swift/Basic/Compiler.h"
#include"swift/Basic/SourceManager.h"
#include"swift/Demangling/ManglingUtils.h"
#include"swift/Frontend/Frontend.h"
#include"swift/Frontend/PrintingDiagnosticConsumer.h"
#include"swift/IDE/CommentConversion.h"
#include"swift/IDE/Indenting.h"
#include"swift/IDE/SourceEntityWalker.h"
#include"swift/IDE/SyntaxModel.h"
#include"swift/Subsystems.h"

#include"llvm/Support/ErrorHandling.h"
#include"llvm/Support/FileSystem.h"
#include"llvm/Support/MemoryBuffer.h"
#include"llvm/Support/Mutex.h"

usingnamespaceSourceKit;
usingnamespaceswift;
usingnamespaceide;

static std::vector<unsigned> getSortedBufferIDs(
const llvm::DenseMap<unsigned, std::vector<DiagnosticEntryInfo>> &Map) {
 std::vector<unsigned> bufferIDs;
 bufferIDs.reserve(Map.size());
for (auto I = Map.begin(), E = Map.end(); I != E; ++I) {
 bufferIDs.push_back(I->getFirst());
 }
llvm::array_pod_sort(bufferIDs.begin(), bufferIDs.end());
return bufferIDs;
}

voidEditorDiagConsumer::getAllDiagnostics(
 SmallVectorImpl<DiagnosticEntryInfo> &Result) {

 Result.append(InvalidLocDiagnostics.begin(), InvalidLocDiagnostics.end());

// Note: We cannot use the input buffer IDs because there may be diagnostics
// outside the inputs. Instead, sort the extant buffers.
auto bufferIDs = getSortedBufferIDs(BufferDiagnostics);
for (unsigned bufferID : bufferIDs) {
constauto &diags = BufferDiagnostics[bufferID];
 Result.append(diags.begin(), diags.end());
 }
}

/// Retrieve the raw range from a range, if it exists in the provided buffer.
/// Otherwise returns \c None.
static std::optional<RawCharSourceRange>
getRawRangeInBuffer(CharSourceRange range, unsigned bufferID,
 SourceManager &SM) {
if (!range.isValid() ||
 SM.findBufferContainingLoc(range.getStart()) != bufferID) {
return std::nullopt;
 }
unsigned offset = SM.getLocOffsetInBuffer(range.getStart(), bufferID);
unsigned length = range.getByteLength();
return {{offset, length}};
}

BufferInfoSharedPtr
EditorDiagConsumer::getBufferInfo(StringRef FileName,
 std::optional<unsigned> BufferID,
 swift::SourceManager &SM) {
auto Result = BufferInfos.find(FileName);
if (Result != BufferInfos.end())
return Result->second;

 std::optional<std::string> GeneratedFileText;
 std::optional<BufferInfo::OriginalLocation> OriginalLocInfo;

// If we have a generated buffer, we need to include the source text, as
// clients otherwise won't be able to access to it.
if (BufferID) {
if (auto Info = SM.getGeneratedSourceInfo(*BufferID)) {
// Don't include this information for replaced function body buffers, as
// they'll just be referencing the original file.
// FIXME: Does this mean that the location information we'll be giving
// will be wrong? Seems like we may need to adjust it to correspond to the
// original file.
if (Info->kind != GeneratedSourceInfo::ReplacedFunctionBody) {
 GeneratedFileText.emplace(SM.getEntireTextForBuffer(*BufferID));

auto OrigRange = Info->originalSourceRange;
if (OrigRange.isValid()) {
auto OrigLoc = OrigRange.getStart();
auto OrigBuffer = SM.findBufferContainingLoc(OrigLoc);

auto OrigRawRange = getRawRangeInBuffer(OrigRange, OrigBuffer, SM);
assert(OrigRawRange);

auto OrigFileName = SM.getDisplayNameForLoc(OrigLoc);
auto OrigInfo = getBufferInfo(OrigFileName, OrigBuffer, SM);
 OriginalLocInfo.emplace(OrigInfo, OrigBuffer, *OrigRawRange);
 }
 }
 }
 }
auto Info = std::make_shared<BufferInfo>(FileName.str(), GeneratedFileText,
 OriginalLocInfo);
 BufferInfos.insert({FileName, Info});
return Info;
}

voidEditorDiagConsumer::handleDiagnostic(SourceManager &SM,
const DiagnosticInfo &Info) {

if (Info.Kind == DiagnosticKind::Error) {
 HadAnyError = true;
 }

// Filter out benign diagnostics for editing.
// oslog_invalid_log_message is spuriously output for live issues as modules
// in the index build are built without function bodies (including inline
// functions). OSLogOptimization expects SIL for bodies and hence errors
// when there isn't any. Ignore in live issues for now and re-evaluate if
// this (not having SIL for inline functions) becomes a more widespread issue.
if (Info.ID == diag::lex_editor_placeholder.ID ||
 Info.ID == diag::oslog_invalid_log_message.ID)
return;

bool IsNote = (Info.Kind == DiagnosticKind::Note);

if (IsNote && !haveLastDiag())
// Is this possible?
return;

if (Info.Kind == DiagnosticKind::Remark) {
// FIXME: we may want to handle optimization remarks in sourcekitd.
LOG_WARN_FUNC("unhandled optimization remark");
return;
 }

 DiagnosticEntryInfo SKInfo;

 SKInfo.ID = DiagnosticEngine::diagnosticIDStringFor(Info.ID).str();

if (Info.Category == "deprecation" ||
 Info.Category.starts_with("Deprecated")) {
 SKInfo.Categories.push_back(DiagnosticCategory::Deprecation);
 } elseif (Info.Category == "no-usage") {
 SKInfo.Categories.push_back(DiagnosticCategory::NoUsage);
 }

// Actually substitute the diagnostic arguments into the diagnostic text.
 llvm::SmallString<256> Text;
 {
 llvm::raw_svector_ostream Out(Text);
DiagnosticEngine::formatDiagnosticText(Out, Info.FormatString,
 Info.FormatArgs);
 }
 SKInfo.Description = Text.str();

if (!Info.CategoryDocumentationURL.empty())
 SKInfo.EducationalNotePaths.push_back(Info.CategoryDocumentationURL);

 std::optional<unsigned> BufferIDOpt;
if (Info.Loc.isValid()) {
 BufferIDOpt = SM.findBufferContainingLoc(Info.Loc);
 }

if (BufferIDOpt.has_value()) {
unsigned BufferID = *BufferIDOpt;

if (auto info = SM.getGeneratedSourceInfo(BufferID)) {
if (IsNote && info->kind == GeneratedSourceInfo::PrettyPrinted) {
// FIXME: This is a note pointing to a synthesized declaration buffer
// for a declaration coming from a module. We should be able to remove
// this check once clients have been updated to deal with the buffer contents
// that we'll include in the response once this check is removed.
//
// For now instead of ignoring it, pick up the declaration name from the
// buffer identifier and append it to the diagnostic message.
auto &LastDiag = getLastDiag();
 SKInfo.Description += " (";
 SKInfo.Description += SM.getIdentifierForBuffer(*BufferIDOpt);
 SKInfo.Description += ")";
 SKInfo.Offset = LastDiag.Offset;
 SKInfo.Line = LastDiag.Line;
 SKInfo.Column = LastDiag.Column;
 SKInfo.FileInfo = LastDiag.FileInfo;
 LastDiag.Notes.push_back(std::move(SKInfo));
return;
 }
 }

 SKInfo.Offset = SM.getLocOffsetInBuffer(Info.Loc, BufferID);
std::tie(SKInfo.Line, SKInfo.Column) =
 SM.getPresumedLineAndColumnForLoc(Info.Loc, BufferID);

auto Filename = SM.getDisplayNameForLoc(Info.Loc);
 SKInfo.FileInfo = getBufferInfo(Filename, BufferID, SM);

for (auto R : Info.Ranges) {
if (auto Raw = getRawRangeInBuffer(R, BufferID, SM))
 SKInfo.Ranges.push_back(*Raw);
 }

for (auto F : Info.FixIts) {
if (auto Range = getRawRangeInBuffer(F.getRange(), BufferID, SM))
 SKInfo.Fixits.emplace_back(*Range, F.getText().str());
 }
 } else {
 SKInfo.FileInfo = getBufferInfo("<unknown>", /*BufferID*/ std::nullopt, SM);
 }

if (IsNote) {
getLastDiag().Notes.push_back(std::move(SKInfo));
return;
 }

switch (Info.Kind) {
case DiagnosticKind::Error:
 SKInfo.Severity = DiagnosticSeverityKind::Error;
break;
case DiagnosticKind::Warning:
 SKInfo.Severity = DiagnosticSeverityKind::Warning;
break;
case DiagnosticKind::Note:
case DiagnosticKind::Remark:
llvm_unreachable("already covered");
 }

if (!BufferIDOpt) {
 InvalidLocDiagnostics.push_back(std::move(SKInfo));
clearLastDiag();
return;
 }

// Look through to the original buffer, so we produce diagnostics that are
// present in generated buffers that originated there.
unsigned OrigBufferID = *BufferIDOpt;
 {
auto BufferInfo = SKInfo.FileInfo;
while (auto &OrigLocation = BufferInfo->OrigLocation) {
 OrigBufferID = OrigLocation->OrigBufferID;
 BufferInfo = OrigLocation->OrigBufferInfo;
 }
 }

 DiagnosticsTy &Diagnostics = BufferDiagnostics[OrigBufferID];

if (Diagnostics.empty() || Diagnostics.back().Offset <= SKInfo.Offset) {
 Diagnostics.push_back(std::move(SKInfo));
 LastDiagBufferID = OrigBufferID;
 LastDiagIndex = Diagnostics.size() - 1;
return;
 }

// Keep the diagnostics array in source order.
auto Pos = std::lower_bound(Diagnostics.begin(), Diagnostics.end(), SKInfo.Offset,
 [&](const DiagnosticEntryInfo &LHS, unsigned Offset) -> bool {
return LHS.Offset < Offset;
 });
 LastDiagBufferID = OrigBufferID;
 LastDiagIndex = Pos - Diagnostics.begin();
 Diagnostics.insert(Pos, std::move(SKInfo));
}

SwiftEditorDocumentRef
SwiftEditorDocumentFileMap::getByUnresolvedName(StringRef FilePath) {
 SwiftEditorDocumentRef EditorDoc;

 Queue.dispatchSync([&]{
auto It = Docs.find(FilePath);
if (It != Docs.end())
 EditorDoc = It->second.DocRef;
 });

return EditorDoc;
}

SwiftEditorDocumentRef
SwiftEditorDocumentFileMap::findByPath(StringRef FilePath, bool IsRealpath) {
 SwiftEditorDocumentRef EditorDoc;

 std::string Scratch;
if (!IsRealpath) {
 Scratch = SwiftLangSupport::resolvePathSymlinks(FilePath);
 FilePath = Scratch;
 }
 Queue.dispatchSync([&]{
for (auto &Entry : Docs) {
if (Entry.getKey() == FilePath ||
 Entry.getValue().ResolvedPath == FilePath) {
 EditorDoc = Entry.getValue().DocRef;
break;
 }
 }
 });

return EditorDoc;
}

boolSwiftEditorDocumentFileMap::getOrUpdate(
 StringRef FilePath, SwiftLangSupport &LangSupport,
 SwiftEditorDocumentRef &EditorDoc) {

bool found = false;

 std::string ResolvedPath = SwiftLangSupport::resolvePathSymlinks(FilePath);
 Queue.dispatchBarrierSync([&]{
 DocInfo &Doc = Docs[FilePath];
if (!Doc.DocRef) {
 Doc.DocRef = EditorDoc;
 Doc.ResolvedPath = ResolvedPath;
 } else {
 EditorDoc = Doc.DocRef;
 found = true;
 }
 });

return found;
}

SwiftEditorDocumentRef SwiftEditorDocumentFileMap::remove(StringRef FilePath) {
 SwiftEditorDocumentRef Removed;
 Queue.dispatchBarrierSync([&]{
auto I = Docs.find(FilePath);
if (I != Docs.end()) {
 Removed = I->second.DocRef;
 Docs.erase(I);
 }
 });
return Removed;
}

namespace {

/// Merges two overlapping ranges and splits the first range into two
/// ranges before and after the overlapping range.
voidmergeSplitRanges(unsigned Off1, unsigned Len1, unsigned Off2, unsigned Len2,
 std::function<void(unsigned BeforeOff, unsigned BeforeLen,
unsigned AfterOff,
unsigned AfterLen)> applier) {
unsigned End1 = Off1 + Len1;
unsigned End2 = Off2 + Len2;
if (End1 > Off2) {
// Overlapping. Split into before and after ranges.
unsigned BeforeOff = Off1;
unsigned BeforeLen = Off2 > Off1 ? Off2 - Off1 : 0;
unsigned AfterOff = End2;
unsigned AfterLen = End1 > End2 ? End1 - End2 : 0;
applier(BeforeOff, BeforeLen, AfterOff, AfterLen);
 }
else {
// Not overlapping.
applier(Off1, Len1, 0, 0);
 }
}

structSwiftSyntaxToken {
unsigned Offset;
unsigned Length:24;
 SyntaxNodeKind Kind:8;

static SwiftSyntaxToken createInvalid() {
return {0, 0, SyntaxNodeKind::AttributeBuiltin};
 }

SwiftSyntaxToken(unsigned Offset, unsigned Length, SyntaxNodeKind Kind)
 : Offset(Offset), Length(Length), Kind(Kind) {}

unsignedendOffset() const { return Offset + Length; }

boolisInvalid() const { return Length == 0; }

booloperator==(const SwiftSyntaxToken &Other) const {
return Offset == Other.Offset && Length == Other.Length &&
 Kind == Other.Kind;
 }

booloperator!=(const SwiftSyntaxToken &Other) const {
return Offset != Other.Offset || Length != Other.Length ||
 Kind != Other.Kind;
 }
};

structSwiftEditorCharRange {
unsigned Offset;
unsigned EndOffset;

SwiftEditorCharRange(unsigned Offset, unsigned EndOffset) :
Offset(Offset), EndOffset(EndOffset) {}

SwiftEditorCharRange(SwiftSyntaxToken Token) :
Offset(Token.Offset), EndOffset(Token.endOffset()) {}

size_tlength() const { return EndOffset - Offset; }
boolisEmpty() const { return Offset == EndOffset; }
boolintersects(const SwiftSyntaxToken &Token) const {
returnthis->Offset < (Token.endOffset()) && this->EndOffset > Token.Offset;
 }
voidextendToInclude(const SwiftEditorCharRange &Range) {
if (Range.Offset < Offset)
 Offset = Range.Offset;
if (Range.EndOffset > EndOffset)
 EndOffset = Range.EndOffset;
 }
voidextendToInclude(unsigned OtherOffset) {
extendToInclude({OtherOffset, OtherOffset});
 }
};

/// Finds and represents the first mismatching tokens in two syntax maps,
/// ignoring invalidated tokens.
template <classIter>
structTokenMismatch {
/// The begin and end iterators of the previous syntax map
 Iter PrevTok, PrevEnd;
/// The begin and end iterators of the current syntax map
 Iter CurrTok, CurrEnd;

TokenMismatch(Iter CurrTok, Iter CurrEnd, Iter PrevTok, Iter PrevEnd) :
PrevTok(PrevTok), PrevEnd(PrevEnd), CurrTok(CurrTok), CurrEnd(CurrEnd) {
skipInvalid();
while(advance());
 }

/// Returns true if a mismatch was found
boolfoundMismatch() const {
return CurrTok != CurrEnd || PrevTok != PrevEnd;
 }

/// Returns the smallest start offset of the mismatched token ranges
unsignedmismatchStart() const {
assert(foundMismatch());
if (CurrTok != CurrEnd) {
if (PrevTok != PrevEnd)
returnstd::min(CurrTok->Offset, PrevTok->Offset);
return CurrTok->Offset;
 }
return PrevTok->Offset;
 }

/// Returns the largest end offset of the mismatched token ranges
unsignedmismatchEnd() const {
assert(foundMismatch());
if (CurrTok != CurrEnd) {
if (PrevTok != PrevEnd)
returnstd::max(CurrTok->endOffset(), PrevTok->endOffset());
return CurrTok->endOffset();
 }
return PrevTok->endOffset();
 }

private:
voidskipInvalid() {
while (PrevTok != PrevEnd && PrevTok->isInvalid())
 ++PrevTok;
 }

booladvance() {
if (CurrTok == CurrEnd || PrevTok == PrevEnd || *CurrTok != *PrevTok)
returnfalse;
 ++CurrTok;
 ++PrevTok;
skipInvalid();
returntrue;
 }
};

/// Represents a the syntax highlighted token ranges in a source file
structSwiftSyntaxMap {
 std::vector<SwiftSyntaxToken> Tokens;

explicitSwiftSyntaxMap(unsigned Capacity = 0) {
if (Capacity)
 Tokens.reserve(Capacity);
 }

voidaddToken(const SwiftSyntaxToken &Token) {
assert(Tokens.empty() || Token.Offset >= Tokens.back().Offset);
 Tokens.push_back(Token);
 }

/// Merge this nested token into the last token that was added
voidmergeToken(const SwiftSyntaxToken &Token) {
if (Tokens.empty()) {
 Tokens.push_back(Token);
return;
 }
auto &LastTok = Tokens.back();
assert(LastTok.Offset <= Token.Offset);
mergeSplitRanges(LastTok.Offset, LastTok.Length, Token.Offset, Token.Length,
 [&](unsigned BeforeOff, unsigned BeforeLen,
unsigned AfterOff, unsigned AfterLen) {
auto LastKind = LastTok.Kind;
 Tokens.pop_back();
if (BeforeLen)
 Tokens.emplace_back(BeforeOff, BeforeLen, LastKind);
 Tokens.push_back(Token);
if (AfterLen)
 Tokens.emplace_back(AfterOff, AfterLen, LastKind);
 });
 }

/// Adjusts the token offsets and lengths in this syntax map to account for
/// replacing \p Len bytes at the given \p Offset with \p NewLen bytes. Tokens
/// before the replacement stay the same, tokens after it are shifted, and
/// tokens that intersect it are 'removed' (really just marked invalid).
/// Clients are expected to match this behavior.
///
/// Returns the union of the replaced range and the token ranges it
/// intersected, or nothing if no tokens were intersected.
 std::optional<SwiftEditorCharRange>
adjustForReplacement(unsigned Offset, unsigned Len, unsigned NewLen) {
unsigned ReplacedStart = Offset;
unsigned ReplacedEnd = Offset + Len;
bool TokenIntersected = false;
 SwiftEditorCharRange Affected = { /*Offset=*/ReplacedStart,
/*EndOffset=*/ReplacedEnd};
// Adjust the tokens
auto Token = Tokens.begin();
while (Token != Tokens.end() && Token->endOffset() <= ReplacedStart) {
// Completely before the replaced range – no change needed
 ++Token;
 }

while (Token != Tokens.end() && Token->Offset < ReplacedEnd) {
// Intersecting the replaced range – extend Affected and invalidate
 TokenIntersected = true;
 Affected.extendToInclude(*Token);
 *Token = SwiftSyntaxToken::createInvalid();
 ++Token;
 }

while (Token != Tokens.end()) {
// Completely after the replaced range - shift to account for NewLen
if (NewLen >= Len)
 Token->Offset += NewLen - Len;
else
 Token->Offset -= Len - NewLen;
 ++Token;
 }

// If the replaced range didn't intersect with any existing tokens, there's
// no need to report an affected range
if (!TokenIntersected)
return std::nullopt;

// Update the end of the affected range to account for NewLen
if (NewLen >= Len) {
 Affected.EndOffset += NewLen - Len;
 } else {
 Affected.EndOffset -= Len - NewLen;
 }

return Affected;
 }

/// Passes each token in this SwiftSyntaxMap to the given \p Consumer
voidforEach(EditorConsumer &Consumer) {
for (auto &Token: Tokens) {
auto Kind = SwiftLangSupport::getUIDForSyntaxNodeKind(Token.Kind);
 Consumer.handleSyntaxMap(Token.Offset, Token.Length, Kind);
 }
 }

/// Finds the delta between the given SwiftSyntaxMap, \p Prev, and this one.
/// It passes each token not in \p Prev to the given \p Consumer and, if
/// needed, also expands or sets the given \p Affected range to cover all
/// non-matching tokens in the two lists.
///
/// Returns true if this SwiftSyntaxMap is different to \p Prev.
boolforEachChanged(const SwiftSyntaxMap &Prev,
 std::optional<SwiftEditorCharRange> &Affected,
 EditorConsumer &Consumer) const {
typedef std::vector<SwiftSyntaxToken>::const_iterator ForwardIt;
typedef std::vector<SwiftSyntaxToken>::const_reverse_iterator ReverseIt;

// Find the first pair of tokens that don't match
 TokenMismatch<ForwardIt>
Forward(Tokens.begin(), Tokens.end(), Prev.Tokens.begin(), Prev.Tokens.end());

// Exit early if there was no mismatch
if (!Forward.foundMismatch())
return Affected && !Affected->isEmpty();

// Find the last pair of tokens that don't match
 TokenMismatch<ReverseIt>
Backward(Tokens.rbegin(), Tokens.rend(), Prev.Tokens.rbegin(), Prev.Tokens.rend());
assert(Backward.foundMismatch());

// Set or extend the affected range to include the mismatched range
 SwiftEditorCharRange
 MismatchRange = {Forward.mismatchStart(),Backward.mismatchEnd()};
if (!Affected) {
 Affected = MismatchRange;
 } else {
 Affected->extendToInclude(MismatchRange);
 }

// Report all tokens in the affected range to the EditorConsumer
auto From = Forward.CurrTok;
auto To = Backward.CurrTok;
while (From != Tokens.begin() && (From-1)->Offset >= Affected->Offset)
 --From;
while (To != Tokens.rbegin() && (To-1)->endOffset() <= Affected->EndOffset)
 --To;
for (; From < To.base(); ++From) {
auto Kind = SwiftLangSupport::getUIDForSyntaxNodeKind(From->Kind);
 Consumer.handleSyntaxMap(From->Offset, From->Length, Kind);
 }

returntrue;
 }
};

structEditorConsumerSyntaxMapEntry {
unsigned Offset;
unsigned Length;
 UIdent Kind;
EditorConsumerSyntaxMapEntry(unsigned Offset, unsigned Length, UIdent Kind)
 :Offset(Offset), Length(Length), Kind(Kind) { }
};

classSwiftDocumentSemanticInfo :
 public ThreadSafeRefCountedBase<SwiftDocumentSemanticInfo> {

const std::string Filename;
 std::weak_ptr<SwiftASTManager> ASTMgr;
 std::shared_ptr<NotificationCenter> NotificationCtr;
 ThreadSafeRefCntPtr<SwiftInvocation> InvokRef;
 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fileSystem;
 std::string CompilerArgsError;

uint64_t ASTGeneration = 0;
 ImmutableTextSnapshotRef TokSnapshot;
 std::vector<SwiftSemanticToken> SemaToks;

 ImmutableTextSnapshotRef DiagSnapshot;
 std::vector<DiagnosticEntryInfo> SemaDiags;

mutable llvm::sys::Mutex Mtx;

public:
SwiftDocumentSemanticInfo(
 StringRef Filename, std::weak_ptr<SwiftASTManager> ASTMgr,
 std::shared_ptr<NotificationCenter> NotificationCtr,
 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fileSystem)
 : Filename(Filename), ASTMgr(ASTMgr), NotificationCtr(NotificationCtr),
fileSystem(fileSystem) {}

 SwiftInvocationRef getInvocation() const {
return InvokRef;
 }

 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> getFileSystem() const {
return fileSystem;
 }

uint64_tgetASTGeneration() const;

voidsetCompilerArgs(ArrayRef<constchar *> Args) {
if (auto ASTMgr = this->ASTMgr.lock()) {
 InvokRef =
 ASTMgr->getTypecheckInvocation(Args, Filename, CompilerArgsError);
 }
 }

voidreadSemanticInfo(ImmutableTextSnapshotRef NewSnapshot,
 std::vector<SwiftSemanticToken> &Tokens,
 std::optional<std::vector<DiagnosticEntryInfo>> &Diags,
 ArrayRef<DiagnosticEntryInfo> ParserDiags);

voidprocessLatestSnapshotAsync(EditableTextBufferRef EditableBuffer,
 SourceKitCancellationToken CancellationToken);

voidupdateSemanticInfo(std::vector<SwiftSemanticToken> Toks,
 std::vector<DiagnosticEntryInfo> Diags,
 ImmutableTextSnapshotRef Snapshot,
uint64_t ASTGeneration);
voidremoveCachedAST() {
if (InvokRef) {
if (auto ASTMgr = this->ASTMgr.lock()) {
 ASTMgr->removeCachedAST(InvokRef);
 }
 }
 }

voidcancelBuildsForCachedAST() {
if (!InvokRef)
return;
if (auto ASTMgr = this->ASTMgr.lock())
 ASTMgr->cancelBuildsForCachedAST(InvokRef);
 }

private:
 std::vector<SwiftSemanticToken> takeSemanticTokens(
 ImmutableTextSnapshotRef NewSnapshot);

 std::optional<std::vector<DiagnosticEntryInfo>>
getSemanticDiagnostics(ImmutableTextSnapshotRef NewSnapshot,
 ArrayRef<DiagnosticEntryInfo> ParserDiags);
};

classSwiftDocumentSyntaxInfo {
 SourceManager SM;
 EditorDiagConsumer DiagConsumer;
 std::unique_ptr<ParserUnit> Parser;
unsigned BufferID;
 std::vector<std::string> Args;
 std::string PrimaryFile;
bool IsParsed;

public:
SwiftDocumentSyntaxInfo(const CompilerInvocation &CompInv,
 ImmutableTextSnapshotRef Snapshot,
 std::vector<std::string> &Args,
 StringRef FilePath)
 : Args(Args), PrimaryFile(FilePath) {

 std::unique_ptr<llvm::MemoryBuffer> BufCopy =
llvm::MemoryBuffer::getMemBufferCopy(
 Snapshot->getBuffer()->getText(), FilePath);

 BufferID = SM.addNewSourceBuffer(std::move(BufCopy));

 Parser.reset(newParserUnit(SM, SourceFileKind::Main, BufferID,
 CompInv.getLangOptions(),
 CompInv.getModuleName()));

registerTypeCheckerRequestFunctions(
 Parser->getParser().Context.evaluator);
registerClangImporterRequestFunctions(Parser->getParser().Context.evaluator);
 Parser->getDiagnosticEngine().addConsumer(DiagConsumer);

 IsParsed = false;
 }

voidparseIfNeeded() {
if (!IsParsed) {
// Perform parsing on a deep stack that's the same size as the main thread
// during normal compilation to avoid stack overflows.
static WorkQueue BigStackQueue{
 WorkQueue::Dequeuing::Concurrent,
"SwiftDocumentSyntaxInfo::parseIfNeeded.BigStackQueue"};
 BigStackQueue.dispatchSync(
 [this]() {
 Parser->parse();
 IsParsed = true;
 },
/*isStackDeep=*/true);
 }
 }

 SourceFile &getSourceFile() {
return Parser->getSourceFile();
 }

unsignedgetBufferID() {
return BufferID;
 }

const LangOptions &getLangOptions() {
return Parser->getLangOptions();
 }

 SourceManager &getSourceManager() {
return SM;
 }

 ArrayRef<DiagnosticEntryInfo> getDiagnostics() {
return DiagConsumer.getDiagnosticsForBuffer(BufferID);
 }
};

} // anonymous namespace

uint64_tSwiftDocumentSemanticInfo::getASTGeneration() const {
 llvm::sys::ScopedLock L(Mtx);
return ASTGeneration;
}

voidSwiftDocumentSemanticInfo::readSemanticInfo(
 ImmutableTextSnapshotRef NewSnapshot,
 std::vector<SwiftSemanticToken> &Tokens,
 std::optional<std::vector<DiagnosticEntryInfo>> &Diags,
 ArrayRef<DiagnosticEntryInfo> ParserDiags) {

 llvm::sys::ScopedLock L(Mtx);

 Tokens = takeSemanticTokens(NewSnapshot);
 Diags = getSemanticDiagnostics(NewSnapshot, ParserDiags);
}

std::vector<SwiftSemanticToken>
SwiftDocumentSemanticInfo::takeSemanticTokens(
 ImmutableTextSnapshotRef NewSnapshot) {

 llvm::sys::ScopedLock L(Mtx);

if (SemaToks.empty())
return {};

// Adjust the position of the tokens.
 TokSnapshot->foreachReplaceUntil(NewSnapshot,
 [&](ReplaceImmutableTextUpdateRef Upd) -> bool {
if (SemaToks.empty())
returnfalse;

auto ReplaceBegin = std::lower_bound(SemaToks.begin(), SemaToks.end(),
 Upd->getByteOffset(),
 [&](const SwiftSemanticToken &Tok, unsigned StartOffset) -> bool {
return Tok.ByteOffset+Tok.Length < StartOffset;
 });

 std::vector<SwiftSemanticToken>::iterator ReplaceEnd;
if (ReplaceBegin == SemaToks.end()) {
 ReplaceEnd = ReplaceBegin;
 } elseif (Upd->getLength() == 0) {
 ReplaceEnd = ReplaceBegin + 1;
 } else {
 ReplaceEnd = std::upper_bound(ReplaceBegin, SemaToks.end(),
 Upd->getByteOffset() + Upd->getLength(),
 [&](unsigned EndOffset, const SwiftSemanticToken &Tok) -> bool {
return EndOffset < Tok.ByteOffset;
 });
 }

unsigned InsertLen = Upd->getText().size();
int Delta = InsertLen - Upd->getLength();
if (Delta != 0) {
for (std::vector<SwiftSemanticToken>::iterator
 I = ReplaceEnd, E = SemaToks.end(); I != E; ++I)
 I->ByteOffset += Delta;
 }
 SemaToks.erase(ReplaceBegin, ReplaceEnd);
returntrue;
 });

returnstd::move(SemaToks);
}

std::optional<std::vector<DiagnosticEntryInfo>>
SwiftDocumentSemanticInfo::getSemanticDiagnostics(
 ImmutableTextSnapshotRef NewSnapshot,
 ArrayRef<DiagnosticEntryInfo> ParserDiags) {

 std::vector<DiagnosticEntryInfo> curSemaDiags;
 {
 llvm::sys::ScopedLock L(Mtx);

if (!DiagSnapshot || DiagSnapshot->getStamp() != NewSnapshot->getStamp()) {
// The semantic diagnostics are out-of-date, ignore them.
return std::nullopt;
 }

 curSemaDiags = SemaDiags;
 }

// Diagnostics from the AST and diagnostics from the parser are based on the
// same source text snapshot. But diagnostics from the AST may have excluded
// the parser diagnostics due to a fatal error, e.g. if the source has a
// 'so such module' error, which will suppress other diagnostics.
// We don't want to turn off the suppression to avoid a flood of diagnostics
// when a module import fails, but we also don't want to lose the parser
// diagnostics in such a case, so merge the parser diagnostics with the sema
// ones.

auto orderDiagnosticEntryInfos = [](const DiagnosticEntryInfo &LHS,
const DiagnosticEntryInfo &RHS) -> bool {
if (LHS.FileInfo->BufferName != RHS.FileInfo->BufferName)
return LHS.FileInfo->BufferName < RHS.FileInfo->BufferName;
if (LHS.Offset != RHS.Offset)
return LHS.Offset < RHS.Offset;
return LHS.Description < RHS.Description;
 };

 std::vector<DiagnosticEntryInfo> sortedParserDiags;
 sortedParserDiags.reserve(ParserDiags.size());
 sortedParserDiags.insert(sortedParserDiags.end(), ParserDiags.begin(),
 ParserDiags.end());
std::stable_sort(sortedParserDiags.begin(), sortedParserDiags.end(),
 orderDiagnosticEntryInfos);

 std::vector<DiagnosticEntryInfo> finalDiags;
 finalDiags.reserve(sortedParserDiags.size()+curSemaDiags.size());

// Add sema diagnostics unless it is an existing parser diagnostic.
// Note that we want to merge and eliminate diagnostics from the 'sema' set
// that also show up in the 'parser' set, but we don't want to remove
// duplicate diagnostics from within the same set (e.g. duplicates existing in
// the 'sema' set). We want to report the diagnostics as the compiler reported
// them, even if there's some duplicate one. This is why we don't just do a
// simple append/sort/keep-uniques step.
for (constauto &curDE : curSemaDiags) {
bool existsAsParserDiag = std::binary_search(sortedParserDiags.begin(),
 sortedParserDiags.end(),
 curDE, orderDiagnosticEntryInfos);
if (!existsAsParserDiag) {
 finalDiags.push_back(curDE);
 }
 }

 finalDiags.insert(finalDiags.end(),
 sortedParserDiags.begin(), sortedParserDiags.end());
std::stable_sort(finalDiags.begin(), finalDiags.end(),
 orderDiagnosticEntryInfos);

return finalDiags;
}

voidSwiftDocumentSemanticInfo::updateSemanticInfo(
 std::vector<SwiftSemanticToken> Toks,
 std::vector<DiagnosticEntryInfo> Diags,
 ImmutableTextSnapshotRef Snapshot,
uint64_t ASTGeneration) {

 {
 llvm::sys::ScopedLock L(Mtx);
if (ASTGeneration > this->ASTGeneration) {
 SemaToks = std::move(Toks);
 SemaDiags = std::move(Diags);
 TokSnapshot = DiagSnapshot = std::move(Snapshot);
this->ASTGeneration = ASTGeneration;
 }
 }

LOG_INFO_FUNC(High, "posted document update notification for: " << Filename);
 NotificationCtr->postDocumentUpdateNotification(Filename);
}

namespace {

classSemanticAnnotator : publicSourceEntityWalker {
 SourceManager &SM;
unsigned BufferID;
public:

 std::vector<SwiftSemanticToken> SemaToks;
bool IsWalkingMacroExpansionBuffer = false;

SemanticAnnotator(SourceManager &SM, unsigned BufferID)
 : SM(SM), BufferID(BufferID) {
if (auto GeneratedSourceInfo = SM.getGeneratedSourceInfo(BufferID)) {
switch (GeneratedSourceInfo->kind) {
#defineMACRO_ROLE(Name, Description) \
case GeneratedSourceInfo::Name##MacroExpansion:
#include"swift/Basic/MacroRoles.def"
 IsWalkingMacroExpansionBuffer = true;
break;
case GeneratedSourceInfo::DefaultArgument:
case GeneratedSourceInfo::ReplacedFunctionBody:
case GeneratedSourceInfo::PrettyPrinted:
case GeneratedSourceInfo::AttributeFromClang:
break;
 }
 }
 }

 MacroWalking getMacroWalkingBehavior() constoverride {
if (IsWalkingMacroExpansionBuffer) {
// When we are walking a macro expansion buffer, we need to set the macro
// walking behavior to walk the expansion, otherwise we skip over all the
// declarations in the buffer.
return MacroWalking::ArgumentsAndExpansion;
 } else {
returnSourceEntityWalker::getMacroWalkingBehavior();
 }
 }

boolvisitDeclReference(ValueDecl *D, CharSourceRange Range,
 TypeDecl *CtorTyRef, ExtensionDecl *ExtTyRef, Type T,
 ReferenceMetaData Data) override {
if (Data.isImplicit)
returntrue;

if (isa<VarDecl>(D) && D->hasName() &&
 D->getName() == D->getASTContext().Id_self)