[NFC][CLANG] Fix static analyzer bugs about unnecessary object copies with auto

[Manna]

Summary

[tahonermann]

Thanks, @Manna, these changes look good to me!

clang/include/clang/ExtractAPI/ExtractAPIVisitor.h

175

I agree that this looks like a good change. CXXBaseSpecifier contains a SourceRange, a SourceLocation, a unsigned (used as a bit-field, and a TypeSourceInfo*. Those are all individually cheap to copy, but together are large enough to justify use of a reference.

clang/lib/Analysis/UnsafeBufferUsage.cpp

2256

This looks good too. The returned map value has const VarDecl* as a key and the element type is FixItList (aka SmallVector<FixItHint, 4>) . FixItHint contains two CharSourceRange objects, a std::string, and a bool, so we definitely don't want to be copying that; especially since the value isn't even wanted here!

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

903

Another case of CXXBaseSpecifier which, per earlier comments, is large enough to justify use of a reference.

[Manna]

Thank you @tahonermann for reviews and feedbacks.

clang/include/clang/ExtractAPI/ExtractAPIVisitor.h

 private:
   Derived &getDerivedExtractAPIVisitor() {
     return *static_cast<Derived *>(this);
   }
 
   SmallVector<SymbolReference> getBases(const CXXRecordDecl *Decl) {
     // FIXME: store AccessSpecifier given by inheritance
     SmallVector<SymbolReference> Bases;
-    for (const auto BaseSpecifier : Decl->bases()) {
+    for (const auto &BaseSpecifier : Decl->bases()) {
       // skip classes not inherited as public
       if (BaseSpecifier.getAccessSpecifier() != AccessSpecifier::AS_public)
         continue;
       SymbolReference BaseClass;
       if (BaseSpecifier.getType().getTypePtr()->isTemplateTypeParmType()) {
         BaseClass.Name = API.copyString(BaseSpecifier.getType().getAsString());
         BaseClass.USR = API.recordUSR(
             BaseSpecifier.getType()->getAs<TemplateTypeParmType>()->getDecl());

clang/lib/Analysis/UnsafeBufferUsage.cpp

 // group mate.  A variable `v` is unfixable iff `FixItsForVariable` does not
 // contain `v`.
 static void eraseVarsForUnfixableGroupMates(
     std::map<const VarDecl *, FixItList> &FixItsForVariable,
     const VariableGroupsManager &VarGrpMgr) {
   // Variables will be removed from `FixItsForVariable`:
   SmallVector<const VarDecl *, 8> ToErase;
 
-  for (auto [VD, Ignore] : FixItsForVariable) {
+  for (const auto &[VD, Ignore] : FixItsForVariable) {
     VarGrpRef Grp = VarGrpMgr.getGroupOfVar(VD);
     if (llvm::any_of(Grp,
                      [&FixItsForVariable](const VarDecl *GrpMember) -> bool {
                        return FixItsForVariable.find(GrpMember) ==
                               FixItsForVariable.end();
                      })) {
       // At least one group member cannot be fixed, so we have to erase the
       // whole group:

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

 std::optional<Object> serializeTemplateMixinImpl(const RecordTy &Record,
                                                  std::true_type) {
   const auto &Template = Record.Templ;
   if (Template.empty())
     return std::nullopt;
 
   Object Generics;
   Array GenericParameters;
-  for (const auto Param : Template.getParameters()) {
+  for (const auto &Param : Template.getParameters()) {
     Object Parameter;
     Parameter["name"] = Param.Name;
     Parameter["index"] = Param.Index;
     Parameter["depth"] = Param.Depth;
     GenericParameters.emplace_back(std::move(Parameter));
   }
   if (!GenericParameters.empty())
     Generics["parameters"] = std::move(GenericParameters);
 
   Array GenericConstraints;
-  for (const auto Constr : Template.getConstraints()) {
+  for (const auto &Constr : Template.getConstraints()) {
     Object Constraint;
     Constraint["kind"] = Constr.Kind;
     Constraint["lhs"] = Constr.LHS;
     Constraint["rhs"] = Constr.RHS;
     GenericConstraints.emplace_back(std::move(Constraint));
   }
 
   if (!GenericConstraints.empty())

 }
 
 void SymbolGraphSerializer::visitCXXClassRecord(const CXXClassRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
-  for (const auto Base : Record.Bases)
+  for (const auto &Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
   if (!Record.ParentInformation.empty())
     serializeRelationship(RelationshipKind::MemberOf, Record,
                           Record.ParentInformation.ParentRecord);
 }
 
 void SymbolGraphSerializer::visitClassTemplateRecord(
     const ClassTemplateRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
-  for (const auto Base : Record.Bases)
+  for (const auto &Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
   if (!Record.ParentInformation.empty())
     serializeRelationship(RelationshipKind::MemberOf, Record,
                           Record.ParentInformation.ParentRecord);
 }
 
 void SymbolGraphSerializer::visitClassTemplateSpecializationRecord(
     const ClassTemplateSpecializationRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
 
-  for (const auto Base : Record.Bases)
+  for (const auto &Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
   if (!Record.ParentInformation.empty())
     serializeRelationship(RelationshipKind::MemberOf, Record,
                           Record.ParentInformation.ParentRecord);
 }
 
 void SymbolGraphSerializer::visitClassTemplatePartialSpecializationRecord(
     const ClassTemplatePartialSpecializationRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
 
-  for (const auto Base : Record.Bases)
+  for (const auto &Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
   if (!Record.ParentInformation.empty())
     serializeRelationship(RelationshipKind::MemberOf, Record,
                           Record.ParentInformation.ParentRecord);
 }
 
 void SymbolGraphSerializer::visitCXXInstanceMethodRecord(
     const CXXInstanceMethodRecord &Record) {