Remove by-name cache from RustASTContext

Remove the by-name cache from RustASTContext.  This was not needed and
could interact badly with the DWARF parser.  Closes llvm#22

Signed-off-by: Gabor Greif <[email protected]>

Author: tromey

lldb/include/lldb/Symbol/RustASTContext.h

@@ -449,14 +449,12 @@ class RustASTContext : public TypeSystem {
 
 private:
   int m_pointer_byte_size;
-  std::map<ConstString, std::unique_ptr<RustType>> m_types;
-  std::set<std::unique_ptr<RustType>> m_anon_types;
+  std::set<std::unique_ptr<RustType>> m_types;
   std::unique_ptr<DWARFASTParser> m_dwarf_ast_parser_ap;
 
   std::unique_ptr<RustDeclContext> m_tu_decl;
 
-  RustType *FindCachedType(const lldb_private::ConstString &name);
-  CompilerType CacheType(const lldb_private::ConstString &name, RustType *new_type);
+  CompilerType CacheType(RustType *new_type);
 
   RustASTContext(const RustASTContext &) = delete;
   const RustASTContext &operator=(const RustASTContext &) = delete;

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

@@ -237,6 +237,9 @@ TypeSP DWARFASTParserRust::ParseSimpleType(const DWARFDIE &die) {
       compiler_type = m_ast.CreateBoolType(type_name_const_str);
     else if (encoding == DW_ATE_float)
       compiler_type = m_ast.CreateFloatType(type_name_const_str, byte_size);
+    else if (byte_size == 0 && type_name_const_str &&
+	     strcmp(type_name_const_str.AsCString(), "()") == 0)
+      compiler_type = m_ast.CreateTupleType(type_name_const_str, byte_size, false);
     else if (encoding == DW_ATE_signed || encoding == DW_ATE_unsigned ||
              // DW_ATE_UCS seems to be less used (perhaps
              // Fortran-specific?) and since I'm not planning to have

lldb/source/Symbol/RustASTContext.cpp

@@ -1834,40 +1834,22 @@ void RustASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, Stre
   s->PutCString(name.AsCString());
 }
 
-RustType *RustASTContext::FindCachedType(const lldb_private::ConstString &name) {
-  if (name.IsEmpty())
-    return nullptr;
-  auto result = m_types.find(name);
-  if (result == m_types.end ())
-    return nullptr;
-  return result->second.get();
-}
-
-CompilerType RustASTContext::CacheType(const ConstString &name, RustType *new_type) {
-  if (name.IsEmpty()) {
-    // Be sure to keep nameless types alive.
-    m_anon_types.insert(std::unique_ptr<RustType>(new_type));
-  } else {
-    m_types[name].reset(new_type);
-  }
+CompilerType RustASTContext::CacheType(RustType *new_type) {
+  m_types.insert(std::unique_ptr<RustType>(new_type));
   return CompilerType(this, new_type);
 }
 
 CompilerType RustASTContext::CreateBoolType(const lldb_private::ConstString &name) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustBool(name);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType RustASTContext::CreateIntegralType(const lldb_private::ConstString &name,
                                                 bool is_signed,
                                                 uint64_t byte_size,
                                                 bool is_char_type) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustIntegral(name, is_signed, byte_size, is_char_type);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType RustASTContext::CreateIntrinsicIntegralType(bool is_signed, uint64_t byte_size) {
@@ -1885,10 +1867,8 @@ CompilerType RustASTContext::CreateCharType() {
 
 CompilerType RustASTContext::CreateFloatType(const lldb_private::ConstString &name,
                                              uint64_t byte_size) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustFloat(name, byte_size);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType RustASTContext::CreateArrayType(const CompilerType &element_type,
@@ -1900,53 +1880,41 @@ CompilerType RustASTContext::CreateArrayType(const CompilerType &element_type,
   name += "]";
   ConstString newname(name);
 
-  if (RustType *cached = FindCachedType(newname))
-    return CompilerType(this, cached);
   RustType *type = new RustArray(newname, length, element_type);
-  return CacheType(newname, type);
+  return CacheType(type);
 }
 
 CompilerType RustASTContext::CreateTypedefType(const ConstString &name, CompilerType impl) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustTypedef(name, impl);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreateStructType(const lldb_private::ConstString &name, uint32_t byte_size,
                                  bool has_discriminant) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustStruct(name, byte_size, has_discriminant);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreateTupleType(const lldb_private::ConstString &name, uint32_t byte_size,
                                 bool has_discriminant) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustTuple(name, byte_size, has_discriminant);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreateUnionType(const lldb_private::ConstString &name, uint32_t byte_size) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustUnion(name, byte_size);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreatePointerType(const lldb_private::ConstString &name,
                                   const CompilerType &pointee_type,
                                   uint32_t byte_size) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustPointer(name, pointee_type, byte_size);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 void RustASTContext::AddFieldToStruct(const CompilerType &struct_type,
@@ -1973,39 +1941,31 @@ CompilerType
 RustASTContext::CreateFunctionType(const lldb_private::ConstString &name,
                                    const CompilerType &return_type,
                                    const std::vector<CompilerType> &&params) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustFunction(name, m_pointer_byte_size, return_type, std::move(params));
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreateVoidType() {
   ConstString name("()");
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustTuple(name, 0, false);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreateEnumType(const lldb_private::ConstString &name,
                                uint64_t byte_size, uint32_t discr_offset,
                                uint32_t discr_byte_size) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustEnum(name, byte_size, discr_offset, discr_byte_size);
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 CompilerType
 RustASTContext::CreateCLikeEnumType(const lldb_private::ConstString &name,
                                     const CompilerType &underlying_type,
                                     std::map<uint64_t, std::string> &&values) {
-  if (RustType *cached = FindCachedType(name))
-    return CompilerType(this, cached);
   RustType *type = new RustCLikeEnum(name, underlying_type, std::move(values));
-  return CacheType(name, type);
+  return CacheType(type);
 }
 
 bool