Move initialization of Variable::m_loc_is_const_data into constructor (NFC)

[aprantl]

Summary

This makes it symmetric with all other flags and makes it easier to not forget to initialize it.

[shafik]

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

823

Can we add comments for these bool arguments, I have seen this done in llvm/clang and really helps readability e.g.:

/*artificial*/ false, /*location_is_constant_data*/ false, /*static_member*/ false);

Same goes for other places as well.

[aprantl]

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

823

commit f9586a3b3c28f87652d00512236c43e8951a1bc4 (HEAD -> master, origin/master, origin/HEAD)
Author: Adrian Prantl <[e-mail]>
Date: Tue Oct 13 17:31:33 2020 -0700

Replace bool constants with named constants for improved readibility (NFC)

[aprantl]

landed in 9b1c06c0e84a9cc763e12b289becb5fc3c9d01ea

lldb/include/lldb/Symbol/Variable.h

public:
 
   /// Constructors and Destructors.
   ///
   /// \param mangled The mangled or fully qualified name of the variable.
   Variable(lldb::user_id_t uid, const char *name, const char *mangled,
            const lldb::SymbolFileTypeSP &symfile_type_sp, lldb::ValueType scope,
            SymbolContextScope *owner_scope, const RangeList &scope_range,
            Declaration *decl, const DWARFExpression &location, bool external,
-           bool artificial, bool static_member = false);
+           bool artificial, bool location_is_constant_data,
+           bool static_member = false);
 
   virtual ~Variable();
 
   void Dump(Stream *s, bool show_context) const;
 
   bool DumpDeclaration(Stream *s, bool show_fullpaths, bool show_module);
 
   const Declaration &GetDeclaration() const { return m_declaration; }

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (use_type_size_for_value && type_sp->GetType())
       location.UpdateValue(
           const_value_form.Unsigned(),
           type_sp->GetType()->GetByteSize(nullptr).getValueOr(0),
           die.GetCU()->GetAddressByteSize());
 
     var_sp = std::make_shared<Variable>(
         die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
         scope_ranges, &decl, location, is_external, is_artificial,
-        is_static_member);
-
-    var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
+        location_is_const_value_data, is_static_member);
   } else {
     // Not ready to parse this variable yet. It might be a global or static
     // variable that is in a function scope and the function in the symbol
     // context wasn't filled in yet
     return var_sp;
   }
   // Cache var_sp even if NULL (the variable was just a specification or was
   // missing vital information to be able to be displayed in the debugger

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
   DWARFExpression location = MakeGlobalLocationExpression(
       section, offset, GetObjectFile()->GetModule());
 
   std::string global_name("::");
   global_name += name;
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), name.str().c_str(), global_name.c_str(), type_sp,
       scope, comp_unit.get(), ranges, &decl, location, is_external, false,
-      false);
-  var_sp->SetLocationIsConstantValueData(false);
+      false, false);
 
   return var_sp;
 }
 
 lldb::VariableSP
 SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
                                           const CVSymbol &cvs) {
   TpiStream &tpi = m_index->tpi();
SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
   Variable::RangeList ranges;
   ModuleSP module = GetObjectFile()->GetModule();
   DWARFExpression location = MakeConstantLocationExpression(
       constant.Type, tpi, constant.Value, module);
 
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), constant.Name.str().c_str(), global_name.c_str(),
       type_sp, eValueTypeVariableGlobal, module.get(), ranges, &decl, location,
-      false, false, false);
-  var_sp->SetLocationIsConstantValueData(true);
+      false, false, true, false);
   return var_sp;
 }
 
 VariableSP
 SymbolFileNativePDB::GetOrCreateGlobalVariable(PdbGlobalSymId var_id) {
   auto emplace_result = m_global_vars.try_emplace(toOpaqueUid(var_id), nullptr);
   if (emplace_result.second)
     emplace_result.first->second = CreateGlobalVariable(var_id);
VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
   SymbolFileTypeSP sftype =
       std::make_shared<SymbolFileType>(*this, type_sp->GetID());
 
   ValueType var_scope =
       is_param ? eValueTypeVariableArgument : eValueTypeVariableLocal;
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), name.c_str(), name.c_str(), sftype, var_scope,
       comp_unit_sp.get(), *var_info.ranges, &decl, *var_info.location, false,
-      false, false);
+      false, false, false);
 
   if (!is_param)
     m_ast->GetOrCreateVariableDecl(scope_id, var_id);
 
   m_local_variables[toOpaqueUid(var_id)] = var_sp;
   return var_sp;
 }
 

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

VariableSP SymbolFilePDB::ParseVariableForPDBData(
   auto mangled_cstr = mangled.empty() ? nullptr : mangled.c_str();
 
   bool is_constant;
   DWARFExpression location = ConvertPDBLocationToDWARFExpression(
       GetObjectFile()->GetModule(), pdb_data, ranges, is_constant);
 
   var_sp = std::make_shared<Variable>(
       var_uid, var_name.c_str(), mangled_cstr, type_sp, scope, context_scope,
-      ranges, &decl, location, is_external, is_artificial, is_static_member);
-  var_sp->SetLocationIsConstantValueData(is_constant);
+      ranges, &decl, location, is_external, is_artificial, is_constant,
+      is_static_member);
 
   m_variables.insert(std::make_pair(var_uid, var_sp));
   return var_sp;
 }
 
 size_t
 SymbolFilePDB::ParseVariables(const lldb_private::SymbolContext &sc,
                               const llvm::pdb::PDBSymbol &pdb_symbol,

lldb/source/Symbol/Variable.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 Variable::Variable(lldb::user_id_t uid, const char *name, const char *mangled,
                    const lldb::SymbolFileTypeSP &symfile_type_sp,
                    ValueType scope, SymbolContextScope *context,
                    const RangeList &scope_range, Declaration *decl_ptr,
                    const DWARFExpression &location, bool external,
-                   bool artificial, bool static_member)
+                   bool artificial, bool location_is_constant_data,
+                   bool static_member)
     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
       m_owner_scope(context), m_scope_range(scope_range),
       m_declaration(decl_ptr), m_location(location), m_external(external),
-      m_artificial(artificial), m_loc_is_const_data(false),
+      m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
       m_static_member(static_member) {}
 
 Variable::~Variable() {}
 
 lldb::LanguageType Variable::GetLanguage() const {
   lldb::LanguageType lang = m_mangled.GuessLanguage();
   if (lang != lldb::eLanguageTypeUnknown)
     return lang;