[lldb][NFC] Allow range-based for-loops on VariableList

[teemperor]

Summary

Adds support for doing range-based for-loops on LLDB's VariableList and
modernises all the index-based for-loops in LLDB where possible.

[labath]

Since copying shared pointers isn't completely cheap, I think we should use const shared_ptr &s whereever possible. Also, the typical lldb naming convention for shared_pointer variables is to have them end in _sp, so I'd try to preserve that.
Besides that, LGTM.

[teemperor]

• Added _sp suffix to variable names.
• Using const-references where possible.

lldb/include/lldb/Symbol/VariableList.h

 
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class VariableList {
+  typedef std::vector<lldb::VariableSP> collection;
+
 public:
   // Constructors and Destructors
   //  VariableList(const SymbolContext &symbol_context);
   VariableList();
   virtual ~VariableList();
 
   void AddVariable(const lldb::VariableSP &var_sp);
 
public:
 
   uint32_t FindIndexForVariable(Variable *variable);
 
   size_t MemorySize() const;
 
   size_t GetSize() const;
   bool Empty() const { return m_variables.empty(); }
 
-protected:
-  typedef std::vector<lldb::VariableSP> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
+  iterator begin() { return m_variables.begin(); }
+  iterator end() { return m_variables.end(); }
+  const_iterator begin() const { return m_variables.begin(); }
+  const_iterator end() const { return m_variables.end(); }
+
+protected:
   collection m_variables;
 
 private:
   // For VariableList only
   DISALLOW_COPY_AND_ASSIGN(VariableList);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_VariableList_h_

lldb/source/API/SBFrame.cpp

SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
 
   std::set<VariableSP> variable_set;
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
-        size_t i;
         VariableList *variable_list = nullptr;
         variable_list = frame->GetVariableList(true);
         if (variable_list) {
           const size_t num_variables = variable_list->GetSize();
           if (num_variables) {
-            for (i = 0; i < num_variables; ++i) {
-              VariableSP variable_sp(variable_list->GetVariableAtIndex(i));
+            for (const VariableSP &variable_sp : *variable_list) {
               if (variable_sp) {
                 bool add_variable = false;
                 switch (variable_sp->GetScope()) {
                 case eValueTypeVariableGlobal:
                 case eValueTypeVariableStatic:
                 case eValueTypeVariableThreadLocal:
                   add_variable = statics;
                   break;

lldb/source/API/SBModule.cpp

LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
                      max_matches);
 
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     VariableList variable_list;
     module_sp->FindGlobalVariables(ConstString(name), nullptr, max_matches,
                                    variable_list);
-    const uint32_t match_count = variable_list.GetSize();
-    if (match_count > 0) {
-      for (uint32_t i = 0; i < match_count; ++i) {
-        lldb::ValueObjectSP valobj_sp;
-        TargetSP target_sp(target.GetSP());
-        valobj_sp = ValueObjectVariable::Create(
-            target_sp.get(), variable_list.GetVariableAtIndex(i));
-        if (valobj_sp)
-          sb_value_list.Append(SBValue(valobj_sp));
-      }
-    }
-  }
+    for (const VariableSP &var_sp : variable_list) {
+      valobj_sp = ValueObjectVariable::Create(target_sp.get(), var_sp);
 
   return LLDB_RECORD_RESULT(sb_value_list);
 }
 
 lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
                                                 const char *name) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
                      (lldb::SBTarget &, const char *), target, name);

lldb/source/API/SBTarget.cpp

SBValueList SBTarget::FindGlobalVariables(const char *name,
 
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());
   if (name && target_sp) {
     VariableList variable_list;
     target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
                                                variable_list);
-    const uint32_t match_count = variable_list.GetSize();
-    if (match_count > 0) {
+    if (!variable_list.Empty()) {
       ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
       if (exe_scope == nullptr)
         exe_scope = target_sp.get();
-      for (uint32_t i = 0; i < match_count; ++i) {
-        lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create(
-            exe_scope, variable_list.GetVariableAtIndex(i)));
+      for (const VariableSP &var_sp : variable_list) {
+        lldb::ValueObjectSP valobj_sp(
+            ValueObjectVariable::Create(exe_scope, var_sp));
         if (valobj_sp)
           sb_value_list.Append(SBValue(valobj_sp));
       }
     }
   }
 
   return LLDB_RECORD_RESULT(sb_value_list);
 }
 
 SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches,
                                           MatchType matchtype) {
   LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
                      (const char *, uint32_t, lldb::MatchType), name,
                      max_matches, matchtype);
 
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());
   if (name && target_sp) {
     llvm::StringRef name_ref(name);
     VariableList variable_list;
 
     std::string regexstr;
-    uint32_t match_count;
     switch (matchtype) {
     case eMatchTypeNormal:
       target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
                                                  variable_list);
       break;
     case eMatchTypeRegex:
       target_sp->GetImages().FindGlobalVariables(RegularExpression(name_ref),
                                                  max_matches, variable_list);
       break;
     case eMatchTypeStartsWith:
       regexstr = llvm::Regex::escape(name) + ".*";
       target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr),
                                                  max_matches, variable_list);
       break;
     }
