[clangd] NFC: Use SmallVector<T> where possible

[kbobyrev]

Summary

SmallVector<T> with default size is now the recommended version (D92522).

[kbobyrev]

I've excluded the cases where the size does not seem arbitrary (e.g. 1/ code relying on sizeof(Something) == Value, e.g. dex payloads and CodeCompletion bundles). The rest looks fairly innocent but I don't know all the code around changed lines.

[njames93]

Not sure I'm a huge fan of this, Some of these cases the size is specified because that's the upper limit we typically expect the SmallVector to use.

[sammccall]

Thanks for cleaning up!

In D92788#2438207, @njames93 wrote:

Not sure I'm a huge fan of this, Some of these cases the size is specified because that's the upper limit we typically expect the SmallVector to use.

The idea behind the new LLVM-wide recommendation is that in principle this is true but in practice it's mostly false (at least, these estimates often aren't chosen carefully).

This seems true to me - we do try to guess a sensible value (when forced to choose something), but we probably shouldn't be specifying these where we wouldn't choose to e.g. reserve() in a std::vector.
There's some readability/maintenance cost and in most cases no performance difference at the level we typically care about.

I've flagged cases where it seems like it might matter - please do the same if you find any!

clang-tools-extra/clangd/CompileCommands.cpp

334

This is significant in size (around half a megabyte per the comment on ArgStripper). Rule is 24 bytes, so we're reducing N from 4 to 2 I believe.
Please leave this alone or check that it's a reduction in memory usage (if memory usage is roughly equal, fewer heap allocations is better).

clang-tools-extra/clangd/Selection.cpp

784

I'd prefer to keep the 2 here for readability, it's a nice hint/reminder that we *always* return 1 or 2 values

clang-tools-extra/clangd/TUScheduler.cpp

1414

This *always* allocates and the previous version *never* allocates, please revert this one.

clang-tools-extra/clangd/index/FileIndex.cpp

330

this is a reduction from 4 to 2, and this is fairly performance-sensitive code (for the preamble index).
My intuition is that not that many symbols are referenced 1-2 times across all TUs, and when many are, it's a tiny project where performance doesn't matter.
Guessing about performance is probably folly. But I'd probably avoid reducing this without measuring.

[kbobyrev]

Resolve review comments.

@sammccall, thanks for clarifying the cases you thought should be remaining as
they are!

[njames93]

clang-tools-extra/clangd/ConfigProvider.cpp

100

This should be using the same size as the vector below as they are guaranteed to be the same size. There may be an argument for merging them both into the same vector using a pair but obviously that wouldn't be part of this patch.

clang-tools-extra/clangd/SemanticHighlighting.cpp

608

Looks like this is referring to how many bytes are in a line, having 128 seems like a good amount, most coding standards don't like lines longer than that. As a follow up refractor, this could be extracted out the loop to reuse the buffer on the case it does need to allocate.

clang-tools-extra/clangd/unittests/TestTU.cpp

190

A follow up refractor, this doesn't strictly need to be stored in a vector.

[sammccall]

clang-tools-extra/clangd/SemanticHighlighting.cpp

608

Nit; This is rather the encoded data for all the highlighted tokens on a line of source code. Which appears to be a constant 8 bytes for token. So previously 16 tokens, now 32 tokens. Either seems fine to me given we don't highlight most punctuation I think.

