Switch TypeSystemClang over to CreateDeserialized() (NFC)

[aprantl]

Summary

Based on a suggestion from Richard Smith, this switches TypeSystemClang over to Decl*::CreateDeserialized() which is the more appropriate API for its use-case.

[teemperor]

The changes that remove the non-existent module parameter slipped in by mistake I think and the rest LGTM. I didn't verify if all the setX calls are 100% identical to what the constructor would do but *usually* Decl constructor don't any fancy logic so the new code should be equivalent. Maybe dump some module AST before and after this patch and just diff it to see if anything changed.

[shafik]

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

1265

static_cast<TagDecl::TagKind>(kind)

1448

static_cast<TagDecl::TagKind>(kind)

1966

static_cast<StorageClass>(storage)

2028

static_cast<StorageClass>(storage)

[shafik]

A bunch of small comments but a few more serious ones as well.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

1394

It does not look like func_decl->getLocation() get used at all.

1526

static_cast<TagDecl::TagKind>(kind)

1836

I guess clang::SC_None is the default?

7268

Where does 1 << 1 come from? What does it mean?

7999

Everywhere else we do:

if (name && name[0])

Why not for this case?

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

if (imported_uid) {
       if (imported_decl) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamedDecl *clang_imported_decl =
                 llvm::dyn_cast<clang::NamedDecl>(
                     (clang::Decl *)imported_decl.GetOpaqueDecl()))
           decl =
-            m_ast.CreateUsingDeclaration(decl_context, 0, clang_imported_decl);
+              m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
       }
     }
     break;
   }
   case DW_TAG_imported_module: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
 
     if (imported_uid) {
       CompilerDeclContext imported_decl_ctx =
           SymbolFileDWARF::GetDeclContext(imported_uid);
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamespaceDecl *ns_decl =
                 TypeSystemClang::DeclContextGetAsNamespaceDecl(
                     imported_decl_ctx))
-          decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, 0, ns_decl);
+          decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
       }
     }
     break;
   }
   default:
     break;
   }
 

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

public:
 
   // Returns a mask containing bits from the TypeSystemClang::eTypeXXX
   // enumerations
 
   // Namespace Declarations
 
   clang::NamespaceDecl *
   GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx,
-                                unsigned owning_module, bool is_inline = false);
+                                bool is_inline = false);
 
   // Function Types
 
   clang::FunctionDecl *CreateFunctionDeclaration(
       clang::DeclContext *decl_ctx, unsigned owning_module, const char *name,
       const CompilerType &function_Type, int storage, bool is_inline);
 
   CompilerType CreateFunctionType(const CompilerType &result_type,
clang::ClassTemplateDecl *ParseClassTemplateDecl(
       lldb::AccessType access_type, const char *parent_name, int tag_decl_kind,
       const TypeSystemClang::TemplateParameterInfos &template_param_infos);
 
   clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx,
                                            unsigned owning_module);
 
   clang::UsingDirectiveDecl *
   CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
-                                  unsigned owning_module,
                                   clang::NamespaceDecl *ns_decl);
 
   clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
-                                           unsigned owning_module,
                                            clang::NamedDecl *target);
 
   clang::VarDecl *CreateVariableDeclaration(clang::DeclContext *decl_context,
                                             unsigned owning_module,
                                             const char *name,
                                             clang::QualType type);
 
   static lldb::opaque_compiler_type_t

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

