[clang-tidy] Don't use assignment for value-initialized enums

[malcolm.parsons]

Summary

The modernize-use-default-member-init check crashes when trying to
create an assignment value for a value-initialized enum because it isn't a
BuiltinType.
An enum cannot be initialized by assigning 0 to it unless a cast is added.
It could be initialized with an enumerator with the value 0, but there might not
be one.
Avoid these issues by ignoring the UseAssignment setting for value-initialized
enums.

Fixes PR35050.

[JonasToth]

How are the semantics for enum class in this case?

clang-tools-extra/test/clang-tidy/modernize-use-default-member-init-assignment.cpp

172 ↗

(On Diff #185649)

What happens for the case enum Enum { Foo = 3 }; /* ... */ : e() /* ... */, is that even well formed?
I feel a testcase along those lines is missing.

[malcolm.parsons]

In D57852#1388526, @JonasToth wrote:

How are the semantics for enum class in this case?

No enumerators are present in the initialisation or the fixit, so there is no difference.

clang-tools-extra/test/clang-tidy/modernize-use-default-member-init-assignment.cpp

172 ↗

(On Diff #185649)

There are no errors or warnings from gcc or clang for that code.
Adding a testcase wouldn't increase coverage.

[JonasToth]

LGTM

clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

void UseDefaultMemberInitCheck::checkDefaultInit(
   SourceLocation FieldEnd =
       Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
                                  *Result.SourceManager, getLangOpts());
   SourceLocation LParenEnd = Lexer::getLocForEndOfToken(
       Init->getLParenLoc(), 0, *Result.SourceManager, getLangOpts());
   CharSourceRange InitRange =
       CharSourceRange::getCharRange(LParenEnd, Init->getRParenLoc());
 
+  bool ValueInit = isa<ImplicitValueInitExpr>(Init->getInit());
+  bool CanAssign = UseAssignment && (!ValueInit || !Init->getInit()->getType()->isEnumeralType());
+
   auto Diag =
       diag(Field->getLocation(), "use default member initializer for %0")
       << Field
-      << FixItHint::CreateInsertion(FieldEnd, UseAssignment ? " = " : "{")
+      << FixItHint::CreateInsertion(FieldEnd, CanAssign ? " = " : "{")
       << FixItHint::CreateInsertionFromRange(FieldEnd, InitRange);
 
-  if (UseAssignment && isa<ImplicitValueInitExpr>(Init->getInit()))
+  if (CanAssign && ValueInit)
     Diag << FixItHint::CreateInsertion(
         FieldEnd, getValueOfValueInit(Init->getInit()->getType()));
 
-  if (!UseAssignment)
+  if (!CanAssign)
     Diag << FixItHint::CreateInsertion(FieldEnd, "}");
 
   Diag << FixItHint::CreateRemoval(Init->getSourceRange());
 }
 
 void UseDefaultMemberInitCheck::checkExistingInit(
     const MatchFinder::MatchResult &Result, const CXXCtorInitializer *Init) {
   const FieldDecl *Field = Init->getAnyMember();

test/clang-tidy/modernize-use-default-member-init-assignment.cpp

 struct PositiveEnum {
   PositiveEnum() : e(Foo) {}
   // CHECK-FIXES: PositiveEnum()  {}
   Enum e;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use default member initializer for 'e'
   // CHECK-FIXES: Enum e = Foo;
 };
 
+struct PositiveValueEnum {
+  PositiveValueEnum() : e() {}
+  // CHECK-FIXES: PositiveValueEnum()  {}
+  Enum e;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use default member initializer for 'e'
+  // CHECK-FIXES: Enum e{};
+};
+
 struct PositiveString {
   PositiveString() : s("foo") {}
   // CHECK-FIXES: PositiveString()  {}
   const char *s;
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use default member initializer for 's'
   // CHECK-FIXES: const char *s = "foo";
 };
 
 template <typename T>
 struct NegativeTemplate {
     NegativeTemplate() : t() {}
     T t;
 };
 
 NegativeTemplate<int> nti;
 NegativeTemplate<double> ntd;

test/clang-tidy/modernize-use-default-member-init.cpp

 struct PositiveEnum {
   PositiveEnum() : e(Foo) {}
   // CHECK-FIXES: PositiveEnum()  {}
   Enum e;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use default member initializer for 'e'
   // CHECK-FIXES: Enum e{Foo};
 };
 
+struct PositiveValueEnum {
+  PositiveValueEnum() : e() {}
+  // CHECK-FIXES: PositiveValueEnum()  {}
+  Enum e;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use default member initializer for 'e'
+  // CHECK-FIXES: Enum e{};
+};
+
 struct PositiveString {
   PositiveString() : s("foo") {}
   // CHECK-FIXES: PositiveString()  {}
   const char *s;
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use default member initializer for 's'
   // CHECK-FIXES: const char *s{"foo"};
 };