[AST] Use TinyPtrVector for the list of overridden declarations.

TinyPtrVector is a more-space-efficient SmallVector<_, 1>. Use it.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2482,7 +2482,7 @@ class ValueDecl : public Decl {
   ValueDecl *getOverriddenDecl() const;
 
   /// Retrieve the declarations that this declaration overrides, if any.
-  SmallVector<ValueDecl *, 1> getOverriddenDecls() const;
+  llvm::TinyPtrVector<ValueDecl *> getOverriddenDecls() const;
 
   /// Set the declaration that this declaration overrides.
   void setOverriddenDecl(ValueDecl *overridden) {
@@ -2901,7 +2901,7 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
 
   /// Retrieve the set of associated types overridden by this associated
   /// type.
-  SmallVector<AssociatedTypeDecl *, 1> getOverriddenDecls() const;
+  llvm::TinyPtrVector<AssociatedTypeDecl *> getOverriddenDecls() const;
 
   SourceLoc getStartLoc() const { return KeywordLoc; }
   SourceRange getSourceRange() const;

include/swift/AST/TypeCheckRequests.h

@@ -21,6 +21,7 @@
 #include "swift/AST/SimpleRequest.h"
 #include "swift/Basic/Statistic.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/TinyPtrVector.h"
 
 namespace swift {
 
@@ -126,7 +127,7 @@ class EnumRawTypeRequest :
 class OverriddenDeclsRequest
   : public SimpleRequest<OverriddenDeclsRequest,
                          CacheKind::SeparatelyCached,
-                         SmallVector<ValueDecl *, 1>,
+                         llvm::TinyPtrVector<ValueDecl *>,
                          ValueDecl *> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -135,19 +136,19 @@ class OverriddenDeclsRequest
   friend class SimpleRequest;
 
   // Evaluation.
-  SmallVector<ValueDecl *, 1> evaluate(Evaluator &evaluator,
-                                       ValueDecl *decl) const;
+  llvm::TinyPtrVector<ValueDecl *> evaluate(Evaluator &evaluator,
+                                            ValueDecl *decl) const;
 
 public:
   // Cycle handling
-  SmallVector<ValueDecl *, 1> breakCycle() const { return { }; }
+  llvm::TinyPtrVector<ValueDecl *> breakCycle() const { return { }; }
   void diagnoseCycle(DiagnosticEngine &diags) const;
   void noteCycleStep(DiagnosticEngine &diags) const;
 
   // Separate caching.
   bool isCached() const { return true; }
-  Optional<SmallVector<ValueDecl *, 1>> getCachedResult() const;
-  void cacheResult(SmallVector<ValueDecl *, 1> value) const;
+  Optional<llvm::TinyPtrVector<ValueDecl *>> getCachedResult() const;
+  void cacheResult(llvm::TinyPtrVector<ValueDecl *> value) const;
 };
 
 /// Determine whether the given declaration is exposed to Objective-C.

lib/AST/ASTContext.cpp

@@ -1595,26 +1595,27 @@ GenericEnvironment *ASTContext::getOrCreateCanonicalGenericEnvironment(
   return env;
 }
 
-Optional<SmallVector<ValueDecl *, 1>>
+Optional<llvm::TinyPtrVector<ValueDecl *>>
 OverriddenDeclsRequest::getCachedResult() const {
   auto decl = std::get<0>(getStorage());
   if (!decl->LazySemanticInfo.hasOverriddenComputed)
     return None;
 
   // If there are no overridden declarations (the common case), return.
-  SmallVector<ValueDecl *, 1> overridden;
+  llvm::TinyPtrVector<ValueDecl *> overridden;
   if (!decl->LazySemanticInfo.hasOverridden) return overridden;
 
   // Retrieve the set of overrides from the ASTContext.
   ASTContext &ctx = decl->getASTContext();
   auto known = ctx.getImpl().Overrides.find(decl);
   assert(known != ctx.getImpl().Overrides.end());
-  overridden.assign(known->second.begin(), known->second.end());
+  overridden.insert(overridden.end(),
+                    known->second.begin(), known->second.end());
   return overridden;
 }
 
 void OverriddenDeclsRequest::cacheResult(
-                                    SmallVector<ValueDecl *, 1> value) const {
+                                llvm::TinyPtrVector<ValueDecl *> value) const {
   auto decl = std::get<0>(getStorage());
   decl->LazySemanticInfo.hasOverriddenComputed = true;
   decl->LazySemanticInfo.hasOverridden = !value.empty();
@@ -1632,7 +1633,8 @@ void OverriddenDeclsRequest::cacheResult(
 
   // Record the overrides in the context.
   auto &ctx = decl->getASTContext();
-  auto overriddenCopy = ctx.AllocateCopy(value);
+  auto overriddenCopy =
+    ctx.AllocateCopy(value.operator ArrayRef<ValueDecl *>());
   (void)ctx.getImpl().Overrides.insert({decl, overriddenCopy});
 }
 

lib/AST/Decl.cpp

@@ -2022,14 +2022,13 @@ CanType ValueDecl::getOverloadSignatureType() const {
   return CanType();
 }
 
-SmallVector<ValueDecl *, 1> ValueDecl::getOverriddenDecls() const {
+llvm::TinyPtrVector<ValueDecl *> ValueDecl::getOverriddenDecls() const {
   ASTContext &ctx = getASTContext();
   return ctx.evaluator(OverriddenDeclsRequest{const_cast<ValueDecl *>(this)});
 }
 
 void ValueDecl::setOverriddenDecls(ArrayRef<ValueDecl *> overridden) {
-  SmallVector<ValueDecl *, 1> overriddenVec(overridden.begin(),
-                                            overridden.end());
+  llvm::TinyPtrVector<ValueDecl *> overriddenVec(overridden);
   OverriddenDeclsRequest request{const_cast<ValueDecl *>(this)};
   request.cacheResult(overriddenVec);
 }
@@ -2892,18 +2891,18 @@ SourceRange AssociatedTypeDecl::getSourceRange() const {
   return SourceRange(KeywordLoc, endLoc);
 }
 
-SmallVector<AssociatedTypeDecl *, 1>
+llvm::TinyPtrVector<AssociatedTypeDecl *>
 AssociatedTypeDecl::getOverriddenDecls() const {
   // FIXME: Performance hack because we end up looking at the overridden
   // declarations of an associated type a *lot*.
   OverriddenDeclsRequest request{const_cast<AssociatedTypeDecl *>(this)};
-  SmallVector<ValueDecl *, 1> overridden;
+  llvm::TinyPtrVector<ValueDecl *> overridden;
   if (auto cached = request.getCachedResult())
     overridden = std::move(*cached);
   else
     overridden = AbstractTypeParamDecl::getOverriddenDecls();
 
-  SmallVector<AssociatedTypeDecl *, 1> assocTypes;
+  llvm::TinyPtrVector<AssociatedTypeDecl *> assocTypes;
   for (auto decl : overridden) {
     assocTypes.push_back(cast<AssociatedTypeDecl>(decl));
   }

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1534,7 +1534,7 @@ static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
 /// Minimize the set of overridden associated types, eliminating any
 /// associated types that are overridden by other associated types.
 static void minimizeOverriddenAssociatedTypes(
-                           SmallVectorImpl<ValueDecl *> &assocTypes) {
+                           llvm::TinyPtrVector<ValueDecl *> &assocTypes) {
   // Mark associated types that are "worse" than some other associated type,
   // because they come from an inherited protocol.
   bool anyWorse = false;
@@ -1562,9 +1562,10 @@ static void minimizeOverriddenAssociatedTypes(
   // Copy in the associated types that aren't worse than any other associated
   // type.
   unsigned nextIndex = 0;
-  for (unsigned i : indices(assocTypes)) {
+  MutableArrayRef<ValueDecl *> buffer = assocTypes;
+  for (unsigned i : indices(buffer)) {
     if (worseThanAny[i]) continue;
-    assocTypes[nextIndex++] = assocTypes[i];
+    buffer[nextIndex++] = buffer[i];
   }
 
   assocTypes.erase(assocTypes.begin() + nextIndex, assocTypes.end());
@@ -1580,11 +1581,11 @@ static int compareSimilarAssociatedTypes(ValueDecl *const *lhs,
 
 /// Compute the set of associated types that are overridden by the given
 /// associated type.
-static SmallVector<ValueDecl *, 1>
+static llvm::TinyPtrVector<ValueDecl *>
 computeOverriddenAssociatedTypes(AssociatedTypeDecl *assocType) {
   // Find associated types with the given name in all of the inherited
   // protocols.
-  SmallVector<ValueDecl *, 1> overriddenAssocTypes;
+  llvm::TinyPtrVector<ValueDecl *> overriddenAssocTypes;
   auto proto = assocType->getProtocol();
   proto->walkInheritedProtocols([&](ProtocolDecl *inheritedProto) {
     if (proto == inheritedProto) return TypeWalker::Action::Continue;
@@ -1619,7 +1620,7 @@ computeOverriddenAssociatedTypes(AssociatedTypeDecl *assocType) {
   return overriddenAssocTypes;
 }
 
-SmallVector<ValueDecl *, 1>
+llvm::TinyPtrVector<ValueDecl *>
 OverriddenDeclsRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
   // For an associated type, compute the (minimized) set of overridden
   // declarations.
@@ -1687,7 +1688,7 @@ OverriddenDeclsRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
       return { };
     }
 
-    return SmallVector<ValueDecl *, 1>{baseAccessor};
+    return llvm::TinyPtrVector<ValueDecl *>{baseAccessor};
   }
 
   // Only initializers and declarations marked with the 'override' declaration
@@ -1723,5 +1724,5 @@ OverriddenDeclsRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
     return { };
   }
 
-  return SmallVector<ValueDecl *, 1>{matches.front().Decl};
+  return llvm::TinyPtrVector<ValueDecl *>{matches.front().Decl};
 }