[DebugInfo] Don't emit DW_AT_enum_class unless it's actually an 'enum class'.

[probinson]

Summary

The original fix for PR36168 would emit DW_AT_enum_class for both of these cases:

enum Fixed : short { F1 = 1 };
enum class Class { C1 = 1 };

However, it really should be applied only to the latter case.

I'd just do this, except I'm not sure whether PDB cares about this difference. If it does, let me know and I guess we'll have to invent a new flag so the DWARF and PDB generators can each DTRT.

If not, I'll follow up with NFC name changes so the flag becomes DIFlagEnumClass.

lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
   llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
 
   llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
   unsigned Line = getLineNumber(ED->getLocation());
   llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
   llvm::DIType *ClassTy = getOrCreateType(ED->getIntegerType(), DefUnit);
   return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
                                         Line, Size, Align, EltArray, ClassTy,
-                                        Identifier, ED->isFixed());
+                                        Identifier, ED->isScoped());
 }
 
 llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent,
                                         unsigned MType, SourceLocation LineLoc,
                                         StringRef Name, StringRef Value) {
   unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
   return DBuilder.createMacro(Parent, Line, MType, Name, Value);
 }

test/CodeGenCXX/debug-info-enum-class.cpp

namespace PR14029 {
   };
   Test<int> t;
 }
 
 namespace test2 {
 // FIXME: this should just be a declaration under -fno-standalone-debug
 // CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E"
 // CHECK-SAME:             scope: [[TEST2:![0-9]+]]
+// CHECK-NOT:              DIFlagFixedEnum
 // CHECK-SAME:             elements: [[TEST_ENUMS:![0-9]+]]
 // CHECK-SAME:             identifier: "_ZTSN5test21EE"
 // CHECK: [[TEST2]] = !DINamespace(name: "test2"
 // CHECK: [[TEST_ENUMS]] = !{[[TEST_E:![0-9]*]]}
 // CHECK: [[TEST_E]] = !DIEnumerator(name: "e", value: 0)
 enum E : int;
 void func(E *) {
 }
 enum E : int { e };
 }
 
 namespace test3 {
 // FIXME: this should just be a declaration under -fno-standalone-debug
 // CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E"
 // CHECK-SAME:             scope: [[TEST3:![0-9]+]]
+// CHECK-NOT:              DIFlagFixedEnum
 // CHECK-SAME:             elements: [[TEST_ENUMS]]
 // CHECK-SAME:             identifier: "_ZTSN5test31EE"
 // CHECK: [[TEST3]] = !DINamespace(name: "test3"
 enum E : int { e };
 void func(E *) {
 }
 }
 
 namespace test4 {
 // CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E"
 // CHECK-SAME:             scope: [[TEST4:![0-9]+]]
+// CHECK-NOT:              DIFlagFixedEnum
 // CHECK-SAME:             elements: [[TEST_ENUMS]]
 // CHECK-SAME:             identifier: "_ZTSN5test41EE"
 // CHECK: [[TEST4]] = !DINamespace(name: "test4"
 enum E : int;
 void f1(E *) {
 }
 enum E : int { e };
 void f2(E) {