1//===--- SourceCode.h - Manipulating source code as strings -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8#include "SourceCode.h"
9
10#include "FuzzyMatch.h"
11#include "Preamble.h"
12#include "Protocol.h"
13#include "support/Context.h"
14#include "support/Logger.h"
15#include "clang/Basic/FileEntry.h"
16#include "clang/Basic/LangOptions.h"
17#include "clang/Basic/SourceLocation.h"
18#include "clang/Basic/SourceManager.h"
19#include "clang/Basic/TokenKinds.h"
20#include "clang/Driver/Types.h"
21#include "clang/Format/Format.h"
22#include "clang/Lex/Lexer.h"
23#include "clang/Lex/Preprocessor.h"
24#include "clang/Lex/Token.h"
25#include "clang/Tooling/Core/Replacement.h"
26#include "clang/Tooling/Syntax/Tokens.h"
27#include "llvm/ADT/ArrayRef.h"
28#include "llvm/ADT/BitVector.h"
29#include "llvm/ADT/STLExtras.h"
30#include "llvm/ADT/StringExtras.h"
31#include "llvm/ADT/StringMap.h"
32#include "llvm/ADT/StringRef.h"
33#include "llvm/Support/Compiler.h"
34#include "llvm/Support/Errc.h"
35#include "llvm/Support/Error.h"
36#include "llvm/Support/ErrorHandling.h"
37#include "llvm/Support/LineIterator.h"
38#include "llvm/Support/MemoryBuffer.h"
39#include "llvm/Support/Path.h"
40#include "llvm/Support/VirtualFileSystem.h"
41#include "llvm/Support/xxhash.h"
42#include <algorithm>
43#include <cstddef>
44#include <optional>
45#include <string>
46#include <vector>
47
48namespace clang {
49namespace clangd {
50
51// Here be dragons. LSP positions use columns measured in *UTF-16 code units*!
52// Clangd uses UTF-8 and byte-offsets internally, so conversion is nontrivial.
53
54// Iterates over unicode codepoints in the (UTF-8) string. For each,
55// invokes CB(UTF-8 length, UTF-16 length), and breaks if it returns true.
56// Returns true if CB returned true, false if we hit the end of string.
57//
58// If the string is not valid UTF-8, we log this error and "decode" the
59// text in some arbitrary way. This is pretty sad, but this tends to happen deep
60// within indexing of headers where clang misdetected the encoding, and
61// propagating the error all the way back up is (probably?) not be worth it.
62template <typename Callback>
63static bool iterateCodepoints(llvm::StringRef U8, const Callback &CB) {
64 bool LoggedInvalid = false;
65 // A codepoint takes two UTF-16 code unit if it's astral (outside BMP).
66 // Astral codepoints are encoded as 4 bytes in UTF-8, starting with 11110xxx.
67 for (size_t I = 0; I < U8.size();) {
68 unsigned char C = static_cast<unsigned char>(U8[I]);
69 if (LLVM_LIKELY(!(C & 0x80))) { // ASCII character.
70 if (CB(1, 1))
71 return true;
72 ++I;
73 continue;
74 }
75 // This convenient property of UTF-8 holds for all non-ASCII characters.
76 size_t UTF8Length = llvm::countl_one(C);
77 // 0xxx is ASCII, handled above. 10xxx is a trailing byte, invalid here.
78 // 11111xxx is not valid UTF-8 at all, maybe some ISO-8859-*.
79 if (LLVM_UNLIKELY(UTF8Length < 2 || UTF8Length > 4)) {
80 if (!LoggedInvalid) {
81 elog("File has invalid UTF-8 near offset {0}: {1}", I, llvm::toHex(U8));
82 LoggedInvalid = true;
83 }
84 // We can't give a correct result, but avoid returning something wild.
85 // Pretend this is a valid ASCII byte, for lack of better options.
86 // (Too late to get ISO-8859-* right, we've skipped some bytes already).
87 if (CB(1, 1))
88 return true;
89 ++I;
90 continue;
91 }
92 I += UTF8Length; // Skip over all trailing bytes.
93 // A codepoint takes two UTF-16 code unit if it's astral (outside BMP).
94 // Astral codepoints are encoded as 4 bytes in UTF-8 (11110xxx ...)
95 if (CB(UTF8Length, UTF8Length == 4 ? 2 : 1))
96 return true;
97 }
98 return false;
99}
100
101// Returns the byte offset into the string that is an offset of \p Units in
102// the specified encoding.
103// Conceptually, this converts to the encoding, truncates to CodeUnits,
104// converts back to UTF-8, and returns the length in bytes.
105static size_t measureUnits(llvm::StringRef U8, int Units, OffsetEncoding Enc,
106 bool &Valid) {
107 Valid = Units >= 0;
108 if (Units <= 0)
109 return 0;
110 size_t Result = 0;
111 switch (Enc) {
112 case OffsetEncoding::UTF8:
113 Result = Units;
114 break;
115 case OffsetEncoding::UTF16:
116 Valid = iterateCodepoints(U8, [&](int U8Len, int U16Len) {
117 Result += U8Len;
118 Units -= U16Len;
119 return Units <= 0;
120 });
121 if (Units < 0) // Offset in the middle of a surrogate pair.
122 Valid = false;
123 break;
124 case OffsetEncoding::UTF32:
125 Valid = iterateCodepoints(U8, [&](int U8Len, int U16Len) {
126 Result += U8Len;
127 Units--;
128 return Units <= 0;
129 });
130 break;
131 case OffsetEncoding::UnsupportedEncoding:
132 llvm_unreachable("unsupported encoding");
133 }
134 // Don't return an out-of-range index if we overran.
135 if (Result > U8.size()) {
136 Valid = false;
137 return U8.size();
138 }
139 return Result;
140}
141
142Key<OffsetEncoding> kCurrentOffsetEncoding;
143static OffsetEncoding lspEncoding() {
144 auto *Enc = Context::current().get(kCurrentOffsetEncoding);
145 return Enc ? *Enc : OffsetEncoding::UTF16;
146}
147
148// Like most strings in clangd, the input is UTF-8 encoded.
149size_t lspLength(llvm::StringRef Code) {
150 size_t Count = 0;
151 switch (lspEncoding()) {
152 case OffsetEncoding::UTF8:
153 Count = Code.size();
154 break;
155 case OffsetEncoding::UTF16:
156 iterateCodepoints(Code, [&](int U8Len, int U16Len) {
157 Count += U16Len;
158 return false;
159 });
160 break;
161 case OffsetEncoding::UTF32:
162 iterateCodepoints(Code, [&](int U8Len, int U16Len) {
163 ++Count;
164 return false;
165 });
166 break;
167 case OffsetEncoding::UnsupportedEncoding:
168 llvm_unreachable("unsupported encoding");
169 }
170 return Count;
171}
172
173llvm::Expected<size_t> positionToOffset(llvm::StringRef Code, Position P,
174 bool AllowColumnsBeyondLineLength) {
175 if (P.line < 0)
176 return error(llvm::errc::invalid_argument,
177 "Line value can't be negative ({0})", P.line);
178 if (P.character < 0)
179 return error(llvm::errc::invalid_argument,
180 "Character value can't be negative ({0})", P.character);
181 size_t StartOfLine = 0;
182 for (int I = 0; I != P.line; ++I) {
183 size_t NextNL = Code.find('\n', StartOfLine);
184 if (NextNL == llvm::StringRef::npos)
185 return error(llvm::errc::invalid_argument,
186 "Line value is out of range ({0})", P.line);
187 StartOfLine = NextNL + 1;
188 }
189 StringRef Line =
190 Code.substr(StartOfLine).take_until([](char C) { return C == '\n'; });
191
192 // P.character may be in UTF-16, transcode if necessary.
193 bool Valid;
194 size_t ByteInLine = measureUnits(Line, P.character, lspEncoding(), Valid);
195 if (!Valid && !AllowColumnsBeyondLineLength)
196 return error(llvm::errc::invalid_argument,
197 "{0} offset {1} is invalid for line {2}", lspEncoding(),
198 P.character, P.line);
199 return StartOfLine + ByteInLine;
200}
201
202Position offsetToPosition(llvm::StringRef Code, size_t Offset) {
203 Offset = std::min(Code.size(), Offset);
204 llvm::StringRef Before = Code.substr(0, Offset);
205 int Lines = Before.count('\n');
206 size_t PrevNL = Before.rfind('\n');
207 size_t StartOfLine = (PrevNL == llvm::StringRef::npos) ? 0 : (PrevNL + 1);
208 Position Pos;
209 Pos.line = Lines;
210 Pos.character = lspLength(Before.substr(StartOfLine));
211 return Pos;
212}
213
214Position sourceLocToPosition(const SourceManager &SM, SourceLocation Loc) {
215 // We use the SourceManager's line tables, but its column number is in bytes.
216 FileID FID;
217 unsigned Offset;
218 std::tie(FID, Offset) = SM.getDecomposedSpellingLoc(Loc);
219 Position P;
220 P.line = static_cast<int>(SM.getLineNumber(FID, Offset)) - 1;
221 bool Invalid = false;
222 llvm::StringRef Code = SM.getBufferData(FID, &Invalid);
223 if (!Invalid) {
224 auto ColumnInBytes = SM.getColumnNumber(FID, Offset) - 1;
225 auto LineSoFar = Code.substr(Offset - ColumnInBytes, ColumnInBytes);
226 P.character = lspLength(LineSoFar);
227 }
228 return P;
229}
230
231bool isSpelledInSource(SourceLocation Loc, const SourceManager &SM) {
232 if (Loc.isFileID())
233 return true;
234 auto Spelling = SM.getDecomposedSpellingLoc(Loc);
235 StringRef SpellingFile = SM.getSLocEntry(Spelling.first).getFile().getName();
236 if (SpellingFile == "<scratch space>")
237 return false;
238 if (SpellingFile == "<built-in>")
239 // __STDC__ etc are considered spelled, but BAR in arg -DFOO=BAR is not.
240 return !SM.isWrittenInCommandLineFile(
241 SM.getComposedLoc(Spelling.first, Spelling.second));
242 return true;
243}
244
245bool isValidFileRange(const SourceManager &Mgr, SourceRange R) {
246 if (!R.getBegin().isValid() || !R.getEnd().isValid())
247 return false;
248
249 FileID BeginFID;
250 size_t BeginOffset = 0;
251 std::tie(BeginFID, BeginOffset) = Mgr.getDecomposedLoc(R.getBegin());
252
253 FileID EndFID;
254 size_t EndOffset = 0;
255 std::tie(EndFID, EndOffset) = Mgr.getDecomposedLoc(R.getEnd());
256
257 return BeginFID.isValid() && BeginFID == EndFID && BeginOffset <= EndOffset;
258}
259
260SourceLocation includeHashLoc(FileID IncludedFile, const SourceManager &SM) {
261 assert(SM.getLocForEndOfFile(IncludedFile).isFileID());
262 FileID IncludingFile;
263 unsigned Offset;
264 std::tie(IncludingFile, Offset) =
265 SM.getDecomposedExpansionLoc(SM.getIncludeLoc(IncludedFile));
266 bool Invalid = false;
267 llvm::StringRef Buf = SM.getBufferData(IncludingFile, &Invalid);
268 if (Invalid)
269 return SourceLocation();
270 // Now buf is "...\n#include <foo>\n..."
271 // and Offset points here: ^
272 // Rewind to the preceding # on the line.
273 assert(Offset < Buf.size());
274 for (;; --Offset) {
275 if (Buf[Offset] == '#')
276 return SM.getComposedLoc(IncludingFile, Offset);
277 if (Buf[Offset] == '\n' || Offset == 0) // no hash, what's going on?
278 return SourceLocation();
279 }
280}
281
282static unsigned getTokenLengthAtLoc(SourceLocation Loc, const SourceManager &SM,
283 const LangOptions &LangOpts) {
284 Token TheTok;
285 if (Lexer::getRawToken(Loc, TheTok, SM, LangOpts))
286 return 0;
287 // FIXME: Here we check whether the token at the location is a greatergreater
288 // (>>) token and consider it as a single greater (>). This is to get it
289 // working for templates but it isn't correct for the right shift operator. We
290 // can avoid this by using half open char ranges in getFileRange() but getting
291 // token ending is not well supported in macroIDs.
292 if (TheTok.is(tok::greatergreater))
293 return 1;
294 return TheTok.getLength();
295}
296
297// Returns location of the last character of the token at a given loc
298static SourceLocation getLocForTokenEnd(SourceLocation BeginLoc,
299 const SourceManager &SM,
300 const LangOptions &LangOpts) {
301 unsigned Len = getTokenLengthAtLoc(BeginLoc, SM, LangOpts);
302 return BeginLoc.getLocWithOffset(Len ? Len - 1 : 0);
303}
304
305// Returns location of the starting of the token at a given EndLoc
306static SourceLocation getLocForTokenBegin(SourceLocation EndLoc,
307 const SourceManager &SM,
308 const LangOptions &LangOpts) {
309 return EndLoc.getLocWithOffset(
310 -(signed)getTokenLengthAtLoc(EndLoc, SM, LangOpts));
311}
312
313// Converts a char source range to a token range.
314static SourceRange toTokenRange(CharSourceRange Range, const SourceManager &SM,
315 const LangOptions &LangOpts) {
316 if (!Range.isTokenRange())
317 Range.setEnd(getLocForTokenBegin(Range.getEnd(), SM, LangOpts));
318 return Range.getAsRange();
319}
320// Returns the union of two token ranges.
321// To find the maximum of the Ends of the ranges, we compare the location of the
322// last character of the token.
323static SourceRange unionTokenRange(SourceRange R1, SourceRange R2,
324 const SourceManager &SM,
325 const LangOptions &LangOpts) {
326 SourceLocation Begin =
327 SM.isBeforeInTranslationUnit(R1.getBegin(), R2.getBegin())
328 ? R1.getBegin()
329 : R2.getBegin();
330 SourceLocation End =
331 SM.isBeforeInTranslationUnit(getLocForTokenEnd(R1.getEnd(), SM, LangOpts),
332 getLocForTokenEnd(R2.getEnd(), SM, LangOpts))
333 ? R2.getEnd()
334 : R1.getEnd();
335 return SourceRange(Begin, End);
336}
337
338// Given a range whose endpoints may be in different expansions or files,
339// tries to find a range within a common file by following up the expansion and
340// include location in each.
341static SourceRange rangeInCommonFile(SourceRange R, const SourceManager &SM,
342 const LangOptions &LangOpts) {
343 // Fast path for most common cases.
344 if (SM.isWrittenInSameFile(R.getBegin(), R.getEnd()))
345 return R;
346 // Record the stack of expansion locations for the beginning, keyed by FileID.
347 llvm::DenseMap<FileID, SourceLocation> BeginExpansions;
348 for (SourceLocation Begin = R.getBegin(); Begin.isValid();
349 Begin = Begin.isFileID()
350 ? includeHashLoc(SM.getFileID(Begin), SM)
351 : SM.getImmediateExpansionRange(Begin).getBegin()) {
352 BeginExpansions[SM.getFileID(Begin)] = Begin;
353 }
354 // Move up the stack of expansion locations for the end until we find the
355 // location in BeginExpansions with that has the same file id.
356 for (SourceLocation End = R.getEnd(); End.isValid();
357 End = End.isFileID() ? includeHashLoc(SM.getFileID(End), SM)
358 : toTokenRange(SM.getImmediateExpansionRange(End),
359 SM, LangOpts)
360 .getEnd()) {
361 auto It = BeginExpansions.find(SM.getFileID(End));
362 if (It != BeginExpansions.end()) {
363 if (SM.getFileOffset(It->second) > SM.getFileOffset(End))
364 return SourceLocation();
365 return {It->second, End};
366 }
367 }
368 return SourceRange();
369}
370
371// Find an expansion range (not necessarily immediate) the ends of which are in
372// the same file id.
373static SourceRange
374getExpansionTokenRangeInSameFile(SourceLocation Loc, const SourceManager &SM,
375 const LangOptions &LangOpts) {
376 return rangeInCommonFile(
377 toTokenRange(SM.getImmediateExpansionRange(Loc), SM, LangOpts), SM,
378 LangOpts);
379}
380
381// Returns the file range for a given Location as a Token Range
382// This is quite similar to getFileLoc in SourceManager as both use
383// getImmediateExpansionRange and getImmediateSpellingLoc (for macro IDs).
384// However:
385// - We want to maintain the full range information as we move from one file to
386// the next. getFileLoc only uses the BeginLoc of getImmediateExpansionRange.
387// - We want to split '>>' tokens as the lexer parses the '>>' in nested
388// template instantiations as a '>>' instead of two '>'s.
389// There is also getExpansionRange but it simply calls
390// getImmediateExpansionRange on the begin and ends separately which is wrong.
391static SourceRange getTokenFileRange(SourceLocation Loc,
392 const SourceManager &SM,
393 const LangOptions &LangOpts) {
394 SourceRange FileRange = Loc;
395 while (!FileRange.getBegin().isFileID()) {
396 if (SM.isMacroArgExpansion(FileRange.getBegin())) {
397 FileRange = unionTokenRange(
398 SM.getImmediateSpellingLoc(FileRange.getBegin()),
399 SM.getImmediateSpellingLoc(FileRange.getEnd()), SM, LangOpts);
400 assert(SM.isWrittenInSameFile(FileRange.getBegin(), FileRange.getEnd()));
401 } else {
402 SourceRange ExpansionRangeForBegin =
403 getExpansionTokenRangeInSameFile(FileRange.getBegin(), SM, LangOpts);
404 SourceRange ExpansionRangeForEnd =
405 getExpansionTokenRangeInSameFile(FileRange.getEnd(), SM, LangOpts);
406 if (ExpansionRangeForBegin.isInvalid() ||
407 ExpansionRangeForEnd.isInvalid())
408 return SourceRange();
409 assert(SM.isWrittenInSameFile(ExpansionRangeForBegin.getBegin(),
410 ExpansionRangeForEnd.getBegin()) &&
411 "Both Expansion ranges should be in same file.");
412 FileRange = unionTokenRange(ExpansionRangeForBegin, ExpansionRangeForEnd,
413 SM, LangOpts);
414 }
415 }
416 return FileRange;
417}
418
419bool isInsideMainFile(SourceLocation Loc, const SourceManager &SM) {
420 if (!Loc.isValid())
421 return false;
422 FileID FID = SM.getFileID(SM.getExpansionLoc(Loc));
423 return FID == SM.getMainFileID() || FID == SM.getPreambleFileID();
424}
425
426std::optional<SourceRange> toHalfOpenFileRange(const SourceManager &SM,
427 const LangOptions &LangOpts,
428 SourceRange R) {
429 SourceRange R1 = getTokenFileRange(R.getBegin(), SM, LangOpts);
430 if (!isValidFileRange(SM, R1))
431 return std::nullopt;
432
433 SourceRange R2 = getTokenFileRange(R.getEnd(), SM, LangOpts);
434 if (!isValidFileRange(SM, R2))
435 return std::nullopt;
436
437 SourceRange Result =
438 rangeInCommonFile(unionTokenRange(R1, R2, SM, LangOpts), SM, LangOpts);
439 unsigned TokLen = getTokenLengthAtLoc(Result.getEnd(), SM, LangOpts);
440 // Convert from closed token range to half-open (char) range
441 Result.setEnd(Result.getEnd().getLocWithOffset(TokLen));
442 if (!isValidFileRange(SM, Result))
443 return std::nullopt;
444
445 return Result;
446}
447
448llvm::StringRef toSourceCode(const SourceManager &SM, SourceRange R) {
449 assert(isValidFileRange(SM, R));
450 auto Buf = SM.getBufferOrNone(SM.getFileID(R.getBegin()));
451 assert(Buf);
452
453 size_t BeginOffset = SM.getFileOffset(R.getBegin());
454 size_t EndOffset = SM.getFileOffset(R.getEnd());
455 return Buf->getBuffer().substr(BeginOffset, EndOffset - BeginOffset);
456}
457
458llvm::Expected<SourceLocation> sourceLocationInMainFile(const SourceManager &SM,
459 Position P) {
460 llvm::StringRef Code = SM.getBufferOrFake(SM.getMainFileID()).getBuffer();
461 auto Offset =
462 positionToOffset(Code, P, /*AllowColumnsBeyondLineLength=*/false);
463 if (!Offset)
464 return Offset.takeError();
465 return SM.getLocForStartOfFile(SM.getMainFileID()).getLocWithOffset(*Offset);
466}
467
468Range halfOpenToRange(const SourceManager &SM, CharSourceRange R) {
469 // Clang is 1-based, LSP uses 0-based indexes.
470 Position Begin = sourceLocToPosition(SM, R.getBegin());
471 Position End = sourceLocToPosition(SM, R.getEnd());
472
473 return {Begin, End};
474}
475
476void unionRanges(Range &A, Range B) {
477 if (B.start < A.start)
478 A.start = B.start;
479 if (A.end < B.end)
480 A.end = B.end;
481}
482
483std::pair<size_t, size_t> offsetToClangLineColumn(llvm::StringRef Code,
484 size_t Offset) {
485 Offset = std::min(Code.size(), Offset);
486 llvm::StringRef Before = Code.substr(0, Offset);
487 int Lines = Before.count('\n');
488 size_t PrevNL = Before.rfind('\n');
489 size_t StartOfLine = (PrevNL == llvm::StringRef::npos) ? 0 : (PrevNL + 1);
490 return {Lines + 1, Offset - StartOfLine + 1};
491}
492
493std::pair<StringRef, StringRef> splitQualifiedName(StringRef QName) {
494 size_t Pos = QName.rfind("::");
495 if (Pos == llvm::StringRef::npos)
496 return {llvm::StringRef(), QName};
497 return {QName.substr(0, Pos + 2), QName.substr(Pos + 2)};
498}
499
500TextEdit replacementToEdit(llvm::StringRef Code,
501 const tooling::Replacement &R) {
502 Range ReplacementRange = {
503 offsetToPosition(Code, R.getOffset()),
504 offsetToPosition(Code, R.getOffset() + R.getLength())};
505 return {ReplacementRange, std::string(R.getReplacementText())};
506}
507
508std::vector<TextEdit> replacementsToEdits(llvm::StringRef Code,
509 const tooling::Replacements &Repls) {
510 std::vector<TextEdit> Edits;
511 for (const auto &R : Repls)
512 Edits.push_back(replacementToEdit(Code, R));
513 return Edits;
514}
515
516std::optional<std::string> getCanonicalPath(const FileEntryRef F,
517 FileManager &FileMgr) {
518 llvm::SmallString<128> FilePath = F.getName();
519 if (!llvm::sys::path::is_absolute(FilePath)) {
520 if (auto EC =
521 FileMgr.getVirtualFileSystem().makeAbsolute(
522 FilePath)) {
523 elog("Could not turn relative path '{0}' to absolute: {1}", FilePath,
524 EC.message());
525 return std::nullopt;
526 }
527 }
528
529 // Handle the symbolic link path case where the current working directory
530 // (getCurrentWorkingDirectory) is a symlink. We always want to the real
531 // file path (instead of the symlink path) for the C++ symbols.
532 //
533 // Consider the following example:
534 //
535 // src dir: /project/src/foo.h
536 // current working directory (symlink): /tmp/build -> /project/src/
537 //
538 // The file path of Symbol is "/project/src/foo.h" instead of
539 // "/tmp/build/foo.h"
540 if (auto Dir = FileMgr.getOptionalDirectoryRef(
541 llvm::sys::path::parent_path(FilePath))) {
542 llvm::SmallString<128> RealPath;
543 llvm::StringRef DirName = FileMgr.getCanonicalName(*Dir);
544 llvm::sys::path::append(RealPath, DirName,
545 llvm::sys::path::filename(FilePath));
546 return RealPath.str().str();
547 }
548
549 return FilePath.str().str();
550}
551
552TextEdit toTextEdit(const FixItHint &FixIt, const SourceManager &M,
553 const LangOptions &L) {
554 TextEdit Result;
555 Result.range =
556 halfOpenToRange(M, Lexer::makeFileCharRange(FixIt.RemoveRange, M, L));
557 Result.newText = FixIt.CodeToInsert;
558 return Result;
559}
560
561FileDigest digest(llvm::StringRef Content) {
562 uint64_t Hash{llvm::xxHash64(Content)};
563 FileDigest Result;
564 for (unsigned I = 0; I < Result.size(); ++I) {
565 Result[I] = uint8_t(Hash);
566 Hash >>= 8;
567 }
568 return Result;
569}
570
571std::optional<FileDigest> digestFile(const SourceManager &SM, FileID FID) {
572 bool Invalid = false;
573 llvm::StringRef Content = SM.getBufferData(FID, &Invalid);
574 if (Invalid)
575 return std::nullopt;
576 return digest(Content);
577}
578
579format::FormatStyle getFormatStyleForFile(llvm::StringRef File,
580 llvm::StringRef Content,
581 const ThreadsafeFS &TFS) {
582 auto Style = format::getStyle(format::DefaultFormatStyle, File,
583 format::DefaultFallbackStyle, Content,
584 TFS.view(/*CWD=*/std::nullopt).get());
585 if (!Style) {
586 log("getStyle() failed for file {0}: {1}. Fallback is LLVM style.", File,
587 Style.takeError());
588 return format::getLLVMStyle();
589 }
590 return *Style;
591}
592
593llvm::Expected<tooling::Replacements>
594cleanupAndFormat(StringRef Code, const tooling::Replacements &Replaces,
595 const format::FormatStyle &Style) {
596 auto CleanReplaces = cleanupAroundReplacements(Code, Replaces, Style);
597 if (!CleanReplaces)
598 return CleanReplaces;
599 return formatReplacements(Code, std::move(*CleanReplaces), Style);
600}
601
602static void
603lex(llvm::StringRef Code, const LangOptions &LangOpts,
604 llvm::function_ref<void(const syntax::Token &, const SourceManager &SM)>
605 Action) {
606 // FIXME: InMemoryFileAdapter crashes unless the buffer is null terminated!
607 std::string NullTerminatedCode = Code.str();
608 SourceManagerForFile FileSM("mock_file_name.cpp", NullTerminatedCode);
609 auto &SM = FileSM.get();
610 for (const auto &Tok : syntax::tokenize(SM.getMainFileID(), SM, LangOpts))
611 Action(Tok, SM);
612}
613
614llvm::StringMap<unsigned> collectIdentifiers(llvm::StringRef Content,
615 const format::FormatStyle &Style) {
616 llvm::StringMap<unsigned> Identifiers;
617 auto LangOpt = format::getFormattingLangOpts(Style);
618 lex(Content, LangOpt, [&](const syntax::Token &Tok, const SourceManager &SM) {
619 if (Tok.kind() == tok::identifier)
620 ++Identifiers[Tok.text(SM)];
621 // FIXME: Should this function really return keywords too ?
622 else if (const auto *Keyword = tok::getKeywordSpelling(Tok.kind()))
623 ++Identifiers[Keyword];
624 });
625 return Identifiers;
626}
627
628std::vector<Range> collectIdentifierRanges(llvm::StringRef Identifier,
629 llvm::StringRef Content,
630 const LangOptions &LangOpts) {
631 std::vector<Range> Ranges;
632 lex(Content, LangOpts,
633 [&](const syntax::Token &Tok, const SourceManager &SM) {
634 if (Tok.kind() != tok::identifier || Tok.text(SM) != Identifier)
635 return;
636 Ranges.push_back(halfOpenToRange(SM, Tok.range(SM).toCharRange(SM)));
637 });
638 return Ranges;
639}
640
641bool isKeyword(llvm::StringRef NewName, const LangOptions &LangOpts) {
642 // Keywords are initialized in constructor.
643 clang::IdentifierTable KeywordsTable(LangOpts);
644 return KeywordsTable.find(NewName) != KeywordsTable.end();
645}
646
647namespace {
648struct NamespaceEvent {
649 enum {
650 BeginNamespace, // namespace <ns> {. Payload is resolved <ns>.
651 EndNamespace, // } // namespace <ns>. Payload is resolved *outer*
652 // namespace.
653 UsingDirective // using namespace <ns>. Payload is unresolved <ns>.
654 } Trigger;
655 std::string Payload;
656 Position Pos;
657};
658// Scans C++ source code for constructs that change the visible namespaces.
659void parseNamespaceEvents(llvm::StringRef Code, const LangOptions &LangOpts,
660 llvm::function_ref<void(NamespaceEvent)> Callback) {
661
662 // Stack of enclosing namespaces, e.g. {"clang", "clangd"}
663 std::vector<std::string> Enclosing; // Contains e.g. "clang", "clangd"
664 // Stack counts open braces. true if the brace opened a namespace.
665 llvm::BitVector BraceStack;
666
667 enum {
668 Default,
669 Namespace, // just saw 'namespace'
670 NamespaceName, // just saw 'namespace' NSName
671 Using, // just saw 'using'
672 UsingNamespace, // just saw 'using namespace'
673 UsingNamespaceName, // just saw 'using namespace' NSName
674 } State = Default;
675 std::string NSName;
676
677 NamespaceEvent Event;
678 lex(Code, LangOpts, [&](const syntax::Token &Tok, const SourceManager &SM) {
679 Event.Pos = sourceLocToPosition(SM, Tok.location());
680 switch (Tok.kind()) {
681 case tok::kw_using:
682 State = State == Default ? Using : Default;
683 break;
684 case tok::kw_namespace:
685 switch (State) {
686 case Using:
687 State = UsingNamespace;
688 break;
689 case Default:
690 State = Namespace;
691 break;
692 default:
693 State = Default;
694 break;
695 }
696 break;
697 case tok::identifier:
698 switch (State) {
699 case UsingNamespace:
700 NSName.clear();
701 [[fallthrough]];
702 case UsingNamespaceName:
703 NSName.append(Tok.text(SM).str());
704 State = UsingNamespaceName;
705 break;
706 case Namespace:
707 NSName.clear();
708 [[fallthrough]];
709 case NamespaceName:
710 NSName.append(Tok.text(SM).str());
711 State = NamespaceName;
712 break;
713 case Using:
714 case Default:
715 State = Default;
716 break;
717 }
718 break;
719 case tok::coloncolon:
720 // This can come at the beginning or in the middle of a namespace
721 // name.
722 switch (State) {
723 case UsingNamespace:
724 NSName.clear();
725 [[fallthrough]];
726 case UsingNamespaceName:
727 NSName.append("::");
728 State = UsingNamespaceName;
729 break;
730 case NamespaceName:
731 NSName.append("::");
732 State = NamespaceName;
733 break;
734 case Namespace: // Not legal here.
735 case Using:
736 case Default:
737 State = Default;
738 break;
739 }
740 break;
741 case tok::l_brace:
742 // Record which { started a namespace, so we know when } ends one.
743 if (State == NamespaceName) {
744 // Parsed: namespace <name> {
745 BraceStack.push_back(true);
746 Enclosing.push_back(NSName);
747 Event.Trigger = NamespaceEvent::BeginNamespace;
748 Event.Payload = llvm::join(Enclosing, "::");
749 Callback(Event);
750 } else {
751 // This case includes anonymous namespaces (State = Namespace).
752 // For our purposes, they're not namespaces and we ignore them.
753 BraceStack.push_back(false);
754 }
755 State = Default;
756 break;
757 case tok::r_brace:
758 // If braces are unmatched, we're going to be confused, but don't
759 // crash.
760 if (!BraceStack.empty()) {
761 if (BraceStack.back()) {
762 // Parsed: } // namespace
763 Enclosing.pop_back();
764 Event.Trigger = NamespaceEvent::EndNamespace;
765 Event.Payload = llvm::join(Enclosing, "::");
766 Callback(Event);
767 }
768 BraceStack.pop_back();
769 }
770 break;
771 case tok::semi:
772 if (State == UsingNamespaceName) {
773 // Parsed: using namespace <name> ;
774 Event.Trigger = NamespaceEvent::UsingDirective;
775 Event.Payload = std::move(NSName);
776 Callback(Event);
777 }
778 State = Default;
779 break;
780 default:
781 State = Default;
782 break;
783 }
784 });
785}
786
787// Returns the prefix namespaces of NS: {"" ... NS}.
788llvm::SmallVector<llvm::StringRef> ancestorNamespaces(llvm::StringRef NS) {
789 llvm::SmallVector<llvm::StringRef> Results;
790 Results.push_back(NS.take_front(0));
791 NS.split(Results, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
792 for (llvm::StringRef &R : Results)
793 R = NS.take_front(R.end() - NS.begin());
794 return Results;
795}
796
797// Checks whether \p FileName is a valid spelling of main file.
798bool isMainFile(llvm::StringRef FileName, const SourceManager &SM) {
799 auto FE = SM.getFileManager().getFile(FileName);
800 return FE && *FE == SM.getFileEntryForID(SM.getMainFileID());
801}
802
803} // namespace
804
805std::vector<std::string> visibleNamespaces(llvm::StringRef Code,
806 const LangOptions &LangOpts) {
807 std::string Current;
808 // Map from namespace to (resolved) namespaces introduced via using directive.
809 llvm::StringMap<llvm::StringSet<>> UsingDirectives;
810
811 parseNamespaceEvents(Code, LangOpts, [&](NamespaceEvent Event) {
812 llvm::StringRef NS = Event.Payload;
813 switch (Event.Trigger) {
814 case NamespaceEvent::BeginNamespace:
815 case NamespaceEvent::EndNamespace:
816 Current = std::move(Event.Payload);
817 break;
818 case NamespaceEvent::UsingDirective:
819 if (NS.consume_front("::"))
820 UsingDirectives[Current].insert(NS);
821 else {
822 for (llvm::StringRef Enclosing : ancestorNamespaces(Current)) {
823 if (Enclosing.empty())
824 UsingDirectives[Current].insert(NS);
825 else
826 UsingDirectives[Current].insert((Enclosing + "::" + NS).str());
827 }
828 }
829 break;
830 }
831 });
832
833 std::vector<std::string> Found;
834 for (llvm::StringRef Enclosing : ancestorNamespaces(Current)) {
835 Found.push_back(std::string(Enclosing));
836 auto It = UsingDirectives.find(Enclosing);
837 if (It != UsingDirectives.end())
838 for (const auto &Used : It->second)
839 Found.push_back(std::string(Used.getKey()));
840 }
841
842 llvm::sort(Found, [&](const std::string &LHS, const std::string &RHS) {
843 if (Current == RHS)
844 return false;
845 if (Current == LHS)
846 return true;
847 return LHS < RHS;
848 });
849 Found.erase(std::unique(Found.begin(), Found.end()), Found.end());
850 return Found;
851}
852
853llvm::StringSet<> collectWords(llvm::StringRef Content) {
854 // We assume short words are not significant.
855 // We may want to consider other stopwords, e.g. language keywords.
856 // (A very naive implementation showed no benefit, but lexing might do better)
857 static constexpr int MinWordLength = 4;
858
859 std::vector<CharRole> Roles(Content.size());
860 calculateRoles(Content, Roles);
861
862 llvm::StringSet<> Result;
863 llvm::SmallString<256> Word;
864 auto Flush = [&] {
865 if (Word.size() >= MinWordLength) {
866 for (char &C : Word)
867 C = llvm::toLower(C);
868 Result.insert(Word);
869 }
870 Word.clear();
871 };
872 for (unsigned I = 0; I < Content.size(); ++I) {
873 switch (Roles[I]) {
874 case Head:
875 Flush();
876 [[fallthrough]];
877 case Tail:
878 Word.push_back(Content[I]);
879 break;
880 case Unknown:
881 case Separator:
882 Flush();
883 break;
884 }
885 }
886 Flush();
887
888 return Result;
889}
890
891static bool isLikelyIdentifier(llvm::StringRef Word, llvm::StringRef Before,
892 llvm::StringRef After) {
893 // `foo` is an identifier.
894 if (Before.endswith("`") && After.startswith("`"))
895 return true;
896 // In foo::bar, both foo and bar are identifiers.
897 if (Before.endswith("::") || After.startswith("::"))
898 return true;
899 // Doxygen tags like \c foo indicate identifiers.
900 // Don't search too far back.
901 // This duplicates clang's doxygen parser, revisit if it gets complicated.
902 Before = Before.take_back(100); // Don't search too far back.
903 auto Pos = Before.find_last_of("\\@");
904 if (Pos != llvm::StringRef::npos) {
905 llvm::StringRef Tag = Before.substr(Pos + 1).rtrim(' ');
906 if (Tag == "p" || Tag == "c" || Tag == "class" || Tag == "tparam" ||
907 Tag == "param" || Tag == "param[in]" || Tag == "param[out]" ||
908 Tag == "param[in,out]" || Tag == "retval" || Tag == "throw" ||
909 Tag == "throws" || Tag == "link")
910 return true;
911 }
912
913 // Word contains underscore.
914 // This handles things like snake_case and MACRO_CASE.
915 if (Word.contains('_')) {
916 return true;
917 }
918 // Word contains capital letter other than at beginning.
919 // This handles things like lowerCamel and UpperCamel.
920 // The check for also containing a lowercase letter is to rule out
921 // initialisms like "HTTP".
922 bool HasLower = Word.find_if(clang::isLowercase) != StringRef::npos;
923 bool HasUpper = Word.substr(1).find_if(clang::isUppercase) != StringRef::npos;
924 if (HasLower && HasUpper) {
925 return true;
926 }
927 // FIXME: consider mid-sentence Capitalization?
928 return false;
929}
930
931std::optional<SpelledWord> SpelledWord::touching(SourceLocation SpelledLoc,
932 const syntax::TokenBuffer &TB,
933 const LangOptions &LangOpts) {
934 const auto &SM = TB.sourceManager();
935 auto Touching = syntax::spelledTokensTouching(SpelledLoc, TB);
936 for (const auto &T : Touching) {
937 // If the token is an identifier or a keyword, don't use any heuristics.
938 if (tok::isAnyIdentifier(T.kind()) || tok::getKeywordSpelling(T.kind())) {
939 SpelledWord Result;
940 Result.Location = T.location();
941 Result.Text = T.text(SM);
942 Result.LikelyIdentifier = tok::isAnyIdentifier(T.kind());
943 Result.PartOfSpelledToken = &T;
944 Result.SpelledToken = &T;
945 auto Expanded =
946 TB.expandedTokens(SM.getMacroArgExpandedLocation(T.location()));
947 if (Expanded.size() == 1 && Expanded.front().text(SM) == Result.Text)
948 Result.ExpandedToken = &Expanded.front();
949 return Result;
950 }
951 }
952 FileID File;
953 unsigned Offset;
954 std::tie(File, Offset) = SM.getDecomposedLoc(SpelledLoc);
955 bool Invalid = false;
956 llvm::StringRef Code = SM.getBufferData(File, &Invalid);
957 if (Invalid)
958 return std::nullopt;
959 unsigned B = Offset, E = Offset;
960 while (B > 0 && isAsciiIdentifierContinue(Code[B - 1]))
961 --B;
962 while (E < Code.size() && isAsciiIdentifierContinue(Code[E]))
963 ++E;
964 if (B == E)
965 return std::nullopt;
966
967 SpelledWord Result;
968 Result.Location = SM.getComposedLoc(File, B);
969 Result.Text = Code.slice(B, E);
970 Result.LikelyIdentifier =
971 isLikelyIdentifier(Result.Text, Code.substr(0, B), Code.substr(E)) &&
972 // should not be a keyword
973 tok::isAnyIdentifier(
974 IdentifierTable(LangOpts).get(Result.Text).getTokenID());
975 for (const auto &T : Touching)
976 if (T.location() <= Result.Location)
977 Result.PartOfSpelledToken = &T;
978 return Result;
979}
980
981std::optional<DefinedMacro> locateMacroAt(const syntax::Token &SpelledTok,
982 Preprocessor &PP) {
983 if (SpelledTok.kind() != tok::identifier)
984 return std::nullopt;
985 SourceLocation Loc = SpelledTok.location();
986 assert(Loc.isFileID());
987 const auto &SM = PP.getSourceManager();
988 IdentifierInfo *IdentifierInfo = PP.getIdentifierInfo(SpelledTok.text(SM));
989 if (!IdentifierInfo || !IdentifierInfo->hadMacroDefinition())
990 return std::nullopt;
991
992 // We need to take special case to handle #define and #undef.
993 // Preprocessor::getMacroDefinitionAtLoc() only considers a macro
994 // definition to be in scope *after* the location of the macro name in a
995 // #define that introduces it, and *before* the location of the macro name
996 // in an #undef that undefines it. To handle these cases, we check for
997 // the macro being in scope either just after or just before the location
998 // of the token. In getting the location before, we also take care to check
999 // for start-of-file.
1000 FileID FID = SM.getFileID(Loc);
1001 assert(Loc != SM.getLocForEndOfFile(FID));
1002 SourceLocation JustAfterToken = Loc.getLocWithOffset(1);
1003 auto *MacroInfo =
1004 PP.getMacroDefinitionAtLoc(IdentifierInfo, JustAfterToken).getMacroInfo();
1005 if (!MacroInfo && SM.getLocForStartOfFile(FID) != Loc) {
1006 SourceLocation JustBeforeToken = Loc.getLocWithOffset(-1);
1007 MacroInfo = PP.getMacroDefinitionAtLoc(IdentifierInfo, JustBeforeToken)
1008 .getMacroInfo();
1009 }
1010 if (!MacroInfo) {
1011 return std::nullopt;
1012 }
1013 return DefinedMacro{
1014 IdentifierInfo->getName(), MacroInfo,
1015 translatePreamblePatchLocation(MacroInfo->getDefinitionLoc(), SM)};
1016}
1017
1018llvm::Expected<std::string> Edit::apply() const {
1019 return tooling::applyAllReplacements(InitialCode, Replacements);
1020}
1021
1022std::vector<TextEdit> Edit::asTextEdits() const {
1023 return replacementsToEdits(InitialCode, Replacements);
1024}
1025
1026bool Edit::canApplyTo(llvm::StringRef Code) const {
1027 // Create line iterators, since line numbers are important while applying our
1028 // edit we cannot skip blank lines.
1029 auto LHS = llvm::MemoryBuffer::getMemBuffer(Code);
1030 llvm::line_iterator LHSIt(*LHS, /*SkipBlanks=*/false);
1031
1032 auto RHS = llvm::MemoryBuffer::getMemBuffer(InitialCode);
1033 llvm::line_iterator RHSIt(*RHS, /*SkipBlanks=*/false);
1034
1035 // Compare the InitialCode we prepared the edit for with the Code we received
1036 // line by line to make sure there are no differences.
1037 // FIXME: This check is too conservative now, it should be enough to only
1038 // check lines around the replacements contained inside the Edit.
1039 while (!LHSIt.is_at_eof() && !RHSIt.is_at_eof()) {
1040 if (*LHSIt != *RHSIt)
1041 return false;
1042 ++LHSIt;
1043 ++RHSIt;
1044 }
1045
1046 // After we reach EOF for any of the files we make sure the other one doesn't
1047 // contain any additional content except empty lines, they should not
1048 // interfere with the edit we produced.
1049 while (!LHSIt.is_at_eof()) {
1050 if (!LHSIt->empty())
1051 return false;
1052 ++LHSIt;
1053 }
1054 while (!RHSIt.is_at_eof()) {
1055 if (!RHSIt->empty())
1056 return false;
1057 ++RHSIt;
1058 }
1059 return true;
1060}
1061
1062llvm::Error reformatEdit(Edit &E, const format::FormatStyle &Style) {
1063 if (auto NewEdits = cleanupAndFormat(E.InitialCode, E.Replacements, Style))
1064 E.Replacements = std::move(*NewEdits);
1065 else
1066 return NewEdits.takeError();
1067 return llvm::Error::success();
1068}
1069
1070// Workaround for editors that have buggy handling of newlines at end of file.
1071//
1072// The editor is supposed to expose document contents over LSP as an exact
1073// string, with whitespace and newlines well-defined. But internally many
1074// editors treat text as an array of lines, and there can be ambiguity over
1075// whether the last line ends with a newline or not.
1076//
1077// This confusion can lead to incorrect edits being sent. Failing to apply them
1078// is catastrophic: we're desynced, LSP has no mechanism to get back in sync.
1079// We apply a heuristic to avoid this state.
1080//
1081// If our current view of an N-line file does *not* end in a newline, but the
1082// editor refers to the start of the next line (an impossible location), then
1083// we silently add a newline to make this valid.
1084// We will still validate that the rangeLength is correct, *including* the
1085// inferred newline.
1086//
1087// See https://github.com/neovim/neovim/issues/17085
1088static void inferFinalNewline(llvm::Expected<size_t> &Err,
1089 std::string &Contents, const Position &Pos) {
1090 if (Err)
1091 return;
1092 if (!Contents.empty() && Contents.back() == '\n')
1093 return;
1094 if (Pos.character != 0)
1095 return;
1096 if (Pos.line != llvm::count(Contents, '\n') + 1)
1097 return;
1098 log("Editor sent invalid change coordinates, inferring newline at EOF");
1099 Contents.push_back('\n');
1100 consumeError(Err.takeError());
1101 Err = Contents.size();
1102}
1103
1104llvm::Error applyChange(std::string &Contents,
1105 const TextDocumentContentChangeEvent &Change) {
1106 if (!Change.range) {
1107 Contents = Change.text;
1108 return llvm::Error::success();
1109 }
1110
1111 const Position &Start = Change.range->start;
1112 llvm::Expected<size_t> StartIndex = positionToOffset(Contents, Start, false);
1113 inferFinalNewline(StartIndex, Contents, Start);
1114 if (!StartIndex)
1115 return StartIndex.takeError();
1116
1117 const Position &End = Change.range->end;
1118 llvm::Expected<size_t> EndIndex = positionToOffset(Contents, End, false);
1119 inferFinalNewline(EndIndex, Contents, End);
1120 if (!EndIndex)
1121 return EndIndex.takeError();
1122
1123 if (*EndIndex < *StartIndex)
1124 return error(llvm::errc::invalid_argument,
1125 "Range's end position ({0}) is before start position ({1})",
1126 End, Start);
1127
1128 // Since the range length between two LSP positions is dependent on the
1129 // contents of the buffer we compute the range length between the start and
1130 // end position ourselves and compare it to the range length of the LSP
1131 // message to verify the buffers of the client and server are in sync.
1132
1133 // EndIndex and StartIndex are in bytes, but Change.rangeLength is in UTF-16
1134 // code units.
1135 ssize_t ComputedRangeLength =
1136 lspLength(Contents.substr(*StartIndex, *EndIndex - *StartIndex));
1137
1138 if (Change.rangeLength && ComputedRangeLength != *Change.rangeLength)
1139 return error(llvm::errc::invalid_argument,
1140 "Change's rangeLength ({0}) doesn't match the "
1141 "computed range length ({1}).",
1142 *Change.rangeLength, ComputedRangeLength);
1143
1144 Contents.replace(*StartIndex, *EndIndex - *StartIndex, Change.text);
1145
1146 return llvm::Error::success();
1147}
1148
1149EligibleRegion getEligiblePoints(llvm::StringRef Code,
1150 llvm::StringRef FullyQualifiedName,
1151 const LangOptions &LangOpts) {
1152 EligibleRegion ER;
1153 // Start with global namespace.
1154 std::vector<std::string> Enclosing = {""};
1155 // FIXME: In addition to namespaces try to generate events for function
1156 // definitions as well. One might use a closing parantheses(")" followed by an
1157 // opening brace "{" to trigger the start.
1158 parseNamespaceEvents(Code, LangOpts, [&](NamespaceEvent Event) {
1159 // Using Directives only introduces declarations to current scope, they do
1160 // not change the current namespace, so skip them.
1161 if (Event.Trigger == NamespaceEvent::UsingDirective)
1162 return;
1163 // Do not qualify the global namespace.
1164 if (!Event.Payload.empty())
1165 Event.Payload.append("::");
1166
1167 std::string CurrentNamespace;
1168 if (Event.Trigger == NamespaceEvent::BeginNamespace) {
1169 Enclosing.emplace_back(std::move(Event.Payload));
1170 CurrentNamespace = Enclosing.back();
1171 // parseNameSpaceEvents reports the beginning position of a token; we want
1172 // to insert after '{', so increment by one.
1173 ++Event.Pos.character;
1174 } else {
1175 // Event.Payload points to outer namespace when exiting a scope, so use
1176 // the namespace we've last entered instead.
1177 CurrentNamespace = std::move(Enclosing.back());
1178 Enclosing.pop_back();
1179 assert(Enclosing.back() == Event.Payload);
1180 }
1181
1182 // Ignore namespaces that are not a prefix of the target.
1183 if (!FullyQualifiedName.startswith(CurrentNamespace))
1184 return;
1185
1186 // Prefer the namespace that shares the longest prefix with target.
1187 if (CurrentNamespace.size() > ER.EnclosingNamespace.size()) {
1188 ER.EligiblePoints.clear();
1189 ER.EnclosingNamespace = CurrentNamespace;
1190 }
1191 if (CurrentNamespace.size() == ER.EnclosingNamespace.size())
1192 ER.EligiblePoints.emplace_back(std::move(Event.Pos));
1193 });
1194 // If there were no shared namespaces just return EOF.
1195 if (ER.EligiblePoints.empty()) {
1196 assert(ER.EnclosingNamespace.empty());
1197 ER.EligiblePoints.emplace_back(offsetToPosition(Code, Code.size()));
1198 }
1199 return ER;
1200}
1201
1202bool isHeaderFile(llvm::StringRef FileName,
1203 std::optional<LangOptions> LangOpts) {
1204 // Respect the langOpts, for non-file-extension cases, e.g. standard library
1205 // files.
1206 if (LangOpts && LangOpts->IsHeaderFile)
1207 return true;
1208 namespace types = clang::driver::types;
1209 auto Lang = types::lookupTypeForExtension(
1210 llvm::sys::path::extension(FileName).substr(1));
1211 return Lang != types::TY_INVALID && types::onlyPrecompileType(Lang);
1212}
1213
1214bool isProtoFile(SourceLocation Loc, const SourceManager &SM) {
1215 auto FileName = SM.getFilename(Loc);
1216 if (!FileName.endswith(".proto.h") && !FileName.endswith(".pb.h"))
1217 return false;
1218 auto FID = SM.getFileID(Loc);
1219 // All proto generated headers should start with this line.
1220 static const char *ProtoHeaderComment =
1221 "// Generated by the protocol buffer compiler. DO NOT EDIT!";
1222 // Double check that this is an actual protobuf header.
1223 return SM.getBufferData(FID).startswith(ProtoHeaderComment);
1224}
1225
1226SourceLocation translatePreamblePatchLocation(SourceLocation Loc,
1227 const SourceManager &SM) {
1228 auto DefFile = SM.getFileID(Loc);
1229 if (auto FE = SM.getFileEntryRefForID(DefFile)) {
1230 auto IncludeLoc = SM.getIncludeLoc(DefFile);
1231 // Preamble patch is included inside the builtin file.
1232 if (IncludeLoc.isValid() && SM.isWrittenInBuiltinFile(IncludeLoc) &&
1233 FE->getName().endswith(PreamblePatch::HeaderName)) {
1234 auto Presumed = SM.getPresumedLoc(Loc);
1235 // Check that line directive is pointing at main file.
1236 if (Presumed.isValid() && Presumed.getFileID().isInvalid() &&
1237 isMainFile(Presumed.getFilename(), SM)) {
1238 Loc = SM.translateLineCol(SM.getMainFileID(), Presumed.getLine(),
1239 Presumed.getColumn());
1240 }
1241 }
1242 }
1243 return Loc;
1244}
1245
1246clangd::Range rangeTillEOL(llvm::StringRef Code, unsigned HashOffset) {
1247 clangd::Range Result;
1248 Result.end = Result.start = offsetToPosition(Code, HashOffset);
1249
1250 // Span the warning until the EOL or EOF.
1251 Result.end.character +=
1252 lspLength(Code.drop_front(HashOffset).take_until([](char C) {
1253 return C == '\n' || C == '\r';
1254 }));
1255 return Result;
1256}
1257} // namespace clangd
1258} // namespace clang
1259