Support scoped enums in the DWARF AST parser

[tberghammer]

Fix test failures

[tberghammer]

This change is needed to make LLDB compatible with D39239

[clayborg]

Looks good.

include/lldb/Symbol/ClangASTContext.h

CompilerType CreateArrayType(const CompilerType &element_type,
                                size_t element_count, bool is_vector);
 
   //------------------------------------------------------------------
   // Enumeration Types
   //------------------------------------------------------------------
   CompilerType CreateEnumerationType(const char *name,
                                      clang::DeclContext *decl_ctx,
                                      const Declaration &decl,
-                                     const CompilerType &integer_qual_type);
+                                     const CompilerType &integer_qual_type,
+                                     bool is_scoped);
 
   //------------------------------------------------------------------
   // Integer type functions
   //------------------------------------------------------------------
 
   static CompilerType GetIntTypeFromBitSize(clang::ASTContext *ast,
                                             size_t bit_size, bool is_signed);
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (type_ptr == NULL) {
           }
         }
       } break;
 
       case DW_TAG_enumeration_type: {
         // Set a bit that lets us know that we are currently parsing this
         dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
+        bool is_scoped = false;
         DWARFFormValue encoding_form;
 
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0) {
           uint32_t i;
 
           for (i = 0; i < num_attributes; ++i) {
             attr = attributes.AttributeAtIndex(i);
if (type_ptr == NULL) {
                 byte_size = form_value.Unsigned();
                 break;
               case DW_AT_accessibility:
                 break; // accessibility =
                        // DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
               case DW_AT_declaration:
                 is_forward_declaration = form_value.Boolean();
                 break;
+              case DW_AT_enum_class:
+                is_scoped = form_value.Boolean();
+                break;
               case DW_AT_allocated:
               case DW_AT_associated:
               case DW_AT_bit_stride:
               case DW_AT_byte_stride:
               case DW_AT_data_location:
               case DW_AT_description:
               case DW_AT_start_scope:
               case DW_AT_visibility:
if (type_ptr == NULL) {
                         NULL, DW_ATE_signed, byte_size * 8);
               } else {
                 enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt);
               }
             }
 
             clang_type = m_ast.CreateEnumerationType(
                 type_name_cstr, GetClangDeclContextContainingDIE(die, nullptr),
-                decl, enumerator_clang_type);
+                decl, enumerator_clang_type, is_scoped);
           } else {
             enumerator_clang_type =
                 m_ast.GetEnumerationIntegerType(clang_type.GetOpaqueQualType());
           }
 
           LinkDeclContextToDIE(
               ClangASTContext::GetDeclContextForType(clang_type), die);
 

source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

if (auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&type)) {
     std::string name = enum_type->getName();
     lldb::Encoding encoding =
         TranslateBuiltinEncoding(enum_type->getBuiltinType());
     uint64_t bytes = enum_type->getLength();
     CompilerType builtin_type =
         m_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, bytes * 8);
 
     CompilerType ast_enum = m_ast.CreateEnumerationType(
-        name.c_str(), tu_decl_ctx, decl, builtin_type);
+        name.c_str(), tu_decl_ctx, decl, builtin_type, false);
     auto enum_values = enum_type->findAllChildren<PDBSymbolData>();
     while (auto enum_value = enum_values->getNext()) {
       if (enum_value->getDataKind() != PDB_DataKind::Constant)
         continue;
       AddEnumValue(ast_enum, *enum_value);
     }
 
     return std::make_shared<lldb_private::Type>(

source/Symbol/ClangASTContext.cpp

CompilerType ClangASTContext::GetOrCreateStructForIdentifier(
   return CreateStructForIdentifier(type_name, type_fields, packed);
 }
 
 #pragma mark Enumeration Types
 
 CompilerType
 ClangASTContext::CreateEnumerationType(const char *name, DeclContext *decl_ctx,
                                        const Declaration &decl,
-                                       const CompilerType &integer_clang_type) {
+                                       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 IsScoped = false;
   //    const bool IsFixed = false;
 
   EnumDecl *enum_decl = EnumDecl::Create(
       *ast, decl_ctx, SourceLocation(), SourceLocation(),
       name && name[0] ? &ast->Idents.get(name) : nullptr, nullptr,
-      false,  // IsScoped
+      is_scoped,
       false,  // IsScopedUsingClassTag
       false); // IsFixed
 
   if (enum_decl) {
     // TODO: check if we should be setting the promotion type too?
     enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
 
     enum_decl->setAccess(AS_public); // TODO respect what's in the debug info