[lldb][NFCI] Use size_t in OptionValueProperties

[bulbazord]

Summary

In many places we're using uint32_t where we should be using size_t.
We should be consistent.

lldb/include/lldb/Interpreter/OptionValueProperties.h

public:
 
   void Initialize(const PropertyDefinitions &setting_definitions);
 
   // Subclass specific functions
 
   // Get the index of a property given its exact name in this property
   // collection, "name" can't be a path to a property path that refers to a
   // property within a property
-  virtual uint32_t GetPropertyIndex(ConstString name) const;
+  virtual size_t GetPropertyIndex(ConstString name) const;
 
   // Get a property by exact name exists in this property collection, name can
   // not be a path to a property path that refers to a property within a
   // property
   virtual const Property *
   GetProperty(ConstString name,
               const ExecutionContext *exe_ctx = nullptr) const;
 
   virtual const Property *
-  GetPropertyAtIndex(uint32_t idx,
+  GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx = nullptr) const {
     return ProtectedGetPropertyAtIndex(idx);
   }
 
   // Property can be be a property path like
   // "target.process.extra-startup-command"
   virtual const Property *
   GetPropertyAtPath(const ExecutionContext *exe_ctx,
 
                     llvm::StringRef property_path) const;
 
   virtual lldb::OptionValueSP
-  GetPropertyValueAtIndex(uint32_t idx, const ExecutionContext *exe_ctx) const;
+  GetPropertyValueAtIndex(size_t idx, const ExecutionContext *exe_ctx) const;
 
   virtual lldb::OptionValueSP GetValueForKey(const ExecutionContext *exe_ctx,
                                              ConstString key) const;
 
   lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                   llvm::StringRef name,
                                   Status &error) const override;
 
   Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
                      llvm::StringRef path, llvm::StringRef value) override;
 
   bool