CompilerType TypeSystemClang::CreateRecordType(clang::DeclContext *decl_ctx,
 
   // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
   // we will need to update this code. I was told to currently always use the
   // CXXRecordDecl class since we often don't know from debug information if
   // something is struct or a class, so we default to always use the more
   // complete definition just in case.
 
   bool has_name = !name.empty();
-  CXXRecordDecl *decl = CXXRecordDecl::Create(
-      ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(),
-      SourceLocation(), has_name ? &ast.Idents.get(name) : nullptr);
+  CXXRecordDecl *decl = CXXRecordDecl::CreateDeserialized(ast, 0);
+  decl->setTagKind((TagDecl::TagKind)kind);
+  decl->setDeclContext(decl_ctx);
+  if (has_name)
+    decl->setDeclName(&ast.Idents.get(name));
   SetOwningModule(decl, owning_module);
 
   if (!has_name) {
     // In C++ a lambda is also represented as an unnamed class. This is
     // different from an *anonymous class* that the user wrote:
     //
     // struct A {
     //  // anonymous class (GNU/MSVC extension)
clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl(
     clang::FunctionDecl *func_decl, const char *name,
     const TemplateParameterInfos &template_param_infos) {
   //    /// Create a function template node.
   ASTContext &ast = getASTContext();
 
   llvm::SmallVector<NamedDecl *, 8> template_param_decls;
   TemplateParameterList *template_param_list = CreateTemplateParameterList(
       ast, template_param_infos, template_param_decls);
-  FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create(
-      ast, decl_ctx, func_decl->getLocation(), func_decl->getDeclName(),
-      template_param_list, func_decl);
+  FunctionTemplateDecl *func_tmpl_decl =
+      FunctionTemplateDecl::CreateDeserialized(ast, 0);
+  func_tmpl_decl->setDeclContext(decl_ctx);
+  func_tmpl_decl->setDeclName(func_decl->getDeclName());
+  func_tmpl_decl->init(func_decl, template_param_list);
   SetOwningModule(func_tmpl_decl, owning_module);
 
   for (size_t i = 0, template_param_decl_count = template_param_decls.size();
        i < template_param_decl_count; ++i) {
     // TODO: verify which decl context we should put template_param_decls into..
     template_param_decls[i]->setDeclContext(func_decl);
   }
   // Function templates inside a record need to have an access specifier.
if (class_template_decl)
       return class_template_decl;
   }
 
   llvm::SmallVector<NamedDecl *, 8> template_param_decls;
 
   TemplateParameterList *template_param_list = CreateTemplateParameterList(
       ast, template_param_infos, template_param_decls);
 
-  CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create(
-      ast, (TagDecl::TagKind)kind,
-      decl_ctx, // What decl context do we use here? TU? The actual
-                            // decl context?
-      SourceLocation(), SourceLocation(), &identifier_info);
+  CXXRecordDecl *template_cxx_decl = CXXRecordDecl::CreateDeserialized(ast, 0);
+  template_cxx_decl->setTagKind((TagDecl::TagKind)kind);
+  // What decl context do we use here? TU? The actual decl context?
+  template_cxx_decl->setDeclContext(decl_ctx);
+  template_cxx_decl->setDeclName(decl_name);
   SetOwningModule(template_cxx_decl, owning_module);
 
   for (size_t i = 0, template_param_decl_count = template_param_decls.size();
        i < template_param_decl_count; ++i) {
     template_param_decls[i]->setDeclContext(template_cxx_decl);
   }
 
   // With templated classes, we say that a class is templated with
   // specializations, but that the bare class has no functions.
   // template_cxx_decl->startDefinition();
   // template_cxx_decl->completeDefinition();
 
-  class_template_decl = ClassTemplateDecl::Create(
-      ast,
-      decl_ctx, // What decl context do we use here? TU? The actual
-                            // decl context?
-      SourceLocation(), decl_name, template_param_list, template_cxx_decl);
+  class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0);
+  // What decl context do we use here? TU? The actual decl context?
+  class_template_decl->setDeclContext(decl_ctx);
+  class_template_decl->setDeclName(decl_name);
+  class_template_decl->init(template_cxx_decl, template_param_list);
   template_cxx_decl->setDescribedClassTemplate(class_template_decl);
   SetOwningModule(class_template_decl, owning_module);
 
   if (class_template_decl) {
     if (access_type != eAccessNone)
       class_template_decl->setAccess(
           ConvertAccessTypeToAccessSpecifier(access_type));
 
llvm::SmallVector<clang::TemplateArgument, 2> args(
       (template_param_infos.packed_args ? 1 : 0));
   std::copy(template_param_infos.args.begin(), template_param_infos.args.end(),
             args.begin());
   if (template_param_infos.packed_args) {
     args[args.size() - 1] = TemplateArgument::CreatePackCopy(
         ast, template_param_infos.packed_args->args);
   }
   ClassTemplateSpecializationDecl *class_template_specialization_decl =
-      ClassTemplateSpecializationDecl::Create(
-          ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(),
-          SourceLocation(), class_template_decl, args, nullptr);
+      ClassTemplateSpecializationDecl::CreateDeserialized(
+                                                          ast, 0);
+  class_template_specialization_decl->setTagKind((TagDecl::TagKind)kind);
+  class_template_specialization_decl->setDeclContext(decl_ctx);
+  class_template_specialization_decl->setInstantiationOf(class_template_decl);
+  class_template_specialization_decl->setTemplateArgs(
+      TemplateArgumentList::CreateCopy(ast, args));
+
   SetOwningModule(class_template_decl, owning_module);
 
   class_template_specialization_decl->setSpecializationKind(
       TSK_ExplicitSpecialization);
 
   return class_template_specialization_decl;
 }
 
CompilerType TypeSystemClang::CreateObjCClass(llvm::StringRef name,
                                               bool isForwardDecl,
                                               bool isInternal,
                                               ClangASTMetadata *metadata) {
   ASTContext &ast = getASTContext();
   assert(!name.empty());
   if (!decl_ctx)
     decl_ctx = ast.getTranslationUnitDecl();
 
-  ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create(
-      ast, decl_ctx, SourceLocation(), &ast.Idents.get(name), nullptr, nullptr,
-      SourceLocation(),
-      /*isForwardDecl,*/
-      isInternal);
+  ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0);
+  decl->setDeclContext(decl_ctx);
+  decl->setDeclName(&ast.Idents.get(name));
+  decl->setImplicit(isInternal);
   SetOwningModule(decl, owning_module);
 
   if (decl && metadata)
     SetMetadata(decl, *metadata);
 
   return GetType(ast.getObjCInterfaceType(decl));
 }
 
