clang  15.0.0git
SortJavaScriptImports.cpp
Go to the documentation of this file.
1 //===--- SortJavaScriptImports.cpp - Sort ES6 Imports -----------*- 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 ///
9 /// \file
10 /// This file implements a sort operation for JavaScript ES6 imports.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "SortJavaScriptImports.h"
15 #include "TokenAnalyzer.h"
16 #include "TokenAnnotator.h"
17 #include "clang/Basic/Diagnostic.h"
19 #include "clang/Basic/LLVM.h"
22 #include "clang/Basic/TokenKinds.h"
23 #include "clang/Format/Format.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/Support/Debug.h"
27 #include <algorithm>
28 #include <string>
29 
30 #define DEBUG_TYPE "format-formatter"
31 
32 namespace clang {
33 namespace format {
34 
35 class FormatTokenLexer;
36 
38 
39 // An imported symbol in a JavaScript ES6 import/export, possibly aliased.
41  StringRef Symbol;
42  StringRef Alias;
44 
45  bool operator==(const JsImportedSymbol &RHS) const {
46  // Ignore Range for comparison, it is only used to stitch code together,
47  // but imports at different code locations are still conceptually the same.
48  return Symbol == RHS.Symbol && Alias == RHS.Alias;
49  }
50 };
51 
52 // An ES6 module reference.
53 //
54 // ES6 implements a module system, where individual modules (~= source files)
55 // can reference other modules, either importing symbols from them, or exporting
56 // symbols from them:
57 // import {foo} from 'foo';
58 // export {foo};
59 // export {bar} from 'bar';
60 //
61 // `export`s with URLs are syntactic sugar for an import of the symbol from the
62 // URL, followed by an export of the symbol, allowing this code to treat both
63 // statements more or less identically, with the exception being that `export`s
64 // are sorted last.
65 //
66 // imports and exports support individual symbols, but also a wildcard syntax:
67 // import * as prefix from 'foo';
68 // export * from 'bar';
69 //
70 // This struct represents both exports and imports to build up the information
71 // required for sorting module references.
73  bool FormattingOff = false;
74  bool IsExport = false;
75  // Module references are sorted into these categories, in order.
77  SIDE_EFFECT, // "import 'something';"
78  ABSOLUTE, // from 'something'
79  RELATIVE_PARENT, // from '../*'
80  RELATIVE, // from './*'
81  ALIAS, // import X = A.B;
82  };
83  ReferenceCategory Category = ReferenceCategory::SIDE_EFFECT;
84  // The URL imported, e.g. `import .. from 'url';`. Empty for `export {a, b};`.
85  StringRef URL;
86  // Prefix from "import * as prefix". Empty for symbol imports and `export *`.
87  // Implies an empty names list.
88  StringRef Prefix;
89  // Default import from "import DefaultName from '...';".
90  StringRef DefaultImport;
91  // Symbols from `import {SymbolA, SymbolB, ...} from ...;`.
93  // Whether some symbols were merged into this one. Controls if the module
94  // reference needs re-formatting.
95  bool SymbolsMerged = false;
96  // The source location just after { and just before } in the import.
97  // Extracted eagerly to allow modification of Symbols later on.
99  // Textual position of the import/export, including preceding and trailing
100  // comments.
102 };
103 
104 bool operator<(const JsModuleReference &LHS, const JsModuleReference &RHS) {
105  if (LHS.IsExport != RHS.IsExport)
106  return LHS.IsExport < RHS.IsExport;
107  if (LHS.Category != RHS.Category)
108  return LHS.Category < RHS.Category;
109  if (LHS.Category == JsModuleReference::ReferenceCategory::SIDE_EFFECT ||
111  // Side effect imports and aliases might be ordering sensitive. Consider
112  // them equal so that they maintain their relative order in the stable sort
113  // below. This retains transitivity because LHS.Category == RHS.Category
114  // here.
115  return false;
116  }
117  // Empty URLs sort *last* (for export {...};).
118  if (LHS.URL.empty() != RHS.URL.empty())
119  return LHS.URL.empty() < RHS.URL.empty();
120  if (int Res = LHS.URL.compare_insensitive(RHS.URL))
121  return Res < 0;
122  // '*' imports (with prefix) sort before {a, b, ...} imports.
123  if (LHS.Prefix.empty() != RHS.Prefix.empty())
124  return LHS.Prefix.empty() < RHS.Prefix.empty();
125  if (LHS.Prefix != RHS.Prefix)
126  return LHS.Prefix > RHS.Prefix;
127  return false;
128 }
129 
130 // JavaScriptImportSorter sorts JavaScript ES6 imports and exports. It is
131 // implemented as a TokenAnalyzer because ES6 imports have substantial syntactic
132 // structure, making it messy to sort them using regular expressions.
134 public:
136  : TokenAnalyzer(Env, Style),
137  FileContents(Env.getSourceManager().getBufferData(Env.getFileID())) {
138  // FormatToken.Tok starts out in an uninitialized state.
139  invalidToken.Tok.startToken();
140  }
141 
142  std::pair<tooling::Replacements, unsigned>
144  SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
145  FormatTokenLexer &Tokens) override {
146  tooling::Replacements Result;
147  AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
148 
149  const AdditionalKeywords &Keywords = Tokens.getKeywords();
151  AnnotatedLine *FirstNonImportLine;
152  std::tie(References, FirstNonImportLine) =
153  parseModuleReferences(Keywords, AnnotatedLines);
154 
155  if (References.empty())
156  return {Result, 0};
157 
158  // The text range of all parsed imports, to be replaced later.
159  SourceRange InsertionPoint = References[0].Range;
160  InsertionPoint.setEnd(References[References.size() - 1].Range.getEnd());
161 
162  References = sortModuleReferences(References);
163 
164  std::string ReferencesText;
165  for (unsigned I = 0, E = References.size(); I != E; ++I) {
166  JsModuleReference Reference = References[I];
167  appendReference(ReferencesText, Reference);
168  if (I + 1 < E) {
169  // Insert breaks between imports and exports.
170  ReferencesText += "\n";
171  // Separate imports groups with two line breaks, but keep all exports
172  // in a single group.
173  if (!Reference.IsExport &&
174  (Reference.IsExport != References[I + 1].IsExport ||
175  Reference.Category != References[I + 1].Category)) {
176  ReferencesText += "\n";
177  }
178  }
179  }
180  llvm::StringRef PreviousText = getSourceText(InsertionPoint);
181  if (ReferencesText == PreviousText)
182  return {Result, 0};
183 
184  // The loop above might collapse previously existing line breaks between
185  // import blocks, and thus shrink the file. SortIncludes must not shrink
186  // overall source length as there is currently no re-calculation of ranges
187  // after applying source sorting.
188  // This loop just backfills trailing spaces after the imports, which are
189  // harmless and will be stripped by the subsequent formatting pass.
190  // FIXME: A better long term fix is to re-calculate Ranges after sorting.
191  unsigned PreviousSize = PreviousText.size();
192  while (ReferencesText.size() < PreviousSize)
193  ReferencesText += " ";
194 
195  // Separate references from the main code body of the file.
196  if (FirstNonImportLine && FirstNonImportLine->First->NewlinesBefore < 2 &&
197  !(FirstNonImportLine->First->is(tok::comment) &&
198  FirstNonImportLine->First->TokenText.trim() ==
199  "// clang-format on")) {
200  ReferencesText += "\n";
201  }
202 
203  LLVM_DEBUG(llvm::dbgs() << "Replacing imports:\n"
204  << PreviousText << "\nwith:\n"
205  << ReferencesText << "\n");
206  auto Err = Result.add(tooling::Replacement(
208  ReferencesText));
209  // FIXME: better error handling. For now, just print error message and skip
210  // the replacement for the release version.
211  if (Err) {
212  llvm::errs() << llvm::toString(std::move(Err)) << "\n";
213  assert(false);
214  }
215 
216  return {Result, 0};
217  }
218 
219 private:
220  FormatToken *Current;
221  FormatToken *LineEnd;
222 
223  FormatToken invalidToken;
224 
225  StringRef FileContents;
226 
227  void skipComments() { Current = skipComments(Current); }
228 
229  FormatToken *skipComments(FormatToken *Tok) {
230  while (Tok && Tok->is(tok::comment))
231  Tok = Tok->Next;
232  return Tok;
233  }
234 
235  void nextToken() {
236  Current = Current->Next;
237  skipComments();
238  if (!Current || Current == LineEnd->Next) {
239  // Set the current token to an invalid token, so that further parsing on
240  // this line fails.
241  Current = &invalidToken;
242  }
243  }
244 
245  StringRef getSourceText(SourceRange Range) {
246  return getSourceText(Range.getBegin(), Range.getEnd());
247  }
248 
249  StringRef getSourceText(SourceLocation Begin, SourceLocation End) {
250  const SourceManager &SM = Env.getSourceManager();
251  return FileContents.substr(SM.getFileOffset(Begin),
252  SM.getFileOffset(End) - SM.getFileOffset(Begin));
253  }
254 
255  // Sorts the given module references.
256  // Imports can have formatting disabled (FormattingOff), so the code below
257  // skips runs of "no-formatting" module references, and sorts/merges the
258  // references that have formatting enabled in individual chunks.
259  SmallVector<JsModuleReference, 16>
260  sortModuleReferences(const SmallVector<JsModuleReference, 16> &References) {
261  // Sort module references.
262  // Imports can have formatting disabled (FormattingOff), so the code below
263  // skips runs of "no-formatting" module references, and sorts other
264  // references per group.
265  const auto *Start = References.begin();
266  SmallVector<JsModuleReference, 16> ReferencesSorted;
267  while (Start != References.end()) {
268  while (Start != References.end() && Start->FormattingOff) {
269  // Skip over all imports w/ disabled formatting.
270  ReferencesSorted.push_back(*Start);
271  ++Start;
272  }
273  SmallVector<JsModuleReference, 16> SortChunk;
274  while (Start != References.end() && !Start->FormattingOff) {
275  // Skip over all imports w/ disabled formatting.
276  SortChunk.push_back(*Start);
277  ++Start;
278  }
279  llvm::stable_sort(SortChunk);
280  mergeModuleReferences(SortChunk);
281  ReferencesSorted.insert(ReferencesSorted.end(), SortChunk.begin(),
282  SortChunk.end());
283  }
284  return ReferencesSorted;
285  }
286 
287  // Merge module references.
288  // After sorting, find all references that import named symbols from the
289  // same URL and merge their names. E.g.
290  // import {X} from 'a';
291  // import {Y} from 'a';
292  // should be rewritten to:
293  // import {X, Y} from 'a';
294  // Note: this modifies the passed in ``References`` vector (by removing no
295  // longer needed references).
296  void mergeModuleReferences(SmallVector<JsModuleReference, 16> &References) {
297  if (References.empty())
298  return;
299  JsModuleReference *PreviousReference = References.begin();
300  auto *Reference = std::next(References.begin());
301  while (Reference != References.end()) {
302  // Skip:
303  // import 'foo';
304  // import * as foo from 'foo'; on either previous or this.
305  // import Default from 'foo'; on either previous or this.
306  // mismatching
307  if (Reference->Category == JsModuleReference::SIDE_EFFECT ||
308  PreviousReference->Category == JsModuleReference::SIDE_EFFECT ||
309  Reference->IsExport != PreviousReference->IsExport ||
310  !PreviousReference->Prefix.empty() || !Reference->Prefix.empty() ||
311  !PreviousReference->DefaultImport.empty() ||
312  !Reference->DefaultImport.empty() || Reference->Symbols.empty() ||
313  PreviousReference->URL != Reference->URL) {
314  PreviousReference = Reference;
315  ++Reference;
316  continue;
317  }
318  // Merge symbols from identical imports.
319  PreviousReference->Symbols.append(Reference->Symbols);
320  PreviousReference->SymbolsMerged = true;
321  // Remove the merged import.
322  Reference = References.erase(Reference);
323  }
324  }
325 
326  // Appends ``Reference`` to ``Buffer``.
327  void appendReference(std::string &Buffer, JsModuleReference &Reference) {
328  if (Reference.FormattingOff) {
329  Buffer +=
330  getSourceText(Reference.Range.getBegin(), Reference.Range.getEnd());
331  return;
332  }
333  // Sort the individual symbols within the import.
334  // E.g. `import {b, a} from 'x';` -> `import {a, b} from 'x';`
335  SmallVector<JsImportedSymbol, 1> Symbols = Reference.Symbols;
336  llvm::stable_sort(
337  Symbols, [&](const JsImportedSymbol &LHS, const JsImportedSymbol &RHS) {
338  return LHS.Symbol.compare_insensitive(RHS.Symbol) < 0;
339  });
340  if (!Reference.SymbolsMerged && Symbols == Reference.Symbols) {
341  // Symbols didn't change, just emit the entire module reference.
342  StringRef ReferenceStmt = getSourceText(Reference.Range);
343  Buffer += ReferenceStmt;
344  return;
345  }
346  // Stitch together the module reference start...
347  Buffer += getSourceText(Reference.Range.getBegin(), Reference.SymbolsStart);
348  // ... then the references in order ...
349  if (!Symbols.empty()) {
350  Buffer += getSourceText(Symbols.front().Range);
351  for (const JsImportedSymbol &Symbol : llvm::drop_begin(Symbols)) {
352  Buffer += ",";
353  Buffer += getSourceText(Symbol.Range);
354  }
355  }
356  // ... followed by the module reference end.
357  Buffer += getSourceText(Reference.SymbolsEnd, Reference.Range.getEnd());
358  }
359 
360  // Parses module references in the given lines. Returns the module references,
361  // and a pointer to the first "main code" line if that is adjacent to the
362  // affected lines of module references, nullptr otherwise.
363  std::pair<SmallVector<JsModuleReference, 16>, AnnotatedLine *>
364  parseModuleReferences(const AdditionalKeywords &Keywords,
365  SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
366  SmallVector<JsModuleReference, 16> References;
367  SourceLocation Start;
368  AnnotatedLine *FirstNonImportLine = nullptr;
369  bool AnyImportAffected = false;
370  bool FormattingOff = false;
371  for (auto *Line : AnnotatedLines) {
372  assert(Line->First);
373  Current = Line->First;
374  LineEnd = Line->Last;
375  // clang-format comments toggle formatting on/off.
376  // This is tracked in FormattingOff here and on JsModuleReference.
377  while (Current && Current->is(tok::comment)) {
378  StringRef CommentText = Current->TokenText.trim();
379  if (CommentText == "// clang-format off") {
380  FormattingOff = true;
381  } else if (CommentText == "// clang-format on") {
382  FormattingOff = false;
383  // Special case: consider a trailing "clang-format on" line to be part
384  // of the module reference, so that it gets moved around together with
385  // it (as opposed to the next module reference, which might get sorted
386  // around).
387  if (!References.empty()) {
388  References.back().Range.setEnd(Current->Tok.getEndLoc());
389  Start = Current->Tok.getEndLoc().getLocWithOffset(1);
390  }
391  }
392  // Handle all clang-format comments on a line, e.g. for an empty block.
393  Current = Current->Next;
394  }
395  skipComments();
396  if (Start.isInvalid() || References.empty()) {
397  // After the first file level comment, consider line comments to be part
398  // of the import that immediately follows them by using the previously
399  // set Start.
400  Start = Line->First->Tok.getLocation();
401  }
402  if (!Current) {
403  // Only comments on this line. Could be the first non-import line.
404  FirstNonImportLine = Line;
405  continue;
406  }
407  JsModuleReference Reference;
408  Reference.FormattingOff = FormattingOff;
409  Reference.Range.setBegin(Start);
410  // References w/o a URL, e.g. export {A}, groups with RELATIVE.
411  Reference.Category = JsModuleReference::ReferenceCategory::RELATIVE;
412  if (!parseModuleReference(Keywords, Reference)) {
413  if (!FirstNonImportLine)
414  FirstNonImportLine = Line; // if no comment before.
415  break;
416  }
417  FirstNonImportLine = nullptr;
418  AnyImportAffected = AnyImportAffected || Line->Affected;
419  Reference.Range.setEnd(LineEnd->Tok.getEndLoc());
420  LLVM_DEBUG({
421  llvm::dbgs() << "JsModuleReference: {"
422  << "formatting_off: " << Reference.FormattingOff
423  << ", is_export: " << Reference.IsExport
424  << ", cat: " << Reference.Category
425  << ", url: " << Reference.URL
426  << ", prefix: " << Reference.Prefix;
427  for (const JsImportedSymbol &Symbol : Reference.Symbols)
428  llvm::dbgs() << ", " << Symbol.Symbol << " as " << Symbol.Alias;
429  llvm::dbgs() << ", text: " << getSourceText(Reference.Range);
430  llvm::dbgs() << "}\n";
431  });
432  References.push_back(Reference);
433  Start = SourceLocation();
434  }
435  // Sort imports if any import line was affected.
436  if (!AnyImportAffected)
437  References.clear();
438  return std::make_pair(References, FirstNonImportLine);
439  }
440 
441  // Parses a JavaScript/ECMAScript 6 module reference.
442  // See http://www.ecma-international.org/ecma-262/6.0/#sec-scripts-and-modules
443  // for grammar EBNF (production ModuleItem).
444  bool parseModuleReference(const AdditionalKeywords &Keywords,
445  JsModuleReference &Reference) {
446  if (!Current || !Current->isOneOf(Keywords.kw_import, tok::kw_export))
447  return false;
448  Reference.IsExport = Current->is(tok::kw_export);
449 
450  nextToken();
451  if (Current->isStringLiteral() && !Reference.IsExport) {
452  // "import 'side-effect';"
453  Reference.Category = JsModuleReference::ReferenceCategory::SIDE_EFFECT;
454  Reference.URL =
455  Current->TokenText.substr(1, Current->TokenText.size() - 2);
456  return true;
457  }
458 
459  if (!parseModuleBindings(Keywords, Reference))
460  return false;
461 
462  if (Current->is(Keywords.kw_from)) {
463  // imports have a 'from' clause, exports might not.
464  nextToken();
465  if (!Current->isStringLiteral())
466  return false;
467  // URL = TokenText without the quotes.
468  Reference.URL =
469  Current->TokenText.substr(1, Current->TokenText.size() - 2);
470  if (Reference.URL.startswith("..")) {
471  Reference.Category =
472  JsModuleReference::ReferenceCategory::RELATIVE_PARENT;
473  } else if (Reference.URL.startswith(".")) {
474  Reference.Category = JsModuleReference::ReferenceCategory::RELATIVE;
475  } else {
476  Reference.Category = JsModuleReference::ReferenceCategory::ABSOLUTE;
477  }
478  }
479  return true;
480  }
481 
482  bool parseModuleBindings(const AdditionalKeywords &Keywords,
483  JsModuleReference &Reference) {
484  if (parseStarBinding(Keywords, Reference))
485  return true;
486  return parseNamedBindings(Keywords, Reference);
487  }
488 
489  bool parseStarBinding(const AdditionalKeywords &Keywords,
490  JsModuleReference &Reference) {
491  // * as prefix from '...';
492  if (Current->isNot(tok::star))
493  return false;
494  nextToken();
495  if (Current->isNot(Keywords.kw_as))
496  return false;
497  nextToken();
498  if (Current->isNot(tok::identifier))
499  return false;
500  Reference.Prefix = Current->TokenText;
501  nextToken();
502  return true;
503  }
504 
505  bool parseNamedBindings(const AdditionalKeywords &Keywords,
506  JsModuleReference &Reference) {
507  // eat a potential "import X, " prefix.
508  if (Current->is(tok::identifier)) {
509  Reference.DefaultImport = Current->TokenText;
510  nextToken();
511  if (Current->is(Keywords.kw_from))
512  return true;
513  // import X = A.B.C;
514  if (Current->is(tok::equal)) {
516  nextToken();
517  while (Current->is(tok::identifier)) {
518  nextToken();
519  if (Current->is(tok::semi))
520  return true;
521  if (!Current->is(tok::period))
522  return false;
523  nextToken();
524  }
525  }
526  if (Current->isNot(tok::comma))
527  return false;
528  nextToken(); // eat comma.
529  }
530  if (Current->isNot(tok::l_brace))
531  return false;
532 
533  // {sym as alias, sym2 as ...} from '...';
534  Reference.SymbolsStart = Current->Tok.getEndLoc();
535  while (Current->isNot(tok::r_brace)) {
536  nextToken();
537  if (Current->is(tok::r_brace))
538  break;
539  if (!Current->isOneOf(tok::identifier, tok::kw_default))
540  return false;
541 
542  JsImportedSymbol Symbol;
543  Symbol.Symbol = Current->TokenText;
544  // Make sure to include any preceding comments.
545  Symbol.Range.setBegin(
546  Current->getPreviousNonComment()->Next->WhitespaceRange.getBegin());
547  nextToken();
548 
549  if (Current->is(Keywords.kw_as)) {
550  nextToken();
551  if (!Current->isOneOf(tok::identifier, tok::kw_default))
552  return false;
553  Symbol.Alias = Current->TokenText;
554  nextToken();
555  }
556  Symbol.Range.setEnd(Current->Tok.getLocation());
557  Reference.Symbols.push_back(Symbol);
558 
559  if (!Current->isOneOf(tok::r_brace, tok::comma))
560  return false;
561  }
562  Reference.SymbolsEnd = Current->Tok.getLocation();
563  // For named imports with a trailing comma ("import {X,}"), consider the
564  // comma to be the end of the import list, so that it doesn't get removed.
565  if (Current->Previous->is(tok::comma))
566  Reference.SymbolsEnd = Current->Previous->Tok.getLocation();
567  nextToken(); // consume r_brace
568  return true;
569  }
570 };
571 
573  StringRef Code,
575  StringRef FileName) {
576  // FIXME: Cursor support.
577  auto Env = Environment::make(Code, FileName, Ranges);
578  if (!Env)
579  return {};
580  return JavaScriptImportSorter(*Env, Style).process().first;
581 }
582 
583 } // end namespace format
584 } // end namespace clang
clang::Token::startToken
void startToken()
Reset all flags to cleared.
Definition: Token.h:170
clang::format::JsModuleReference
Definition: SortJavaScriptImports.cpp:72
clang::format::JsModuleReference::RELATIVE
@ RELATIVE
Definition: SortJavaScriptImports.cpp:80
clang::format::JsModuleReference::SymbolsEnd
SourceLocation SymbolsEnd
Definition: SortJavaScriptImports.cpp:98
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::format::TokenAnalyzer::Env
const Environment & Env
Definition: TokenAnalyzer.h:106
clang::format::JsImportedSymbol::Symbol
StringRef Symbol
Definition: SortJavaScriptImports.cpp:41
clang::format::AnnotatedLine::First
FormatToken * First
Definition: TokenAnnotator.h:121
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::format::JsModuleReference::IsExport
bool IsExport
Definition: SortJavaScriptImports.cpp:74
clang::format::JsImportedSymbol::Range
SourceRange Range
Definition: SortJavaScriptImports.cpp:43
clang::Token::getEndLoc
SourceLocation getEndLoc() const
Definition: Token.h:152
clang::format::JavaScriptImportSorter::JavaScriptImportSorter
JavaScriptImportSorter(const Environment &Env, const FormatStyle &Style)
Definition: SortJavaScriptImports.cpp:135
clang::tooling::Replacements
Maintains a set of replacements that are conflict-free.
Definition: Replacement.h:209
clang::format::FormatStyle
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:54
clang::format::FormatToken::TokenText
StringRef TokenText
The raw text of the token.
Definition: FormatToken.h:245
clang::dataflow::SkipPast::Reference
@ Reference
An optional reference should be skipped past.
clang::format::FormatToken
A wrapper around a Token storing information about the whitespace characters preceding it.
Definition: FormatToken.h:227
clang::format::JsModuleReference::Symbols
SmallVector< JsImportedSymbol, 1 > Symbols
Definition: SortJavaScriptImports.cpp:92
clang::format::AdditionalKeywords
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's l...
Definition: FormatToken.h:885
SourceManager.h
clang::format::TokenAnalyzer::process
std::pair< tooling::Replacements, unsigned > process()
Definition: TokenAnalyzer.cpp:100
Format.h
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::format::FormatToken::NewlinesBefore
unsigned NewlinesBefore
The number of newlines immediately before the Token.
Definition: FormatToken.h:375
TokenAnnotator.h
TokenKinds.h
clang::CharSourceRange::getCharRange
static CharSourceRange getCharRange(SourceRange R)
Definition: SourceLocation.h:265
clang::format::JavaScriptImportSorter
Definition: SortJavaScriptImports.cpp:133
clang::format::FormatToken::Tok
Token Tok
The Token.
Definition: FormatToken.h:239
clang::format::JavaScriptImportSorter::analyze
std::pair< tooling::Replacements, unsigned > analyze(TokenAnnotator &Annotator, SmallVectorImpl< AnnotatedLine * > &AnnotatedLines, FormatTokenLexer &Tokens) override
Definition: SortJavaScriptImports.cpp:143
clang::format::TokenAnalyzer::AffectedRangeMgr
AffectedRangeManager AffectedRangeMgr
Definition: TokenAnalyzer.h:108
clang::threadSafety::sx::toString
std::string toString(const til::SExpr *E)
Definition: ThreadSafetyCommon.h:90
clang::format::JsModuleReference::SymbolsStart
SourceLocation SymbolsStart
Definition: SortJavaScriptImports.cpp:98
Diagnostic.h
clang::format::AnnotatedLine
Definition: TokenAnnotator.h:36
clang::format::Environment
Definition: TokenAnalyzer.h:37
clang::format::JsImportedSymbol::operator==
bool operator==(const JsImportedSymbol &RHS) const
Definition: SortJavaScriptImports.cpp:45
clang::format::TokenAnnotator
Determines extra information about the tokens comprising an UnwrappedLine.
Definition: TokenAnnotator.h:156
SortJavaScriptImports.h
clang::SourceRange::setEnd
void setEnd(SourceLocation e)
Definition: SourceLocation.h:223
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:68
clang::format::JsModuleReference::Prefix
StringRef Prefix
Definition: SortJavaScriptImports.cpp:88
clang::format::operator<
bool operator<(const JsModuleReference &LHS, const JsModuleReference &RHS)
Definition: SortJavaScriptImports.cpp:104
clang::format::JsModuleReference::Range
SourceRange Range
Definition: SortJavaScriptImports.cpp:101
clang::transformer::EditKind::Range
@ Range
clang::format::Environment::getSourceManager
const SourceManager & getSourceManager() const
Definition: TokenAnalyzer.h:49
SourceLocation.h
clang::format::JsModuleReference::FormattingOff
bool FormattingOff
Definition: SortJavaScriptImports.cpp:73
ALIAS
#define ALIAS(NAME, TOK, FLAGS)
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:165
llvm::ArrayRef
Definition: LLVM.h:34
clang::tooling::Replacement
A text replacement.
Definition: Replacement.h:83
clang::format::FormatToken::is
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:500
LLVM.h
clang::format::JsModuleReference::ALIAS
@ ALIAS
Definition: SortJavaScriptImports.cpp:81
clang::format::sortJavaScriptImports
tooling::Replacements sortJavaScriptImports(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName)
Definition: SortJavaScriptImports.cpp:572
clang::format::JsImportedSymbol
Definition: SortJavaScriptImports.cpp:40
clang
Definition: CalledOnceCheck.h:17
clang::format::TokenAnalyzer
Definition: TokenAnalyzer.h:88
clang::format::JsModuleReference::ReferenceCategory
ReferenceCategory
Definition: SortJavaScriptImports.cpp:76
clang::format::JsModuleReference::RELATIVE_PARENT
@ RELATIVE_PARENT
Definition: SortJavaScriptImports.cpp:79
clang::format::FormatTokenLexer
Definition: FormatTokenLexer.h:39
clang::format::JsModuleReference::URL
StringRef URL
Definition: SortJavaScriptImports.cpp:85
clang::format::JsModuleReference::SymbolsMerged
bool SymbolsMerged
Definition: SortJavaScriptImports.cpp:95
clang::format::JsModuleReference::DefaultImport
StringRef DefaultImport
Definition: SortJavaScriptImports.cpp:90
DiagnosticOptions.h
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::format::FormatToken::Next
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:472
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::format::JsModuleReference::Category
ReferenceCategory Category
Definition: SortJavaScriptImports.cpp:83
clang::format::JsImportedSymbol::Alias
StringRef Alias
Definition: SortJavaScriptImports.cpp:42
clang::format::AffectedRangeManager::computeAffectedLines
bool computeAffectedLines(SmallVectorImpl< AnnotatedLine * > &Lines)
Definition: AffectedRangeManager.cpp:22
clang::format::TokenAnalyzer::Style
FormatStyle Style
Definition: TokenAnalyzer.h:104
TokenAnalyzer.h
clang::format::JsModuleReference::SIDE_EFFECT
@ SIDE_EFFECT
Definition: SortJavaScriptImports.cpp:77
clang::format::Environment::make
static std::unique_ptr< Environment > make(StringRef Code, StringRef FileName, ArrayRef< tooling::Range > Ranges, unsigned FirstStartColumn=0, unsigned NextStartColumn=0, unsigned LastStartColumn=0)
Definition: TokenAnalyzer.cpp:59
clang::format::JsModuleReference::ABSOLUTE
@ ABSOLUTE
Definition: SortJavaScriptImports.cpp:78