-    match_count = variable_list.GetSize();
-    if (match_count > 0) {
+    if (!variable_list.Empty()) {
       ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
       if (exe_scope == nullptr)
         exe_scope = target_sp.get();
-      for (uint32_t i = 0; i < match_count; ++i) {
-        lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create(
-            exe_scope, variable_list.GetVariableAtIndex(i)));
+      for (const VariableSP &var_sp : variable_list) {
+        lldb::ValueObjectSP valobj_sp(
+            ValueObjectVariable::Create(exe_scope, var_sp));
         if (valobj_sp)
           sb_value_list.Append(SBValue(valobj_sp));
       }
     }
   }
 
   return LLDB_RECORD_RESULT(sb_value_list);
 }

lldb/source/Commands/CommandObjectTarget.cpp

public:
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   void DumpGlobalVariableList(const ExecutionContext &exe_ctx,
                               const SymbolContext &sc,
                               const VariableList &variable_list, Stream &s) {
-    size_t count = variable_list.GetSize();
-    if (count > 0) {
-      if (sc.module_sp) {
-        if (sc.comp_unit) {
-          s.Printf("Global variables for %s in %s:\n",
-                   sc.comp_unit->GetPath().c_str(),
-                   sc.module_sp->GetFileSpec().GetPath().c_str());
-        } else {
-          s.Printf("Global variables for %s\n",
-                   sc.module_sp->GetFileSpec().GetPath().c_str());
-        }
-      } else if (sc.comp_unit) {
-        s.Printf("Global variables for %s\n", sc.comp_unit->GetPath().c_str());
-      }
+    if (variable_list.Empty())
+      return;
 
-      for (uint32_t i = 0; i < count; ++i) {
-        VariableSP var_sp(variable_list.GetVariableAtIndex(i));
-        if (var_sp) {
-          ValueObjectSP valobj_sp(ValueObjectVariable::Create(
-              exe_ctx.GetBestExecutionContextScope(), var_sp));
+    for (VariableSP var_sp : variable_list) {
+      if (!var_sp)
+        continue;
 
-          if (valobj_sp)
-            DumpValueObject(s, var_sp, valobj_sp,
-                            var_sp->GetName().GetCString());
-        }
-      }
+        DumpValueObject(s, var_sp, valobj_sp, var_sp->GetName().GetCString());
     }
   }
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     Target *target = m_exe_ctx.GetTargetPtr();
     const size_t argc = args.GetArgumentCount();
     Stream &s = result.GetOutputStream();
 

lldb/source/Core/Address.cpp

if (IsSectionOffset()) {
           bool get_parent_variables = true;
           bool stop_if_block_is_inlined_function = false;
           VariableList variable_list;
           sc.block->AppendVariables(can_create, get_parent_variables,
                                     stop_if_block_is_inlined_function,
                                     [](Variable *) { return true; },
                                     &variable_list);
 
-          const size_t num_variables = variable_list.GetSize();
-          for (size_t var_idx = 0; var_idx < num_variables; ++var_idx) {
-            Variable *var = variable_list.GetVariableAtIndex(var_idx).get();
-            if (var && var->LocationIsValidForAddress(*this)) {
+          for (const VariableSP &var_sp : variable_list) {
+            if (var_sp && var_sp->LocationIsValidForAddress(*this)) {
               s->Indent();
               s->Printf("   Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"",
-                        var->GetID(), var->GetName().GetCString());
-              Type *type = var->GetType();
+                        var_sp->GetID(), var_sp->GetName().GetCString());
+              Type *type = var_sp->GetType();
               if (type)
                 s->Printf(", type = \"%s\"", type->GetName().GetCString());
               else
                 s->PutCString(", type = <unknown>");
               s->PutCString(", location = ");
-              var->DumpLocationForAddress(s, *this);
+              var_sp->DumpLocationForAddress(s, *this);
               s->PutCString(", decl = ");
-              var->GetDeclaration().DumpStopContext(s, false);
+              var_sp->GetDeclaration().DumpStopContext(s, false);
               s->EOL();
             }
           }
         }
       }
     } else {
       if (fallback_style != DumpStyleInvalid)
         return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);

