Fix 31480 - warn more aggressively when assignments get used as a boolean values

[incertia]

Summary

To my understanding, the contents of a condition will always be implicitly casted to an rvalue before evaluation. Thus, moving the check to PerformImplicitConversion should be correct. We can also check the more general case here of general boolean expressions. This should catch a few more cases vs gcc. The only examples that I can come up with that will bypass this check would be

bool & f(bool &b) { return b = true; }
f(b = false); // b = false is an lvalue, the reference passed into the function is an lvalue, and the reference returned out is an lvalue, which causes no warnings.

Clearly passing in the result of an assignment to a function is not very good, so we should probably have a separate check for that. On the other hand, I have no idea if we should even warn on returning the (boolean) result of assigning to a boolean reference or how such a check would be implemented, outside of brute force within ActOnReturnStmt, which would collide with the warnings in PerformImplicitConversion.

[incertia]

Pulled the check outside of the case statement.

[lebedev.ri]

Test?

lib/Sema/SemaExpr.cpp

if (opE->getOpcode() == BO_EQ &&
         << FixItHint::CreateRemoval(ParenERange.getEnd());
       Diag(Loc, diag::note_equality_comparison_to_assign)
         << FixItHint::CreateReplacement(Loc, "=");
     }
 }
 
 ExprResult Sema::CheckBooleanCondition(SourceLocation Loc, Expr *E,
                                        bool IsConstexpr) {
-  DiagnoseAssignmentAsCondition(E);
+  // an assignment always produces an lvalue, and we now check this inside
+  // PerformImplicitConversion, as conditions will always be implicitly
+  // converted to an rvalue
+  // DiagnoseAssignmentAsCondition(E);
   if (ParenExpr *parenE = dyn_cast<ParenExpr>(E))
     DiagnoseEqualityWithExtraParens(parenE);
 
   ExprResult result = CheckPlaceholderExpr(E);
   if (result.isInvalid()) return ExprError();
   E = result.get();
 
   if (!E->isTypeDependent()) {

lib/Sema/SemaExprCXX.cpp

if (Context.hasSameType(FromType, Context.OverloadTy)) {
 
     if (DiagnoseUseOfDecl(Fn, From->getLocStart()))
       return ExprError();
 
     From = FixOverloadedFunctionReference(From, Found, Fn);
     FromType = From->getType();
   }
 
+  // implicit boolean conversions should have their assignments checked
+  if (SCS.Second == ICK_Boolean_Conversion || FromType == Context.BoolTy) {
+    DiagnoseAssignmentAsCondition(From->IgnoreImpCasts());
+  }
+
   // If we're converting to an atomic type, first convert to the corresponding
   // non-atomic type.
   QualType ToAtomicType;
   if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) {
     ToAtomicType = ToType;
     ToType = ToAtomic->getValueType();
   }