-  GetPropertyAtIndexAsArgs(uint32_t idx, Args &args,
+  GetPropertyAtIndexAsArgs(size_t idx, Args &args,
                            const ExecutionContext *exe_ctx = nullptr) const;
 
-  bool SetPropertyAtIndexFromArgs(uint32_t idx, const Args &args,
+  bool SetPropertyAtIndexFromArgs(size_t idx, const Args &args,
                                   const ExecutionContext *exe_ctx = nullptr);
 
   OptionValueDictionary *GetPropertyAtIndexAsOptionValueDictionary(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   OptionValueSInt64 *GetPropertyAtIndexAsOptionValueSInt64(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   OptionValueUInt64 *GetPropertyAtIndexAsOptionValueUInt64(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   OptionValueString *GetPropertyAtIndexAsOptionValueString(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   OptionValueFileSpec *GetPropertyAtIndexAsOptionValueFileSpec(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   OptionValuePathMappings *GetPropertyAtIndexAsOptionValuePathMappings(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   OptionValueFileSpecList *GetPropertyAtIndexAsOptionValueFileSpecList(
-      uint32_t idx, const ExecutionContext *exe_ctx = nullptr) const;
+      size_t idx, const ExecutionContext *exe_ctx = nullptr) const;
 
   void AppendProperty(ConstString name, llvm::StringRef desc, bool is_global,
                       const lldb::OptionValueSP &value_sp);
 
   lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx,
                                                ConstString name);
 
-  void SetValueChangedCallback(uint32_t property_idx,
+  void SetValueChangedCallback(size_t property_idx,
                                std::function<void()> callback);
 
   template <typename T>
-  auto GetPropertyAtIndexAs(uint32_t idx,
+  auto GetPropertyAtIndexAs(size_t idx,
                             const ExecutionContext *exe_ctx = nullptr) const {
     if (const Property *property = GetPropertyAtIndex(idx, exe_ctx)) {
       if (OptionValue *value = property->GetValue().get())
         return value->GetValueAs<T>();
     }
     if constexpr (std::is_pointer_v<T>)
       return T{nullptr};
     else
       return std::optional<T>{std::nullopt};
   }
 
   template <typename T>
-  bool SetPropertyAtIndex(uint32_t idx, T t,
+  bool SetPropertyAtIndex(size_t idx, T t,
                           const ExecutionContext *exe_ctx = nullptr) const {
     if (const Property *property = GetPropertyAtIndex(idx, exe_ctx)) {
       if (OptionValue *value = property->GetValue().get()) {
         value->SetValueAs(t);
         return true;
       }
     }
     return false;
   }
 
 protected:
-  Property *ProtectedGetPropertyAtIndex(uint32_t idx) {
+  Property *ProtectedGetPropertyAtIndex(size_t idx) {
     assert(idx < m_properties.size() && "invalid property index");
     return ((idx < m_properties.size()) ? &m_properties[idx] : nullptr);
   }
 
-  const Property *ProtectedGetPropertyAtIndex(uint32_t idx) const {
+  const Property *ProtectedGetPropertyAtIndex(size_t idx) const {
     assert(idx < m_properties.size() && "invalid property index");
     return ((idx < m_properties.size()) ? &m_properties[idx] : nullptr);
   }
 
   typedef UniqueCStringMap<size_t> NameToIndex;
 
   ConstString m_name;
   std::vector<Property> m_properties;
   NameToIndex m_name_to_index;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUEPROPERTIES_H

lldb/source/Interpreter/OptionValueProperties.cpp

m_name_to_index.Append(ConstString(property.GetName()),
                            m_properties.size());
     property.GetValue()->SetParent(shared_from_this());
     m_properties.push_back(property);
   }
   m_name_to_index.Sort();
 }
 
 void OptionValueProperties::SetValueChangedCallback(
-    uint32_t property_idx, std::function<void()> callback) {
+    size_t property_idx, std::function<void()> callback) {
   Property *property = ProtectedGetPropertyAtIndex(property_idx);
   if (property)
     property->SetValueChangedCallback(std::move(callback));
 }
 
 void OptionValueProperties::AppendProperty(ConstString name,
                                            llvm::StringRef desc, bool is_global,
                                            const OptionValueSP &value_sp) {
else {
     if (!name_contains_experimental && error.AsCString() == nullptr) {
       error.SetErrorStringWithFormat("invalid value path '%s'",
                                      name.str().c_str());
     }
   }
   return error;
 }
 
-uint32_t OptionValueProperties::GetPropertyIndex(ConstString name) const {
+size_t OptionValueProperties::GetPropertyIndex(ConstString name) const {
   return m_name_to_index.Find(name, SIZE_MAX);
 }
 
 const Property *
 OptionValueProperties::GetProperty(ConstString name,
                                    const ExecutionContext *exe_ctx) const {
   return GetPropertyAtIndex(m_name_to_index.Find(name, SIZE_MAX), exe_ctx);
 }
 
 lldb::OptionValueSP OptionValueProperties::GetPropertyValueAtIndex(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   const Property *setting = GetPropertyAtIndex(idx, exe_ctx);
   if (setting)
     return setting->GetValue();
   return OptionValueSP();
 }
 
 OptionValuePathMappings *
 OptionValueProperties::GetPropertyAtIndexAsOptionValuePathMappings(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   OptionValueSP value_sp(GetPropertyValueAtIndex(idx, exe_ctx));
   if (value_sp)
     return value_sp->GetAsPathMappings();
   return nullptr;
 }
 
 OptionValueFileSpecList *
 OptionValueProperties::GetPropertyAtIndexAsOptionValueFileSpecList(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   OptionValueSP value_sp(GetPropertyValueAtIndex(idx, exe_ctx));
   if (value_sp)
     return value_sp->GetAsFileSpecList();
   return nullptr;
 }
 
 bool OptionValueProperties::GetPropertyAtIndexAsArgs(
-    uint32_t idx, Args &args, const ExecutionContext *exe_ctx) const {
+    size_t idx, Args &args, const ExecutionContext *exe_ctx) const {
   const Property *property = GetPropertyAtIndex(idx, exe_ctx);
   if (!property)
     return false;
 
   OptionValue *value = property->GetValue().get();
   if (!value)
     return false;
 
if (dict) {
     dict->GetArgs(args);
     return true;
   }
 
   return false;
 }
 
 bool OptionValueProperties::SetPropertyAtIndexFromArgs(
-    uint32_t idx, const Args &args, const ExecutionContext *exe_ctx) {
+    size_t idx, const Args &args, const ExecutionContext *exe_ctx) {
   const Property *property = GetPropertyAtIndex(idx, exe_ctx);
   if (!property)
     return false;
 
   OptionValue *value = property->GetValue().get();
   if (!value)
     return false;
 
bool OptionValueProperties::SetPropertyAtIndexFromArgs(
   if (dict)
     return dict->SetArgs(args, eVarSetOperationAssign).Success();
 
   return false;
 }
 
 OptionValueDictionary *
 OptionValueProperties::GetPropertyAtIndexAsOptionValueDictionary(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   const Property *property = GetPropertyAtIndex(idx, exe_ctx);
   if (property)
     return property->GetValue()->GetAsDictionary();
   return nullptr;
 }
 
 OptionValueFileSpec *
 OptionValueProperties::GetPropertyAtIndexAsOptionValueFileSpec(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   const Property *property = GetPropertyAtIndex(idx, exe_ctx);
   if (property) {
     OptionValue *value = property->GetValue().get();
     if (value)
       return value->GetAsFileSpec();
   }
   return nullptr;
 }
 
 OptionValueSInt64 *OptionValueProperties::GetPropertyAtIndexAsOptionValueSInt64(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   const Property *property = GetPropertyAtIndex(idx, exe_ctx);
   if (property) {
     OptionValue *value = property->GetValue().get();
     if (value)
       return value->GetAsSInt64();
   }
   return nullptr;
 }
 
 OptionValueUInt64 *OptionValueProperties::GetPropertyAtIndexAsOptionValueUInt64(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   const Property *property = GetPropertyAtIndex(idx, exe_ctx);
   if (property) {
     OptionValue *value = property->GetValue().get();
     if (value)
       return value->GetAsUInt64();
   }
   return nullptr;
 }
 
 OptionValueString *OptionValueProperties::GetPropertyAtIndexAsOptionValueString(
-    uint32_t idx, const ExecutionContext *exe_ctx) const {
+    size_t idx, const ExecutionContext *exe_ctx) const {
   OptionValueSP value_sp(GetPropertyValueAtIndex(idx, exe_ctx));
   if (value_sp)
     return value_sp->GetAsString();
   return nullptr;
 }
 
 void OptionValueProperties::Clear() {
   const size_t num_properties = m_properties.size();

lldb/source/Target/Process.cpp

 #endif
 
 class ProcessOptionValueProperties
     : public Cloneable<ProcessOptionValueProperties, OptionValueProperties> {
 public:
   ProcessOptionValueProperties(ConstString name) : Cloneable(name) {}
 
   const Property *
-  GetPropertyAtIndex(uint32_t idx,
+  GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx) const override {
     // When getting the value for a key from the process options, we will
     // always try and grab the setting from the current process if there is
     // one. Else we just use the one from this instance.
     if (exe_ctx) {
       Process *process = exe_ctx->GetProcessPtr();
       if (process) {
         ProcessOptionValueProperties *instance_properties =

lldb/source/Target/Target.cpp

 };
 
 class TargetOptionValueProperties
     : public Cloneable<TargetOptionValueProperties, OptionValueProperties> {
 public:
   TargetOptionValueProperties(ConstString name) : Cloneable(name) {}
 
   const Property *
-  GetPropertyAtIndex(uint32_t idx,
+  GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx = nullptr) const override {
     // When getting the value for a key from the target options, we will always
     // try and grab the setting from the current target if there is one. Else
     // we just use the one from this instance.
     if (exe_ctx) {
       Target *target = exe_ctx->GetTargetPtr();
       if (target) {
         TargetOptionValueProperties *target_properties =

lldb/source/Target/Thread.cpp

 };
 
 class ThreadOptionValueProperties
     : public Cloneable<ThreadOptionValueProperties, OptionValueProperties> {
 public:
   ThreadOptionValueProperties(ConstString name) : Cloneable(name) {}
 
   const Property *
-  GetPropertyAtIndex(uint32_t idx,
+  GetPropertyAtIndex(size_t idx,
                      const ExecutionContext *exe_ctx) const override {
     // When getting the value for a key from the thread options, we will always
     // try and grab the setting from the current thread if there is one. Else
     // we just use the one from this instance.
     if (exe_ctx) {
       Thread *thread = exe_ctx->GetThreadPtr();
       if (thread) {
         ThreadOptionValueProperties *instance_properties =