[lldb] Remove unused IsFunctionType is_variadic_ptr parameter (NFC)

[kastiglione]

Summary

is_variadic_ptr is unused.

[kastiglione]

I can't read.

[kastiglione]

Remove function use of is_variadic_ptr

[teemperor]

LGTM, thanks! Bonus points for the emotional rollercoaster in the review history.

(You probably want to update the downstream next branch too once this has landed just to keep it green less red)

[kastiglione]

Yes I plan to merge this manually (rather than automerge) to ensure it's not disruptive.

lldb/include/lldb/Symbol/CompilerType.h

 //===-- CompilerType.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_COMPILERTYPE_H
 #define LLDB_SYMBOL_COMPILERTYPE_H
 
 #include <functional>
 #include <string>
 #include <vector>
 
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/APSInt.h"
 
 namespace lldb_private {
 
 class DataExtractor;
 
 /// Generic representation of a type in a programming language.
 ///
public:
   bool IsConst() const;
 
   bool IsCStringType(uint32_t &length) const;
 
   bool IsDefined() const;
 
   bool IsFloatingPointType(uint32_t &count, bool &is_complex) const;
 
-  bool IsFunctionType(bool *is_variadic_ptr = nullptr) const;
+  bool IsFunctionType() const;
 
   uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const;
 
   size_t GetNumberOfFunctionArguments() const;
 
   CompilerType GetFunctionArgumentAtIndex(const size_t index) const;
 
   bool IsVariadicFunctionType() const;

lldb/include/lldb/Symbol/TypeSystem.h

 #include <string>
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
 class DWARFASTParser;
 class PDBASTParser;
#endif
 
   virtual bool IsCompleteType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual bool IsDefined(lldb::opaque_compiler_type_t type) = 0;
 
   virtual bool IsFloatingPointType(lldb::opaque_compiler_type_t type,
                                    uint32_t &count, bool &is_complex) = 0;
 
-  virtual bool IsFunctionType(lldb::opaque_compiler_type_t type,
-                              bool *is_variadic_ptr) = 0;
+  virtual bool IsFunctionType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual size_t
   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) = 0;
 
   virtual CompilerType
   GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
                              const size_t index) = 0;
 

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
#endif
 
   static bool IsCXXClassType(const CompilerType &type);
 
   bool IsDefined(lldb::opaque_compiler_type_t type) override;
 
   bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
                            bool &is_complex) override;
 
-  bool IsFunctionType(lldb::opaque_compiler_type_t type,
-                      bool *is_variadic_ptr) override;
+  bool IsFunctionType(lldb::opaque_compiler_type_t type) override;
 
   uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
                                   CompilerType *base_type_ptr) override;
 
   size_t
   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

if (pointee_or_element_clang_type.IsCharType()) {
                      .getLimitedValue();
       }
       return true;
     }
   }
   return false;
 }
 
-bool TypeSystemClang::IsFunctionType(lldb::opaque_compiler_type_t type,
-                                     bool *is_variadic_ptr) {
+bool TypeSystemClang::IsFunctionType(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isFunctionType()) {
-      if (is_variadic_ptr) {
-        const clang::FunctionProtoType *function_proto_type =
-            llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
-        if (function_proto_type)
-          *is_variadic_ptr = function_proto_type->isVariadic();
-        else
-          *is_variadic_ptr = false;
-      }
       return true;
     }
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     default:
       break;
     case clang::Type::LValueReference:
     case clang::Type::RValueReference: {
       const clang::ReferenceType *reference_type =
           llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
       if (reference_type)
-        return IsFunctionType(reference_type->getPointeeType().getAsOpaquePtr(),
-                              nullptr);
+        return IsFunctionType(
+            reference_type->getPointeeType().getAsOpaquePtr());
     } break;
     }
   }
   return false;
 }
 
 // Used to detect "Homogeneous Floating-point Aggregates"
 uint32_t

lldb/source/Symbol/CompilerType.cpp

 //===-- CompilerType.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/CompilerType.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferHeap.h"

 }
 
 bool CompilerType::IsCStringType(uint32_t &length) const {
   if (IsValid())
     return m_type_system->IsCStringType(m_type, length);
   return false;
 }
 
-bool CompilerType::IsFunctionType(bool *is_variadic_ptr) const {
+bool CompilerType::IsFunctionType() const {
   if (IsValid())
-    return m_type_system->IsFunctionType(m_type, is_variadic_ptr);
+    return m_type_system->IsFunctionType(m_type);
   return false;
 }
 
 // Used to detect "Homogeneous Floating-point Aggregates"
 uint32_t
 CompilerType::IsHomogeneousAggregate(CompilerType *base_type_ptr) const {
   if (IsValid())
     return m_type_system->IsHomogeneousAggregate(m_type, base_type_ptr);