averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
149b50d901e5722797e658346705122b3b544641
swift-mirror/tools/SourceKit/lib/SwiftLang/SwiftEditor.cpp
practicalswift 149b50d901 Fix typos in code (non-comment/documentation typos).
2015-12-28 11:42:15 +01:00

2931 lines
97 KiB
C++
Raw Blame History

//===--- SwiftEditor.cpp --------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://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/ImmutableTextBuffer.h"
#include "SourceKit/Support/Logging.h"
#include "SourceKit/Support/Tracing.h"
#include "SourceKit/Support/UIdent.h"
#include "swift/AST/AST.h"
#include "swift/AST/ASTVisitor.h"
#include "swift/AST/ASTWalker.h"
#include "swift/AST/DiagnosticsClangImporter.h"
#include "swift/AST/DiagnosticsParse.h"
#include "swift/Basic/SourceManager.h"
#include "swift/Frontend/Frontend.h"
#include "swift/Frontend/PrintingDiagnosticConsumer.h"
#include "swift/IDE/CodeCompletion.h"
#include "swift/IDE/CommentConversion.h"
#include "swift/IDE/SyntaxModel.h"
#include "swift/IDE/SourceEntityWalker.h"
#include "swift/Subsystems.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Mutex.h"
using namespace SourceKit;
using namespace swift;
using namespace ide;
void EditorDiagConsumer::handleDiagnostic(SourceManager &SM, SourceLoc Loc,
DiagnosticKind Kind, StringRef Text,
const DiagnosticInfo &Info) {
if (Kind == DiagnosticKind::Error) {
HadAnyError = true;
}
// Filter out lexer errors for placeholders.
if (Info.ID == diag::lex_editor_placeholder.ID)
return;
if (Loc.isInvalid()) {
if (Kind == DiagnosticKind::Error)
HadInvalidLocError = true;
clearLastDiag();
return;
}
bool IsNote = (Kind == DiagnosticKind::Note);
if (IsNote && !haveLastDiag())
// Is this possible?
return;
DiagnosticEntryInfo SKInfo;
SKInfo.Description = Text;
unsigned BufferID = SM.findBufferContainingLoc(Loc);
if (!isInputBufferID(BufferID)) {
if (Info.ID == diag::error_from_clang.ID ||
Info.ID == diag::warning_from_clang.ID ||
Info.ID == diag::note_from_clang.ID) {
// Handle it as other diagnostics.
} else {
if (!IsNote) {
LOG_WARN_FUNC("got swift diagnostic not pointing at input file, "
"buffer name: " << SM.getIdentifierForBuffer(BufferID));
return;
}
// FIXME: This is a note pointing to a synthesized declaration buffer for
// a declaration coming from a module.
// We should include the Decl* in the DiagnosticInfo and have a way for
// Xcode to handle this "points-at-a-decl-from-module" location.
//
// 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(BufferID);
SKInfo.Description += ")";
SKInfo.Offset = LastDiag.Offset;
SKInfo.Line = LastDiag.Line;
SKInfo.Column = LastDiag.Column;
SKInfo.Filename = LastDiag.Filename;
LastDiag.Notes.push_back(std::move(SKInfo));
return;
}
}
SKInfo.Offset = SM.getLocOffsetInBuffer(Loc, BufferID);
std::tie(SKInfo.Line, SKInfo.Column) = SM.getLineAndColumn(Loc, BufferID);
SKInfo.Filename = SM.getIdentifierForBuffer(BufferID);
for (auto R : Info.Ranges) {
if (R.isInvalid() || SM.findBufferContainingLoc(R.getStart()) != BufferID)
continue;
unsigned Offset = SM.getLocOffsetInBuffer(R.getStart(), BufferID);
unsigned Length = R.getByteLength();
SKInfo.Ranges.push_back({ Offset, Length });
}
for (auto F : Info.FixIts) {
if (F.getRange().isInvalid() ||
SM.findBufferContainingLoc(F.getRange().getStart()) != BufferID)
continue;
unsigned Offset = SM.getLocOffsetInBuffer(F.getRange().getStart(),
BufferID);
unsigned Length = F.getRange().getByteLength();
SKInfo.Fixits.push_back({ Offset, Length, F.getText() });
}
if (IsNote) {
getLastDiag().Notes.push_back(std::move(SKInfo));
return;
}
DiagnosticsTy &Diagnostics = BufferDiagnostics[BufferID];
switch (Kind) {
case DiagnosticKind::Error:
SKInfo.Severity = DiagnosticSeverityKind::Error;
break;
case DiagnosticKind::Warning:
SKInfo.Severity = DiagnosticSeverityKind::Warning;
break;
case DiagnosticKind::Note:
llvm_unreachable("already covered");
}
if (Diagnostics.empty() || Diagnostics.back().Offset <= SKInfo.Offset) {
Diagnostics.push_back(std::move(SKInfo));
LastDiagBufferID = BufferID;
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 = BufferID;
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) {
SwiftEditorDocumentRef EditorDoc;
std::string ResolvedPath = SwiftLangSupport::resolvePathSymlinks(FilePath);
Queue.dispatchSync([&]{
for (auto &Entry : Docs) {
if (Entry.getKey() == FilePath ||
Entry.getValue().ResolvedPath == ResolvedPath) {
EditorDoc = Entry.getValue().DocRef;
break;
}
}
});
return EditorDoc;
}
bool SwiftEditorDocumentFileMap::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.
void mergeSplitRanges(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);
}
}
struct SwiftSyntaxToken {
unsigned Column;
unsigned Length:24;
swift::ide::SyntaxNodeKind Kind:8;
SwiftSyntaxToken(unsigned Column, unsigned Length,
swift::ide::SyntaxNodeKind Kind)
:Column(Column), Length(Length), Kind(Kind) { }
};
class SwiftSyntaxMap {
typedef std::vector<SwiftSyntaxToken> SwiftSyntaxLineMap;
std::vector<SwiftSyntaxLineMap> Lines;
public:
bool matchesFirstTokenOnLine(unsigned Line,
const SwiftSyntaxToken &Token) const {
assert(Line > 0);
if (Lines.size() < Line)
return false;
unsigned LineOffset = Line - 1;
const SwiftSyntaxLineMap &LineMap = Lines[LineOffset];
if (LineMap.empty())
return false;
const SwiftSyntaxToken &Tok = LineMap.front();
if (Tok.Column == Token.Column && Tok.Length == Token.Length
&& Tok.Kind == Token.Kind) {
return true;
}
return false;
}
void addTokenForLine(unsigned Line, const SwiftSyntaxToken &Token) {
assert(Line > 0);
if (Lines.size() < Line) {
Lines.resize(Line);
}
unsigned LineOffset = Line - 1;
SwiftSyntaxLineMap &LineMap = Lines[LineOffset];
// FIXME: Assert this token is after the last one
LineMap.push_back(Token);
}
void mergeTokenForLine(unsigned Line, const SwiftSyntaxToken &Token) {
assert(Line > 0);
if (Lines.size() < Line) {
Lines.resize(Line);
}
unsigned LineOffset = Line - 1;
SwiftSyntaxLineMap &LineMap = Lines[LineOffset];
if (!LineMap.empty()) {
auto &LastTok = LineMap.back();
mergeSplitRanges(LastTok.Column, LastTok.Length,
Token.Column, Token.Length,
[&](unsigned BeforeOff, unsigned BeforeLen,
unsigned AfterOff, unsigned AfterLen) {
auto LastKind = LastTok.Kind;
LineMap.pop_back();
if (BeforeLen)
LineMap.emplace_back(BeforeOff, BeforeLen, LastKind);
LineMap.push_back(Token);
if (AfterLen)
LineMap.emplace_back(AfterOff, AfterLen, LastKind);
});
}
else {
// Not overlapping, just add the new token to the end
LineMap.push_back(Token);
}
}
void clearLineRange(unsigned StartLine, unsigned Length) {
assert(StartLine > 0);
unsigned LineOffset = StartLine - 1;
for (unsigned Line = LineOffset; Line < LineOffset + Length
&& Line < Lines.size(); ++Line) {
Lines[Line].clear();
}
}
void removeLineRange(unsigned StartLine, unsigned Length) {
assert(StartLine > 0 && Length > 0);
if (StartLine < Lines.size()) {
unsigned EndLine = StartLine + Length - 1;
// Delete all syntax map data from start line through end line
Lines.erase(Lines.begin() + StartLine - 1,
EndLine >= Lines.size() ? Lines.end()
: Lines.begin() + EndLine);
}
}
void insertLineRange(unsigned StartLine, unsigned Length) {
Lines.insert(StartLine <= Lines.size() ? Lines.begin() + StartLine - 1
: Lines.end(),
Length, SwiftSyntaxLineMap());
}
void reset() {
Lines.clear();
}
};
struct EditorConsumerSyntaxMapEntry {
unsigned Offset;
unsigned Length;
UIdent Kind;
EditorConsumerSyntaxMapEntry(unsigned Offset, unsigned Length, UIdent Kind)
:Offset(Offset), Length(Length), Kind(Kind) { }
};
class SwiftEditorLineRange {
unsigned StartLine;
unsigned Length;
public:
SwiftEditorLineRange()
:StartLine(0), Length(0) { }
SwiftEditorLineRange(unsigned StartLine, unsigned Length)
:StartLine(StartLine), Length(Length) { }
SwiftEditorLineRange(const SwiftEditorLineRange &Other)
:StartLine(Other.StartLine), Length(Other.Length) { }
bool isValid() const {
return Length != 0;
}
unsigned startLine() const {
return StartLine;
}
unsigned endLine() const {
return isValid() ? StartLine + Length - 1 : 0;
}
unsigned lineCount() const {
return Length;
}
void setRange(unsigned NewStartLine, unsigned NewLength) {
StartLine = NewStartLine;
Length = NewLength;
}
void extendToIncludeLine(unsigned Line) {
if (!isValid()) {
StartLine = Line;
Length = 1;
}
else if (Line >= StartLine + Length) {
Length = Line - StartLine + 1;
}
}
};
typedef std::pair<unsigned, unsigned> SwiftEditorCharRange;
struct SwiftSemanticToken {
unsigned ByteOffset;
unsigned Length : 24;
// The code-completion kinds are a good match for the semantic kinds we want.
// FIXME: Maybe rename CodeCompletionDeclKind to a more general concept ?
CodeCompletionDeclKind Kind : 6;
bool IsRef : 1;
bool IsSystem : 1;
SwiftSemanticToken(CodeCompletionDeclKind Kind,
unsigned ByteOffset, unsigned Length,
bool IsRef, bool IsSystem)
: ByteOffset(ByteOffset), Length(Length), Kind(Kind),
IsRef(IsRef), IsSystem(IsSystem) { }
UIdent getUIdentForKind() const {
return SwiftLangSupport::getUIDForCodeCompletionDeclKind(Kind, IsRef);
}
};
static_assert(sizeof(SwiftSemanticToken) == 8, "Too big");
class SwiftDocumentSemanticInfo :
public ThreadSafeRefCountedBase<SwiftDocumentSemanticInfo> {
const std::string Filename;
SwiftASTManager &ASTMgr;
NotificationCenter &NotificationCtr;
ThreadSafeRefCntPtr<SwiftInvocation> InvokRef;
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, SwiftLangSupport &LangSupport)
: Filename(Filename),
ASTMgr(LangSupport.getASTManager()),
NotificationCtr(LangSupport.getContext().getNotificationCenter()) {}
SwiftInvocationRef getInvocation() const {
return InvokRef;
}
uint64_t getASTGeneration() const;
void setCompilerArgs(ArrayRef<const char *> Args) {
InvokRef = ASTMgr.getInvocation(Args, Filename, CompilerArgsError);
}
void readSemanticInfo(ImmutableTextSnapshotRef NewSnapshot,
std::vector<SwiftSemanticToken> &Tokens,
std::vector<DiagnosticEntryInfo> &Diags,
ArrayRef<DiagnosticEntryInfo> ParserDiags);
void processLatestSnapshotAsync(EditableTextBufferRef EditableBuffer);
void updateSemanticInfo(std::vector<SwiftSemanticToken> Toks,
std::vector<DiagnosticEntryInfo> Diags,
ImmutableTextSnapshotRef Snapshot,
uint64_t ASTGeneration);
void removeCachedAST() {
if (InvokRef)
ASTMgr.removeCachedAST(InvokRef);
}
private:
std::vector<SwiftSemanticToken> takeSemanticTokens(
ImmutableTextSnapshotRef NewSnapshot);
std::vector<DiagnosticEntryInfo> getSemanticDiagnostics(
ImmutableTextSnapshotRef NewSnapshot,
ArrayRef<DiagnosticEntryInfo> ParserDiags);
};
class SwiftDocumentSyntaxInfo {
SourceManager SM;
EditorDiagConsumer DiagConsumer;
std::unique_ptr<ParserUnit> Parser;
unsigned BufferID;
std::vector<std::string> Args;
std::string PrimaryFile;
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));
SM.setHashbangBufferID(BufferID);
DiagConsumer.setInputBufferIDs(BufferID);
Parser.reset(
new ParserUnit(SM, BufferID,
CompInv.getLangOptions(),
CompInv.getModuleName())
);
Parser->getDiagnosticEngine().addConsumer(DiagConsumer);
}
void initArgsAndPrimaryFile(trace::SwiftInvocation &Info) {
Info.Args.PrimaryFile = PrimaryFile;
Info.Args.Args = Args;
}
void parse() {
auto &P = Parser->getParser();
trace::TracedOperation TracedOp;
if (trace::enabled()) {
trace::SwiftInvocation Info;
initArgsAndPrimaryFile(Info);
auto Text = SM.getLLVMSourceMgr().getMemoryBuffer(BufferID)->getBuffer();
Info.Files.push_back(std::make_pair(PrimaryFile, Text));
TracedOp.start(trace::OperationKind::SimpleParse, Info);
}
bool Done = false;
while (!Done) {
P.parseTopLevel();
Done = P.Tok.is(tok::eof);
}
}
SourceFile &getSourceFile() {
return Parser->getSourceFile();
}
unsigned getBufferID() {
return BufferID;
}
const LangOptions &getLangOptions() {
return Parser->getLangOptions();
}
SourceManager &getSourceManager() {
return SM;
}
ArrayRef<DiagnosticEntryInfo> getDiagnostics() {
return DiagConsumer.getDiagnosticsForBuffer(BufferID);
}
};
} // anonymous namespace.
uint64_t SwiftDocumentSemanticInfo::getASTGeneration() const {
llvm::sys::ScopedLock L(Mtx);
return ASTGeneration;
}
void SwiftDocumentSemanticInfo::readSemanticInfo(
ImmutableTextSnapshotRef NewSnapshot,
std::vector<SwiftSemanticToken> &Tokens,
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())
return false;
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 (Upd->getLength() == 0) {
ReplaceEnd = ReplaceBegin;
} 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);
return true;
});
return std::move(SemaToks);
}
static bool
adjustDiagnosticRanges(SmallVectorImpl<std::pair<unsigned, unsigned>> &Ranges,
unsigned ByteOffset, unsigned RemoveLen, int Delta) {
for (auto &Range : Ranges) {
unsigned RangeBegin = Range.first;
unsigned RangeEnd = Range.first + Range.second;
unsigned RemoveEnd = ByteOffset + RemoveLen;
// If it intersects with the remove range, ignore the whole diagnostic.
if (!(RangeEnd < ByteOffset || RangeBegin > RemoveEnd))
return true; // Ignore.
if (RangeBegin > RemoveEnd)
Range.first += Delta;
}
return false;
}
static bool
adjustDiagnosticFixits(SmallVectorImpl<DiagnosticEntryInfo::Fixit> &Fixits,
unsigned ByteOffset, unsigned RemoveLen, int Delta) {
for (auto &Fixit : Fixits) {
unsigned FixitBegin = Fixit.Offset;
unsigned FixitEnd = Fixit.Offset + Fixit.Length;
unsigned RemoveEnd = ByteOffset + RemoveLen;
// If it intersects with the remove range, ignore the whole diagnostic.
if (!(FixitEnd < ByteOffset || FixitBegin > RemoveEnd))
return true; // Ignore.
if (FixitBegin > FixitEnd)
Fixit.Offset += Delta;
}
return false;
}
static bool
adjustDiagnosticBase(DiagnosticEntryInfoBase &Diag,
unsigned ByteOffset, unsigned RemoveLen, int Delta) {
if (Diag.Offset >= ByteOffset && Diag.Offset < ByteOffset+RemoveLen)
return true; // Ignore.
bool Ignore = adjustDiagnosticRanges(Diag.Ranges, ByteOffset, RemoveLen, Delta);
if (Ignore)
return true;
Ignore = adjustDiagnosticFixits(Diag.Fixits, ByteOffset, RemoveLen, Delta);
if (Ignore)
return true;
if (Diag.Offset > ByteOffset)
Diag.Offset += Delta;
return false;
}
static bool
adjustDiagnostic(DiagnosticEntryInfo &Diag, StringRef Filename,
unsigned ByteOffset, unsigned RemoveLen, int Delta) {
for (auto &Note : Diag.Notes) {
if (Filename != Note.Filename)
continue;
bool Ignore = adjustDiagnosticBase(Note, ByteOffset, RemoveLen, Delta);
if (Ignore)
return true;
}
return adjustDiagnosticBase(Diag, ByteOffset, RemoveLen, Delta);
}
static std::vector<DiagnosticEntryInfo>
adjustDiagnostics(std::vector<DiagnosticEntryInfo> Diags, StringRef Filename,
unsigned ByteOffset, unsigned RemoveLen, int Delta) {
std::vector<DiagnosticEntryInfo> NewDiags;
NewDiags.reserve(Diags.size());
for (auto &Diag : Diags) {
bool Ignore = adjustDiagnostic(Diag, Filename, ByteOffset, RemoveLen, Delta);
if (!Ignore) {
NewDiags.push_back(std::move(Diag));
}
}
return NewDiags;
}
std::vector<DiagnosticEntryInfo>
SwiftDocumentSemanticInfo::getSemanticDiagnostics(
ImmutableTextSnapshotRef NewSnapshot,
ArrayRef<DiagnosticEntryInfo> ParserDiags) {
llvm::sys::ScopedLock L(Mtx);
if (SemaDiags.empty())
return SemaDiags;
assert(DiagSnapshot && "If we have diagnostics, we must have snapshot!");
if (!DiagSnapshot->precedesOrSame(NewSnapshot)) {
// It may happen that other thread has already updated the diagnostics to
// the version *after* NewSnapshot. This can happen in at least two cases:
// (a) two or more editor.open or editor.replacetext queries are being
// processed concurrently (not valid, but possible call pattern)
// (b) while editor.replacetext processing is running, a concurrent
// thread executes getBuffer()/getBufferForSnapshot() on the same
// Snapshot/EditableBuffer (thus creating a new ImmutableTextBuffer)
// and updates DiagSnapshot/SemaDiags
assert(NewSnapshot->precedesOrSame(DiagSnapshot));
// Since we cannot "adjust back" diagnostics, we just return an empty set.
// FIXME: add handling of the case#b above
return {};
}
SmallVector<unsigned, 16> ParserDiagLines;
for (auto Diag : ParserDiags)
ParserDiagLines.push_back(Diag.Line);
std::sort(ParserDiagLines.begin(), ParserDiagLines.end());
auto hasParserDiagAtLine = [&](unsigned Line) {
return std::binary_search(ParserDiagLines.begin(), ParserDiagLines.end(),
Line);
};
// Adjust the position of the diagnostics.
DiagSnapshot->foreachReplaceUntil(NewSnapshot,
[&](ReplaceImmutableTextUpdateRef Upd) -> bool {
if (SemaDiags.empty())
return false;
unsigned ByteOffset = Upd->getByteOffset();
unsigned RemoveLen = Upd->getLength();
unsigned InsertLen = Upd->getText().size();
int Delta = InsertLen - RemoveLen;
SemaDiags = adjustDiagnostics(std::move(SemaDiags), Filename,
ByteOffset, RemoveLen, Delta);
return true;
});
if (!SemaDiags.empty()) {
auto ImmBuf = NewSnapshot->getBuffer();
for (auto &Diag : SemaDiags) {
std::tie(Diag.Line, Diag.Column) = ImmBuf->getLineAndColumn(Diag.Offset);
}
// If there is a parser diagnostic in a line, ignore diagnostics in the same
// line that we got from the semantic pass.
// Note that the semantic pass also includes parser diagnostics so this
// avoids duplicates.
SemaDiags.erase(std::remove_if(SemaDiags.begin(), SemaDiags.end(),
[&](const DiagnosticEntryInfo &Diag) -> bool {
return hasParserDiagAtLine(Diag.Line);
}),
SemaDiags.end());
}
DiagSnapshot = NewSnapshot;
return SemaDiags;
}
void SwiftDocumentSemanticInfo::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 {
class SemanticAnnotator : public SourceEntityWalker {
SourceManager &SM;
unsigned BufferID;
public:
std::vector<SwiftSemanticToken> SemaToks;
SemanticAnnotator(SourceManager &SM, unsigned BufferID)
: SM(SM), BufferID(BufferID) {}
bool visitDeclReference(ValueDecl *D, CharSourceRange Range,
TypeDecl *CtorTyRef, Type T) override {
if (isa<VarDecl>(D) && D->hasName() && D->getName().str() == "self")
return true;
// Do not annotate references to unavailable decls.
if (AvailableAttr::isUnavailable(D))
return true;
if (CtorTyRef)
D = CtorTyRef;
annotate(D, /*IsRef=*/true, Range);
return true;
}
bool visitSubscriptReference(ValueDecl *D, CharSourceRange Range,
bool IsOpenBracket) override {
// We should treat both open and close brackets equally
return visitDeclReference(D, Range, nullptr, Type());
}
void annotate(const Decl *D, bool IsRef, CharSourceRange Range) {
unsigned ByteOffset = SM.getLocOffsetInBuffer(Range.getStart(), BufferID);
unsigned Length = Range.getByteLength();
auto Kind = CodeCompletionResult::getCodeCompletionDeclKind(D);
bool IsSystem = D->getModuleContext()->isSystemModule();
SemaToks.emplace_back(Kind, ByteOffset, Length, IsRef, IsSystem);
}
};
} // anonymous namespace
namespace {
class AnnotAndDiagASTConsumer : public SwiftASTConsumer {
EditableTextBufferRef EditableBuffer;
RefPtr<SwiftDocumentSemanticInfo> SemaInfoRef;
public:
std::vector<SwiftSemanticToken> SemaToks;
AnnotAndDiagASTConsumer(EditableTextBufferRef EditableBuffer,
RefPtr<SwiftDocumentSemanticInfo> SemaInfoRef)
: EditableBuffer(std::move(EditableBuffer)),
SemaInfoRef(std::move(SemaInfoRef)) { }
void failed(StringRef Error) override {
LOG_WARN_FUNC("sema annotations failed: " << Error);
}
void handlePrimaryAST(ASTUnitRef AstUnit) override {
auto Generation = AstUnit->getGeneration();
auto &CompIns = AstUnit->getCompilerInstance();
auto &Consumer = AstUnit->getEditorDiagConsumer();
assert(Generation);
if (Generation < SemaInfoRef->getASTGeneration()) {
// It may happen that this request was waiting in async queue for
// too long so another thread has already updated this sema with
// ast generation bigger than ASTGeneration
return;
}
ImmutableTextSnapshotRef DocSnapshot;
for (auto &Snap : AstUnit->getSnapshots()) {
if (Snap->getEditableBuffer() == EditableBuffer) {
DocSnapshot = Snap;
break;
}
}
if (!DocSnapshot) {
LOG_WARN_FUNC("did not find document snapshot when handling the AST");
return;
}
if (Generation == SemaInfoRef->getASTGeneration()) {
// Save time if we already know we processed this AST version.
if (DocSnapshot->getStamp() != EditableBuffer->getSnapshot()->getStamp()){
// Handle edits that occurred after we processed the AST.
SemaInfoRef->processLatestSnapshotAsync(EditableBuffer);
}
return;
}
if (!AstUnit->getPrimarySourceFile().getBufferID().hasValue()) {
LOG_WARN_FUNC("Primary SourceFile is expected to have a BufferID");
return;
}
unsigned BufferID = AstUnit->getPrimarySourceFile().getBufferID().getValue();
trace::TracedOperation TracedOp;
if (trace::enabled()) {
trace::SwiftInvocation SwiftArgs;
SemaInfoRef->getInvocation()->raw(SwiftArgs.Args.Args,
SwiftArgs.Args.PrimaryFile);
trace::initTraceFiles(SwiftArgs, CompIns);
TracedOp.start(trace::OperationKind::AnnotAndDiag, SwiftArgs);
}
SemanticAnnotator Annotator(CompIns.getSourceMgr(), BufferID);
Annotator.walk(AstUnit->getPrimarySourceFile());
SemaToks = std::move(Annotator.SemaToks);
TracedOp.finish();
SemaInfoRef->
updateSemanticInfo(std::move(SemaToks),
std::move(Consumer.getDiagnosticsForBuffer(BufferID)),
DocSnapshot,
Generation);
if (DocSnapshot->getStamp() != EditableBuffer->getSnapshot()->getStamp()) {
// Handle edits that occurred after we processed the AST.
SemaInfoRef->processLatestSnapshotAsync(EditableBuffer);
}
}
};
} // anonymous namespace
void SwiftDocumentSemanticInfo::processLatestSnapshotAsync(
EditableTextBufferRef EditableBuffer) {
SwiftInvocationRef Invok = InvokRef;
if (!Invok)
return;
RefPtr<SwiftDocumentSemanticInfo> SemaInfoRef = this;
auto Consumer = std::make_shared<AnnotAndDiagASTConsumer>(EditableBuffer,
SemaInfoRef);
// Semantic annotation queries for a particular document should cancel
// previously queued queries for the same document. Each document has a
// SwiftDocumentSemanticInfo pointer so use that for the token.
const void *OncePerASTToken = SemaInfoRef.get();
ASTMgr.processASTAsync(Invok, std::move(Consumer), OncePerASTToken);
}
struct SwiftEditorDocument::CodeFormatOptions {
bool UseTabs = false;
unsigned IndentWidth = 4;
unsigned TabWidth = 4;
};
struct SwiftEditorDocument::Implementation {
SwiftLangSupport &LangSupport;
const std::string FilePath;
EditableTextBufferRef EditableBuffer;
SwiftSyntaxMap SyntaxMap;
SwiftEditorLineRange EditedLineRange;
SwiftEditorCharRange AffectedRange;
std::vector<DiagnosticEntryInfo> ParserDiagnostics;
RefPtr<SwiftDocumentSemanticInfo> SemanticInfo;
CodeFormatOptions FormatOptions;
std::shared_ptr<SwiftDocumentSyntaxInfo> SyntaxInfo;
std::shared_ptr<SwiftDocumentSyntaxInfo> getSyntaxInfo() {
llvm::sys::ScopedLock L(AccessMtx);
return SyntaxInfo;
}
llvm::sys::Mutex AccessMtx;
Implementation(StringRef FilePath, SwiftLangSupport &LangSupport)
: LangSupport(LangSupport), FilePath(FilePath) {
SemanticInfo = new SwiftDocumentSemanticInfo(FilePath, LangSupport);
}
void buildSwiftInv(trace::SwiftInvocation &Inv);
};
void SwiftEditorDocument::Implementation::buildSwiftInv(
trace::SwiftInvocation &Inv) {
if (SemanticInfo->getInvocation()) {
std::string PrimaryFile; // Ignored, FilePath will be used
SemanticInfo->getInvocation()->raw(Inv.Args.Args, PrimaryFile);
}
Inv.Args.PrimaryFile = FilePath;
auto &SM = SyntaxInfo->getSourceManager();
auto ID = SyntaxInfo->getBufferID();
auto Text = SM.getLLVMSourceMgr().getMemoryBuffer(ID)->getBuffer();
Inv.Files.push_back(std::make_pair(FilePath, Text));
}
namespace {
static UIdent getAccessibilityUID(Accessibility Access) {
static UIdent AccessPublic("source.lang.swift.accessibility.public");
static UIdent AccessInternal("source.lang.swift.accessibility.internal");
static UIdent AccessPrivate("source.lang.swift.accessibility.private");
switch (Access) {
case Accessibility::Private:
return AccessPrivate;
case Accessibility::Internal:
return AccessInternal;
case Accessibility::Public:
return AccessPublic;
}
}
static Accessibility inferDefaultAccessibility(const ExtensionDecl *ED) {
if (ED->hasDefaultAccessibility())
return ED->getDefaultAccessibility();
if (auto *AA = ED->getAttrs().getAttribute<AccessibilityAttr>())
return AA->getAccess();
// Assume "internal", which is the most common thing anyway.
return Accessibility::Internal;
}
/// If typechecking was performed we use the computed accessibility, otherwise
/// we fallback to inferring accessibility syntactically. This may not be as
/// accurate but it's only until we have typechecked the AST.
static Accessibility inferAccessibility(const ValueDecl *D) {
assert(D);
if (D->hasAccessibility())
return D->getFormalAccess();
// Check if the decl has an explicit accessibility attribute.
if (auto *AA = D->getAttrs().getAttribute<AccessibilityAttr>())
return AA->getAccess();
DeclContext *DC = D->getDeclContext();
switch (DC->getContextKind()) {
case DeclContextKind::SerializedLocal:
case DeclContextKind::AbstractClosureExpr:
case DeclContextKind::Initializer:
case DeclContextKind::TopLevelCodeDecl:
case DeclContextKind::AbstractFunctionDecl:
return Accessibility::Private;
case DeclContextKind::Module:
case DeclContextKind::FileUnit:
return Accessibility::Internal;
case DeclContextKind::NominalTypeDecl: {
auto Nominal = cast<NominalTypeDecl>(DC);
Accessibility Access = inferAccessibility(Nominal);
if (!isa<ProtocolDecl>(Nominal))
Access = std::min(Access, Accessibility::Internal);
return Access;
}
case DeclContextKind::ExtensionDecl:
return inferDefaultAccessibility(cast<ExtensionDecl>(DC));
}
}
static Optional<Accessibility>
inferSetterAccessibility(const AbstractStorageDecl *D) {
if (auto *VD = dyn_cast<VarDecl>(D)) {
if (VD->isLet())
return None;
}
if (D->getGetter() && !D->getSetter())
return None;
// FIXME: Have the parser detect as read-only the syntactic form of generated
// interfaces, which is "var foo : Int { get }"
if (auto *AA = D->getAttrs().getAttribute<SetterAccessibilityAttr>())
return AA->getAccess();
else
return inferAccessibility(D);
}
std::vector<UIdent> UIDsFromDeclAttributes(const DeclAttributes &Attrs) {
std::vector<UIdent> AttrUIDs;
#define ATTR(X) \
if (Attrs.has(AK_##X)) { \
static UIdent Attr_##X("source.decl.attribute."#X); \
AttrUIDs.push_back(Attr_##X); \
}
#include "swift/AST/Attr.def"
for (auto Attr : Attrs) {
// Check special-case names first.
switch (Attr->getKind()) {
case DAK_IBAction: {
static UIdent Attr_IBAction("source.decl.attribute.ibaction");
AttrUIDs.push_back(Attr_IBAction);
continue;
}
case DAK_IBOutlet: {
static UIdent Attr_IBOutlet("source.decl.attribute.iboutlet");
AttrUIDs.push_back(Attr_IBOutlet);
continue;
}
case DAK_IBDesignable: {
static UIdent Attr_IBDesignable("source.decl.attribute.ibdesignable");
AttrUIDs.push_back(Attr_IBDesignable);
continue;
}
case DAK_IBInspectable: {
static UIdent Attr_IBInspectable("source.decl.attribute.ibinspectable");
AttrUIDs.push_back(Attr_IBInspectable);
continue;
}
case DAK_ObjC: {
static UIdent Attr_Objc("source.decl.attribute.objc");
static UIdent Attr_ObjcNamed("source.decl.attribute.objc.name");
if (cast<ObjCAttr>(Attr)->hasName()) {
AttrUIDs.push_back(Attr_ObjcNamed);
} else {
AttrUIDs.push_back(Attr_Objc);
}
continue;
}
// We handle accessibility explicitly.
case DAK_Accessibility:
case DAK_SetterAccessibility:
continue;
default:
break;
}
switch (Attr->getKind()) {
case DAK_Count:
break;
#define DECL_ATTR(X, CLASS, ...)\
case DAK_##CLASS: {\
static UIdent Attr_##X("source.decl.attribute."#X); \
AttrUIDs.push_back(Attr_##X); \
break;\
}
#include "swift/AST/Attr.def"
}
}
return AttrUIDs;
}
class SwiftDocumentStructureWalker: public ide::SyntaxModelWalker {
SourceManager &SrcManager;
EditorConsumer &Consumer;
unsigned BufferID;
public:
SwiftDocumentStructureWalker(SourceManager &SrcManager,
unsigned BufferID,
EditorConsumer &Consumer)
: SrcManager(SrcManager), Consumer(Consumer), BufferID(BufferID) { }
bool walkToSubStructurePre(SyntaxStructureNode Node) override {
unsigned StartOffset = SrcManager.getLocOffsetInBuffer(Node.Range.getStart(),
BufferID);
unsigned EndOffset = SrcManager.getLocOffsetInBuffer(Node.Range.getEnd(),
BufferID);
unsigned NameStart;
unsigned NameEnd;
if (Node.NameRange.isValid()) {
NameStart = SrcManager.getLocOffsetInBuffer(Node.NameRange.getStart(),
BufferID);
NameEnd = SrcManager.getLocOffsetInBuffer(Node.NameRange.getEnd(),
BufferID);
}
else {
NameStart = NameEnd = 0;
}
unsigned BodyOffset;
unsigned BodyEnd;
if (Node.BodyRange.isValid()) {
BodyOffset = SrcManager.getLocOffsetInBuffer(Node.BodyRange.getStart(),
BufferID);
BodyEnd = SrcManager.getLocOffsetInBuffer(Node.BodyRange.getEnd(),
BufferID);
}
else {
BodyOffset = BodyEnd = 0;
}
UIdent Kind = SwiftLangSupport::getUIDForSyntaxStructureKind(Node.Kind);
UIdent AccessLevel;
UIdent SetterAccessLevel;
if (Node.Kind != SyntaxStructureKind::Parameter) {
if (auto *VD = dyn_cast_or_null<ValueDecl>(Node.Dcl)) {
AccessLevel = getAccessibilityUID(inferAccessibility(VD));
}
if (auto *ASD = dyn_cast_or_null<AbstractStorageDecl>(Node.Dcl)) {
Optional<Accessibility> SetAccess = inferSetterAccessibility(ASD);
if (SetAccess.hasValue()) {
SetterAccessLevel = getAccessibilityUID(SetAccess.getValue());
}
}
}
SmallVector<StringRef, 4> InheritedNames;
if (!Node.InheritedTypeRanges.empty()) {
for (auto &TR : Node.InheritedTypeRanges) {
InheritedNames.push_back(SrcManager.extractText(TR));
}
}
StringRef TypeName;
if (Node.TypeRange.isValid()) {
TypeName = SrcManager.extractText(Node.TypeRange);
}
SmallString<64> DisplayNameBuf;
StringRef DisplayName;
if (auto ValueD = dyn_cast_or_null<ValueDecl>(Node.Dcl)) {
llvm::raw_svector_ostream OS(DisplayNameBuf);
if (!SwiftLangSupport::printDisplayName(ValueD, OS))
DisplayName = OS.str();
}
else if (Node.NameRange.isValid()) {
DisplayName = SrcManager.extractText(Node.NameRange);
}
SmallString<64> RuntimeNameBuf;
StringRef RuntimeName = getObjCRuntimeName(Node.Dcl, RuntimeNameBuf);
SmallString<64> SelectorNameBuf;
StringRef SelectorName = getObjCSelectorName(Node.Dcl, SelectorNameBuf);
std::vector<UIdent> Attrs = UIDsFromDeclAttributes(Node.Attrs);
Consumer.beginDocumentSubStructure(StartOffset, EndOffset - StartOffset,
Kind, AccessLevel, SetterAccessLevel,
NameStart, NameEnd - NameStart,
BodyOffset, BodyEnd - BodyOffset,
DisplayName,
TypeName, RuntimeName,
SelectorName,
InheritedNames, Attrs);
for (const auto &Elem : Node.Elements) {
if (Elem.Range.isInvalid())
continue;
UIdent Kind = SwiftLangSupport::getUIDForSyntaxStructureElementKind(Elem.Kind);
unsigned Offset = SrcManager.getLocOffsetInBuffer(Elem.Range.getStart(),
BufferID);
unsigned Length = Elem.Range.getByteLength();
Consumer.handleDocumentSubStructureElement(Kind, Offset, Length);
}
return true;
}
StringRef getObjCRuntimeName(const Decl *D, SmallString<64> &Buf) {
if (!D)
return StringRef();
if (!isa<ClassDecl>(D) && !isa<ProtocolDecl>(D))
return StringRef();
// We don't support getting the runtime name for nested classes.
// This would require typechecking or at least name lookup, if the nested
// class is in an extension.
if (!D->getDeclContext()->isModuleScopeContext())
return StringRef();
if (auto ClassD = dyn_cast<ClassDecl>(D)) {
// We don't vend the runtime name for generic classes for now.
if (ClassD->getGenericParams())
return StringRef();
return ClassD->getObjCRuntimeName(Buf);
}
return cast<ProtocolDecl>(D)->getObjCRuntimeName(Buf);
}
StringRef getObjCSelectorName(const Decl *D, SmallString<64> &Buf) {
if (auto FuncD = dyn_cast_or_null<AbstractFunctionDecl>(D)) {
// We only vend the selector name for @IBAction methods.
if (FuncD->getAttrs().hasAttribute<IBActionAttr>())
return FuncD->getObjCSelector().getString(Buf);
}
return StringRef();
}
bool walkToSubStructurePost(SyntaxStructureNode Node) override {
Consumer.endDocumentSubStructure();
return true;
}
bool walkToNodePre(SyntaxNode Node) override {
if (Node.Kind != SyntaxNodeKind::CommentMarker)
return false;
unsigned StartOffset = SrcManager.getLocOffsetInBuffer(Node.Range.getStart(),
BufferID);
unsigned EndOffset = SrcManager.getLocOffsetInBuffer(Node.Range.getEnd(),
BufferID);
UIdent Kind = SwiftLangSupport::getUIDForSyntaxNodeKind(Node.Kind);
Consumer.beginDocumentSubStructure(StartOffset, EndOffset - StartOffset,
Kind, UIdent(), UIdent(), 0, 0,
0, 0,
StringRef(),
StringRef(), StringRef(),
StringRef(),
{}, {});
return true;
}
bool walkToNodePost(SyntaxNode Node) override {
if (Node.Kind != SyntaxNodeKind::CommentMarker)
return true;
Consumer.endDocumentSubStructure();
return true;
}
};
class SwiftEditorSyntaxWalker: public ide::SyntaxModelWalker {
SwiftSyntaxMap &SyntaxMap;
SwiftEditorLineRange EditedLineRange;
SwiftEditorCharRange &AffectedRange;
SourceManager &SrcManager;
EditorConsumer &Consumer;
unsigned BufferID;
SwiftDocumentStructureWalker DocStructureWalker;
std::vector<EditorConsumerSyntaxMapEntry> ConsumerSyntaxMap;
unsigned NestingLevel = 0;
public:
SwiftEditorSyntaxWalker(SwiftSyntaxMap &SyntaxMap,
SwiftEditorLineRange EditedLineRange,
SwiftEditorCharRange &AffectedRange,
SourceManager &SrcManager, EditorConsumer &Consumer,
unsigned BufferID)
: SyntaxMap(SyntaxMap), EditedLineRange(EditedLineRange),
AffectedRange(AffectedRange), SrcManager(SrcManager), Consumer(Consumer),
BufferID(BufferID),
DocStructureWalker(SrcManager, BufferID, Consumer) { }
bool walkToNodePre(SyntaxNode Node) override {
if (Node.Kind == SyntaxNodeKind::CommentMarker)
return DocStructureWalker.walkToNodePre(Node);
++NestingLevel;
SourceLoc StartLoc = Node.Range.getStart();
auto StartLineAndColumn = SrcManager.getLineAndColumn(StartLoc);
auto EndLineAndColumn = SrcManager.getLineAndColumn(Node.Range.getEnd());
unsigned StartLine = StartLineAndColumn.first;
unsigned EndLine = EndLineAndColumn.second > 1 ? EndLineAndColumn.first
: EndLineAndColumn.first - 1;
unsigned Offset = SrcManager.getByteDistance(
SrcManager.getLocForBufferStart(BufferID), StartLoc);
// Note that the length can span multiple lines.
unsigned Length = Node.Range.getByteLength();
SwiftSyntaxToken Token(StartLineAndColumn.second, Length,
Node.Kind);
if (EditedLineRange.isValid()) {
if (StartLine < EditedLineRange.startLine()) {
if (EndLine < EditedLineRange.startLine()) {
// We're entirely before the edited range, no update needed.
return true;
}
// This token starts before the edited range, but doesn't end before it,
// we need to adjust edited line range and clear the affected syntax map
// line range.
unsigned AdjLineCount = EditedLineRange.startLine() - StartLine;
EditedLineRange.setRange(StartLine, AdjLineCount
+ EditedLineRange.lineCount());
SyntaxMap.clearLineRange(StartLine, AdjLineCount);
// Also adjust the affected char range accordingly.
unsigned AdjCharCount = AffectedRange.first - Offset;
AffectedRange.first -= AdjCharCount;
AffectedRange.second += AdjCharCount;
}
else if (Offset > AffectedRange.first + AffectedRange.second) {
// We're passed the affected range and already synced up, just return.
return true;
}
else if (StartLine > EditedLineRange.endLine()) {
// We're after the edited line range, let's test if we're synced up.
if (SyntaxMap.matchesFirstTokenOnLine(StartLine, Token)) {
// We're synced up, mark the affected range and return.
AffectedRange.second =
Offset - (StartLineAndColumn.second - 1) - AffectedRange.first;
return true;
}
// We're not synced up, continue replacing syntax map data on this line.
SyntaxMap.clearLineRange(StartLine, 1);
EditedLineRange.extendToIncludeLine(StartLine);
}
if (EndLine > StartLine) {
// The token spans multiple lines, make sure to replace syntax map data
// for affected lines.
EditedLineRange.extendToIncludeLine(EndLine);
unsigned LineCount = EndLine - StartLine + 1;
SyntaxMap.clearLineRange(StartLine, LineCount);
}
}
// Add the syntax map token.
if (NestingLevel > 1)
SyntaxMap.mergeTokenForLine(StartLine, Token);
else
SyntaxMap.addTokenForLine(StartLine, Token);
// Add consumer entry.
unsigned ByteOffset = SrcManager.getLocOffsetInBuffer(Node.Range.getStart(),
BufferID);
UIdent Kind = SwiftLangSupport::getUIDForSyntaxNodeKind(Node.Kind);
if (NestingLevel > 1) {
assert(!ConsumerSyntaxMap.empty());
auto &Last = ConsumerSyntaxMap.back();
mergeSplitRanges(Last.Offset, Last.Length, ByteOffset, Length,
[&](unsigned BeforeOff, unsigned BeforeLen,
unsigned AfterOff, unsigned AfterLen) {
auto LastKind = Last.Kind;
ConsumerSyntaxMap.pop_back();
if (BeforeLen)
ConsumerSyntaxMap.emplace_back(BeforeOff, BeforeLen, LastKind);
ConsumerSyntaxMap.emplace_back(ByteOffset, Length, Kind);
if (AfterLen)
ConsumerSyntaxMap.emplace_back(AfterOff, AfterLen, LastKind);
});
}
else
ConsumerSyntaxMap.emplace_back(ByteOffset, Length, Kind);
return true;
}
bool walkToNodePost(SyntaxNode Node) override {
if (Node.Kind == SyntaxNodeKind::CommentMarker)
return DocStructureWalker.walkToNodePost(Node);
if (--NestingLevel == 0) {
// We've unwound to the top level, so inform the consumer and drain
// the consumer syntax map queue.
for (auto &Entry: ConsumerSyntaxMap)
Consumer.handleSyntaxMap(Entry.Offset, Entry.Length, Entry.Kind);
ConsumerSyntaxMap.clear();
}
return true;
}
bool walkToSubStructurePre(SyntaxStructureNode Node) override {
return DocStructureWalker.walkToSubStructurePre(Node);
}
bool walkToSubStructurePost(SyntaxStructureNode Node) override {
return DocStructureWalker.walkToSubStructurePost(Node);
}
};
typedef llvm::SmallString<64> StringBuilder;
static SourceLoc getVarDeclInitEnd(VarDecl *VD) {
return VD->getBracesRange().isValid() ? VD->getBracesRange().End :
VD->getParentInitializer() &&
VD->getParentInitializer()->getEndLoc().isValid() ?
VD->getParentInitializer()->getEndLoc() :
SourceLoc();
}
class FormatContext
{
SourceManager &SM;
std::vector<swift::ASTWalker::ParentTy>& Stack;
std::vector<swift::ASTWalker::ParentTy>::reverse_iterator Cursor;
swift::ASTWalker::ParentTy Start;
swift::ASTWalker::ParentTy End;
bool InDocCommentBlock;
bool InCommentLine;
SourceLoc SiblingLoc;
public:
FormatContext(SourceManager &SM,
std::vector<swift::ASTWalker::ParentTy>& Stack,
swift::ASTWalker::ParentTy Start = swift::ASTWalker::ParentTy(),
swift::ASTWalker::ParentTy End = swift::ASTWalker::ParentTy(),
bool InDocCommentBlock = false,
bool InCommentLine = false,
SourceLoc SiblingLoc = SourceLoc())
:SM(SM), Stack(Stack), Cursor(Stack.rbegin()), Start(Start), End(End),
InDocCommentBlock(InDocCommentBlock), InCommentLine(InCommentLine),
SiblingLoc(SiblingLoc) { }
FormatContext parent() {
assert(Cursor != Stack.rend());
FormatContext Parent(*this);
++Parent.Cursor;
return Parent;
}
bool IsInDocCommentBlock() {
return InDocCommentBlock;
}
bool IsInCommentLine() {
return InCommentLine;
}
void padToSiblingColumn(StringBuilder &Builder) {
assert(SiblingLoc.isValid() && "No sibling to align with.");
CharSourceRange Range(SM, Lexer::getLocForStartOfLine(SM, SiblingLoc),
SiblingLoc);
for (auto C : Range.str()) {
Builder.append(1, C == '\t' ? C : ' ');
}
}
bool HasSibling() {
return SiblingLoc.isValid();
}
std::pair<unsigned, unsigned> lineAndColumn() {
if (Cursor == Stack.rend())
return std::make_pair(0, 0);
if (Stmt *S = Cursor->getAsStmt()) {
SourceLoc SL = S->getStartLoc();
return SM.getLineAndColumn(SL);
}
if (Decl *D = Cursor->getAsDecl()) {
SourceLoc SL = D->getStartLoc();
// FIXME: put the attributes into forward source order so we don't need
// to iterate through them.
for (auto *Attr : D->getAttrs()) {
SourceLoc AttrLoc = Attr->getRangeWithAt().Start;
if (AttrLoc.isValid() && SM.isBeforeInBuffer(AttrLoc, SL))
SL = AttrLoc;
}
return SM.getLineAndColumn(SL);
}
if (Expr *E = Cursor->getAsExpr()) {
SourceLoc SL = E->getStartLoc();
return SM.getLineAndColumn(SL);
}
return std::make_pair(0, 0);
}
template <class T>
bool isStmtContext() {
if (Cursor == Stack.rend())
return false;
Stmt *ContextStmt = Cursor->getAsStmt();
return ContextStmt && isa<T>(ContextStmt);
}
bool isBraceContext() {
return isStmtContext<BraceStmt>();
}
bool isImplicitBraceContext() {
// If we're directly at the top, it's implicit.
if (Cursor == Stack.rend())
return true;
if (!isBraceContext())
return false;
auto Parent = parent();
// If the parent is directly at the top, it's implicit.
if (Parent.Cursor == Stack.rend())
return true;
// If we're within a case body, it's implicit.
// For example:
// case ...:
// case body is implicitly wrapped in a brace statement
if (Parent.isCaseContext())
return true;
return false;
}
bool isCaseContext() {
return isStmtContext<CaseStmt>();
}
bool isSwitchContext() {
return isStmtContext<SwitchStmt>();
}
std::pair<unsigned, unsigned> indentLineAndColumn() {
if (Cursor == Stack.rend())
return std::make_pair(0, 0);
// Get the line and indent position for this context.
auto LineAndColumn = lineAndColumn();
auto SavedCursor = Cursor;
// Walk up the context stack to find the topmost applicable context.
while (++Cursor != Stack.rend()) {
auto ParentLineAndColumn = lineAndColumn();
if (ParentLineAndColumn.second == 0)
break;
if (ParentLineAndColumn.first != LineAndColumn.first) {
// The start line is not the same, see if this is at the 'else' clause.
if (IfStmt *If = dyn_cast_or_null<IfStmt>(Cursor->getAsStmt())) {
SourceLoc ElseLoc = If->getElseLoc();
// If we're at 'else', take the indent of 'if' and continue.
if (ElseLoc.isValid() &&
LineAndColumn.first == SM.getLineAndColumn(ElseLoc).first) {
LineAndColumn = ParentLineAndColumn;
continue;
}
// If we are at conditions, take the indent of 'if' and continue.
for (auto Cond : If->getCond()) {
if (LineAndColumn.first == SM.getLineNumber(Cond.getEndLoc())) {
LineAndColumn = ParentLineAndColumn;
continue;
}
}
}
// No extra indentation level for getters without explicit names.
// e.g.
// public var someValue: Int {
// return 0; <- No indentation added because of the getter.
// }
if (auto VD = dyn_cast_or_null<VarDecl>(Cursor->getAsDecl())) {
if (auto Getter = VD->getGetter()) {
if (Getter->getAccessorKeywordLoc().isInvalid()) {
LineAndColumn = ParentLineAndColumn;
continue;
}
}
}
// Align with Func start instead of with param decls.
if (auto *FD = dyn_cast_or_null<AbstractFunctionDecl>(Cursor->getAsDecl())) {
if (LineAndColumn.first <= SM.getLineNumber(FD->getSignatureSourceRange().End)) {
LineAndColumn = ParentLineAndColumn;
continue;
}
}
// Break out if the line is no longer the same.
break;
}
LineAndColumn.second = ParentLineAndColumn.second;
}
Cursor = SavedCursor;
return LineAndColumn;
}
bool shouldAddIndentForLine(unsigned Line) {
if (Cursor == Stack.rend())
return false;
// Handle switch / case, indent unless at a case label.
if (CaseStmt *Case = dyn_cast_or_null<CaseStmt>(Cursor->getAsStmt())) {
auto LabelItems = Case->getCaseLabelItems();
SourceLoc Loc;
if (!LabelItems.empty())
Loc = LabelItems.back().getPattern()->getLoc();
if (Loc.isValid())
return Line > SM.getLineAndColumn(Loc).first;
return true;
}
if (isSwitchContext()) {
// If we're at the start of a case label, don't add indent.
// For example:
// switch ... {
// case xyz: <-- No indent here, should be at same level as switch.
Stmt *AtStmtStart = Start.getAsStmt();
if (AtStmtStart && isa<CaseStmt>(AtStmtStart))
return false;
// If we're at the open brace of the switch, don't add an indent.
// For example:
// switch ...
// { <-- No indent here, open brace should be at same level as switch.
auto *S = cast<SwitchStmt>(Cursor->getAsStmt());
if (SM.getLineAndColumn(S->getLBraceLoc()).first == Line)
return false;
if(IsInCommentLine()) {
for (auto Case : S->getCases()) {
// switch ...
// {
// // case comment <-- No indent here.
// case 0:
if (SM.getLineAndColumn(Case->swift::Stmt::getStartLoc()).first == Line + 1)
return false;
}
}
}
// If we're within an implicit brace context, don't add indent.
if (isImplicitBraceContext())
return false;
// If we're at the open brace of a no-name getter, don't add an indent.
// For example:
// public var someValue: Int
// { <- We add no indentation here.
// return 0
// }
if (auto FD = dyn_cast_or_null<FuncDecl>(Start.getAsDecl())) {
if(FD->isGetter() && FD->getAccessorKeywordLoc().isInvalid()) {
if(SM.getLineNumber(FD->getBody()->getLBraceLoc()) == Line)
return false;
}
}
// If we're at the beginning of a brace on a separate line in the context
// of anything other than BraceStmt, don't add an indent.
// For example:
// func foo()
// { <-- No indent here, open brace should be at same level as func.
Stmt *AtStmtStart = Start.getAsStmt();
if (AtStmtStart && isa<BraceStmt>(AtStmtStart) && !isBraceContext())
return false;
// If we're at the end of a brace on a separate line in the context
// of anything other than BraceStmt, don't add an indent.
// For example:
if (Stmt *AtStmtEnd = End.getAsStmt()) {
if (!isBraceContext()) {
// func foo() {
// } <-- No indent here, close brace should be at same level as func.
if (isa<BraceStmt>(AtStmtEnd))
return false;
// do {
// }
// catch {
// } <-- No indent here, close brace should be at same level as do.
// catch {
// }
if (isa<CatchStmt>(AtStmtEnd))
return false;
}
}
// If we're at the open brace of a NominalTypeDecl or ExtensionDecl,
// don't add an indent.
// For example:
// class Foo
// { <-- No indent here, open brace should be at same level as class.
auto *NTD = dyn_cast_or_null<NominalTypeDecl>(Cursor->getAsDecl());
if (NTD && SM.getLineAndColumn(NTD->getBraces().Start).first == Line)
return false;
auto *ETD = dyn_cast_or_null<ExtensionDecl>(Cursor->getAsDecl());
if (ETD && SM.getLineAndColumn(ETD->getBraces().Start).first == Line)
return false;
// If we are at the start of a trailing closure, do not add indentation.
// For example:
// foo(1)
// { <-- No indent here.
auto *TE = dyn_cast_or_null<TupleExpr>(Cursor->getAsExpr());
if (TE && TE->hasTrailingClosure() &&
SM.getLineNumber(TE->getElements().back()->getStartLoc()) == Line) {
return false;
}
// If we're in an IfStmt and at the 'else', don't add an indent.
IfStmt *If = dyn_cast_or_null<IfStmt>(Cursor->getAsStmt());
if (If && If->getElseLoc().isValid() &&
SM.getLineAndColumn(If->getElseLoc()).first == Line)
return false;
// If we're in a DoCatchStmt and at a 'catch', don't add an indent.
if (auto *DoCatchS = dyn_cast_or_null<DoCatchStmt>(Cursor->getAsStmt())) {
for (CatchStmt *CatchS : DoCatchS->getCatches()) {
SourceLoc Loc = CatchS->getCatchLoc();
if (Loc.isValid() && SM.getLineAndColumn(Loc).first == Line)
return false;
}
}
// If we're at the end of a closure, paren or tuple expr, and the context
// is a paren/tuple expr ending with that sub expression, and it ends on the
// same line, don't add an indent.
// For example:
// foo(x, {
// }) <-- No indent here, the paren expr for the call ends on the same line.
Expr *AtExprEnd = End.getAsExpr();
if (AtExprEnd && (isa<ClosureExpr>(AtExprEnd) ||
isa<ParenExpr>(AtExprEnd) ||
isa<TupleExpr>(AtExprEnd))) {
if (auto *Paren = dyn_cast_or_null<ParenExpr>(Cursor->getAsExpr())) {
auto *SubExpr = Paren->getSubExpr();
if (SubExpr && SubExpr == AtExprEnd &&
SM.getLineAndColumn(Paren->getEndLoc()).first == Line)
return false;
}
else if (auto *Tuple = dyn_cast_or_null<TupleExpr>(Cursor->getAsExpr())) {
auto SubExprs = Tuple->getElements();
if (!SubExprs.empty() && SubExprs.back() == AtExprEnd &&
SM.getLineAndColumn(Tuple->getEndLoc()).first == Line) {
return false;
}
} else if (auto *VD = dyn_cast_or_null<VarDecl>(Cursor->getAsDecl())) {
SourceLoc Loc = getVarDeclInitEnd(VD);
if (Loc.isValid() && SM.getLineNumber(Loc) == Line) {
return false;
}
}
}
// Indent another level from the outer context by default.
return true;
}
};
class FormatWalker: public ide::SourceEntityWalker {
typedef std::vector<Token>::iterator TokenIt;
class SiblingCollector {
SourceLoc FoundSibling;
SourceManager &SM;
std::vector<Token> &Tokens;
SourceLoc &TargetLoc;
TokenIt TI;
bool isImmediateAfterSeparator(SourceLoc End, tok Separator) {
auto BeforeE = [&]() {
return TI != Tokens.end() &&
!SM.isBeforeInBuffer(End, TI->getLoc());
};
if (!BeforeE())
return false;
for (; BeforeE(); TI ++);
if (TI == Tokens.end() || TI->getKind() != Separator)
return false;
auto SeparatorLoc = TI->getLoc();
TI ++;
if (TI == Tokens.end())
return false;
auto NextLoc = TI->getLoc();
return SM.isBeforeInBuffer(SeparatorLoc, TargetLoc) &&
!SM.isBeforeInBuffer(NextLoc, TargetLoc);
}
public:
SiblingCollector(SourceManager &SM, std::vector<Token> &Tokens,
SourceLoc &TargetLoc) : SM(SM), Tokens(Tokens),
TargetLoc(TargetLoc), TI(Tokens.begin()) {}
void collect(ASTNode Node) {
if (FoundSibling.isValid())
return;
SourceLoc PrevLoc;
auto FindAlignLoc = [&](SourceLoc Loc) {
if (PrevLoc.isValid() &&
SM.getLineNumber(PrevLoc) == SM.getLineNumber(Loc))
return PrevLoc;
return PrevLoc = Loc;
};
auto addPair = [&](SourceLoc EndLoc, SourceLoc AlignLoc, tok Separator) {
if (isImmediateAfterSeparator(EndLoc, Separator))
FoundSibling = AlignLoc;
};
if (auto AE = dyn_cast_or_null<ApplyExpr>(Node.dyn_cast<Expr *>())) {
collect(AE->getArg());
return;
}
if (auto PE = dyn_cast_or_null<ParenExpr>(Node.dyn_cast<Expr *>())) {
if (auto Sub = PE->getSubExpr()) {
addPair(Sub->getEndLoc(), FindAlignLoc(Sub->getStartLoc()),
tok::comma);
}
}
// Tuple elements are siblings.
if (auto TE = dyn_cast_or_null<TupleExpr>(Node.dyn_cast<Expr *>())) {
// Trailing closures are not considered siblings to other args.
unsigned EndAdjust = TE->hasTrailingClosure() ? 1 : 0;
for (unsigned I = 0, N = TE->getNumElements() - EndAdjust; I < N; I ++) {
addPair(TE->getElement(I)->getEndLoc(),
FindAlignLoc(TE->getElement(I)->getStartLoc()), tok::comma);
}
}
if (auto AFD = dyn_cast_or_null<AbstractFunctionDecl>(Node.dyn_cast<Decl*>())) {
// Generic type params are siblings to align.
if (auto GPL = AFD->getGenericParams()) {
const auto Params = GPL->getParams();
for (unsigned I = 0, N = Params.size(); I < N; I ++) {
addPair(Params[I]->getEndLoc(), FindAlignLoc(Params[I]->getStartLoc()),
tok::comma);
}
}
// Function parameters are siblings.
for (auto P : AFD->getBodyParamPatterns()) {
if (auto TU = dyn_cast<TuplePattern>(P)) {
for (unsigned I = 0, N = TU->getNumElements(); I < N; I ++) {
addPair(TU->getElement(I).getPattern()->getEndLoc(),
FindAlignLoc(TU->getElement(I).getLabelLoc()), tok::comma);
}
}
}
}
// Array/Dictionary elements are siblings to align with each other.
if (auto AE = dyn_cast_or_null<CollectionExpr>(Node.dyn_cast<Expr *>())) {
for (unsigned I = 0, N = AE->getNumElements(); I < N; I ++) {
addPair(AE->getElement(I)->getEndLoc(),
FindAlignLoc(AE->getElement(I)->getStartLoc()), tok::comma);
}
}
};
SourceLoc findSibling() {
return FoundSibling;
}
};
SourceFile &SF;
SourceManager &SM;
SourceLoc TargetLocation;
std::vector<swift::ASTWalker::ParentTy> Stack;
swift::ASTWalker::ParentTy AtStart;
swift::ASTWalker::ParentTy AtEnd;
bool InDocCommentBlock = false;
bool InCommentLine = false;
std::vector<Token> Tokens;
LangOptions Options;
TokenIt CurrentTokIt;
unsigned TargetLine;
SiblingCollector SCollector;
/// Sometimes, target is a part of "parent", for instance, "#else" is a part
/// of an ifconfigstmt, so that ifconfigstmt is not really the parent of "#else".
bool isTargetPartOf(swift::ASTWalker::ParentTy Parent) {
if(auto Conf = dyn_cast_or_null<IfConfigStmt>(Parent.getAsStmt())) {
for (auto Clause : Conf->getClauses()) {
if (Clause.Loc == TargetLocation)
return true;
}
} else if (auto Call = dyn_cast_or_null<CallExpr>(Parent.getAsExpr())) {
if(auto Clo = dyn_cast<ClosureExpr>(Call->getFn())) {
if (Clo->getBody()->getLBraceLoc() == TargetLocation ||
Clo->getBody()->getRBraceLoc() == TargetLocation) {
return true;
}
}
}
return false;
}
template <class T>
bool HandlePre(T* Node, SourceLoc Start, SourceLoc End) {
scanForComments(Start);
SCollector.collect(Node);
if (SM.isBeforeInBuffer(TargetLocation, Start))
return false; // Target is before start of Node, skip it.
if (SM.isBeforeInBuffer(End, TargetLocation))
return false; // Target is after end of Node, skip it.
if (TargetLocation == Start) {
// Target is right at the start of Node, mark it.
AtStart = Node;
return false;
}
if (TargetLocation == End) {
// Target is right at the end of Node, mark it.
AtEnd = Node;
return false;
}
// Target is within Node and Node is really the parent of Target, take it.
if (!isTargetPartOf(Node))
Stack.push_back(Node);
return true;
}
void scanForComments(SourceLoc Loc) {
if (InDocCommentBlock || InCommentLine)
return;
for (auto InValid = Loc.isInvalid(); CurrentTokIt != Tokens.end() &&
(InValid || SM.isBeforeInBuffer(CurrentTokIt->getLoc(), Loc));
CurrentTokIt ++) {
if (CurrentTokIt->getKind() == tok::comment) {
auto StartLine = SM.getLineNumber(CurrentTokIt->getRange().getStart());
auto EndLine = SM.getLineNumber(CurrentTokIt->getRange().getEnd());
auto TokenStr = CurrentTokIt->getRange().str();
InDocCommentBlock |= TargetLine > StartLine && TargetLine <= EndLine &&
TokenStr.startswith("/*");
InCommentLine |= StartLine == TargetLine && TokenStr.startswith("//");
}
}
}
template <typename T>
bool HandlePost(T* Node) {
if (SM.isBeforeInBuffer(TargetLocation, Node->getStartLoc()))
return false; // Target is before start of Node, terminate walking.
return true;
}
public:
explicit FormatWalker(SourceFile &SF, SourceManager &SM)
:SF(SF), SM(SM),
Tokens(tokenize(Options, SM, SF.getBufferID().getValue())),
CurrentTokIt(Tokens.begin()),
SCollector(SM, Tokens, TargetLocation) {}
FormatContext walkToLocation(SourceLoc Loc) {
Stack.clear();
TargetLocation = Loc;
TargetLine = SM.getLineNumber(TargetLocation);
AtStart = AtEnd = swift::ASTWalker::ParentTy();
walk(SF);
scanForComments(SourceLoc());
return FormatContext(SM, Stack, AtStart, AtEnd, InDocCommentBlock,
InCommentLine, SCollector.findSibling());
}
bool walkToDeclPre(Decl *D, CharSourceRange Range) override {
SourceLoc Start = D->getStartLoc();
SourceLoc End = D->getEndLoc();
if (auto *VD = dyn_cast<VarDecl>(D)) {
// We'll treat properties with accessors as spanning the braces as well.
// This will ensure we can do indentation inside the braces.
auto Loc = getVarDeclInitEnd(VD);
End = Loc.isValid() ? Loc : End;
}
return HandlePre(D, Start, End);
}
bool walkToDeclPost(Decl *D) override {
return HandlePost(D);
}
bool walkToStmtPre(Stmt *S) override {
return HandlePre(S, S->getStartLoc(), S->getEndLoc());
}
bool walkToStmtPost(Stmt *S) override {
return HandlePost(S);
}
bool walkToExprPre(Expr *E) override {
return HandlePre(E, E->getStartLoc(), E->getEndLoc());
}
bool walkToExprPost(Expr *E) override {
return HandlePost(E);
}
bool shouldWalkInactiveConfigRegion() override {
return true;
}
};
class CodeFormatter {
SwiftEditorDocument &Doc;
EditorConsumer &Consumer;
public:
CodeFormatter(SwiftEditorDocument &Doc, EditorConsumer& Consumer)
:Doc(Doc), Consumer(Consumer) { }
SwiftEditorLineRange indent(unsigned LineIndex, FormatContext &FC) {
auto &FmtOptions = Doc.getFormatOptions();
// If having sibling locs to align with, respect siblings.
if (FC.HasSibling()) {
StringRef Line = Doc.getTrimmedTextForLine(LineIndex);
StringBuilder Builder;
FC.padToSiblingColumn(Builder);
Builder.append(Line);
Consumer.recordFormattedText(Builder.str().str());
return SwiftEditorLineRange(LineIndex, 1);
}
// Take the current indent position of the outer context, then add another
// indent level if expected.
auto LineAndColumn = FC.indentLineAndColumn();
size_t ExpandedIndent = Doc.getExpandedIndentForLine(LineAndColumn.first);
auto AddIndentFunc = [&] () {
auto Width = FmtOptions.UseTabs ? FmtOptions.TabWidth
: FmtOptions.IndentWidth;
// Increment indent.
ExpandedIndent += Width;
// Normalize indent to align on proper column indent width.
ExpandedIndent -= ExpandedIndent % Width;
};
if (LineAndColumn.second > 0 && FC.shouldAddIndentForLine(LineIndex))
AddIndentFunc();
if (FC.IsInDocCommentBlock()) {
// Inside doc comment block, the indent is one space, e.g.
// /**
// * <---Indent to align with the first star.
// */
ExpandedIndent += 1;
}
// Reformat the specified line with the calculated indent.
StringRef Line = Doc.getTrimmedTextForLine(LineIndex);
std::string IndentedLine;
if (FmtOptions.UseTabs)
IndentedLine.assign(ExpandedIndent / FmtOptions.TabWidth, '\t');
else
IndentedLine.assign(ExpandedIndent, ' ');
IndentedLine.append(Line);
Consumer.recordFormattedText(IndentedLine);
// Return affected line range, which can later be more than one line.
return SwiftEditorLineRange(LineIndex, 1);
}
};
class PlaceholderExpansionScanner {
public:
struct Param {
CharSourceRange NameRange;
CharSourceRange TypeRange;
Param(CharSourceRange NameRange, CharSourceRange TypeRange)
:NameRange(NameRange), TypeRange(TypeRange) { }
};
private:
SourceManager &SM;
std::vector<Param> Params;
CharSourceRange ReturnTypeRange;
EditorPlaceholderExpr *PHE = nullptr;
class PlaceholderFinder: public ASTWalker {
SourceLoc PlaceholderLoc;
EditorPlaceholderExpr *&Found;
public:
PlaceholderFinder(SourceLoc PlaceholderLoc,
EditorPlaceholderExpr *&Found)
: PlaceholderLoc(PlaceholderLoc), Found(Found) {
}
std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
if (isa<EditorPlaceholderExpr>(E) && E->getStartLoc() == PlaceholderLoc) {
Found = cast<EditorPlaceholderExpr>(E);
return { false, nullptr };
}
return { true, E };
}
};
bool scanClosureType(SourceFile &SF, SourceLoc PlaceholderLoc) {
Params.clear();
ReturnTypeRange = CharSourceRange();
PlaceholderFinder Finder(PlaceholderLoc, PHE);
SF.walk(Finder);
if (!PHE || !PHE->getTypeForExpansion())
return false;
class ClosureTypeWalker: public ASTWalker {
public:
PlaceholderExpansionScanner &S;
bool FoundFunctionTypeRepr = false;
explicit ClosureTypeWalker(PlaceholderExpansionScanner &S)
:S(S) { }
bool walkToTypeReprPre(TypeRepr *T) override {
if (auto *FTR = dyn_cast<FunctionTypeRepr>(T)) {
FoundFunctionTypeRepr = true;
if (auto *TTR = dyn_cast_or_null<TupleTypeRepr>(FTR->getArgsTypeRepr())) {
for (auto *ArgTR : TTR->getElements()) {
CharSourceRange NR;
CharSourceRange TR;
auto *NTR = dyn_cast<NamedTypeRepr>(ArgTR);
if (NTR && NTR->hasName()) {
NR = CharSourceRange(NTR->getNameLoc(),
NTR->getName().getLength());
ArgTR = NTR->getTypeRepr();
}
SourceLoc SRE = Lexer::getLocForEndOfToken(S.SM,
ArgTR->getEndLoc());
TR = CharSourceRange(S.SM, ArgTR->getStartLoc(), SRE);
S.Params.emplace_back(NR, TR);
}
} else if (FTR->getArgsTypeRepr()) {
CharSourceRange TR;
TR = CharSourceRange(S.SM, FTR->getArgsTypeRepr()->getStartLoc(),
Lexer::getLocForEndOfToken(S.SM,
FTR->getArgsTypeRepr()->getEndLoc()));
S.Params.emplace_back(CharSourceRange(), TR);
}
if (auto *RTR = FTR->getResultTypeRepr()) {
SourceLoc SRE = Lexer::getLocForEndOfToken(S.SM, RTR->getEndLoc());
S.ReturnTypeRange = CharSourceRange(S.SM, RTR->getStartLoc(), SRE);
}
}
return !FoundFunctionTypeRepr;
}
bool walkToTypeReprPost(TypeRepr *T) override {
// If we just visited the FunctionTypeRepr, end traversal.
return !FoundFunctionTypeRepr;
}
} PW(*this);
PHE->getTypeForExpansion()->walk(PW);
return PW.FoundFunctionTypeRepr;
}
/// Finds the enclosing CallExpr, and indicates whether it should be further
/// considered a candidate for application of trailing closure.
/// For example, if the CallExpr is enclosed in another expression or statement
/// such as "outer(inner(<#closure#>))", or "if inner(<#closure#>)", then trailing
/// closure should not be applied to the inner call.
std::pair<CallExpr *, bool> enclosingCallExpr(SourceFile &SF, SourceLoc SL) {
class CallExprFinder: public ide::SourceEntityWalker {
public:
const SourceManager &SM;
SourceLoc TargetLoc;
CallExpr *EnclosingCall;
Expr *OuterExpr;
Stmt *OuterStmt;
explicit CallExprFinder(const SourceManager &SM)
:SM(SM) { }
bool walkToExprPre(Expr *E) override {
auto SR = E->getSourceRange();
if (SR.isValid() && SM.rangeContainsTokenLoc(SR, TargetLoc)) {
if (auto *CE = dyn_cast<CallExpr>(E)) {
if (EnclosingCall)
OuterExpr = EnclosingCall;
EnclosingCall = CE;
}
else if (!EnclosingCall)
OuterExpr = E;
}
return true;
}
bool walkToExprPost(Expr *E) override {
if (E->getStartLoc() == TargetLoc)
return false; // found what we needed to find, stop walking.
return true;
}
bool walkToStmtPre(Stmt *S) override {
auto SR = S->getSourceRange();
if (SR.isValid() && SM.rangeContainsTokenLoc(SR, TargetLoc)) {
if(!EnclosingCall && !isa<BraceStmt>(S))
OuterStmt = S;
}
return true;
}
CallExpr *findEnclosingCall(SourceFile &SF, SourceLoc SL) {
EnclosingCall = nullptr;
OuterExpr = nullptr;
OuterStmt = nullptr;
TargetLoc = SL;
walk(SF);
return EnclosingCall;
}
};
CallExprFinder CEFinder(SM);
auto *CE = CEFinder.findEnclosingCall(SF, SL);
if (!CE)
return std::make_pair(CE, false);
if (CEFinder.OuterExpr)
return std::make_pair(CE, false);
if (CEFinder.OuterStmt)
return std::make_pair(CE, false);
return std::make_pair(CE, true);
}
public:
explicit PlaceholderExpansionScanner(SourceManager &SM) : SM(SM) { }
/// Retrieves the parameter list, return type and context info for
/// a typed completion placeholder in a function call.
/// For example: foo.bar(aaa, <#T##(Int, Int) -> Bool#>).
bool scan(SourceFile &SF, unsigned BufID, unsigned Offset,
unsigned Length, std::function<void(Expr *Args,
bool UseTrailingClosure,
ArrayRef<Param>,
CharSourceRange)> Callback,
std::function<bool(EditorPlaceholderExpr*)> NonClosureCallback) {
SourceLoc PlaceholderStartLoc = SM.getLocForOffset(BufID, Offset);
// See if the placeholder is encapsulated with an EditorPlaceholderExpr
// and retrieve parameter and return type ranges.
if (!scanClosureType(SF, PlaceholderStartLoc)) {
return NonClosureCallback(PHE);
}
// Now we need to see if we can suggest trailing closure expansion,
// and if the call parens can be removed in that case.
// We'll first find the enclosing CallExpr, and then do further analysis.
bool UseTrailingClosure = false;
std::pair<CallExpr*, bool> ECE = enclosingCallExpr(SF, PlaceholderStartLoc);
Expr *Args = ECE.first ? ECE.first->getArg() : nullptr;
if (Args && ECE.second) {
if (isa<ParenExpr>(Args)) {
UseTrailingClosure = true;
} else if (auto *TE = dyn_cast<TupleExpr>(Args)) {
if (!TE->getElements().empty())
UseTrailingClosure =
TE->getElements().back()->getStartLoc() == PlaceholderStartLoc;
}
}
Callback(Args, UseTrailingClosure, Params, ReturnTypeRange);
return true;
}
};
} // anonymous namespace
SwiftEditorDocument::SwiftEditorDocument(StringRef FilePath,
SwiftLangSupport &LangSupport)
:Impl(*new Implementation(FilePath, LangSupport)) { }
SwiftEditorDocument::~SwiftEditorDocument()
{
delete &Impl;
}
ImmutableTextSnapshotRef SwiftEditorDocument::initializeText(
llvm::MemoryBuffer *Buf, ArrayRef<const char *> Args) {
llvm::sys::ScopedLock L(Impl.AccessMtx);
Impl.EditableBuffer =
new EditableTextBuffer(Impl.FilePath, Buf->getBuffer());
Impl.SyntaxMap.reset();
Impl.EditedLineRange.setRange(0,0);
Impl.AffectedRange = std::make_pair(0, Buf->getBufferSize());
Impl.SemanticInfo =
new SwiftDocumentSemanticInfo(Impl.FilePath, Impl.LangSupport);
Impl.SemanticInfo->setCompilerArgs(Args);
return Impl.EditableBuffer->getSnapshot();
}
ImmutableTextSnapshotRef SwiftEditorDocument::replaceText(
unsigned int Offset, unsigned int Length, llvm::MemoryBuffer *Buf,
bool ProvideSemanticInfo) {
llvm::sys::ScopedLock L(Impl.AccessMtx);
llvm::StringRef Str = Buf->getBuffer();
ImmutableTextSnapshotRef Snapshot =
Impl.EditableBuffer->replace(Offset, Length, Str);
if (ProvideSemanticInfo) {
// If this is not a no-op, update semantic info.
if (Length != 0 || Buf->getBufferSize() != 0) {
updateSemaInfo();
if (auto Invok = Impl.SemanticInfo->getInvocation()) {
// Update semantic info for open editor documents of the same module.
// FIXME: Detect edits that don't affect other files, e.g. whitespace,
// comments, inside a function body, etc.
CompilerInvocation CI;
Invok->applyTo(CI);
auto &EditorDocs = Impl.LangSupport.getEditorDocuments();
for (auto &Input : CI.getInputFilenames()) {
if (auto EditorDoc = EditorDocs.findByPath(Input)) {
if (EditorDoc.get() != this)
EditorDoc->updateSemaInfo();
}
}
}
}
}
SourceManager &SrcManager = Impl.SyntaxInfo->getSourceManager();
unsigned BufID = Impl.SyntaxInfo->getBufferID();
SourceLoc StartLoc = SrcManager.getLocForBufferStart(BufID).getAdvancedLoc(
Offset);
unsigned StartLine = SrcManager.getLineAndColumn(StartLoc).first;
unsigned EndLine = SrcManager.getLineAndColumn(
StartLoc.getAdvancedLoc(Length)).first;
// Delete all syntax map data from start line through end line.
unsigned OldLineCount = EndLine - StartLine + 1;
Impl.SyntaxMap.removeLineRange(StartLine, OldLineCount);
// Insert empty syntax map data for replaced lines.
unsigned NewLineCount = Str.count('\n') + 1;
Impl.SyntaxMap.insertLineRange(StartLine, NewLineCount);
// Update the edited line range.
Impl.EditedLineRange.setRange(StartLine, NewLineCount);
ImmutableTextBufferRef ImmBuf = Snapshot->getBuffer();
// The affected range starts from the previous newline.
if (Offset > 0) {
auto AffectedRangeOffset = ImmBuf->getText().rfind('\n', Offset);
Impl.AffectedRange.first =
AffectedRangeOffset != StringRef::npos ? AffectedRangeOffset + 1 : 0;
}
else
Impl.AffectedRange.first = 0;
Impl.AffectedRange.second = ImmBuf->getText().size() - Impl.AffectedRange.first;
return Snapshot;
}
void SwiftEditorDocument::updateSemaInfo() {
if (auto SemaInfo = Impl.SemanticInfo) {
Impl.SemanticInfo->processLatestSnapshotAsync(Impl.EditableBuffer);
}
}
void SwiftEditorDocument::parse(ImmutableTextSnapshotRef Snapshot,
SwiftLangSupport &Lang) {
llvm::sys::ScopedLock L(Impl.AccessMtx);
assert(Impl.SemanticInfo && "Impl.SemanticInfo must be set");
std::vector<std::string> Args;
std::string PrimaryFile; // Ignored, Impl.FilePath will be used
CompilerInvocation CompInv;
if (Impl.SemanticInfo->getInvocation()) {
Impl.SemanticInfo->getInvocation()->applyTo(CompInv);
Impl.SemanticInfo->getInvocation()->raw(Args, PrimaryFile);
} else {
ArrayRef<const char *> Args;
std::string Error;
// Ignore possible error(s)
Lang.getASTManager().
initCompilerInvocation(CompInv, Args, StringRef(), Error);
}
// Access to Impl.SyntaxInfo is guarded by Impl.AccessMtx
Impl.SyntaxInfo.reset(
new SwiftDocumentSyntaxInfo(CompInv, Snapshot, Args, Impl.FilePath));
Impl.SyntaxInfo->parse();
}
void SwiftEditorDocument::readSyntaxInfo(EditorConsumer &Consumer) {
llvm::sys::ScopedLock L(Impl.AccessMtx);
trace::TracedOperation TracedOp;
if (trace::enabled()) {
trace::SwiftInvocation Info;
Impl.buildSwiftInv(Info);
TracedOp.start(trace::OperationKind::ReadSyntaxInfo, Info);
}
Impl.ParserDiagnostics = Impl.SyntaxInfo->getDiagnostics();
ide::SyntaxModelContext ModelContext(Impl.SyntaxInfo->getSourceFile());
SwiftEditorSyntaxWalker SyntaxWalker(Impl.SyntaxMap,
Impl.EditedLineRange,
Impl.AffectedRange,
Impl.SyntaxInfo->getSourceManager(),
Consumer,
Impl.SyntaxInfo->getBufferID());
ModelContext.walk(SyntaxWalker);
Consumer.recordAffectedRange(Impl.AffectedRange.first,
Impl.AffectedRange.second);
}
void SwiftEditorDocument::readSemanticInfo(ImmutableTextSnapshotRef Snapshot,
EditorConsumer& Consumer) {
trace::TracedOperation TracedOp;
if (trace::enabled()) {
trace::SwiftInvocation Info;
Impl.buildSwiftInv(Info);
TracedOp.start(trace::OperationKind::ReadSemanticInfo, Info);
}
std::vector<SwiftSemanticToken> SemaToks;
std::vector<DiagnosticEntryInfo> SemaDiags;
// FIXME: Parser diagnostics should be filtered out of the semantic ones,
// Then just merge the semantic ones with the current parse ones.
Impl.SemanticInfo->readSemanticInfo(Snapshot, SemaToks, SemaDiags,
Impl.ParserDiagnostics);
for (auto SemaTok : SemaToks) {
unsigned Offset = SemaTok.ByteOffset;
unsigned Length = SemaTok.Length;
UIdent Kind = SemaTok.getUIdentForKind();
bool IsSystem = SemaTok.IsSystem;
if (Kind.isValid())
if (!Consumer.handleSemanticAnnotation(Offset, Length, Kind, IsSystem))
break;
}
static UIdent SemaDiagStage("source.diagnostic.stage.swift.sema");
static UIdent ParseDiagStage("source.diagnostic.stage.swift.parse");
if (!SemaDiags.empty() || !SemaToks.empty()) {
Consumer.setDiagnosticStage(SemaDiagStage);
} else {
Consumer.setDiagnosticStage(ParseDiagStage);
}
for (auto &Diag : Impl.ParserDiagnostics)
Consumer.handleDiagnostic(Diag, ParseDiagStage);
for (auto &Diag : SemaDiags)
Consumer.handleDiagnostic(Diag, SemaDiagStage);
}
void SwiftEditorDocument::removeCachedAST() {
Impl.SemanticInfo->removeCachedAST();
}
void SwiftEditorDocument::applyFormatOptions(OptionsDictionary &FmtOptions) {
static UIdent KeyUseTabs("key.editor.format.usetabs");
static UIdent KeyIndentWidth("key.editor.format.indentwidth");
static UIdent KeyTabWidth("key.editor.format.tabwidth");
FmtOptions.valueForOption(KeyUseTabs, Impl.FormatOptions.UseTabs);
FmtOptions.valueForOption(KeyIndentWidth, Impl.FormatOptions.IndentWidth);
FmtOptions.valueForOption(KeyTabWidth, Impl.FormatOptions.TabWidth);
}
const
SwiftEditorDocument::CodeFormatOptions &SwiftEditorDocument::getFormatOptions() {
return Impl.FormatOptions;
}
void SwiftEditorDocument::formatText(unsigned Line, unsigned Length,
EditorConsumer &Consumer) {
auto SyntaxInfo = Impl.getSyntaxInfo();
SourceFile &SF = SyntaxInfo->getSourceFile();
SourceManager &SM = SyntaxInfo->getSourceManager();
unsigned BufID = SyntaxInfo->getBufferID();
trace::TracedOperation TracedOp;
if (trace::enabled()) {
trace::SwiftInvocation SwiftArgs;
// Compiler arguments do not matter
auto Buf = SM.getLLVMSourceMgr().getMemoryBuffer(BufID);
SwiftArgs.Args.PrimaryFile = Buf->getBufferIdentifier();
SwiftArgs.addFile(SwiftArgs.Args.PrimaryFile, Buf->getBuffer());
trace::StringPairs OpArgs = {
std::make_pair("Line", std::to_string(Line)),
std::make_pair("Length", std::to_string(Length)),
std::make_pair("IndentWidth",
std::to_string(Impl.FormatOptions.IndentWidth)),
std::make_pair("TabWidth",
std::to_string(Impl.FormatOptions.TabWidth)),
std::make_pair("UseTabs",
std::to_string(Impl.FormatOptions.UseTabs))};
TracedOp.start(trace::OperationKind::FormatText, SwiftArgs, OpArgs);
}
FormatWalker walker(SF, SM);
size_t Offset = getTrimmedLineOffset(Line);
SourceLoc Loc = SM.getLocForBufferStart(BufID).getAdvancedLoc(Offset);
FormatContext FC = walker.walkToLocation(Loc);
CodeFormatter CF(*this, Consumer);
SwiftEditorLineRange LineRange = CF.indent(Line, FC);
Consumer.recordAffectedLineRange(LineRange.startLine(), LineRange.lineCount());
}
bool isReturningVoid(SourceManager &SM, CharSourceRange Range) {
if (Range.isInvalid())
return false;
StringRef Text = SM.extractText(Range);
return "()" == Text || "Void" == Text;
}
void SwiftEditorDocument::expandPlaceholder(unsigned Offset, unsigned Length,
EditorConsumer &Consumer) {
auto SyntaxInfo = Impl.getSyntaxInfo();
SourceManager &SM = SyntaxInfo->getSourceManager();
unsigned BufID = SyntaxInfo->getBufferID();
const unsigned PlaceholderStartLen = 2;
const unsigned PlaceholderEndLen = 2;
if (Length < (PlaceholderStartLen + PlaceholderEndLen)) {
Consumer.handleRequestError("Invalid Length parameter");
return;
}
trace::TracedOperation TracedOp;
if (trace::enabled()) {
trace::SwiftInvocation SwiftArgs;
SyntaxInfo->initArgsAndPrimaryFile(SwiftArgs);
auto Buf = SM.getLLVMSourceMgr().getMemoryBuffer(BufID);
SwiftArgs.addFile(Buf->getBufferIdentifier(), Buf->getBuffer());
trace::StringPairs OpArgs = {
std::make_pair("Offset", std::to_string(Offset)),
std::make_pair("Length", std::to_string(Length))};
TracedOp.start(trace::OperationKind::ExpandPlaceholder, SwiftArgs, OpArgs);
}
PlaceholderExpansionScanner Scanner(SM);
SourceFile &SF = SyntaxInfo->getSourceFile();
Scanner.scan(SF, BufID, Offset, Length,
[&](Expr *Args,
bool UseTrailingClosure,
ArrayRef<PlaceholderExpansionScanner::Param> ClosureParams,
CharSourceRange ClosureReturnTypeRange) {
unsigned EffectiveOffset = Offset;
unsigned EffectiveLength = Length;
llvm::SmallString<128> ExpansionStr;
{
llvm::raw_svector_ostream OS(ExpansionStr);
if (UseTrailingClosure) {
assert(Args);
if (isa<ParenExpr>(Args)) {
// There appears to be no other parameters in this call, so we'll
// expand replacement for trailing closure and cover call parens.
// For example:
// foo.bar(<#closure#>) turns into foo.bar <#closure#>.
EffectiveOffset = SM.getLocOffsetInBuffer(Args->getStartLoc(), BufID);
OS << " ";
} else {
auto *TupleE = cast<TupleExpr>(Args);
auto Elems = TupleE->getElements();
assert(!Elems.empty());
if (Elems.size() == 1) {
EffectiveOffset = SM.getLocOffsetInBuffer(Args->getStartLoc(), BufID);
OS << " ";
} else {
// Expand replacement range for trailing closure.
// For example:
// foo.bar(a, <#closure#>) turns into foo.bar(a) <#closure#>.
// If the preceding token in the call is the leading parameter
// separator, we'll expand replacement to cover that.
assert(Elems.size() > 1);
SourceLoc BeforeLoc = Lexer::getLocForEndOfToken(SM,
Elems[Elems.size()-2]->getEndLoc());
EffectiveOffset = SM.getLocOffsetInBuffer(BeforeLoc, BufID);
OS << ") ";
}
}
unsigned End = SM.getLocOffsetInBuffer(Args->getEndLoc(), BufID);
EffectiveLength = (End + 1) - EffectiveOffset;
}
OS << "{ ";
bool ReturningVoid = isReturningVoid(SM, ClosureReturnTypeRange);
bool HasSignature = !ClosureParams.empty() ||
(ClosureReturnTypeRange.isValid() && !ReturningVoid);
bool FirstParam = true;
if (HasSignature)
OS << "(";
for (auto &Param: ClosureParams) {
if (!FirstParam)
OS << ", ";
FirstParam = false;
if (Param.NameRange.isValid()) {
// If we have a parameter name, just output the name as is and skip
// the type. For example:
// <#(arg1: Int, arg2: Int)#> turns into (arg1, arg2).
OS << SM.extractText(Param.NameRange);
}
else {
// If we only have the parameter type, output the type as a
// placeholder. For example:
// <#(Int, Int)#> turns into (<#Int#>, <#Int#>).
OS << "<#";
OS << SM.extractText(Param.TypeRange);
OS << "#>";
}
}
if (HasSignature)
OS << ") ";
if (ClosureReturnTypeRange.isValid()) {
auto ReturnTypeText = SM.extractText(ClosureReturnTypeRange);
// We need return type if it is not Void.
if (!ReturningVoid) {
OS << "-> ";
OS << ReturnTypeText << " ";
}
}
if (HasSignature)
OS << "in";
OS << "\n<#code#>\n";
OS << "}";
}
Consumer.handleSourceText(ExpansionStr);
Consumer.recordAffectedRange(EffectiveOffset, EffectiveLength);
}, [&](EditorPlaceholderExpr *PHE) {
if (!PHE)
return false;
if (auto Ty = PHE->getTypeForExpansion()) {
std::string S;
llvm::raw_string_ostream OS(S);
Ty->print(OS);
Consumer.handleSourceText(OS.str());
Consumer.recordAffectedRange(Offset, Length);
return true;
}
return false;
});
}
size_t SwiftEditorDocument::getLineOffset(unsigned LineIndex) {
StringRef Text = Impl.EditableBuffer->getBuffer()->getText();
// FIXME: We should have a cached line map in EditableTextBuffer, for now
// we just do the slow naive thing here.
size_t LineOffset = 0;
unsigned CurrentLine = 0;
while (LineOffset < Text.size() && ++CurrentLine < LineIndex) {
LineOffset = Text.find_first_of("\r\n", LineOffset);
if (LineOffset != std::string::npos) {
++LineOffset;
if (LineOffset < Text.size() &&
Text[LineOffset - 1] == '\r' && Text[LineOffset] == '\n')
++LineOffset;
}
}
if (LineOffset == std::string::npos)
LineOffset = 0;
return LineOffset;
}
size_t SwiftEditorDocument::getTrimmedLineOffset(unsigned LineIndex) {
size_t LineOffset = getLineOffset(LineIndex);
// Skip leading whitespace.
StringRef Text = Impl.EditableBuffer->getBuffer()->getText();
size_t FirstNonWSOnLine = Text.find_first_not_of(" \t\v\f", LineOffset);
if (FirstNonWSOnLine != std::string::npos)
LineOffset = FirstNonWSOnLine;
return LineOffset;
}
size_t SwiftEditorDocument::getExpandedIndentForLine(unsigned LineIndex) {
size_t LineOffset = getLineOffset(LineIndex);
// Tab-expand all leading whitespace
StringRef Text = Impl.EditableBuffer->getBuffer()->getText();
size_t FirstNonWSOnLine = Text.find_first_not_of(" \t\v\f", LineOffset);
size_t Indent = 0;
while (LineOffset < Text.size() && LineOffset < FirstNonWSOnLine) {
if (Text[LineOffset++] == '\t')
Indent += Impl.FormatOptions.TabWidth;
else
Indent += 1;
}
return Indent;
}
StringRef SwiftEditorDocument::getTrimmedTextForLine(unsigned LineIndex) {
StringRef Text = Impl.EditableBuffer->getBuffer()->getText();
size_t LineOffset = getTrimmedLineOffset(LineIndex);
size_t LineEnd = Text.find_first_of("\r\n", LineOffset);
return Text.slice(LineOffset, LineEnd);
}
ImmutableTextSnapshotRef SwiftEditorDocument::getLatestSnapshot() const {
return Impl.EditableBuffer->getSnapshot();
}
void SwiftEditorDocument::reportDocumentStructure(swift::SourceFile &SrcFile,
EditorConsumer &Consumer) {
ide::SyntaxModelContext ModelContext(SrcFile);
SwiftDocumentStructureWalker Walker(SrcFile.getASTContext().SourceMgr,
*SrcFile.getBufferID(),
Consumer);
ModelContext.walk(Walker);
}
//============================================================================//
// EditorOpen
//============================================================================//
void SwiftLangSupport::editorOpen(StringRef Name, llvm::MemoryBuffer *Buf,
bool EnableSyntaxMap,
EditorConsumer &Consumer,
ArrayRef<const char *> Args) {
ImmutableTextSnapshotRef Snapshot = nullptr;
auto EditorDoc = EditorDocuments.getByUnresolvedName(Name);
if (!EditorDoc) {
EditorDoc = new SwiftEditorDocument(Name, *this);
Snapshot = EditorDoc->initializeText(Buf, Args);
EditorDoc->parse(Snapshot, *this);
if (EditorDocuments.getOrUpdate(Name, *this, EditorDoc)) {
// Document already exists, re-initialize it. This should only happen
// if we get OPEN request while the previous document is not closed.
LOG_WARN_FUNC("Document already exists in editorOpen(..): " << Name);
Snapshot = nullptr;
}
}
if (!Snapshot) {
Snapshot = EditorDoc->initializeText(Buf, Args);
EditorDoc->parse(Snapshot, *this);
}
if (Consumer.needsSemanticInfo()) {
EditorDoc->updateSemaInfo();
}
EditorDoc->readSyntaxInfo(Consumer);
EditorDoc->readSemanticInfo(Snapshot, Consumer);
}
//============================================================================//
// EditorClose
//============================================================================//
void SwiftLangSupport::editorClose(StringRef Name, bool RemoveCache) {
auto Removed = EditorDocuments.remove(Name);
if (!Removed)
IFaceGenContexts.remove(Name);
if (Removed && RemoveCache)
Removed->removeCachedAST();
// FIXME: Report error if Name did not apply to anything ?
}
//============================================================================//
// EditorReplaceText
//============================================================================//
void SwiftLangSupport::editorReplaceText(StringRef Name, llvm::MemoryBuffer *Buf,
unsigned Offset, unsigned Length,
EditorConsumer &Consumer) {
auto EditorDoc = EditorDocuments.getByUnresolvedName(Name);
if (!EditorDoc) {
Consumer.handleRequestError("No associated Editor Document");
return;
}
ImmutableTextSnapshotRef Snapshot;
if (Length != 0 || Buf->getBufferSize() != 0) {
Snapshot = EditorDoc->replaceText(Offset, Length, Buf,
Consumer.needsSemanticInfo());
assert(Snapshot);
EditorDoc->parse(Snapshot, *this);
EditorDoc->readSyntaxInfo(Consumer);
} else {
Snapshot = EditorDoc->getLatestSnapshot();
}
EditorDoc->readSemanticInfo(Snapshot, Consumer);
}
//============================================================================//
// EditorFormatText
//============================================================================//
void SwiftLangSupport::editorApplyFormatOptions(StringRef Name,
OptionsDictionary &FmtOptions) {
auto EditorDoc = EditorDocuments.getByUnresolvedName(Name);
if (EditorDoc)
EditorDoc->applyFormatOptions(FmtOptions);
}
void SwiftLangSupport::editorFormatText(StringRef Name, unsigned Line,
unsigned Length,
EditorConsumer &Consumer) {
auto EditorDoc = EditorDocuments.getByUnresolvedName(Name);
if (!EditorDoc) {
Consumer.handleRequestError("No associated Editor Document");
return;
}
EditorDoc->formatText(Line, Length, Consumer);
}
void SwiftLangSupport::editorExtractTextFromComment(StringRef Source,
EditorConsumer &Consumer) {
Consumer.handleSourceText(extractPlainTextFromComment(Source));
}
//============================================================================//
// EditorExpandPlaceholder
//============================================================================//
void SwiftLangSupport::editorExpandPlaceholder(StringRef Name, unsigned Offset,
unsigned Length,
EditorConsumer &Consumer) {
auto EditorDoc = EditorDocuments.getByUnresolvedName(Name);
if (!EditorDoc) {
Consumer.handleRequestError("No associated Editor Document");
return;
}
EditorDoc->expandPlaceholder(Offset, Length, Consumer);
}
Reference in New Issue View Git Blame Copy Permalink