lldb/source/Core/IOHandler.cpp

bool WindowDelegateDraw(Window &window, bool force) override {
     if (frame_block) {
       // Only update the variables if they have changed
       if (m_frame_block != frame_block) {
         m_frame_block = frame_block;
 
         VariableList *locals = frame->GetVariableList(true);
         if (locals) {
           const DynamicValueType use_dynamic = eDynamicDontRunTarget;
-          const size_t num_locals = locals->GetSize();
-          for (size_t i = 0; i < num_locals; ++i) {
-            ValueObjectSP value_sp = frame->GetValueObjectForFrameVariable(
-                locals->GetVariableAtIndex(i), use_dynamic);
+          for (const VariableSP &local_sp : *locals) {
+            ValueObjectSP value_sp =
+                frame->GetValueObjectForFrameVariable(local_sp, use_dynamic);
             if (value_sp) {
               ValueObjectSP synthetic_value_sp = value_sp->GetSyntheticValue();
               if (synthetic_value_sp)
                 local_values.Append(synthetic_value_sp);
               else
                 local_values.Append(value_sp);
             }
           }

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
 
   if (module && namespace_decl)
     module->FindGlobalVariables(name, namespace_decl, -1, vars);
   else
     target.GetImages().FindGlobalVariables(name, -1, vars);
 
   if (vars.GetSize()) {
     if (type) {
-      for (size_t i = 0; i < vars.GetSize(); ++i) {
-        VariableSP var_sp = vars.GetVariableAtIndex(i);
-
+      for (VariableSP var_sp : vars) {
         if (ClangASTContext::AreTypesSame(
                 *type, var_sp->GetType()->GetFullCompilerType()))
           return var_sp;
       }
     } else {
       return vars.GetVariableAtIndex(0);
     }
   }

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

void RenderScriptRuntime::FindStructTypeName(Element &elem,
   VariableList var_list;
   for (auto module_sp : m_rsmodules)
     module_sp->m_module->FindGlobalVariables(
         RegularExpression(llvm::StringRef(".")), UINT32_MAX, var_list);
 
   // Iterate over all the global variables looking for one with a matching type
   // to the Element. We make the assumption a match exists since there needs to
   // be a global variable to reflect the struct type back into java host code.
-  for (uint32_t i = 0; i < var_list.GetSize(); ++i) {
-    const VariableSP var_sp(var_list.GetVariableAtIndex(i));
+  for (const VariableSP &var_sp : var_list) {
     if (!var_sp)
       continue;
 
     ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp);
     if (!valobj_sp)
       continue;
 
     // Find the number of variable fields.

lldb/source/Symbol/Block.cpp

 uint32_t
 Block::AppendBlockVariables(bool can_create, bool get_child_block_variables,
                             bool stop_if_child_block_is_inlined_function,
                             const std::function<bool(Variable *)> &filter,
                             VariableList *variable_list) {
   uint32_t num_variables_added = 0;
   VariableList *block_var_list = GetBlockVariableList(can_create).get();
   if (block_var_list) {
-    for (size_t i = 0; i < block_var_list->GetSize(); ++i) {
-      VariableSP variable = block_var_list->GetVariableAtIndex(i);
-      if (filter(variable.get())) {
+    for (const VariableSP &var_sp : *block_var_list) {
+      if (filter(var_sp.get())) {
         num_variables_added++;
-        variable_list->AddVariable(variable);
+        variable_list->AddVariable(var_sp);
       }
     }
   }
 
   if (get_child_block_variables) {
     collection::const_iterator pos, end = m_children.end();
     for (pos = m_children.begin(); pos != end; ++pos) {
       Block *child_block = pos->get();

lldb/source/Symbol/Variable.cpp

if (compiler_type.IsValid()) {
       }
     } else {
       if (frame) {
         const bool get_file_globals = true;
 
         VariableList *variable_list = frame->GetVariableList(get_file_globals);
 
         if (variable_list) {
-          const size_t num_variables = variable_list->GetSize();
-          for (size_t i = 0; i < num_variables; ++i) {
-            Variable *variable = variable_list->GetVariableAtIndex(i).get();
-            request.AddCompletion(variable->GetName().AsCString());
-          }
+          for (const VariableSP &var_sp : *variable_list)
+            request.AddCompletion(var_sp->GetName().AsCString());
         }
       }
     }
   } else {
     const char ch = partial_path[0];
     switch (ch) {
     case '*':
       if (prefix_path.str().empty()) {
default:
           const bool get_file_globals = true;
 
           VariableList *variable_list =
               frame->GetVariableList(get_file_globals);
 
           if (!variable_list)
             break;
 
-          const size_t num_variables = variable_list->GetSize();
-          for (size_t i = 0; i < num_variables; ++i) {
-            Variable *variable = variable_list->GetVariableAtIndex(i).get();
+          for (VariableSP var_sp : *variable_list) {
 
-            if (!variable)
+            if (!var_sp)
               continue;
 
-            const char *variable_name = variable->GetName().AsCString();
+            const char *variable_name = var_sp->GetName().AsCString();
             if (strstr(variable_name, token.c_str()) == variable_name) {
               if (strcmp(variable_name, token.c_str()) == 0) {
-                Type *variable_type = variable->GetType();
+                Type *variable_type = var_sp->GetType();
                 if (variable_type) {
                   CompilerType variable_compiler_type(
                       variable_type->GetForwardCompilerType());
                   PrivateAutoComplete(
                       frame, remaining_partial_path,
                       prefix_path + token, // Anything that has been resolved
                                            // already will be in here
                       variable_compiler_type.GetCanonicalType(), request);

lldb/source/Target/StackFrame.cpp

if (m_sc.GetFunctionMethodInfo(method_language, is_instance_method,
         }
       }
     }
   }
 
   if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
     // Check if any anonymous unions are there which contain a variable with
     // the name we need
-    for (size_t i = 0; i < variable_list->GetSize(); i++) {
-      VariableSP variable_sp = variable_list->GetVariableAtIndex(i);
+    for (const VariableSP &variable_sp : *variable_list) {
       if (!variable_sp)
         continue;
       if (!variable_sp->GetName().IsEmpty())
         continue;
 
       Type *var_type = variable_sp->GetType();
       if (!var_type)
         continue;
lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
   Instruction::Operand op =
       offset ? Instruction::Operand::BuildDereference(
                    Instruction::Operand::BuildSum(
                        Instruction::Operand::BuildRegister(reg),
                        Instruction::Operand::BuildImmediate(offset)))
              : Instruction::Operand::BuildDereference(
                    Instruction::Operand::BuildRegister(reg));
 
-  for (size_t vi = 0, ve = variables.GetSize(); vi != ve; ++vi) {
-    VariableSP var_sp = variables.GetVariableAtIndex(vi);
-    if (var_sp->LocationExpression().MatchesOperand(frame, op)) {
+  for (VariableSP var_sp : variables) {
+    if (var_sp->LocationExpression().MatchesOperand(frame, op))
       return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
-    }
-  }
 
   const uint32_t current_inst =
       disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
   if (current_inst == UINT32_MAX) {
     return ValueObjectSP();
   }
 
   for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {