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