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