if (omit_empty_base_classes) {
       num_bases = cxx_record_decl->getNumBases();
   }
   return num_bases;
 }
 
 #pragma mark Namespace Declarations
 
 NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration(
-    const char *name, clang::DeclContext *decl_ctx, unsigned owning_module,
-    bool is_inline) {
+    const char *name, clang::DeclContext *decl_ctx, bool is_inline) {
   NamespaceDecl *namespace_decl = nullptr;
   ASTContext &ast = getASTContext();
   TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl();
   if (!decl_ctx)
     decl_ctx = translation_unit_decl;
 
   if (name) {
     IdentifierInfo &identifier_info = ast.Idents.get(name);
if (decl_ctx == translation_unit_decl) {
         assert(namespace_decl ==
                parent_namespace_decl->getAnonymousNamespace());
       } else {
         assert(false && "GetUniqueNamespaceDeclaration called with no name and "
                         "no namespace as decl_ctx");
       }
     }
   }
-  // Note: namespaces can span multiple modules, so perhaps this isn't a good idea.
-  SetOwningModule(namespace_decl, owning_module);
 
   VerifyDecl(namespace_decl);
   return namespace_decl;
 }
 
 clang::BlockDecl *
 TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx,
                                         unsigned owning_module) {
   if (ctx) {
-    clang::BlockDecl *decl = clang::BlockDecl::Create(
-        getASTContext(), ctx, clang::SourceLocation());
+    clang::BlockDecl *decl =
+        clang::BlockDecl::CreateDeserialized(getASTContext(), 0);
+    decl->setDeclContext(ctx);
     ctx->addDecl(decl);
     SetOwningModule(decl, owning_module);
     return decl;
   }
   return nullptr;
 }
 
 clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left,
clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left,
   for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
     if (path_left.find(d) != path_left.end())
       return d;
 
   return nullptr;
 }
 
 clang::UsingDirectiveDecl *TypeSystemClang::CreateUsingDirectiveDeclaration(
-    clang::DeclContext *decl_ctx, unsigned owning_module,
-    clang::NamespaceDecl *ns_decl) {
+    clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) {
   if (decl_ctx && ns_decl) {
     auto *translation_unit = getASTContext().getTranslationUnitDecl();
-      clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
           getASTContext(), decl_ctx, clang::SourceLocation(),
           clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
           clang::SourceLocation(), ns_decl,
           FindLCABetweenDecls(decl_ctx, ns_decl,
                               translation_unit));
       decl_ctx->addDecl(using_decl);
-      SetOwningModule(using_decl, owning_module);
-
       return using_decl;
   }
   return nullptr;
 }
 
 clang::UsingDecl *
 TypeSystemClang::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
-                                        unsigned owning_module,
                                         clang::NamedDecl *target) {
   if (current_decl_ctx && target) {
     clang::UsingDecl *using_decl = clang::UsingDecl::Create(
         getASTContext(), current_decl_ctx, clang::SourceLocation(),
         clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false);
-    SetOwningModule(using_decl, owning_module);
     clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
         getASTContext(), current_decl_ctx, clang::SourceLocation(), using_decl,
         target);
-    SetOwningModule(shadow_decl, owning_module);
     using_decl->addShadowDecl(shadow_decl);
     current_decl_ctx->addDecl(using_decl);
     return using_decl;
   }
   return nullptr;
 }
 
 clang::VarDecl *TypeSystemClang::CreateVariableDeclaration(
     clang::DeclContext *decl_context, unsigned owning_module, const char *name,
     clang::QualType type) {
   if (decl_context) {
-    clang::VarDecl *var_decl = clang::VarDecl::Create(
-        getASTContext(), decl_context, clang::SourceLocation(),
-        clang::SourceLocation(),
-        name && name[0] ? &getASTContext().Idents.getOwn(name) : nullptr, type,
-        nullptr, clang::SC_None);
+    clang::VarDecl *var_decl =
+        clang::VarDecl::CreateDeserialized(getASTContext(), 0);
+    var_decl->setDeclContext(decl_context);
+    if (name && name[0])
+      var_decl->setDeclName(&getASTContext().Idents.getOwn(name));
+    var_decl->setType(type);
     SetOwningModule(var_decl, owning_module);
 
     var_decl->setAccess(clang::AS_public);
     decl_context->addDecl(var_decl);
     return var_decl;
   }
   return nullptr;
 }
FunctionDecl *TypeSystemClang::CreateFunctionDeclaration(
   if (!decl_ctx)
     decl_ctx = ast.getTranslationUnitDecl();
 
   const bool hasWrittenPrototype = true;
   const bool isConstexprSpecified = false;
 
   clang::DeclarationName declarationName =
       GetDeclarationName(name, function_clang_type);
-  func_decl = FunctionDecl::Create(
-      ast, decl_ctx, SourceLocation(), SourceLocation(), declarationName,
-      ClangUtil::GetQualType(function_clang_type), nullptr,
-      (clang::StorageClass)storage, is_inline, hasWrittenPrototype,
-      isConstexprSpecified ? CSK_constexpr : CSK_unspecified);
+  func_decl = FunctionDecl::CreateDeserialized(ast, 0);
+  func_decl->setDeclContext(decl_ctx);
+  func_decl->setDeclName(declarationName);
+  func_decl->setType(ClangUtil::GetQualType(function_clang_type));
+  func_decl->setStorageClass((clang::StorageClass)storage);
+  func_decl->setInlineSpecified(is_inline);
+  func_decl->setHasWrittenPrototype(hasWrittenPrototype);
+  func_decl->setConstexprKind(isConstexprSpecified ? CSK_constexpr
+                                                   : CSK_unspecified);
   SetOwningModule(func_decl, owning_module);
   if (func_decl)
     decl_ctx->addDecl(func_decl);
 
   VerifyDecl(func_decl);
 
   return func_decl;
 }
TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
   return GetType(getASTContext().getFunctionType(
       ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
 }
 
 ParmVarDecl *TypeSystemClang::CreateParameterDeclaration(
     clang::DeclContext *decl_ctx, unsigned owning_module, const char *name,
     const CompilerType &param_type, int storage, bool add_decl) {
   ASTContext &ast = getASTContext();
-  auto *decl =
-      ParmVarDecl::Create(ast, decl_ctx, SourceLocation(), SourceLocation(),
-                          name && name[0] ? &ast.Idents.get(name) : nullptr,
-                          ClangUtil::GetQualType(param_type), nullptr,
-                          (clang::StorageClass)storage, nullptr);
+  auto *decl = ParmVarDecl::CreateDeserialized(ast, 0);
+  decl->setDeclContext(decl_ctx);
+  if (name && name[0])
+    decl->setDeclName(&ast.Idents.get(name));
+  decl->setType(ClangUtil::GetQualType(param_type));
+  decl->setStorageClass((clang::StorageClass)storage);
   SetOwningModule(decl, owning_module);
  
   if (add_decl)
     decl_ctx->addDecl(decl);
 
   return decl;
 }
 
CompilerType TypeSystemClang::CreateEnumerationType(
     const Declaration &decl, const CompilerType &integer_clang_type,
     bool is_scoped) {
   // TODO: Do something intelligent with the Declaration object passed in
   // like maybe filling in the SourceLocation with it...
   ASTContext &ast = getASTContext();
 
   // TODO: ask about these...
   //    const bool IsFixed = false;
-  EnumDecl *enum_decl = EnumDecl::Create(
-      ast, decl_ctx, SourceLocation(), SourceLocation(),
-      name && name[0] ? &ast.Idents.get(name) : nullptr, nullptr,
-      is_scoped, // IsScoped
-      is_scoped, // IsScopedUsingClassTag
-      false);    // TODO: IsFixed
+  EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0);
+  enum_decl->setDeclContext(decl_ctx);
+  if (name && name[0])
+    enum_decl->setDeclName(&ast.Idents.get(name));
+  enum_decl->setScoped(is_scoped);
+  enum_decl->setScopedUsingClassTag(is_scoped);
+  enum_decl->setFixed(false);
   SetOwningModule(enum_decl, owning_module);
   if (enum_decl) {
     if (decl_ctx)
       decl_ctx->addDecl(enum_decl);
 
     // TODO: check if we should be setting the promotion type too?
     enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
 
if (type && typedef_name && typedef_name[0]) {
     clang::ASTContext &clang_ast = ast->getASTContext();
     clang::QualType qual_type(ClangUtil::GetQualType(type));
 
     clang::DeclContext *decl_ctx =
         TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (!decl_ctx)
       decl_ctx = ast->getASTContext().getTranslationUnitDecl();
 
-    clang::TypedefDecl *decl = clang::TypedefDecl::Create(
-        clang_ast, decl_ctx, clang::SourceLocation(),
-        clang::SourceLocation(), &clang_ast.Idents.get(typedef_name),
-        clang_ast.getTrivialTypeSourceInfo(qual_type));
+    clang::TypedefDecl *decl =
+        clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
+    decl->setDeclContext(decl_ctx);
+    decl->setDeclName(&clang_ast.Idents.get(typedef_name));
+    decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
 
     SetOwningModule(decl, TypePayloadClang(payload).GetOwningModuleID());
     decl->setAccess(clang::AS_public); // TODO respect proper access specifier
 
     decl_ctx->addDecl(decl);
 
     // Get a uniqued clang::QualType for the typedef decl type
     return ast->GetType(clang_ast.getTypedefType(decl));
if (type) {
     clang::ASTContext &clang_ast = getASTContext();
     clang::QualType qual_type(GetQualType(type));
 
     clang::DeclContext *decl_ctx =
         TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (!decl_ctx)
       decl_ctx = getASTContext().getTranslationUnitDecl();
 
-    clang::TypedefDecl *decl = clang::TypedefDecl::Create(
-        clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(),
-        &clang_ast.Idents.get(typedef_name),
-        clang_ast.getTrivialTypeSourceInfo(qual_type));
+    clang::TypedefDecl *decl =
+        clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
+    decl->setDeclContext(decl_ctx);
+    decl->setDeclName(&clang_ast.Idents.get(typedef_name));
+    decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
     SetOwningModule(decl, TypePayloadClang(payload).GetOwningModuleID());
 
     clang::TagDecl *tdecl = nullptr;
     if (!qual_type.isNull()) {
       if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
         tdecl = rt->getDecl();
       if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
         tdecl = et->getDecl();
llvm::APInt bitfield_bit_size_apint(clang_ast.getTypeSize(clang_ast.IntTy),
                                         bitfield_bit_size);
     bit_width = new (clang_ast)
         clang::IntegerLiteral(clang_ast, bitfield_bit_size_apint,
                               clang_ast.IntTy, clang::SourceLocation());
   }
 
   clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
   if (record_decl) {
-    field = clang::FieldDecl::Create(
-        clang_ast, record_decl, clang::SourceLocation(),
-        clang::SourceLocation(),
-        ident,                                    // Identifier
-        ClangUtil::GetQualType(field_clang_type), // Field type
-        nullptr,                                  // TInfo *
-        bit_width,                                // BitWidth
-        false,                                    // Mutable
-        clang::ICIS_NoInit);                      // HasInit
+    field = clang::FieldDecl::CreateDeserialized(clang_ast, 0);
+    field->setDeclContext(record_decl);
+    field->setDeclName(ident);
+    field->setType(ClangUtil::GetQualType(field_clang_type));
+    if (bit_width)
+      field->setBitWidth(bit_width);
     SetMemberOwningModule(field, record_decl);
 
     if (name.empty()) {
       // Determine whether this field corresponds to an anonymous struct or
       // union.
       if (const clang::TagType *TagT =
               field->getType()->getAs<clang::TagType>()) {
         if (clang::RecordDecl *Rec =
if (record_decl) {
     clang::ObjCInterfaceDecl *class_interface_decl =
         ast->GetAsObjCInterfaceDecl(type);
 
     if (class_interface_decl) {
       const bool is_synthesized = false;
 
       field_clang_type.GetCompleteType();
 
-      field = clang::ObjCIvarDecl::Create(
-          clang_ast, class_interface_decl, clang::SourceLocation(),
-          clang::SourceLocation(),
-          ident,                                    // Identifier
-          ClangUtil::GetQualType(field_clang_type), // Field type
-          nullptr,                                  // TypeSourceInfo *
-          ConvertAccessTypeToObjCIvarAccessControl(access), bit_width,
-          is_synthesized);
+      auto ivar = clang::ObjCIvarDecl::CreateDeserialized(clang_ast, 0);
+      ivar->setDeclContext(class_interface_decl);
+      ivar->setDeclName(ident);
+      ivar->setType(ClangUtil::GetQualType(field_clang_type));
+      ivar->setAccessControl(ConvertAccessTypeToObjCIvarAccessControl(access));
+      if (bit_width)
+        ivar->setBitWidth(bit_width);
+      ivar->setSynthesize(is_synthesized);
+      field = ivar;
       SetMemberOwningModule(field, class_interface_decl);
 
       if (field) {
         class_interface_decl->addDecl(field);
 
         VerifyDecl(field);
       }
     }
if (field_pos->isAnonymousStructOrUnion()) {
               new (ast->getASTContext()) clang::NamedDecl *[2];
           chain[0] = *field_pos;
           chain[1] = nested_field_decl;
           clang::IndirectFieldDecl *indirect_field =
               clang::IndirectFieldDecl::Create(
                   ast->getASTContext(), record_decl, clang::SourceLocation(),
                   nested_field_decl->getIdentifier(),
                   nested_field_decl->getType(), {chain, 2});
-          SetMemberOwningModule(indirect_field, record_decl);
 
           indirect_field->setImplicit();
 
           indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers(
               field_pos->getAccess(), nested_field_decl->getAccess()));
 
           indirect_fields.push_back(indirect_field);
         } else if (clang::IndirectFieldDecl *nested_indirect_field_decl =
if (field_pos->isAnonymousStructOrUnion()) {
           }
 
           clang::IndirectFieldDecl *indirect_field =
               clang::IndirectFieldDecl::Create(
                   ast->getASTContext(), record_decl, clang::SourceLocation(),
                   nested_indirect_field_decl->getIdentifier(),
                   nested_indirect_field_decl->getType(),
                   {chain, nested_chain_size + 1});
-          SetMemberOwningModule(indirect_field, record_decl);
  
           indirect_field->setImplicit();
 
           indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers(
               field_pos->getAccess(), nested_indirect_field_decl->getAccess()));
 
           indirect_fields.push_back(indirect_field);
         }
clang::VarDecl *TypeSystemClang::AddVariableToRecordType(
   if (!record_decl)
     return nullptr;
 
   clang::VarDecl *var_decl = nullptr;
   clang::IdentifierInfo *ident = nullptr;
   if (!name.empty())
     ident = &ast->getASTContext().Idents.get(name);
 
-  var_decl = clang::VarDecl::Create(
-      ast->getASTContext(),             // ASTContext &
-      record_decl,                      // DeclContext *
-      clang::SourceLocation(),          // clang::SourceLocation StartLoc
-      clang::SourceLocation(),          // clang::SourceLocation IdLoc
-      ident,                            // clang::IdentifierInfo *
-      ClangUtil::GetQualType(var_type), // Variable clang::QualType
-      nullptr,                          // TypeSourceInfo *
-      clang::SC_Static);                // StorageClass
+  var_decl = clang::VarDecl::CreateDeserialized(ast->getASTContext(), 0);
+  var_decl->setDeclContext(record_decl);
+  var_decl->setDeclName(ident);
+  var_decl->setType(ClangUtil::GetQualType(var_type));
+  var_decl->setStorageClass(clang::SC_Static);
   SetMemberOwningModule(var_decl, record_decl);
   if (!var_decl)
     return nullptr;
 
   var_decl->setAccess(
       TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
   record_decl->addDecl(var_decl);
 
clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType(
   unsigned int num_params = method_function_prototype->getNumParams();
 
   clang::CXXDestructorDecl *cxx_dtor_decl(nullptr);
   clang::CXXConstructorDecl *cxx_ctor_decl(nullptr);
 
   if (is_artificial)
     return nullptr; // skip everything artificial
 
-  const clang::ExplicitSpecifier explicit_spec(
-      nullptr /*expr*/, is_explicit
-                            ? clang::ExplicitSpecKind::ResolvedTrue
-                            : clang::ExplicitSpecKind::ResolvedFalse);
   if (name.startswith("~")) {
-    cxx_dtor_decl = clang::CXXDestructorDecl::Create(
-        getASTContext(), cxx_record_decl, clang::SourceLocation(),
-        clang::DeclarationNameInfo(
-            getASTContext().DeclarationNames.getCXXDestructorName(
-                getASTContext().getCanonicalType(record_qual_type)),
-            clang::SourceLocation()),
-        method_qual_type, nullptr, is_inline, is_artificial,
-        ConstexprSpecKind::CSK_unspecified);
+    cxx_dtor_decl =
+        clang::CXXDestructorDecl::CreateDeserialized(getASTContext(), 0);
+    cxx_dtor_decl->setDeclContext(cxx_record_decl);
+    cxx_dtor_decl->setDeclName(
+            getASTContext().getCanonicalType(record_qual_type)));
+    cxx_dtor_decl->setType(method_qual_type);
+    cxx_dtor_decl->setImplicit(is_artificial);
+    cxx_dtor_decl->setInlineSpecified(is_inline);
+    cxx_dtor_decl->setConstexprKind(CSK_unspecified);
     cxx_method_decl = cxx_dtor_decl;
   } else if (decl_name == cxx_record_decl->getDeclName()) {
-    cxx_ctor_decl = clang::CXXConstructorDecl::Create(
-        getASTContext(), cxx_record_decl, clang::SourceLocation(),
-        clang::DeclarationNameInfo(
-            getASTContext().DeclarationNames.getCXXConstructorName(
-                getASTContext().getCanonicalType(record_qual_type)),
-            clang::SourceLocation()),
-        method_qual_type,
-        nullptr, // TypeSourceInfo *
-        explicit_spec, is_inline, is_artificial, CSK_unspecified);
+    cxx_ctor_decl = clang::CXXConstructorDecl::CreateDeserialized(
+        getASTContext(), 0, is_explicit ? 1 << 1 : 0);
+    cxx_ctor_decl->setDeclContext(cxx_record_decl);
+    cxx_ctor_decl->setDeclName(
+            getASTContext().getCanonicalType(record_qual_type)));
+    cxx_ctor_decl->setType(method_qual_type);
+    cxx_ctor_decl->setImplicit(is_artificial);
+    cxx_ctor_decl->setInlineSpecified(is_inline);
+    cxx_ctor_decl->setConstexprKind(CSK_unspecified);
     cxx_method_decl = cxx_ctor_decl;
   } else {
     clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None;
     clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
 
     if (IsOperator(name, op_kind)) {
       if (op_kind != clang::NUM_OVERLOADED_OPERATORS) {
         // Check the number of operator parameters. Sometimes we have seen bad
         // DWARF that doesn't correctly describe operators and if we try to
         // create a method and add it to the class, clang will assert and
         // crash, so we need to make sure things are acceptable.
         const bool is_method = true;
         if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
                 is_method, op_kind, num_params))
           return nullptr;
-        cxx_method_decl = clang::CXXMethodDecl::Create(
-            getASTContext(), cxx_record_decl, clang::SourceLocation(),
-            clang::DeclarationNameInfo(
-                getASTContext().DeclarationNames.getCXXOperatorName(op_kind),
-                clang::SourceLocation()),
-            method_qual_type,
-            nullptr, // TypeSourceInfo *
-            SC, is_inline, CSK_unspecified, clang::SourceLocation());
+        cxx_method_decl =
+            clang::CXXMethodDecl::CreateDeserialized(getASTContext(), 0);
+        cxx_method_decl->setDeclContext(cxx_record_decl);
+        cxx_method_decl->setDeclName(
+            getASTContext().DeclarationNames.getCXXOperatorName(op_kind));
+        cxx_method_decl->setType(method_qual_type);
+        cxx_method_decl->setStorageClass(SC);
+        cxx_method_decl->setInlineSpecified(is_inline);
+        cxx_method_decl->setConstexprKind(CSK_unspecified);
       } else if (num_params == 0) {
+        const clang::ExplicitSpecifier explicit_spec(
+            nullptr /*expr*/, is_explicit
+                                  ? clang::ExplicitSpecKind::ResolvedTrue
+                                  : clang::ExplicitSpecKind::ResolvedFalse);
+
         // Conversion operators don't take params...
-        cxx_method_decl = clang::CXXConversionDecl::Create(
-            getASTContext(), cxx_record_decl, clang::SourceLocation(),
-            clang::DeclarationNameInfo(
-                getASTContext().DeclarationNames.getCXXConversionFunctionName(
-                    getASTContext().getCanonicalType(
-                        function_type->getReturnType())),
-                clang::SourceLocation()),
-            method_qual_type,
-            nullptr, // TypeSourceInfo *
-            is_inline, explicit_spec, CSK_unspecified, clang::SourceLocation());
+        auto *cxx_conversion_decl =
+            clang::CXXConversionDecl::CreateDeserialized(getASTContext(), 0);
+        cxx_conversion_decl->setDeclContext(cxx_record_decl);
+        cxx_conversion_decl->setDeclName(
+                    function_type->getReturnType())));
+        cxx_conversion_decl->setType(method_qual_type);
+        cxx_conversion_decl->setInlineSpecified(is_inline);
+        cxx_conversion_decl->setExplicitSpecifier(explicit_spec);        
+        cxx_conversion_decl->setConstexprKind(CSK_unspecified);
+        cxx_method_decl = cxx_conversion_decl;
       }
     }
 
     if (cxx_method_decl == nullptr) {
-      cxx_method_decl = clang::CXXMethodDecl::Create(
-          getASTContext(), cxx_record_decl, clang::SourceLocation(),
-          clang::DeclarationNameInfo(decl_name, clang::SourceLocation()),
-          method_qual_type,
-          nullptr, // TypeSourceInfo *
-          SC, is_inline, CSK_unspecified, clang::SourceLocation());
+      cxx_method_decl =
+          clang::CXXMethodDecl::CreateDeserialized(getASTContext(), 0);
+      cxx_method_decl->setDeclContext(cxx_record_decl);
+      cxx_method_decl->setDeclName(decl_name);
+      cxx_method_decl->setType(method_qual_type);
+      cxx_method_decl->setInlineSpecified(is_inline);
+      cxx_method_decl->setStorageClass(SC);
+      cxx_method_decl->setConstexprKind(CSK_unspecified);
     }
   }
   SetMemberOwningModule(cxx_method_decl, cxx_record_decl);
 
   clang::AccessSpecifier access_specifier =
       TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access);
 
   cxx_method_decl->setAccess(access_specifier);
bool TypeSystemClang::AddObjCClassProperty(
 
   clang::TypeSourceInfo *prop_type_source;
   if (ivar_decl)
     prop_type_source = clang_ast.getTrivialTypeSourceInfo(ivar_decl->getType());
   else
     prop_type_source = clang_ast.getTrivialTypeSourceInfo(
         ClangUtil::GetQualType(property_clang_type));
 
-  clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create(
-      clang_ast, class_interface_decl,
-      clang::SourceLocation(), // Source Location
-      &clang_ast.Idents.get(property_name),
-      clang::SourceLocation(), // Source Location for AT
-      clang::SourceLocation(), // Source location for (
-      ivar_decl ? ivar_decl->getType()
+  clang::ObjCPropertyDecl *property_decl =
+      clang::ObjCPropertyDecl::CreateDeserialized(clang_ast, 0);
+  property_decl->setDeclContext(class_interface_decl);
+  property_decl->setDeclName(&clang_ast.Idents.get(property_name));
+  property_decl->setType(ivar_decl
+                             ? ivar_decl->getType()
                              : ClangUtil::GetQualType(property_clang_type),
                          prop_type_source);
   SetMemberOwningModule(property_decl, class_interface_decl);
 
   if (!property_decl)
     return false;
 
   if (metadata)
     ast->SetMetadata(property_decl, *metadata);
 
if (!getter_sel.isNull() && !getter) {
     const bool isPropertyAccessor = false;
     const bool isSynthesizedAccessorStub = false;
     const bool isImplicitlyDeclared = true;
     const bool isDefined = false;
     const clang::ObjCMethodDecl::ImplementationControl impControl =
         clang::ObjCMethodDecl::None;
     const bool HasRelatedResultType = false;
 
-    getter = clang::ObjCMethodDecl::Create(
-        clang_ast, clang::SourceLocation(), clang::SourceLocation(), getter_sel,
-        ClangUtil::GetQualType(property_clang_type_to_access), nullptr,
-        class_interface_decl, isInstance, isVariadic, isPropertyAccessor,
-        isSynthesizedAccessorStub, isImplicitlyDeclared, isDefined, impControl,
-        HasRelatedResultType);
+    getter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0);
+    getter->setDeclName(getter_sel);
+    getter->setReturnType(ClangUtil::GetQualType(property_clang_type_to_access));
+    getter->setDeclContext(class_interface_decl);
+    getter->setInstanceMethod(isInstance);
+    getter->setVariadic(isVariadic);
+    getter->setPropertyAccessor(isPropertyAccessor);
+    getter->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
+    getter->setImplicit(isImplicitlyDeclared);
+    getter->setDefined(isDefined);
+    getter->setDeclImplementation(impControl);
+    getter->setRelatedResultType(HasRelatedResultType);
     SetMemberOwningModule(getter, class_interface_decl);
 
     if (getter) {
       if (metadata)
         ast->SetMetadata(getter, *metadata);
 
       getter->setMethodParams(clang_ast, llvm::ArrayRef<clang::ParmVarDecl *>(),
                               llvm::ArrayRef<clang::SourceLocation>());
if (!setter_sel.isNull() && !setter) {
     const bool isPropertyAccessor = true;
     const bool isSynthesizedAccessorStub = false;
     const bool isImplicitlyDeclared = true;
     const bool isDefined = false;
     const clang::ObjCMethodDecl::ImplementationControl impControl =
         clang::ObjCMethodDecl::None;
     const bool HasRelatedResultType = false;
 
-    setter = clang::ObjCMethodDecl::Create(
-        clang_ast, clang::SourceLocation(), clang::SourceLocation(), setter_sel,
-        result_type, nullptr, class_interface_decl, isInstance, isVariadic,
-        isPropertyAccessor, isSynthesizedAccessorStub, isImplicitlyDeclared,
-        isDefined, impControl, HasRelatedResultType);
-        SetMemberOwningModule(setter, class_interface_decl);
+    setter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0);
+    setter->setDeclName(setter_sel);
+    setter->setReturnType(result_type);
+    setter->setDeclContext(class_interface_decl);
+    setter->setInstanceMethod(isInstance);
+    setter->setVariadic(isVariadic);
+    setter->setPropertyAccessor(isPropertyAccessor);
+    setter->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
+    setter->setImplicit(isImplicitlyDeclared);
+    setter->setDefined(isDefined);
+    setter->setDeclImplementation(impControl);
+    setter->setRelatedResultType(HasRelatedResultType);
 
     if (setter) {
       if (metadata)
         ast->SetMetadata(setter, *metadata);
 
       llvm::SmallVector<clang::ParmVarDecl *, 1> params;
       params.push_back(clang::ParmVarDecl::Create(
           clang_ast, setter, clang::SourceLocation(), clang::SourceLocation(),
clang::ObjCMethodDecl *TypeSystemClang::AddMethodToObjCObjectType(
   const bool HasRelatedResultType = false;
 
   const unsigned num_args = method_function_prototype->getNumParams();
 
   if (num_args != num_selectors_with_args)
     return nullptr; // some debug information is corrupt.  We are not going to
                     // deal with it.
 
-  clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create(
-      ast,
-      clang::SourceLocation(), // beginLoc,
-      clang::SourceLocation(), // endLoc,
-      method_selector, method_function_prototype->getReturnType(),
-      nullptr, // TypeSourceInfo *ResultTInfo,
-      lldb_ast->GetDeclContextForType(ClangUtil::GetQualType(type)), isInstance,
-      isVariadic, isPropertyAccessor, isSynthesizedAccessorStub,
-      isImplicitlyDeclared, isDefined, impControl, HasRelatedResultType);
+  auto *objc_method_decl = clang::ObjCMethodDecl::CreateDeserialized(ast, 0);
+  objc_method_decl->setDeclName(method_selector);
+  objc_method_decl->setReturnType(method_function_prototype->getReturnType());
+  objc_method_decl->setDeclContext(
+      lldb_ast->GetDeclContextForType(ClangUtil::GetQualType(type)));
+  objc_method_decl->setInstanceMethod(isInstance);
+  objc_method_decl->setVariadic(isVariadic);
+  objc_method_decl->setPropertyAccessor(isPropertyAccessor);
+  objc_method_decl->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
+  objc_method_decl->setImplicit(isImplicitlyDeclared);
+  objc_method_decl->setDefined(isDefined);
+  objc_method_decl->setDeclImplementation(impControl);
+  objc_method_decl->setRelatedResultType(HasRelatedResultType);
   SetMemberOwningModule(objc_method_decl, class_interface_decl);
 
   if (objc_method_decl == nullptr)
     return nullptr;
 
   if (num_args > 0) {
     llvm::SmallVector<clang::ParmVarDecl *, 12> params;
 
clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
   if (!clang_type)
     return nullptr;
 
   const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
 
   if (!enutype)
     return nullptr;
 
-  clang::EnumConstantDecl *enumerator_decl = clang::EnumConstantDecl::Create(
-      getASTContext(), enutype->getDecl(), clang::SourceLocation(),
-      name ? &getASTContext().Idents.get(name) : nullptr, // Identifier
-      clang::QualType(enutype, 0), nullptr, value);
+  clang::EnumConstantDecl *enumerator_decl =
+      clang::EnumConstantDecl::CreateDeserialized(getASTContext(), 0);
+  enumerator_decl->setDeclContext(enutype->getDecl());
+  if (name)
+    enumerator_decl->setDeclName(&getASTContext().Idents.get(name));
+  enumerator_decl->setType(clang::QualType(enutype, 0));
+  enumerator_decl->setInitVal(value);
   SetMemberOwningModule(enumerator_decl, enutype->getDecl());
 
   if (!enumerator_decl)
     return nullptr;
 
   enutype->getDecl()->addDecl(enumerator_decl);
 
   VerifyDecl(enumerator_decl);