[clang] [ast] CXXRecordDecl::getVisibleConversionFunctions() could be const

[whisperity]

Summary

The function and its called static helpers don't modify the received CXXRecordDecl arguments at all as the method result is put into an output parameter. Thus, they can be const which allows for neatly grabbing the conversion methods in a context where we only have a const ASTUnit at hand.

[rjmccall]

LGTM.

clang/include/clang/AST/DeclCXX.h

public:
 
   /// Removes a conversion function from this class.  The conversion
   /// function must currently be a member of this class.  Furthermore,
   /// this class must currently be in the process of being defined.
   void removeConversion(const NamedDecl *Old);
 
   /// Get all conversion functions visible in current class,
   /// including conversion function templates.
-  llvm::iterator_range<conversion_iterator> getVisibleConversionFunctions();
+  llvm::iterator_range<conversion_iterator>
+  getVisibleConversionFunctions() const;
 
   /// Determine whether this class is an aggregate (C++ [dcl.init.aggr]),
   /// which is a class with no user-declared constructors, no private
   /// or protected non-static data members, no base classes, and no virtual
   /// functions (C++ [dcl.init.aggr]p1).
   bool isAggregate() const { return data().Aggregate; }
 
   /// Whether this class has any in-class initializers

clang/lib/AST/DeclCXX.cpp

 ///   of a virtual base)
 /// \param Access the access along the inheritance path to this base
 /// \param ParentHiddenTypes the conversions provided by the inheritors
 ///   of this base
 /// \param Output the set to which to add conversions from non-virtual bases
 /// \param VOutput the set to which to add conversions from virtual bases
 /// \param HiddenVBaseCs the set of conversions which were hidden in a
 ///   virtual base along some inheritance path
-static void CollectVisibleConversions(ASTContext &Context,
-                                      CXXRecordDecl *Record,
-                                      bool InVirtual,
-                                      AccessSpecifier Access,
-                  const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
-                                      ASTUnresolvedSet &Output,
-                                      UnresolvedSetImpl &VOutput,
-                           llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
+static void CollectVisibleConversions(
+    ASTContext &Context, const CXXRecordDecl *Record, bool InVirtual,
+    ASTUnresolvedSet &Output, UnresolvedSetImpl &VOutput,
+    llvm::SmallPtrSet<NamedDecl *, 8> &HiddenVBaseCs) {
   // The set of types which have conversions in this class or its
   // subclasses.  As an optimization, we don't copy the derived set
   // unless it might change.
   const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
   llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
 
   // Collect the direct conversions and figure out which conversions
   // will be hidden in the subclasses.
for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
         else
           Output.addDecl(Context, I.getDecl(), IAccess);
       }
     }
   }
 
   // Collect information recursively from any base classes.
   for (const auto &I : Record->bases()) {
-    const RecordType *RT = I.getType()->getAs<RecordType>();
+    const auto *RT = I.getType()->getAs<RecordType>();
     if (!RT) continue;
 
     AccessSpecifier BaseAccess
       = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
     bool BaseInVirtual = InVirtual || I.isVirtual();
 
     auto *Base = cast<CXXRecordDecl>(RT->getDecl());
     CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
                               *HiddenTypes, Output, VOutput, HiddenVBaseCs);
   }
 }
 
 /// Collect the visible conversions of a class.
 ///
 /// This would be extremely straightforward if it weren't for virtual
 /// bases.  It might be worth special-casing that, really.
 static void CollectVisibleConversions(ASTContext &Context,
-                                      CXXRecordDecl *Record,
+                                      const CXXRecordDecl *Record,
                                       ASTUnresolvedSet &Output) {
   // The collection of all conversions in virtual bases that we've
   // found.  These will be added to the output as long as they don't
   // appear in the hidden-conversions set.
   UnresolvedSet<8> VBaseCs;
 
   // The set of conversions in virtual bases that we've determined to
   // be hidden.
   llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
 
   // The set of types hidden by classes derived from this one.
   llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
 
   // Go ahead and collect the direct conversions and add them to the
   // hidden-types set.
   CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
   CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
   Output.append(Context, ConvI, ConvE);
   for (; ConvI != ConvE; ++ConvI)
     HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
 
   // Recursively collect conversions from base classes.
   for (const auto &I : Record->bases()) {
-    const RecordType *RT = I.getType()->getAs<RecordType>();
+    const auto *RT = I.getType()->getAs<RecordType>();
     if (!RT) continue;
 
     CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
                               I.isVirtual(), I.getAccessSpecifier(),
                               HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
   }
 
   // Add any unhidden conversions provided by virtual bases.
   for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
          I != E; ++I) {
     if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
       Output.addDecl(Context, I.getDecl(), I.getAccess());
   }
 }
 
 /// getVisibleConversionFunctions - get all conversion functions visible
 /// in current class; including conversion function templates.
 llvm::iterator_range<CXXRecordDecl::conversion_iterator>
-CXXRecordDecl::getVisibleConversionFunctions() {
+CXXRecordDecl::getVisibleConversionFunctions() const {
   ASTContext &Ctx = getASTContext();
 
   ASTUnresolvedSet *Set;
   if (bases_begin() == bases_end()) {
     // If root class, all conversions are visible.
     Set = &data().Conversions.get(Ctx);
   } else {
     Set = &data().VisibleConversions.get(Ctx);