[clang-format][NFC] Replace most of std::vector with SmallVector

[curdeius]

clang/lib/Format/ContinuationIndenter.cpp

40

Sorry for a late comment. I think that in a parameter list, we should use SmallVectorBase to avoid changing the type if the inplace element count changes. That's not important now though.

[owenpan]

clang/lib/Format/ContinuationIndenter.cpp

40

Hmm. I can't find an example of SmallVectorBase in llvm-project sources, though.

[curdeius]

clang/lib/Format/ContinuationIndenter.cpp

40

Typo, it's Impl: https://llvm.org/doxygen/classllvm_1_1SmallVectorImpl.html

[owenpan]

clang/lib/Format/ContinuationIndenter.cpp

40

Good catch, though ArrayRef is more appropriate in this case. See https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h. Fixed in a7789d6.

clang/lib/Format/ContinuationIndenter.h

struct LineState {
   unsigned LowestLevelOnLine;
 
   /// The start column of the string literal, if we're in a string
   /// literal sequence, 0 otherwise.
   unsigned StartOfStringLiteral;
 
   /// A stack keeping track of properties applying to parenthesis
   /// levels.
-  std::vector<ParenState> Stack;
+  SmallVector<ParenState> Stack;
 
   /// Ignore the stack of \c ParenStates for state comparison.
   ///
   /// In long and deeply nested unwrapped lines, the current algorithm can
   /// be insufficient for finding the best formatting with a reasonable amount
   /// of time and memory. Setting this flag will effectively lead to the
   /// algorithm not analyzing some combinations. However, these combinations
   /// rarely contain the optimal solution: In short, accepting a higher

clang/lib/Format/ContinuationIndenter.cpp

 static bool shouldIndentWrappedSelectorName(const FormatStyle &Style,
                                             LineType LineType) {
   return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl;
 }
 
 // Returns the length of everything up to the first possible line break after
 // the ), ], } or > matching \c Tok.
 static unsigned getLengthToMatchingParen(const FormatToken &Tok,
-                                         const std::vector<ParenState> &Stack) {
+                                         const SmallVector<ParenState> &Stack) {
   // Normally whether or not a break before T is possible is calculated and
   // stored in T.CanBreakBefore. Braces, array initializers and text proto
   // messages like `key: < ... >` are an exception: a break is possible
   // before a closing brace R if a break was inserted after the corresponding
   // opening brace. The information about whether or not a break is needed
   // before a closing brace R is stored in the ParenState field
   // S.BreakBeforeClosingBrace where S is the state that R closes.
   //

clang/lib/Format/Format.cpp

private:
   // Delete the given token.
   inline void deleteToken(FormatToken *Tok) {
     if (Tok)
       DeletedTokens.insert(Tok);
   }
 
   tooling::Replacements generateFixes() {
     tooling::Replacements Fixes;
-    std::vector<FormatToken *> Tokens;
+    SmallVector<FormatToken *> Tokens;
     std::copy(DeletedTokens.begin(), DeletedTokens.end(),
               std::back_inserter(Tokens));
 
     // Merge multiple continuous token deletions into one big deletion so that
     // the number of replacements can be reduced. This makes computing affected
     // ranges more efficient when we run reformat on the changed code.
     unsigned Idx = 0;
     while (Idx < Tokens.size()) {
struct IncludeDirective {
   int Category;
   int Priority;
 };
 
 struct JavaImportDirective {
   StringRef Identifier;
   StringRef Text;
   unsigned Offset;
-  std::vector<StringRef> AssociatedCommentLines;
+  SmallVector<StringRef> AssociatedCommentLines;
   bool IsStatic;
 };
 
 } // end anonymous namespace
 
 // Determines whether 'Ranges' intersects with ('Start', 'End').
 static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
                          unsigned End) {
tooling::Replacements sortJavaImports(const FormatStyle &Style, StringRef Code,
                                       ArrayRef<tooling::Range> Ranges,
                                       StringRef FileName,
                                       tooling::Replacements &Replaces) {
   unsigned Prev = 0;
   unsigned SearchFrom = 0;
   llvm::Regex ImportRegex(JavaImportRegexPattern);
   SmallVector<StringRef, 4> Matches;
   SmallVector<JavaImportDirective, 16> ImportsInBlock;
-  std::vector<StringRef> AssociatedCommentLines;
+  SmallVector<StringRef> AssociatedCommentLines;
 
   bool FormattingOff = false;
 
   for (;;) {
     auto Pos = Code.find('\n', SearchFrom);
     StringRef Line =
         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
 

clang/lib/Format/FormatToken.cpp

if (Commas.size() < 5 || HasSeparatingComment)
     return;
 
   if (Token->NestingLevel != 0 && Token->is(tok::l_brace) && Commas.size() < 19)
     return;
 
   // We can never place more than ColumnLimit / 3 items in a row (because of the
   // spaces and the comma).
   unsigned MaxItems = Style.ColumnLimit / 3;
-  std::vector<unsigned> MinSizeInColumn;
+  SmallVector<unsigned> MinSizeInColumn;
   MinSizeInColumn.reserve(MaxItems);
   for (unsigned Columns = 1; Columns <= MaxItems; ++Columns) {
     ColumnFormat Format;
     Format.Columns = Columns;
     Format.ColumnSizes.resize(Columns);
     MinSizeInColumn.assign(Columns, UINT_MAX);
     Format.LineCount = 1;
     bool HasRowWithSufficientColumns = false;

clang/lib/Format/Macros.h

private:
   class DefinitionParser;
 
   void parseDefinition(const std::string &Macro);
 
   clang::SourceManager &SourceMgr;
   const FormatStyle &Style;
   llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator;
   IdentifierTable &IdentTable;
-  std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers;
+  SmallVector<std::unique_ptr<llvm::MemoryBuffer>> Buffers;
   llvm::StringMap<Definition> Definitions;
 };
 
 /// Converts a sequence of UnwrappedLines containing expanded macros into a
 /// single UnwrappedLine containing the macro calls.  This UnwrappedLine may be
 /// broken into child lines, in a way that best conveys the structure of the
 /// expanded code.
 ///

clang/lib/Format/UnwrappedLineFormatter.cpp

struct StateNode {
     StateNode *Previous;
   };
 
   /// An item in the prioritized BFS search queue. The \c StateNode's
   /// \c State has the given \c OrderedPenalty.
   typedef std::pair<OrderedPenalty, StateNode *> QueueItem;
 
   /// The BFS queue type.
-  typedef std::priority_queue<QueueItem, std::vector<QueueItem>,
+  typedef std::priority_queue<QueueItem, SmallVector<QueueItem>,
                               std::greater<QueueItem>>
       QueueType;
 
   /// Analyze the entire solution space starting from \p InitialState.
   ///
   /// This implements a variant of Dijkstra's algorithm on the graph that spans
   /// the solution space (\c LineStates are the nodes). The algorithm tries to
   /// find the shortest path (the one with lowest penalty) from \p InitialState