lldb/source/Symbol/Variable.cpp

   1 //===-- Variable.cpp ------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Symbol/Variable.h"
  10
  11 #include "lldb/Core/Module.h"
  12 #include "lldb/Core/ValueObject.h"
  13 #include "lldb/Core/ValueObjectVariable.h"
  14 #include "lldb/Symbol/Block.h"
  15 #include "lldb/Symbol/CompileUnit.h"
  16 #include "lldb/Symbol/CompilerDecl.h"
  17 #include "lldb/Symbol/CompilerDeclContext.h"
  18 #include "lldb/Symbol/Function.h"
  19 #include "lldb/Symbol/SymbolContext.h"
  20 #include "lldb/Symbol/SymbolFile.h"
  21 #include "lldb/Symbol/Type.h"
  22 #include "lldb/Symbol/TypeSystem.h"
  23 #include "lldb/Symbol/VariableList.h"
  24 #include "lldb/Target/ABI.h"
  25 #include "lldb/Target/Process.h"
  26 #include "lldb/Target/RegisterContext.h"
  27 #include "lldb/Target/StackFrame.h"
  28 #include "lldb/Target/Target.h"
  29 #include "lldb/Target/Thread.h"
  30 #include "lldb/Utility/RegularExpression.h"
  31 #include "lldb/Utility/Stream.h"
  32
  33 #include "llvm/ADT/Twine.h"
  34
  35 using namespace lldb;
  36 using namespace lldb_private;
  37
  38 Variable::Variable(lldb::user_id_t uid, const char *name, const char *mangled,
  39                    const lldb::SymbolFileTypeSP &symfile_type_sp,
  40                    ValueType scope, SymbolContextScope *context,
  41                    const RangeList &scope_range, Declaration *decl_ptr,
  42                    const DWARFExpressionList &location_list, bool external,
  43                    bool artificial, bool location_is_constant_data,
  44                    bool static_member)
  45     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
  46       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
  47       m_owner_scope(context), m_scope_range(scope_range),
  48       m_declaration(decl_ptr), m_location_list(location_list), m_external(external),
  49       m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
  50       m_static_member(static_member) {}
  51
  52 Variable::~Variable() = default;
  53
  54 lldb::LanguageType Variable::GetLanguage() const {
  55   lldb::LanguageType lang = m_mangled.GuessLanguage();
  56   if (lang != lldb::eLanguageTypeUnknown)
  57     return lang;
  58
  59   if (auto *func = m_owner_scope->CalculateSymbolContextFunction()) {
  60     if ((lang = func->GetLanguage()) != lldb::eLanguageTypeUnknown)
  61       return lang;
  62   } else if (auto *comp_unit =
  63                  m_owner_scope->CalculateSymbolContextCompileUnit()) {
  64     if ((lang = comp_unit->GetLanguage()) != lldb::eLanguageTypeUnknown)
  65       return lang;
  66   }
  67
  68   return lldb::eLanguageTypeUnknown;
  69 }
  70
  71 ConstString Variable::GetName() const {
  72   ConstString name = m_mangled.GetName();
  73   if (name)
  74     return name;
  75   return m_name;
  76 }
  77
  78 ConstString Variable::GetUnqualifiedName() const { return m_name; }
  79
  80 bool Variable::NameMatches(ConstString name) const {
  81   if (m_name == name)
  82     return true;
  83   SymbolContext variable_sc;
  84   m_owner_scope->CalculateSymbolContext(&variable_sc);
  85
  86   return m_mangled.NameMatches(name);
  87 }
  88 bool Variable::NameMatches(const RegularExpression &regex) const {
  89   if (regex.Execute(m_name.AsCString()))
  90     return true;
  91   if (m_mangled)
  92     return m_mangled.NameMatches(regex);
  93   return false;
  94 }
  95
  96 Type *Variable::GetType() {
  97   if (m_symfile_type_sp)
  98     return m_symfile_type_sp->GetType();
  99   return nullptr;
 100 }
 101
 102 void Variable::Dump(Stream *s, bool show_context) const {
 103   s->Printf("%p: ", static_cast<const void *>(this));
 104   s->Indent();
 105   *s << "Variable" << (const UserID &)*this;
 106
 107   if (m_name)
 108     *s << ", name = \"" << m_name << "\"";
 109
 110   if (m_symfile_type_sp) {
 111     Type *type = m_symfile_type_sp->GetType();
 112     if (type) {
 113       s->Format(", type = {{{0:x-16}} {1} (", type->GetID(), type);
 114       type->DumpTypeName(s);
 115       s->PutChar(')');
 116     }
 117   }
 118
 119   if (m_scope != eValueTypeInvalid) {
 120     s->PutCString(", scope = ");
 121     switch (m_scope) {
 122     case eValueTypeVariableGlobal:
 123       s->PutCString(m_external ? "global" : "static");
 124       break;
 125     case eValueTypeVariableArgument:
 126       s->PutCString("parameter");
 127       break;
 128     case eValueTypeVariableLocal:
 129       s->PutCString("local");
 130       break;
 131     case eValueTypeVariableThreadLocal:
 132       s->PutCString("thread local");
 133       break;
 134     default:
 135       s->AsRawOstream() << "??? (" << m_scope << ')';
 136     }
 137   }
 138
 139   if (show_context && m_owner_scope != nullptr) {
 140     s->PutCString(", context = ( ");
 141     m_owner_scope->DumpSymbolContext(s);
 142     s->PutCString(" )");
 143   }
 144
 145   bool show_fullpaths = false;
 146   m_declaration.Dump(s, show_fullpaths);
 147
 148   if (m_location_list.IsValid()) {
 149     s->PutCString(", location = ");
 150     ABISP abi;
 151     if (m_owner_scope) {
 152       ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
 153       if (module_sp)
 154         abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
 155     }
 156     m_location_list.GetDescription(s, lldb::eDescriptionLevelBrief, abi.get());
 157   }
 158
 159   if (m_external)
 160     s->PutCString(", external");
 161
 162   if (m_artificial)
 163     s->PutCString(", artificial");
 164
 165   s->EOL();
 166 }
 167
 168 bool Variable::DumpDeclaration(Stream *s, bool show_fullpaths,
 169                                bool show_module) {
 170   bool dumped_declaration_info = false;
 171   if (m_owner_scope) {
 172     SymbolContext sc;
 173     m_owner_scope->CalculateSymbolContext(&sc);
 174     sc.block = nullptr;
 175     sc.line_entry.Clear();
 176     bool show_inlined_frames = false;
 177     const bool show_function_arguments = true;
 178     const bool show_function_name = true;
 179
 180     dumped_declaration_info = sc.DumpStopContext(
 181         s, nullptr, Address(), show_fullpaths, show_module, show_inlined_frames,
 182         show_function_arguments, show_function_name);
 183
 184     if (sc.function)
 185       s->PutChar(':');
 186   }
 187   if (m_declaration.DumpStopContext(s, false))
 188     dumped_declaration_info = true;
 189   return dumped_declaration_info;
 190 }
 191
 192 size_t Variable::MemorySize() const { return sizeof(Variable); }
 193
 194 CompilerDeclContext Variable::GetDeclContext() {
 195   Type *type = GetType();
 196   if (type)
 197     return type->GetSymbolFile()->GetDeclContextContainingUID(GetID());
 198   return CompilerDeclContext();
 199 }
 200
 201 CompilerDecl Variable::GetDecl() {
 202   Type *type = GetType();
 203   return type ? type->GetSymbolFile()->GetDeclForUID(GetID()) : CompilerDecl();
 204 }
 205
 206 void Variable::CalculateSymbolContext(SymbolContext *sc) {
 207   if (m_owner_scope) {
 208     m_owner_scope->CalculateSymbolContext(sc);
 209     sc->variable = this;
 210   } else
 211     sc->Clear(false);
 212 }
 213
 214 bool Variable::LocationIsValidForFrame(StackFrame *frame) {
 215   if (frame) {
 216     Function *function =
 217         frame->GetSymbolContext(eSymbolContextFunction).function;
 218     if (function) {
 219       TargetSP target_sp(frame->CalculateTarget());
 220
 221       addr_t loclist_base_load_addr =
 222           function->GetAddressRange().GetBaseAddress().GetLoadAddress(
 223               target_sp.get());
 224       if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
 225         return false;
 226       // It is a location list. We just need to tell if the location list
 227       // contains the current address when converted to a load address
 228       return m_location_list.ContainsAddress(
 229           loclist_base_load_addr,
 230           frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
 231     }
 232   }
 233   return false;
 234 }
 235
 236 bool Variable::LocationIsValidForAddress(const Address &address) {
 237   // Be sure to resolve the address to section offset prior to calling this
 238   // function.
 239   if (address.IsSectionOffset()) {
 240     // We need to check if the address is valid for both scope range and value
 241     // range.
 242     // Empty scope range means block range.
 243     bool valid_in_scope_range =
 244         GetScopeRange().IsEmpty() || GetScopeRange().FindEntryThatContains(
 245                                          address.GetFileAddress()) != nullptr;
 246     if (!valid_in_scope_range)
 247       return false;
 248     SymbolContext sc;
 249     CalculateSymbolContext(&sc);
 250     if (sc.module_sp == address.GetModule()) {
 251       // Is the variable is described by a single location?
 252       if (m_location_list.IsAlwaysValidSingleExpr()) {
 253         // Yes it is, the location is valid.
 254         return true;
 255       }
 256
 257       if (sc.function) {
 258         addr_t loclist_base_file_addr =
 259             sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
 260         if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
 261           return false;
 262         // It is a location list. We just need to tell if the location list
 263         // contains the current address when converted to a load address
 264         return m_location_list.ContainsAddress(loclist_base_file_addr,
 265                                                address.GetFileAddress());
 266       }
 267     }
 268   }
 269   return false;
 270 }
 271
 272 bool Variable::IsInScope(StackFrame *frame) {
 273   switch (m_scope) {
 274   case eValueTypeRegister:
 275   case eValueTypeRegisterSet:
 276     return frame != nullptr;
 277
 278   case eValueTypeConstResult:
 279   case eValueTypeVariableGlobal:
 280   case eValueTypeVariableStatic:
 281   case eValueTypeVariableThreadLocal:
 282     return true;
 283
 284   case eValueTypeVariableArgument:
 285   case eValueTypeVariableLocal:
 286     if (frame) {
 287       // We don't have a location list, we just need to see if the block that
 288       // this variable was defined in is currently
 289       Block *deepest_frame_block =
 290           frame->GetSymbolContext(eSymbolContextBlock).block;
 291       if (deepest_frame_block) {
 292         SymbolContext variable_sc;
 293         CalculateSymbolContext(&variable_sc);
 294
 295         // Check for static or global variable defined at the compile unit
 296         // level that wasn't defined in a block
 297         if (variable_sc.block == nullptr)
 298           return true;
 299
 300         // Check if the variable is valid in the current block
 301         if (variable_sc.block != deepest_frame_block &&
 302             !variable_sc.block->Contains(deepest_frame_block))
 303           return false;
 304
 305         // If no scope range is specified then it means that the scope is the
 306         // same as the scope of the enclosing lexical block.
 307         if (m_scope_range.IsEmpty())
 308           return true;
 309
 310         addr_t file_address = frame->GetFrameCodeAddress().GetFileAddress();
 311         return m_scope_range.FindEntryThatContains(file_address) != nullptr;
 312       }
 313     }
 314     break;
 315
 316   default:
 317     break;
 318   }
 319   return false;
 320 }
 321
 322 Status Variable::GetValuesForVariableExpressionPath(
 323     llvm::StringRef variable_expr_path, ExecutionContextScope *scope,
 324     GetVariableCallback callback, void *baton, VariableList &variable_list,
 325     ValueObjectList &valobj_list) {
 326   Status error;
 327   if (!callback || variable_expr_path.empty()) {
 328     error.SetErrorString("unknown error");
 329     return error;
 330   }
 331
 332   switch (variable_expr_path.front()) {
 333   case '*':
 334     error = Variable::GetValuesForVariableExpressionPath(
 335         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
 336         valobj_list);
 337     if (error.Fail()) {
 338       error.SetErrorString("unknown error");
 339       return error;
 340     }
 341     for (uint32_t i = 0; i < valobj_list.GetSize();) {
 342       Status tmp_error;
 343       ValueObjectSP valobj_sp(
 344           valobj_list.GetValueObjectAtIndex(i)->Dereference(tmp_error));
 345       if (tmp_error.Fail()) {
 346         variable_list.RemoveVariableAtIndex(i);
 347         valobj_list.RemoveValueObjectAtIndex(i);
 348       } else {
 349         valobj_list.SetValueObjectAtIndex(i, valobj_sp);
 350         ++i;
 351       }
 352     }
 353     return error;
 354   case '&': {
 355     error = Variable::GetValuesForVariableExpressionPath(
 356         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
 357         valobj_list);
 358     if (error.Success()) {
 359       for (uint32_t i = 0; i < valobj_list.GetSize();) {
 360         Status tmp_error;
 361         ValueObjectSP valobj_sp(
 362             valobj_list.GetValueObjectAtIndex(i)->AddressOf(tmp_error));
 363         if (tmp_error.Fail()) {
 364           variable_list.RemoveVariableAtIndex(i);
 365           valobj_list.RemoveValueObjectAtIndex(i);
 366         } else {
 367           valobj_list.SetValueObjectAtIndex(i, valobj_sp);
 368           ++i;
 369         }
 370       }
 371     } else {
 372       error.SetErrorString("unknown error");
 373     }
 374     return error;
 375   } break;
 376
 377   default: {
 378     static RegularExpression g_regex(
 379         llvm::StringRef("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"));
 380     llvm::SmallVector<llvm::StringRef, 2> matches;
 381     variable_list.Clear();
 382     if (!g_regex.Execute(variable_expr_path, &matches)) {
 383       error.SetErrorStringWithFormatv(
 384           "unable to extract a variable name from '{0}'", variable_expr_path);
 385       return error;
 386     }
 387     std::string variable_name = matches[1].str();
 388     if (!callback(baton, variable_name.c_str(), variable_list)) {
 389       error.SetErrorString("unknown error");
 390       return error;
 391     }
 392     uint32_t i = 0;
 393     while (i < variable_list.GetSize()) {
 394       VariableSP var_sp(variable_list.GetVariableAtIndex(i));
 395       ValueObjectSP valobj_sp;
 396       if (!var_sp) {
 397         variable_list.RemoveVariableAtIndex(i);
 398         continue;
 399       }
 400       ValueObjectSP variable_valobj_sp(
 401           ValueObjectVariable::Create(scope, var_sp));
 402       if (!variable_valobj_sp) {
 403         variable_list.RemoveVariableAtIndex(i);
 404         continue;
 405       }
 406
 407       llvm::StringRef variable_sub_expr_path =
 408           variable_expr_path.drop_front(variable_name.size());
 409       if (!variable_sub_expr_path.empty()) {
 410         valobj_sp = variable_valobj_sp->GetValueForExpressionPath(
 411             variable_sub_expr_path);
 412         if (!valobj_sp) {
 413           error.SetErrorStringWithFormatv(
 414               "invalid expression path '{0}' for variable '{1}'",
 415               variable_sub_expr_path, var_sp->GetName().GetCString());
 416           variable_list.RemoveVariableAtIndex(i);
 417           continue;
 418         }
 419       } else {
 420         // Just the name of a variable with no extras
 421         valobj_sp = variable_valobj_sp;
 422       }
 423
 424       valobj_list.Append(valobj_sp);
 425       ++i;
 426     }
 427
 428     if (variable_list.GetSize() > 0) {
 429       error.Clear();
 430       return error;
 431     }
 432   } break;
 433   }
 434   error.SetErrorString("unknown error");
 435   return error;
 436 }
 437
 438 bool Variable::DumpLocations(Stream *s, const Address &address) {
 439   SymbolContext sc;
 440   CalculateSymbolContext(&sc);
 441   ABISP abi;
 442   if (m_owner_scope) {
 443     ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
 444     if (module_sp)
 445       abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
 446   }
 447
 448   const addr_t file_addr = address.GetFileAddress();
 449   if (sc.function) {
 450     addr_t loclist_base_file_addr =
 451         sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
 452     if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
 453       return false;
 454     return m_location_list.DumpLocations(s, eDescriptionLevelBrief,
 455                                          loclist_base_file_addr, file_addr,
 456                                          abi.get());
 457   }
 458   return false;
 459 }
 460
 461 static void PrivateAutoComplete(
 462     StackFrame *frame, llvm::StringRef partial_path,
 463     const llvm::Twine
 464         &prefix_path, // Anything that has been resolved already will be in here
 465     const CompilerType &compiler_type, CompletionRequest &request);
 466
 467 static void PrivateAutoCompleteMembers(
 468     StackFrame *frame, const std::string &partial_member_name,
 469     llvm::StringRef partial_path,
 470     const llvm::Twine
 471         &prefix_path, // Anything that has been resolved already will be in here
 472     const CompilerType &compiler_type, CompletionRequest &request) {
 473
 474   // We are in a type parsing child members
 475   const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
 476
 477   if (num_bases > 0) {
 478     for (uint32_t i = 0; i < num_bases; ++i) {
 479       CompilerType base_class_type =
 480           compiler_type.GetDirectBaseClassAtIndex(i, nullptr);
 481
 482       PrivateAutoCompleteMembers(frame, partial_member_name, partial_path,
 483                                  prefix_path,
 484                                  base_class_type.GetCanonicalType(), request);
 485     }
 486   }
 487
 488   const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses();
 489
 490   if (num_vbases > 0) {
 491     for (uint32_t i = 0; i < num_vbases; ++i) {
 492       CompilerType vbase_class_type =
 493           compiler_type.GetVirtualBaseClassAtIndex(i, nullptr);
 494
 495       PrivateAutoCompleteMembers(frame, partial_member_name, partial_path,
 496                                  prefix_path,
 497                                  vbase_class_type.GetCanonicalType(), request);
 498     }
 499   }
 500
 501   // We are in a type parsing child members
 502   const uint32_t num_fields = compiler_type.GetNumFields();
 503
 504   if (num_fields > 0) {
 505     for (uint32_t i = 0; i < num_fields; ++i) {
 506       std::string member_name;
 507
 508       CompilerType member_compiler_type = compiler_type.GetFieldAtIndex(
 509           i, member_name, nullptr, nullptr, nullptr);
 510
 511       if (partial_member_name.empty() ||
 512           llvm::StringRef(member_name).startswith(partial_member_name)) {
 513         if (member_name == partial_member_name) {
 514           PrivateAutoComplete(
 515               frame, partial_path,
 516               prefix_path + member_name, // Anything that has been resolved
 517                                          // already will be in here
 518               member_compiler_type.GetCanonicalType(), request);
 519         } else {
 520           request.AddCompletion((prefix_path + member_name).str());
 521         }
 522       }
 523     }
 524   }
 525 }
 526
 527 static void PrivateAutoComplete(
 528     StackFrame *frame, llvm::StringRef partial_path,
 529     const llvm::Twine
 530         &prefix_path, // Anything that has been resolved already will be in here
 531     const CompilerType &compiler_type, CompletionRequest &request) {
 532   //    printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path =
 533   //    '%s'\n", prefix_path.c_str(), partial_path.c_str());
 534   std::string remaining_partial_path;
 535
 536   const lldb::TypeClass type_class = compiler_type.GetTypeClass();
 537   if (partial_path.empty()) {
 538     if (compiler_type.IsValid()) {
 539       switch (type_class) {
 540       default:
 541       case eTypeClassArray:
 542       case eTypeClassBlockPointer:
 543       case eTypeClassBuiltin:
 544       case eTypeClassComplexFloat:
 545       case eTypeClassComplexInteger:
 546       case eTypeClassEnumeration:
 547       case eTypeClassFunction:
 548       case eTypeClassMemberPointer:
 549       case eTypeClassReference:
 550       case eTypeClassTypedef:
 551       case eTypeClassVector: {
 552         request.AddCompletion(prefix_path.str());
 553       } break;
 554
 555       case eTypeClassClass:
 556       case eTypeClassStruct:
 557       case eTypeClassUnion:
 558         if (prefix_path.str().back() != '.')
 559           request.AddCompletion((prefix_path + ".").str());
 560         break;
 561
 562       case eTypeClassObjCObject:
 563       case eTypeClassObjCInterface:
 564         break;
 565       case eTypeClassObjCObjectPointer:
 566       case eTypeClassPointer: {
 567         bool omit_empty_base_classes = true;
 568         if (compiler_type.GetNumChildren(omit_empty_base_classes, nullptr) > 0)
 569           request.AddCompletion((prefix_path + "->").str());
 570         else {
 571           request.AddCompletion(prefix_path.str());
 572         }
 573       } break;
 574       }
 575     } else {
 576       if (frame) {
 577         const bool get_file_globals = true;
 578
 579         VariableList *variable_list = frame->GetVariableList(get_file_globals,
 580                                                              nullptr);
 581
 582         if (variable_list) {
 583           for (const VariableSP &var_sp : *variable_list)
 584             request.AddCompletion(var_sp->GetName().AsCString());
 585         }
 586       }
 587     }
 588   } else {
 589     const char ch = partial_path[0];
 590     switch (ch) {
 591     case '*':
 592       if (prefix_path.str().empty()) {
 593         PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
 594                             request);
 595       }
 596       break;
 597
 598     case '&':
 599       if (prefix_path.isTriviallyEmpty()) {
 600         PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
 601                             compiler_type, request);
 602       }
 603       break;
 604
 605     case '-':
 606       if (partial_path.size() > 1 && partial_path[1] == '>' &&
 607           !prefix_path.str().empty()) {
 608         switch (type_class) {
 609         case lldb::eTypeClassPointer: {
 610           CompilerType pointee_type(compiler_type.GetPointeeType());
 611           if (partial_path.size() > 2 && partial_path[2]) {
 612             // If there is more after the "->", then search deeper
 613             PrivateAutoComplete(frame, partial_path.substr(2),
 614                                 prefix_path + "->",
 615                                 pointee_type.GetCanonicalType(), request);
 616           } else {
 617             // Nothing after the "->", so list all members
 618             PrivateAutoCompleteMembers(
 619                 frame, std::string(), std::string(), prefix_path + "->",
 620                 pointee_type.GetCanonicalType(), request);
 621           }
 622         } break;
 623         default:
 624           break;
 625         }
 626       }
 627       break;
 628
 629     case '.':
 630       if (compiler_type.IsValid()) {
 631         switch (type_class) {
 632         case lldb::eTypeClassUnion:
 633         case lldb::eTypeClassStruct:
 634         case lldb::eTypeClassClass:
 635           if (partial_path.size() > 1 && partial_path[1]) {
 636             // If there is more after the ".", then search deeper
 637             PrivateAutoComplete(frame, partial_path.substr(1),
 638                                 prefix_path + ".", compiler_type, request);
 639
 640           } else {
 641             // Nothing after the ".", so list all members
 642             PrivateAutoCompleteMembers(frame, std::string(), partial_path,
 643                                        prefix_path + ".", compiler_type,
 644                                        request);
 645           }
 646           break;
 647         default:
 648           break;
 649         }
 650       }
 651       break;
 652     default:
 653       if (isalpha(ch) || ch == '_' || ch == '$') {
 654         const size_t partial_path_len = partial_path.size();
 655         size_t pos = 1;
 656         while (pos < partial_path_len) {
 657           const char curr_ch = partial_path[pos];
 658           if (isalnum(curr_ch) || curr_ch == '_' || curr_ch == '$') {
 659             ++pos;
 660             continue;
 661           }
 662           break;
 663         }
 664
 665         std::string token(std::string(partial_path), 0, pos);
 666         remaining_partial_path = std::string(partial_path.substr(pos));
 667
 668         if (compiler_type.IsValid()) {
 669           PrivateAutoCompleteMembers(frame, token, remaining_partial_path,
 670                                      prefix_path, compiler_type, request);
 671         } else if (frame) {
 672           // We haven't found our variable yet
 673           const bool get_file_globals = true;
 674
 675           VariableList *variable_list =
 676               frame->GetVariableList(get_file_globals, nullptr);
 677
 678           if (!variable_list)
 679             break;
 680
 681           for (VariableSP var_sp : *variable_list) {
 682
 683             if (!var_sp)
 684               continue;
 685
 686             llvm::StringRef variable_name = var_sp->GetName().GetStringRef();
 687             if (variable_name.startswith(token)) {
 688               if (variable_name == token) {
 689                 Type *variable_type = var_sp->GetType();
 690                 if (variable_type) {
 691                   CompilerType variable_compiler_type(
 692                       variable_type->GetForwardCompilerType());
 693                   PrivateAutoComplete(
 694                       frame, remaining_partial_path,
 695                       prefix_path + token, // Anything that has been resolved
 696                                            // already will be in here
 697                       variable_compiler_type.GetCanonicalType(), request);
 698                 } else {
 699                   request.AddCompletion((prefix_path + variable_name).str());
 700                 }
 701               } else if (remaining_partial_path.empty()) {
 702                 request.AddCompletion((prefix_path + variable_name).str());
 703               }
 704             }
 705           }
 706         }
 707       }
 708       break;
 709     }
 710   }
 711 }
 712
 713 void Variable::AutoComplete(const ExecutionContext &exe_ctx,
 714                             CompletionRequest &request) {
 715   CompilerType compiler_type;
 716
 717   PrivateAutoComplete(exe_ctx.GetFramePtr(), request.GetCursorArgumentPrefix(),
 718                       "", compiler_type, request);
 719 }