(Incidentally, this is the old pre-standard semantic highlighting protocol that will go away soon, so I wouldn't worry too much about its performance)

[kbobyrev]

Revert the case flagged by @njames93.

clang-tools-extra/clangd/unittests/TestTU.cpp

190

Could you please elaborate? I don't really understand this comment.

[kbobyrev]

clang-tools-extra/clangd/unittests/TestTU.cpp

190

(D92986 for context)

[kbobyrev]

clang-tools-extra/clangd/unittests/TestTU.cpp

190

sigh, sorry, I forgot to remove it before pushing :(

[arphaman]

clang-tools-extra/clangd/Headers.h

139

It looks like the change on this line is failing to compile on Ubuntu 16.04 with the System GCC. (https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-16_04-next/23655/console).

Can I reinstate the llvm::DenseMap<unsigned, SmallVector<unsigned, 8>> for now until we drop support for Ubuntu 16.04?

[kbobyrev]

clang-tools-extra/clangd/Headers.h

139

Uh, didn't see that one, I'm sorry to hear that. Yes, sure, feel free to change it to make your setup work!

[sammccall]

clang-tools-extra/clangd/Headers.h

139

From the error message, it looks like the declarations of clang::SmallVector in LLVM.h are missing the default template arguments (not sure why this is different in the swift CI).

Does changing to qualifying as llvm::SmallVector work here, rather than adding the explicit size? (We usually do this anyway as a matter of style)

[arphaman]

clang-tools-extra/clangd/Headers.h

139

It looks like the GCC there might have a bug and is picking up the template<typename T, unsigned N> class SmallVector; in clang/include/clang/Basic/LLVM.h without taking the declaration from the LLVM headers into account. I'm not quite sure why it does that, but it seems to be fixed in GCC included in Ubuntu 18.

[sammccall]

Should be fixed in 894c4761c67ac850e156a26aa427035a811d7aed, LMK if this workaround doesn't work

clang-tools-extra/clangd/AST.cpp

if (llvm::Optional<llvm::ArrayRef<TemplateArgumentLoc>> Args =
           getTemplateSpecializationArgLocs(ND)) {
     printTemplateArgumentList(OS, *Args, Policy);
   } else if (auto *Cls = llvm::dyn_cast<ClassTemplateSpecializationDecl>(&ND)) {
     if (const TypeSourceInfo *TSI = Cls->getTypeAsWritten()) {
       // ClassTemplateSpecializationDecls do not contain
       // TemplateArgumentTypeLocs, they only have TemplateArgumentTypes. So we
       // create a new argument location list from TypeSourceInfo.
       auto STL = TSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>();
-      llvm::SmallVector<TemplateArgumentLoc, 8> ArgLocs;
+      llvm::SmallVector<TemplateArgumentLoc> ArgLocs;
       ArgLocs.reserve(STL.getNumArgs());
       for (unsigned I = 0; I < STL.getNumArgs(); ++I)
         ArgLocs.push_back(STL.getArgLoc(I));
       printTemplateArgumentList(OS, ArgLocs, Policy);
     } else {
       // FIXME: Fix cases when getTypeAsWritten returns null inside clang AST,
       // e.g. friend decls. Currently we fallback to Template Arguments without
       // location information.

clang-tools-extra/clangd/CompileCommands.h

struct Rule {
     unsigned char Modes = 0; // Rule applies only in specified driver modes.
     uint16_t Priority = 0;   // Lower is better.
     uint16_t ExactArgs = 0;  // Num args consumed when Arg == Text.
     uint16_t PrefixArgs = 0; // Num args consumed when Arg starts with Text.
   };
   static llvm::ArrayRef<Rule> rulesFor(llvm::StringRef Arg);
   const Rule *matchingRule(llvm::StringRef Arg, unsigned Mode,
                            unsigned &ArgCount) const;
-  llvm::SmallVector<Rule, 4> Rules;
+  llvm::SmallVector<Rule> Rules;
   std::deque<std::string> Storage; // Store strings not found in option table.
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/CompileCommands.cpp

 
 } // namespace
 
 llvm::ArrayRef<ArgStripper::Rule> ArgStripper::rulesFor(llvm::StringRef Arg) {
   // All the hard work is done once in a static initializer.
   // We compute a table containing strings to look for and #args to skip.
   // e.g. "-x" => {-x 2 args, -x* 1 arg, --language 2 args, --language=* 1 arg}
   using TableTy =
-      llvm::StringMap<llvm::SmallVector<Rule, 4>, llvm::BumpPtrAllocator>;
+      llvm::StringMap<llvm::SmallVector<Rule>, llvm::BumpPtrAllocator>;
   static TableTy *Table = [] {
     auto &DriverTable = driver::getDriverOptTable();
     using DriverID = clang::driver::options::ID;
 
     // Collect sets of aliases, so we can treat -foo and -foo= as synonyms.
     // Conceptually a double-linked list: PrevAlias[I] -> I -> NextAlias[I].
     // If PrevAlias[I] is INVALID, then I is canonical.
     DriverID PrevAlias[DriverID::LastOption] = {DriverID::OPT_INVALID};

 #undef PREFIX
 
     auto Result = std::make_unique<TableTy>();
     // Iterate over distinct options (represented by the canonical alias).
     // Every spelling of this option will get the same set of rules.
     for (unsigned ID = 1 /*Skip INVALID */; ID < DriverID::LastOption; ++ID) {
       if (PrevAlias[ID] || ID == DriverID::OPT_Xclang)
         continue; // Not canonical, or specially handled.
-      llvm::SmallVector<Rule, 8> Rules;
+      llvm::SmallVector<Rule> Rules;
       // Iterate over each alias, to add rules for parsing it.
       for (unsigned A = ID; A != DriverID::OPT_INVALID; A = NextAlias[A]) {
         if (Prefixes[A] == nullptr) // option groups.
           continue;
         auto Opt = DriverTable.getOption(A);
         // Exclude - and -foo pseudo-options.
         if (Opt.getName().empty())
           continue;

clang-tools-extra/clangd/ConfigCompile.cpp

struct FragmentCompiler {
   }
 
   // Helper with similar API to StringSwitch, for parsing enum values.
   template <typename T> class EnumSwitch {
     FragmentCompiler &Outer;
     llvm::StringRef EnumName;
     const Located<std::string> &Input;
     llvm::Optional<T> Result;
-    llvm::SmallVector<llvm::StringLiteral, 8> ValidValues;
+    llvm::SmallVector<llvm::StringLiteral> ValidValues;
 
   public:
     EnumSwitch(llvm::StringRef EnumName, const Located<std::string> &In,
                FragmentCompiler &Outer)
         : Outer(Outer), EnumName(EnumName), Input(In) {}
 
     EnumSwitch &map(llvm::StringLiteral Name, T Value) {
       assert(!llvm::is_contained(ValidValues, Name) && "Duplicate value!");

clang-tools-extra/clangd/ConfigProvider.cpp

class RelFileProvider : public Provider {
     getFragments(const Params &P, DiagnosticCallback DC) const override {
       namespace path = llvm::sys::path;
 
       if (P.Path.empty())
         return {};
 
       // Compute absolute paths to all ancestors (substrings of P.Path).
       llvm::StringRef Parent = path::parent_path(P.Path);
-      llvm::SmallVector<llvm::StringRef, 8> Ancestors;
+      llvm::SmallVector<llvm::StringRef> Ancestors;
       for (auto I = path::begin(Parent, path::Style::posix),
                 E = path::end(Parent);
            I != E; ++I) {
         // Avoid weird non-substring cases like phantom "." components.
         // In practice, Component is a substring for all "normal" ancestors.
         if (I->end() < Parent.begin() || I->end() > Parent.end())
           continue;
         Ancestors.emplace_back(Parent.begin(), I->end() - Parent.begin());
       }
       // Ensure corresponding cache entries exist in the map.
-      llvm::SmallVector<FileConfigCache *, 8> Caches;
+      llvm::SmallVector<FileConfigCache *> Caches;
       {
         std::lock_guard<std::mutex> Lock(Mu);
         for (llvm::StringRef Ancestor : Ancestors) {
           auto It = Cache.find(Ancestor);
           // Assemble the actual config file path only once.
           if (It == Cache.end()) {
             llvm::SmallString<256> ConfigPath = Ancestor;
             path::append(ConfigPath, RelPath);

clang-tools-extra/clangd/FileDistance.cpp

 
 constexpr const unsigned FileDistance::Unreachable;
 const llvm::hash_code FileDistance::RootHash =
     llvm::hash_value(llvm::StringRef("/"));
 
 FileDistance::FileDistance(llvm::StringMap<SourceParams> Sources,
                            const FileDistanceOptions &Opts)
     : Opts(Opts) {
-  llvm::DenseMap<llvm::hash_code, llvm::SmallVector<llvm::hash_code, 4>>
-      DownEdges;
+  llvm::DenseMap<llvm::hash_code, llvm::SmallVector<llvm::hash_code>> DownEdges;
   // Compute the best distance following only up edges.
   // Keep track of down edges, in case we can use them to improve on this.
   for (const auto &S : Sources) {
     auto Canonical = canonicalize(S.getKey());
     dlog("Source {0} = {1}, MaxUp = {2}", Canonical, S.second.Cost,
          S.second.MaxUpTraversals);
     // Walk up to ancestors of this source, assigning cost.
     llvm::StringRef Rest = Canonical;
for (auto Child : DownEdges.lookup(Parent)) {
       Next.push(Child);
     }
   }
 }
 
 unsigned FileDistance::distance(llvm::StringRef Path) {
   auto Canonical = canonicalize(Path);
   unsigned Cost = Unreachable;
-  llvm::SmallVector<llvm::hash_code, 16> Ancestors;
+  llvm::SmallVector<llvm::hash_code> Ancestors;
   // Walk up ancestors until we find a path we know the distance for.
   for (llvm::StringRef Rest = Canonical; !Rest.empty();
        Rest = parent_path(Rest, llvm::sys::path::Style::posix)) {
     auto Hash = llvm::hash_value(Rest);
     if (Hash == RootHash && !Ancestors.empty() &&
         !Opts.AllowDownTraversalFromRoot) {
       Cost = Unreachable;
       break;
if (!Delegate) {
     dlog("FileDistance for scheme {0}: {1}/{2} sources", Scheme,
          SchemeSources.size(), Sources.size());
     Delegate.reset(new FileDistance(std::move(SchemeSources), Opts));
   }
   return *Delegate;
 }
 
 static std::pair<std::string, int> scopeToPath(llvm::StringRef Scope) {
-  llvm::SmallVector<llvm::StringRef, 4> Split;
+  llvm::SmallVector<llvm::StringRef> Split;
   Scope.split(Split, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
   return {"/" + llvm::join(Split, "/"), Split.size()};
 }
 
 static FileDistance
 createScopeFileDistance(llvm::ArrayRef<std::string> QueryScopes) {
   FileDistanceOptions Opts;
   Opts.UpCost = 2;

clang-tools-extra/clangd/FindTarget.cpp

explicitReferenceTargets(DynTypedNode N, DeclRelationSet Mask) {
   }
   if (!SeenTemplateInstantiations)
     Targets.insert(Targets.end(), TemplatePatterns.begin(),
                    TemplatePatterns.end());
   return Targets;
 }
 
 namespace {
-llvm::SmallVector<ReferenceLoc, 2> refInDecl(const Decl *D) {
+llvm::SmallVector<ReferenceLoc> refInDecl(const Decl *D) {
   struct Visitor : ConstDeclVisitor<Visitor> {
-    llvm::SmallVector<ReferenceLoc, 2> Refs;
+    llvm::SmallVector<ReferenceLoc> Refs;
 
     void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
       // We want to keep it as non-declaration references, as the
       // "using namespace" declaration doesn't have a name.
       Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
                                   D->getIdentLocation(),
                                   /*IsDecl=*/false,
                                   {D->getNominatedNamespaceAsWritten()}});
struct Visitor : ConstDeclVisitor<Visitor> {
     }
   };
 
   Visitor V;
   V.Visit(D);
   return V.Refs;
 }
 
-llvm::SmallVector<ReferenceLoc, 2> refInStmt(const Stmt *S) {
+llvm::SmallVector<ReferenceLoc> refInStmt(const Stmt *S) {
   struct Visitor : ConstStmtVisitor<Visitor> {
     // FIXME: handle more complicated cases: more ObjC, designated initializers.
-    llvm::SmallVector<ReferenceLoc, 2> Refs;
+    llvm::SmallVector<ReferenceLoc> Refs;
 
     void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
       Refs.push_back(ReferenceLoc{E->getNestedNameSpecifierLoc(),
                                   E->getConceptNameLoc(),
                                   /*IsDecl=*/false,
                                   {E->getNamedConcept()}});
     }
 
struct Visitor : ConstStmtVisitor<Visitor> {
     }
   };
 
   Visitor V;
   V.Visit(S);
   return V.Refs;
 }
 
-llvm::SmallVector<ReferenceLoc, 2> refInTypeLoc(TypeLoc L) {
+llvm::SmallVector<ReferenceLoc> refInTypeLoc(TypeLoc L) {
   struct Visitor : TypeLocVisitor<Visitor> {
     llvm::Optional<ReferenceLoc> Ref;
 
     void VisitElaboratedTypeLoc(ElaboratedTypeLoc L) {
       // We only know about qualifier, rest if filled by inner locations.
       Visit(L.getNamedTypeLoc().getUnqualifiedLoc());
       // Fill in the qualifier.
       if (!Ref)
private:
   ///   - for implicitly generated nodes (e.g. MemberExpr from range-based-for),
   ///     source location information may be missing,
   ///   - for dependent code, targets may be empty.
   ///
   /// (!) For the purposes of this function declarations are not considered to
   ///     be references. However, declarations can have references inside them,
   ///     e.g. 'namespace foo = std' references namespace 'std' and this
   ///     function will return the corresponding reference.
-  llvm::SmallVector<ReferenceLoc, 2> explicitReference(DynTypedNode N) {
+  llvm::SmallVector<ReferenceLoc> explicitReference(DynTypedNode N) {
     if (auto *D = N.get<Decl>())
       return refInDecl(D);
     if (auto *S = N.get<Stmt>())
       return refInStmt(S);
     if (auto *NNSL = N.get<NestedNameSpecifierLoc>()) {
       // (!) 'DeclRelation::Alias' ensures we do not loose namespace aliases.
       return {ReferenceLoc{
           NNSL->getPrefix(), NNSL->getLocalBeginLoc(), false,

clang-tools-extra/clangd/Headers.h

private:
   // builds is surprisingly hard. FileID is unavailable in InclusionDirective(),
   // and RealPathName and UniqueID are not preserved in the preamble.
   // We use the FileEntry::Name, which is stable, interned into a "file index".
   // The paths we want to expose are the RealPathName, so store those too.
   std::vector<std::string> RealPathNames; // In file index order.
   unsigned fileIndex(llvm::StringRef Name);
   llvm::StringMap<unsigned> NameToIndex; // Values are file indexes.
   // Maps a file's index to that of the files it includes.
-  llvm::DenseMap<unsigned, SmallVector<unsigned, 8>> IncludeChildren;
+  llvm::DenseMap<unsigned, SmallVector<unsigned>> IncludeChildren;
 };
 
 /// Returns a PPCallback that visits all inclusions in the main file.
 std::unique_ptr<PPCallbacks>
 collectIncludeStructureCallback(const SourceManager &SM, IncludeStructure *Out);
 
 // Calculates insertion edit for including a new header in a file.
 class IncludeInserter {

clang-tools-extra/clangd/QueryDriverDatabase.cpp

bool isValidTarget(llvm::StringRef Triple) {
   return bool(Target);
 }
 
 llvm::Optional<DriverInfo> parseDriverOutput(llvm::StringRef Output) {
   DriverInfo Info;
   const char SIS[] = "#include <...> search starts here:";
   const char SIE[] = "End of search list.";
   const char TS[] = "Target: ";
-  llvm::SmallVector<llvm::StringRef, 8> Lines;
+  llvm::SmallVector<llvm::StringRef> Lines;
   Output.split(Lines, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 
   enum {
     Initial,            // Initial state: searching for target or includes list.
     IncludesExtracting, // Includes extracting.
     Done                // Includes and target extraction done.
   } State = Initial;
   bool SeenIncludes = false;
if (auto EC = llvm::sys::fs::createTemporaryFile("system-includes", "clangd",
     return llvm::None;
   }
   auto CleanUp = llvm::make_scope_exit(
       [&StdErrPath]() { llvm::sys::fs::remove(StdErrPath); });
 
   llvm::Optional<llvm::StringRef> Redirects[] = {
       {""}, {""}, llvm::StringRef(StdErrPath)};
 
-  llvm::SmallVector<llvm::StringRef, 12> Args = {Driver, "-E", "-x",
-                                                 Lang,   "-",  "-v"};
+  llvm::SmallVector<llvm::StringRef> Args = {Driver, "-E", "-x",
 
   // These flags will be preserved
   const llvm::StringRef FlagsToPreserve[] = {
       "-nostdinc", "--no-standard-includes", "-nostdinc++", "-nobuiltininc"};
   // Preserves these flags and their values, either as separate args or with an
   // equalsbetween them
   const llvm::StringRef ArgsToPreserve[] = {"--sysroot", "-isysroot"};
 

clang-tools-extra/clangd/Selection.h

enum Selection : unsigned char {
     Complete,
   };
   // An AST node that is implicated in the selection.
   // (Either selected directly, or some descendant is selected).
   struct Node {
     // The parent within the selection tree. nullptr for TranslationUnitDecl.
     Node *Parent;
     // Direct children within the selection tree.
-    llvm::SmallVector<const Node *, 8> Children;
+    llvm::SmallVector<const Node *> Children;
     // The corresponding node from the full AST.
     ast_type_traits::DynTypedNode ASTNode;
     // The extent to which this node is covered by the selection.
     Selection Selected;
     // Walk up the AST to get the DeclContext of this Node,
     // which is not the node itself.
     const DeclContext &getDeclContext() const;
     // Printable node kind, like "CXXRecordDecl" or "AutoTypeLoc".

clang-tools-extra/clangd/Selection.cpp

 // against the selection to determine whether the node is selected.
 template <typename T> class IntervalSet {
 public:
   IntervalSet(llvm::ArrayRef<T> Range) { UnclaimedRanges.insert(Range); }
 
   // Removes the elements of Claim from the set, modifying or removing ranges
   // that overlap it.
   // Returns the continuous subranges of Claim that were actually removed.
-  llvm::SmallVector<llvm::ArrayRef<T>, 4> erase(llvm::ArrayRef<T> Claim) {
-    llvm::SmallVector<llvm::ArrayRef<T>, 4> Out;
+  llvm::SmallVector<llvm::ArrayRef<T>> erase(llvm::ArrayRef<T> Claim) {
+    llvm::SmallVector<llvm::ArrayRef<T>> Out;
     if (Claim.empty())
       return Out;
 
     // General case:
     // Claim:                   [-----------------]
     // UnclaimedRanges: [-A-] [-B-] [-C-] [-D-] [-E-] [-F-] [-G-]
     // Overlap:               ^first                  ^second
     // Ranges C and D are fully included. Ranges B and E must be trimmed.
std::string SelectionTree::Node::kind() const {
   printNodeKind(OS, ASTNode);
   return std::move(OS.str());
 }
 
 // Decide which selections emulate a "point" query in between characters.
 // If it's ambiguous (the neighboring characters are selectable tokens), returns
 // both possibilities in preference order.
 // Always returns at least one range - if no tokens touched, and empty range.
-static llvm::SmallVector<std::pair<unsigned, unsigned>, 2>
+static llvm::SmallVector<std::pair<unsigned, unsigned>>
 pointBounds(unsigned Offset, const syntax::TokenBuffer &Tokens) {
   const auto &SM = Tokens.sourceManager();
   SourceLocation Loc = SM.getComposedLoc(SM.getMainFileID(), Offset);
-  llvm::SmallVector<std::pair<unsigned, unsigned>, 2> Result;
+  llvm::SmallVector<std::pair<unsigned, unsigned>> Result;
   // Prefer right token over left.
   for (const syntax::Token &Tok :
        llvm::reverse(spelledTokensTouching(Loc, Tokens))) {
     if (shouldIgnore(Tok))
       continue;
     unsigned Offset = Tokens.sourceManager().getFileOffset(Tok.location());
     Result.emplace_back(Offset, Offset + Tok.length());
   }

clang-tools-extra/clangd/SemanticHighlighting.cpp

toTheiaSemanticHighlightingInformation(
   if (Tokens.size() == 0)
     return {};
 
   // FIXME: Tokens might be multiple lines long (block comments) in this case
   // this needs to add multiple lines for those tokens.
   std::vector<TheiaSemanticHighlightingInformation> Lines;
   Lines.reserve(Tokens.size());
   for (const auto &Line : Tokens) {
-    llvm::SmallVector<char, 128> LineByteTokens;
+    llvm::SmallVector<char> LineByteTokens;
     llvm::raw_svector_ostream OS(LineByteTokens);
     for (const auto &Token : Line.Tokens) {
       // Writes the token to LineByteTokens in the byte format specified by the
       // LSP proposal. Described below.
       // |<---- 4 bytes ---->|<-- 2 bytes -->|<--- 2 bytes -->|
       // |    character      |  length       |    index       |
 
       write32be(Token.R.start.character, OS);

clang-tools-extra/clangd/SourceCode.cpp

lex(Code, LangOpts, [&](const syntax::Token &Tok, const SourceManager &SM) {
     default:
       State = Default;
       break;
     }
   });
 }
 
 // Returns the prefix namespaces of NS: {"" ... NS}.
-llvm::SmallVector<llvm::StringRef, 8> ancestorNamespaces(llvm::StringRef NS) {
-  llvm::SmallVector<llvm::StringRef, 8> Results;
+llvm::SmallVector<llvm::StringRef> ancestorNamespaces(llvm::StringRef NS) {
+  llvm::SmallVector<llvm::StringRef> Results;
   Results.push_back(NS.take_front(0));
   NS.split(Results, "::", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
   for (llvm::StringRef &R : Results)
     R = NS.take_front(R.end() - NS.begin());
   return Results;
 }
 
 } // namespace

clang-tools-extra/clangd/TUScheduler.cpp

private:
   bool RanASTCallback = false;
   /// Guards members used by both TUScheduler and the worker thread.
   mutable std::mutex Mutex;
   /// File inputs, currently being used by the worker.
   /// Writes and reads from unknown threads are locked. Reads from the worker
   /// thread are not locked, as it's the only writer.
   ParseInputs FileInputs; /* GUARDED_BY(Mutex) */
   /// Times of recent AST rebuilds, used for UpdateDebounce computation.
-  llvm::SmallVector<DebouncePolicy::clock::duration, 8>
+  llvm::SmallVector<DebouncePolicy::clock::duration>
       RebuildTimes; /* GUARDED_BY(Mutex) */
   /// Set to true to signal run() to finish processing.
   bool Done;                              /* GUARDED_BY(Mutex) */
   std::deque<Request> Requests;           /* GUARDED_BY(Mutex) */
   llvm::Optional<Request> CurrentRequest; /* GUARDED_BY(Mutex) */
   /// Signalled whenever a new request has been scheduled or processing of a
   /// request has completed.
   mutable std::condition_variable RequestsCV;

 DebouncePolicy::compute(llvm::ArrayRef<clock::duration> History) const {
   assert(Min <= Max && "Invalid policy");
   if (History.empty())
     return Max; // Arbitrary.
 
   // Base the result on the median rebuild.
   // nth_element needs a mutable array, take the chance to bound the data size.
   History = History.take_back(15);
-  llvm::SmallVector<clock::duration, 15> Recent(History.begin(), History.end());
+  llvm::SmallVector<clock::duration> Recent(History.begin(), History.end());
   auto Median = Recent.begin() + Recent.size() / 2;
   std::nth_element(Recent.begin(), Median, Recent.end());
 
   clock::duration Target =
       std::chrono::duration_cast<clock::duration>(RebuildRatio * *Median);
   if (Target > Max)
     return Max;
   if (Target < Min)

clang-tools-extra/clangd/TidyProvider.cpp

public:
 
   void apply(tidy::ClangTidyOptions &Result, PathRef AbsPath) {
     namespace path = llvm::sys::path;
     assert(path::is_absolute(AbsPath));
 
     // Compute absolute paths to all ancestors (substrings of P.Path).
     // Ensure cache entries for each ancestor exist in the map.
     llvm::StringRef Parent = path::parent_path(AbsPath);
-    llvm::SmallVector<DotClangTidyCache *, 8> Caches;
+    llvm::SmallVector<DotClangTidyCache *> Caches;
     {
       std::lock_guard<std::mutex> Lock(Mu);
       for (auto I = path::begin(Parent, path::Style::posix),
                 E = path::end(Parent);
            I != E; ++I) {
         assert(I->end() >= Parent.begin() && I->end() <= Parent.end() &&
                "Canonical path components should be substrings");
         llvm::StringRef Ancestor(Parent.begin(), I->end() - Parent.begin());
         auto It = Cache.find(Ancestor);
 
         // Assemble the actual config file path only if needed.
         if (It == Cache.end()) {
           llvm::SmallString<256> ConfigPath = Ancestor;
           path::append(ConfigPath, RelPath);
           It = Cache.try_emplace(Ancestor, ConfigPath.str()).first;
         }
         Caches.push_back(&It->second);
       }
     }
     // Finally query each individual file.
     // This will take a (per-file) lock for each file that actually exists.
     std::chrono::steady_clock::time_point FreshTime =
         std::chrono::steady_clock::now() - MaxStaleness;
-    llvm::SmallVector<std::shared_ptr<const tidy::ClangTidyOptions>, 4>
+    llvm::SmallVector<std::shared_ptr<const tidy::ClangTidyOptions>>
         OptionStack;
     for (const DotClangTidyCache *Cache : Caches)
       if (auto Config = Cache->get(FS, FreshTime)) {
         OptionStack.push_back(std::move(Config));
         if (!OptionStack.back()->InheritParentConfig.getValueOr(false))
           break;
       }
     unsigned Order = 1u;

clang-tools-extra/clangd/index/FileIndex.cpp

for (const auto &Slab : SymbolSlabs)
       }
     break;
   }
   }
 
   std::vector<Ref> RefsStorage; // Contiguous ranges for each SymbolID.
   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> AllRefs;
   {
-    llvm::DenseMap<SymbolID, llvm::SmallVector<Ref, 4>> MergedRefs;
+    llvm::DenseMap<SymbolID, llvm::SmallVector<Ref>> MergedRefs;
     size_t Count = 0;
     for (const auto &RefSlab : RefSlabs)
       for (const auto &Sym : *RefSlab) {
         MergedRefs[Sym.first].append(Sym.second.begin(), Sym.second.end());
         Count += Sym.second.size();
       }
     RefsStorage.reserve(Count);
     AllRefs.reserve(MergedRefs.size());

clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp

llvm::cl::opt<unsigned> Limit{
       llvm::cl::desc("Max results to display"),
   };
 
   void run() override {
     FuzzyFindRequest Request;
     Request.Limit = Limit;
     Request.Query = Query;
     if (Scopes.getNumOccurrences() > 0) {
-      llvm::SmallVector<llvm::StringRef, 8> Scopes;
+      llvm::SmallVector<llvm::StringRef> Scopes;
       llvm::StringRef(this->Scopes).split(Scopes, ',');
       Request.Scopes = {Scopes.begin(), Scopes.end()};
     }
     Request.AnyScope = Request.Scopes.empty();
     // FIXME(kbobyrev): Print symbol final scores to see the distribution.
     static const auto *OutputFormat = "{0,-4} | {1,-40} | {2,-25}\n";
     llvm::outs() << llvm::formatv(OutputFormat, "Rank", "Symbol ID",
                                   "Symbol Name");
return Index.startswith("remote:")
              ? remote::getClient(Index.drop_front(strlen("remote:")),
                                  ProjectRoot)
              : loadIndex(Index, /*UseDex=*/true);
 }
 
 bool runCommand(std::string Request, const SymbolIndex &Index) {
   // Split on spaces and add required null-termination.
   std::replace(Request.begin(), Request.end(), ' ', '\0');
-  llvm::SmallVector<llvm::StringRef, 8> Args;
+  llvm::SmallVector<llvm::StringRef> Args;
   llvm::StringRef(Request).split(Args, '\0', /*MaxSplit=*/-1,
                                  /*KeepEmpty=*/false);
   if (Args.empty())
     return false;
   if (Args.front() == "help") {
     llvm::outs() << "dexp - Index explorer\nCommands:\n";
     for (const auto &C : CommandInfo)
       llvm::outs() << llvm::formatv("{0,16} - {1}\n", C.Name, C.Description);
     llvm::outs() << "Get detailed command help with e.g. `find -help`.\n";
     return true;
   }
-  llvm::SmallVector<const char *, 8> FakeArgv;
+  llvm::SmallVector<const char *> FakeArgv;
   for (llvm::StringRef S : Args)
     FakeArgv.push_back(S.data()); // Terminated by separator or end of string.
 
   for (const auto &Cmd : CommandInfo) {
     if (Cmd.Name == Args.front())
       return Cmd.Implementation()->parseAndRun(FakeArgv, Cmd.Description,
                                                Index);
   }

clang-tools-extra/clangd/refactor/tweaks/DefineInline.cpp

auto DefRange = toHalfOpenFileRange(
             .getAsRange());
     if (!DefRange)
       return error("Couldn't get range for the source.");
     unsigned int SourceLen = SM.getFileOffset(DefRange->getEnd()) -
                              SM.getFileOffset(DefRange->getBegin());
     const tooling::Replacement DeleteFuncBody(SM, DefRange->getBegin(),
                                               SourceLen, "");
 
-    llvm::SmallVector<std::pair<std::string, Edit>, 2> Edits;
+    llvm::SmallVector<std::pair<std::string, Edit>> Edits;
     // Edit for Target.
     auto FE = Effect::fileEdit(SM, SM.getFileID(*Semicolon),
                                std::move(TargetFileReplacements));
     if (!FE)
       return FE.takeError();
     Edits.push_back(std::move(*FE));
 
     // Edit for Source.

clang-tools-extra/clangd/refactor/tweaks/ExtractVariable.cpp

 //    FIXME: it would be nice to exclude these references, by micromanaging
 //    the computeReferencedDecls() calls around the binary operator tree.
 
 // Information extracted about a binary operator encounted in a SelectionTree.
 // It can represent either an overloaded or built-in operator.
 struct ParsedBinaryOperator {
   BinaryOperatorKind Kind;
   SourceLocation ExprLoc;
-  llvm::SmallVector<const SelectionTree::Node*, 8> SelectedOperands;
+  llvm::SmallVector<const SelectionTree::Node *> SelectedOperands;
 
   // If N is a binary operator, populate this and return true.
   bool parse(const SelectionTree::Node &N) {
     SelectedOperands.clear();
 
     if (const BinaryOperator *Op =
         llvm::dyn_cast_or_null<BinaryOperator>(N.ASTNode.get<Expr>())) {
       Kind = Op->getOpcode();

clang-tools-extra/clangd/support/Markup.cpp

std::string getMarkerForCodeBlock(llvm::StringRef Input) {
   }
   MaxBackticks = std::max(Backticks, MaxBackticks);
   // Use the corresponding number of backticks to start and end a code block.
   return std::string(/*Repeat=*/std::max(3u, MaxBackticks + 1), '`');
 }
 
 // Trims the input and concatenates whitespace blocks into a single ` `.
 std::string canonicalizeSpaces(llvm::StringRef Input) {
-  llvm::SmallVector<llvm::StringRef, 4> Words;
+  llvm::SmallVector<llvm::StringRef> Words;
   llvm::SplitString(Input, Words);
   return llvm::join(Words, " ");
 }
 
 std::string renderBlocks(llvm::ArrayRef<std::unique_ptr<Block>> Children,
                          void (Block::*RenderFunc)(llvm::raw_ostream &) const) {
   std::string R;
   llvm::raw_string_ostream OS(R);

clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp

std::vector<std::string> Cmd = {"clang++", "foo.cc"};
     WithContextValue WithConfig(Config::Key, std::move(Cfg));
     Mangler.adjust(Cmd);
   }
   // Edits are applied in given order and before other mangling.
   EXPECT_THAT(Cmd, ElementsAre(_, "FOO.CC", "--hello", "-fsyntax-only"));
 }
 
 static std::string strip(llvm::StringRef Arg, llvm::StringRef Argv) {
-  llvm::SmallVector<llvm::StringRef, 8> Parts;
+  llvm::SmallVector<llvm::StringRef> Parts;
   llvm::SplitString(Argv, Parts);
   std::vector<std::string> Args = {Parts.begin(), Parts.end()};
   ArgStripper S;
   S.strip(Arg);
   S.process(Args);
   return llvm::join(Args, " ");
 }
 

clang-tools-extra/clangd/unittests/TestIndex.cpp

if (Pos == llvm::StringRef::npos) {
     Sym.Name = QName.substr(Pos + 2);
     Sym.Scope = QName.substr(0, Pos + 2);
   }
   return Sym;
 }
 
 static std::string replace(llvm::StringRef Haystack, llvm::StringRef Needle,
                            llvm::StringRef Repl) {
-  llvm::SmallVector<llvm::StringRef, 8> Parts;
+  llvm::SmallVector<llvm::StringRef> Parts;
   Haystack.split(Parts, Needle);
   return llvm::join(Parts, Repl);
 }
 
 // Helpers to produce fake index symbols for memIndex() or completions().
 // USRFormat is a regex replacement string for the unqualified part of the USR.
 Symbol sym(llvm::StringRef QName, index::SymbolKind Kind,
            llvm::StringRef USRFormat) {

clang-tools-extra/clangd/unittests/TestTU.cpp

if (!Result) {
     ADD_FAILURE() << "No symbol named " << QName << " in "
                   << ::testing::PrintToString(Slab);
     assert(false && "No symbol with QName");
   }
   return *Result;
 }
 
 const NamedDecl &findDecl(ParsedAST &AST, llvm::StringRef QName) {
-  llvm::SmallVector<llvm::StringRef, 4> Components;
+  llvm::SmallVector<llvm::StringRef> Components;
   QName.split(Components, "::");
 
   auto &Ctx = AST.getASTContext();
   auto LookupDecl = [&Ctx](const DeclContext &Scope,
                            llvm::StringRef Name) -> const NamedDecl & {
     auto LookupRes = Scope.lookup(DeclarationName(&Ctx.Idents.get(Name)));
     assert(!LookupRes.empty() && "Lookup failed");
     assert(LookupRes.size() == 1 && "Lookup returned multiple results");

clang-tools-extra/clangd/unittests/support/TraceTests.cpp

CSVMetricsTracerTest()
       : OS(Output), Tracer(trace::createCSVMetricTracer(OS)), Session(*Tracer) {
   }
   trace::Metric Dist = {"dist", trace::Metric::Distribution, "lbl"};
   trace::Metric Counter = {"cnt", trace::Metric::Counter};
 
   std::vector<std::string> outputLines() {
     // Deliberately don't flush output stream, the tracer should do that.
     // This is important when clangd crashes.
-    llvm::SmallVector<llvm::StringRef, 4> Lines;
+    llvm::SmallVector<llvm::StringRef> Lines;
     llvm::StringRef(Output).split(Lines, "\r\n");
     return {Lines.begin(), Lines.end()};
   }
 
   std::string Output;
   llvm::raw_string_ostream OS;
   std::unique_ptr<trace::EventTracer> Tracer;
   trace::Session Session;