[c++20] Add deprecation warnings for the expression forms deprecated by P1120R0.

[rsmith]

Summary

This covers:

• usual arithmetic conversions (comparisons, arithmetic, conditionals) between different enumeration types
• usual arithmetic conversions between enums and floating-point types
• comparisons between two operands of array type

The deprecation warnings are on-by-default (in C++20 compilations); it
seems likely that these forms will become ill-formed in C++23, so
warning on them now by default seems wise.

For the first two bullets, off-by-default warnings were also added for
all the cases where we didn't already have warnings (covering language
modes prior to C++20). These warnings are in subgroups of the existing
-Wenum-conversion (except that the first case is not warned on if either
enumeration type is anonymous, consistent with our existing
-Wenum-conversion warnings).

[rnk]

I have no blocking concerns, just some idle thoughts. Up to you if you want Aaron's feedback before landing.

clang/include/clang/Basic/DiagnosticSemaKinds.td

6235

I'm surprised we don't have a TableGen facility to say Warning<warn_foo.Text + " is deprecated">, but I don't see an alternative.

clang/lib/AST/Type.cpp

1865–1866

Is this C++11 comment still relevant? I assume that isComplete handles this case by returning true, and a forward decl can tell us if the enum is scoped.

clang/test/SemaCXX/warn-enum-compare.cpp

79

It seems more technically correct to say that two values are being compared, but I don't see how to keep the diagnostic as well factored as you have it.

[rsmith]

Committed as rG4b0029995853fe37d1dc95ef96f46697c743fcad.

clang/lib/AST/Type.cpp

1865–1866

I don't think this is useful -- and probably nor is the isComplete check. I'll look into this in a follow-up commit.

clang/test/SemaCXX/warn-enum-compare.cpp

79

Yeah, I agonized over this a little, but while I agree with you, in the end I think it's not entirely wrong to talk about (eg) a comparing an int with a float, and the ambiguity between types and values there doesn't seem likely to actually be confusing -- I don't think the extra words help comprehension of the diagnostic. I'm happy to change it back, of course.

[rsmith]

clang/lib/AST/Type.cpp

1865–1866

Fixed in rGeea8ba097c4a86632b88291bea51eb710f8ae4fb. Turns out this was hiding a bug in how we checked static_cast<Enum>(...) for incomplete enum types.

clang/include/clang/AST/Type.h

public:
   bool isAnyCharacterType() const;
   bool isIntegralType(const ASTContext &Ctx) const;
 
   /// Determine whether this type is an integral or enumeration type.
   bool isIntegralOrEnumerationType() const;
 
   /// Determine whether this type is an integral or unscoped enumeration type.
   bool isIntegralOrUnscopedEnumerationType() const;
+  bool isUnscopedEnumerationType() const;
 
   /// Floating point categories.
   bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
   /// isComplexType() does *not* include complex integers (a GCC extension).
   /// isComplexIntegerType() can be used to test for complex integers.
   bool isComplexType() const;      // C99 6.2.5p11 (complex)
   bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
   bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)

clang/include/clang/Basic/DiagnosticGroups.td

 def LiteralConversion : DiagGroup<"literal-conversion">;
 def StringConversion : DiagGroup<"string-conversion">;
 def SignConversion : DiagGroup<"sign-conversion">;
 def PointerBoolConversion : DiagGroup<"pointer-bool-conversion">;
 def UndefinedBoolConversion : DiagGroup<"undefined-bool-conversion">;
 def BoolConversion : DiagGroup<"bool-conversion", [PointerBoolConversion,
                                                    UndefinedBoolConversion]>;
 def IntConversion : DiagGroup<"int-conversion">;
-def EnumConversion : DiagGroup<"enum-conversion">;
+def DeprecatedEnumCompareConditional :
+  DiagGroup<"deprecated-enum-compare-conditional">;
+def EnumCompareConditional : DiagGroup<"enum-compare-conditional",
+                                       [DeprecatedEnumCompareConditional]>;
+def EnumCompareSwitch : DiagGroup<"enum-compare-switch">;
+def DeprecatedEnumCompare : DiagGroup<"deprecated-enum-compare">;
+def EnumCompare : DiagGroup<"enum-compare", [EnumCompareSwitch,
+                                             DeprecatedEnumCompare]>;
+def DeprecatedAnonEnumEnumConversion : DiagGroup<"deprecated-anon-enum-enum-conversion">;
+def DeprecatedEnumEnumConversion : DiagGroup<"deprecated-enum-enum-conversion">;
+def DeprecatedEnumFloatConversion : DiagGroup<"deprecated-enum-float-conversion">;
+def AnonEnumEnumConversion : DiagGroup<"anon-enum-enum-conversion",
+                                   [DeprecatedAnonEnumEnumConversion]>;
+def EnumEnumConversion : DiagGroup<"enum-enum-conversion",
+                                   [DeprecatedEnumEnumConversion]>;
+def EnumFloatConversion : DiagGroup<"enum-float-conversion",
+                                    [DeprecatedEnumFloatConversion]>;
+def EnumConversion : DiagGroup<"enum-conversion",
+                               [EnumEnumConversion,
+                                EnumFloatConversion,
+                                EnumCompareConditional]>;
 def ObjCSignedCharBoolImplicitIntConversion :
   DiagGroup<"objc-signed-char-bool-implicit-int-conversion">;
 def ImplicitIntConversion : DiagGroup<"implicit-int-conversion",
                                      [ObjCSignedCharBoolImplicitIntConversion]>;
 def ImplicitIntFloatConversion : DiagGroup<"implicit-int-float-conversion">;
 def ObjCSignedCharBoolImplicitFloatConversion :
   DiagGroup<"objc-signed-char-bool-implicit-float-conversion">;
 def ImplicitFloatConversion : DiagGroup<"implicit-float-conversion",
def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor",
                                      [DeleteNonAbstractNonVirtualDtor,
                                       DeleteAbstractNonVirtualDtor]>;
 def AbstractFinalClass : DiagGroup<"abstract-final-class">;
 def FinalDtorNonFinalClass : DiagGroup<"final-dtor-non-final-class">;
 
 def CXX11CompatDeprecatedWritableStr :
   DiagGroup<"c++11-compat-deprecated-writable-strings">;
 
+def DeprecatedArrayCompare : DiagGroup<"deprecated-array-compare">;
 def DeprecatedAttributes : DiagGroup<"deprecated-attributes">;
 def DeprecatedCommaSubscript : DiagGroup<"deprecated-comma-subscript">;
 def DeprecatedCopy : DiagGroup<"deprecated-copy">;
 def DeprecatedCopyDtor : DiagGroup<"deprecated-copy-dtor">;
 def DeprecatedDeclarations : DiagGroup<"deprecated-declarations">;
 def UnavailableDeclarations : DiagGroup<"unavailable-declarations">;
 def UnguardedAvailabilityNew : DiagGroup<"unguarded-availability-new">;
 def UnguardedAvailability : DiagGroup<"unguarded-availability",
                                       [UnguardedAvailabilityNew]>;
 // partial-availability is an alias of unguarded-availability.
 def : DiagGroup<"partial-availability", [UnguardedAvailability]>;
 def DeprecatedDynamicExceptionSpec
     : DiagGroup<"deprecated-dynamic-exception-spec">;
 def DeprecatedImplementations :DiagGroup<"deprecated-implementations">;
 def DeprecatedIncrementBool : DiagGroup<"deprecated-increment-bool">;
 def DeprecatedRegister : DiagGroup<"deprecated-register">;
 def DeprecatedThisCapture : DiagGroup<"deprecated-this-capture">;
 def DeprecatedVolatile : DiagGroup<"deprecated-volatile">;
 def DeprecatedWritableStr : DiagGroup<"deprecated-writable-strings",
                                       [CXX11CompatDeprecatedWritableStr]>;
 // FIXME: Why is DeprecatedImplementations not in this group?
-def Deprecated : DiagGroup<"deprecated", [DeprecatedAttributes,
+def Deprecated : DiagGroup<"deprecated", [DeprecatedAnonEnumEnumConversion,
+                                          DeprecatedArrayCompare,
+                                          DeprecatedAttributes,
                                           DeprecatedCommaSubscript,
                                           DeprecatedCopy,
                                           DeprecatedCopyDtor,
                                           DeprecatedDeclarations,
                                           DeprecatedDynamicExceptionSpec,
+                                          DeprecatedEnumCompare,
+                                          DeprecatedEnumCompareConditional,
+                                          DeprecatedEnumEnumConversion,
+                                          DeprecatedEnumFloatConversion,
                                           DeprecatedIncrementBool,
                                           DeprecatedRegister,
                                           DeprecatedThisCapture,
                                           DeprecatedVolatile,
                                           DeprecatedWritableStr]>,
                  DiagCategory<"Deprecations">;
 
 def CXX2aDesignator : DiagGroup<"c++2a-designator">;

 def : DiagGroup<"strict-prototypes">;
 def StrictSelector : DiagGroup<"strict-selector-match">;
 def MethodDuplicate : DiagGroup<"duplicate-method-match">;
 def ObjCCStringFormat : DiagGroup<"cstring-format-directive">;
 def CoveredSwitchDefault : DiagGroup<"covered-switch-default">;
 def SwitchBool     : DiagGroup<"switch-bool">;
 def SwitchEnum     : DiagGroup<"switch-enum">;
 def Switch         : DiagGroup<"switch">;
-def EnumCompareConditional : DiagGroup<"enum-compare-conditional">;
-def EnumCompareSwitch : DiagGroup<"enum-compare-switch">;
-def EnumCompare       : DiagGroup<"enum-compare", [EnumCompareSwitch]>;
 def ImplicitFallthroughPerFunction :
   DiagGroup<"implicit-fallthrough-per-function">;
 def ImplicitFallthrough  : DiagGroup<"implicit-fallthrough",
                                      [ImplicitFallthroughPerFunction]>;
 def InvalidPPToken : DiagGroup<"invalid-pp-token">;
 def Trigraphs      : DiagGroup<"trigraphs">;
 
 def : DiagGroup<"type-limits">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_comparison_of_distinct_pointers : Error<
   "comparison of distinct pointer types%diff{ ($ and $)|}0,1">;
 def err_typecheck_op_on_nonoverlapping_address_space_pointers : Error<
   "%select{comparison between %diff{ ($ and $)|}0,1"
   "|arithmetic operation with operands of type %diff{ ($ and $)|}0,1"
   "|conditional operator with the second and third operands of type "
   "%diff{ ($ and $)|}0,1}2"
   " which are pointers to non-overlapping address spaces">;
 
+def select_arith_conv_kind : TextSubstitution<
+  "%select{arithmetic between|bitwise operation between|comparison of|"
+  "conditional expression between|compound assignment of}0">;
+def warn_arith_conv_enum_float : Warning<
+  "%sub{select_arith_conv_kind}0 "
+  "%select{floating-point|enumeration}1 type %2 "
+  "%plural{2:with|4:from|:and}0 "
+  "%select{enumeration|floating-point}1 type %3">,
+  InGroup<EnumFloatConversion>, DefaultIgnore;
+def warn_arith_conv_enum_float_cxx2a : Warning<
+  "%sub{select_arith_conv_kind}0 "
+  "%select{floating-point|enumeration}1 type %2 "
+  "%plural{2:with|4:from|:and}0 "
+  "%select{enumeration|floating-point}1 type %3 is deprecated">,
+  InGroup<DeprecatedEnumFloatConversion>;
+def warn_arith_conv_mixed_enum_types : Warning<
+  "%sub{select_arith_conv_kind}0 "
+  "different enumeration types%diff{ ($ and $)|}1,2">,
+  InGroup<EnumEnumConversion>, DefaultIgnore;
+def warn_arith_conv_mixed_enum_types_cxx2a : Warning<
+  "%sub{select_arith_conv_kind}0 "
+  "different enumeration types%diff{ ($ and $)|}1,2 is deprecated">,
+  InGroup<DeprecatedEnumEnumConversion>;
+def warn_arith_conv_mixed_anon_enum_types : Warning<
+  warn_arith_conv_mixed_enum_types.Text>,
+  InGroup<AnonEnumEnumConversion>, DefaultIgnore;
+def warn_arith_conv_mixed_anon_enum_types_cxx2a : Warning<
+  warn_arith_conv_mixed_enum_types_cxx2a.Text>,
+  InGroup<DeprecatedAnonEnumEnumConversion>;
+def warn_conditional_mixed_enum_types : Warning<
+  warn_arith_conv_mixed_enum_types.Text>,
+  InGroup<EnumCompareConditional>, DefaultIgnore;
+def warn_conditional_mixed_enum_types_cxx2a : Warning<
+  warn_arith_conv_mixed_enum_types_cxx2a.Text>,
+  InGroup<DeprecatedEnumCompareConditional>;
+def warn_comparison_mixed_enum_types : Warning<
+  warn_arith_conv_mixed_enum_types.Text>,
+  InGroup<EnumCompare>;
+def warn_comparison_mixed_enum_types_cxx2a : Warning<
+  warn_arith_conv_mixed_enum_types_cxx2a.Text>,
+  InGroup<DeprecatedEnumCompare>;
+def warn_comparison_of_mixed_enum_types_switch : Warning<
+  "comparison of different enumeration types in switch statement"
+  "%diff{ ($ and $)|}0,1">,
+  InGroup<EnumCompareSwitch>;
+
 def err_typecheck_assign_const : Error<
   "%select{"
   "cannot assign to return value because function %1 returns a const value|"
   "cannot assign to variable %1 with const-qualified type %2|"
   "cannot assign to %select{non-|}1static data member %2 "
   "with const-qualified type %3|"
   "cannot assign to non-static data member within const member function %1|"
   "cannot assign to %select{variable %2|non-static data member %2|lvalue}1 "

 def warn_integer_constants_in_conditional_always_true : Warning<
   "converting the result of '?:' with integer constants to a boolean always "
   "evaluates to 'true'">,
   InGroup<TautologicalConstantCompare>;
 def warn_left_shift_always : Warning<
   "converting the result of '<<' to a boolean always evaluates "
   "to %select{false|true}0">,
   InGroup<TautologicalConstantCompare>;
-def warn_comparison_of_mixed_enum_types : Warning<
-  "comparison of two values with different enumeration types"
-  "%diff{ ($ and $)|}0,1">,
-  InGroup<EnumCompare>;
-def warn_conditional_mixed_enum_types : Warning<
-  "enumeration type mismatch in conditional expression"
-  "%diff{ ($ and $)|}0,1">,
-  InGroup<EnumCompareConditional>, DefaultIgnore;
-def warn_comparison_of_mixed_enum_types_switch : Warning<
-  "comparison of two values with different enumeration types in switch statement"
-  "%diff{ ($ and $)|}0,1">,
-  InGroup<EnumCompareSwitch>;
 def warn_null_in_arithmetic_operation : Warning<
   "use of NULL in arithmetic operation">,
   InGroup<NullArithmetic>;
 def warn_null_in_comparison_operation : Warning<
   "comparison between NULL and non-pointer "
   "%select{(%1 and NULL)|(NULL and %1)}0">,
   InGroup<NullArithmetic>;
 def err_shift_rhs_only_vector : Error<
def warn_comparison_bitwise_always : Warning<
   "bitwise comparison always evaluates to %select{false|true}0">,
   InGroup<TautologicalBitwiseCompare>, DefaultIgnore;
 def warn_comparison_bitwise_or : Warning<
   "bitwise or with non-zero value always evaluates to true">,
   InGroup<TautologicalBitwiseCompare>, DefaultIgnore;
 def warn_tautological_overlap_comparison : Warning<
   "overlapping comparisons always evaluate to %select{false|true}0">,
   InGroup<TautologicalOverlapCompare>, DefaultIgnore;
+def warn_depr_array_comparison : Warning<
+  "comparison between two arrays is deprecated; "
+  "to compare array addresses, use unary '+' to decay operands to pointers">,
+  InGroup<DeprecatedArrayCompare>;
 
 def warn_stringcompare : Warning<
   "result of comparison against %select{a string literal|@encode}0 is "
   "unspecified (use an explicit string comparison function instead)">,
   InGroup<StringCompare>;
 
 def warn_identity_field_assign : Warning<
   "assigning %select{field|instance variable}0 to itself">,

clang/include/clang/Sema/Sema.h

bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
                               bool AllowExplicit = false,
                               bool IsListInitialization = false);
 
   // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
   // will create a runtime trap if the resulting type is not a POD type.
   ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
                                               FunctionDecl *FDecl);
 
+  /// Context in which we're performing a usual arithmetic conversion.
+  enum ArithConvKind {
+    /// An arithmetic operation.
+    ACK_Arithmetic,
+    /// A bitwise operation.
+    ACK_BitwiseOp,
+    /// A comparison.
+    ACK_Comparison,
+    /// A conditional (?:) operator.
+    ACK_Conditional,
+    /// A compound assignment expression.
+    ACK_CompAssign,
+  };
+
   // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
   // operands and then handles various conversions that are common to binary
   // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
   // routine returns the first non-arithmetic type found. The client is
   // responsible for emitting appropriate error diagnostics.
   QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
-                                      bool IsCompAssign = false);
+                                      SourceLocation Loc, ArithConvKind ACK);
 
   /// AssignConvertType - All of the 'assignment' semantic checks return this
   /// enum to indicate whether the assignment was allowed.  These checks are
   /// done for simple assignments, as well as initialization, return from
   /// function, argument passing, etc.  The query is phrased in terms of a
   /// source and destination type.
   enum AssignConvertType {
     /// Compatible - the types are compatible according to the standard.

clang/lib/AST/Type.cpp

bool Type::isIntegralType(const ASTContext &Ctx) const {
 
   return false;
 }
 
 bool Type::isIntegralOrUnscopedEnumerationType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::Int128;
+  return isUnscopedEnumerationType();
+}
 
+bool Type::isUnscopedEnumerationType() const {
   // Check for a complete enum type; incomplete enum types are not properly an
   // enumeration type in the sense required here.
   // C++0x: However, if the underlying type of the enum is fixed, it is
   // considered complete.
   if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
     return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
 
   return false;
 }
 
 bool Type::isCharType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))

clang/lib/Sema/SemaChecking.cpp

return Diag(TheCall->getArg(2)->getBeginLoc(),
            << SourceRange(TheCall->getArg(2)->getBeginLoc(),
                           (*(TheCall->arg_end() - 1))->getEndLoc());
 
   ExprResult OrigArg0 = TheCall->getArg(0);
   ExprResult OrigArg1 = TheCall->getArg(1);
 
   // Do standard promotions between the two arguments, returning their common
   // type.
-  QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false);
+  QualType Res = UsualArithmeticConversions(
+      OrigArg0, OrigArg1, TheCall->getExprLoc(), ACK_Comparison);
   if (OrigArg0.isInvalid() || OrigArg1.isInvalid())
     return true;
 
   // Make sure any conversions are pushed back into the call; this is
   // type safe since unordered compare builtins are declared as "_Bool
   // foo(...)".
   TheCall->setArg(0, OrigArg0.get());
   TheCall->setArg(1, OrigArg1.get());
if (auto *UO = dyn_cast<UnaryOperator>(E)) {
       if (UO->getOpcode() == UO_Minus)
         return dyn_cast<IntegerLiteral>(UO->getSubExpr());
     }
   }
 
   return IL;
 }
 
-static void CheckConditionalWithEnumTypes(Sema &S, SourceLocation Loc,
-                                          Expr *LHS, Expr *RHS) {
-  QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType();
-  QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType();
-
-  const auto *LHSEnumType = LHSStrippedType->getAs<EnumType>();
-  if (!LHSEnumType)
-    return;
-  const auto *RHSEnumType = RHSStrippedType->getAs<EnumType>();
-  if (!RHSEnumType)
-    return;
-
-  // Ignore anonymous enums.
-  if (!LHSEnumType->getDecl()->hasNameForLinkage())
-    return;
-  if (!RHSEnumType->getDecl()->hasNameForLinkage())
-    return;
-
-  if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType))
-    return;
-
-  S.Diag(Loc, diag::warn_conditional_mixed_enum_types)
-      << LHSStrippedType << RHSStrippedType << LHS->getSourceRange()
-      << RHS->getSourceRange();
-}
-
 static void DiagnoseIntInBoolContext(Sema &S, Expr *E) {
   E = E->IgnoreParenImpCasts();
   SourceLocation ExprLoc = E->getExprLoc();
 
   if (const auto *BO = dyn_cast<BinaryOperator>(E)) {
     BinaryOperator::Opcode Opc = BO->getOpcode();
     Expr::EvalResult Result;
     // Do not diagnose unsigned shifts.

 
 static void CheckConditionalOperator(Sema &S, ConditionalOperator *E,
                                      SourceLocation CC, QualType T) {
   AnalyzeImplicitConversions(S, E->getCond(), E->getQuestionLoc());
 
   bool Suspicious = false;
   CheckConditionalOperand(S, E->getTrueExpr(), T, CC, Suspicious);
   CheckConditionalOperand(S, E->getFalseExpr(), T, CC, Suspicious);
-  CheckConditionalWithEnumTypes(S, E->getBeginLoc(), E->getTrueExpr(),
-                                E->getFalseExpr());
 
   if (T->isBooleanType())
     DiagnoseIntInBoolContext(S, E);
 
   // If -Wconversion would have warned about either of the candidates
   // for a signedness conversion to the context type...
   if (!Suspicious) return;
 

clang/lib/Sema/SemaExpr.cpp

static QualType handleFixedPointConversion(Sema &S, QualType LHSTy,
   QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
 
   if (LHSTy->isSaturatedFixedPointType() || RHSTy->isSaturatedFixedPointType())
     ResultTy = S.Context.getCorrespondingSaturatedType(ResultTy);
 
   return ResultTy;
 }
 
+/// Check that the usual arithmetic conversions can be performed on this pair of
+/// expressions that might be of enumeration type.
+static void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS,
+                                           SourceLocation Loc,
+                                           Sema::ArithConvKind ACK) {
+  // C++2a [expr.arith.conv]p1:
+  //   If one operand is of enumeration type and the other operand is of a
+  //   different enumeration type or a floating-point type, this behavior is
+  //   deprecated ([depr.arith.conv.enum]).
+  //
+  // Warn on this in all language modes. Produce a deprecation warning in C++20.
+  // Eventually we will presumably reject these cases (in C++23 onwards?).
+  QualType L = LHS->getType(), R = RHS->getType();
+  bool LEnum = L->isUnscopedEnumerationType(),
+       REnum = R->isUnscopedEnumerationType();
+  bool IsCompAssign = ACK == Sema::ACK_CompAssign;
+  if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
+      (REnum && L->isFloatingType())) {
+    S.Diag(Loc, S.getLangOpts().CPlusPlus2a
+                    ? diag::warn_arith_conv_enum_float_cxx2a
+                    : diag::warn_arith_conv_enum_float)
+        << LHS->getSourceRange() << RHS->getSourceRange()
+        << (int)ACK << LEnum << L << R;
+  } else if (!IsCompAssign && LEnum && REnum &&
+             !S.Context.hasSameUnqualifiedType(L, R)) {
+    unsigned DiagID;
+    if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() ||
+        !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {
+      // If either enumeration type is unnamed, it's less likely that the
+      // user cares about this, but this situation is still deprecated in
+      // C++2a. Use a different warning group.
+      DiagID = S.getLangOpts().CPlusPlus2a
+                    ? diag::warn_arith_conv_mixed_anon_enum_types_cxx2a
+                    : diag::warn_arith_conv_mixed_anon_enum_types;
+    } else if (ACK == Sema::ACK_Conditional) {
+      // Conditional expressions are separated out because they have
+      // historically had a different warning flag.
+      DiagID = S.getLangOpts().CPlusPlus2a
+                   ? diag::warn_conditional_mixed_enum_types_cxx2a
+                   : diag::warn_conditional_mixed_enum_types;
+    } else if (ACK == Sema::ACK_Comparison) {
+      // Comparison expressions are separated out because they have
+      // historically had a different warning flag.
+      DiagID = S.getLangOpts().CPlusPlus2a
+                   ? diag::warn_comparison_mixed_enum_types_cxx2a
+                   : diag::warn_comparison_mixed_enum_types;
+    } else {
+      DiagID = S.getLangOpts().CPlusPlus2a
+                   ? diag::warn_arith_conv_mixed_enum_types_cxx2a
+                   : diag::warn_arith_conv_mixed_enum_types;
+    }
+    S.Diag(Loc, DiagID) << LHS->getSourceRange() << RHS->getSourceRange()
+                        << (int)ACK << L << R;
+  }
+}
+
 /// UsualArithmeticConversions - Performs various conversions that are common to
 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
 /// routine returns the first non-arithmetic type found. The client is
 /// responsible for emitting appropriate error diagnostics.
 QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
-                                          bool IsCompAssign) {
-  if (!IsCompAssign) {
+                                          SourceLocation Loc,
+                                          ArithConvKind ACK) {
+  checkEnumArithmeticConversions(*this, LHS.get(), RHS.get(), Loc, ACK);
+
+  if (ACK != ACK_CompAssign) {
     LHS = UsualUnaryConversions(LHS.get());
     if (LHS.isInvalid())
       return QualType();
   }
 
   RHS = UsualUnaryConversions(RHS.get());
   if (RHS.isInvalid())
     return QualType();
QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
 
   // Apply unary and bitfield promotions to the LHS's type.
   QualType LHSUnpromotedType = LHSType;
   if (LHSType->isPromotableIntegerType())
     LHSType = Context.getPromotedIntegerType(LHSType);
   QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get());
   if (!LHSBitfieldPromoteTy.isNull())
     LHSType = LHSBitfieldPromoteTy;
-  if (LHSType != LHSUnpromotedType && !IsCompAssign)
+  if (LHSType != LHSUnpromotedType && ACK != ACK_CompAssign)
     LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);
 
   // If both types are identical, no conversion is needed.
   if (LHSType == RHSType)
     return LHSType;
 
   // At this point, we have two different arithmetic types.
 
   // Diagnose attempts to convert between __float128 and long double where
   // such conversions currently can't be handled.
   if (unsupportedTypeConversion(*this, LHSType, RHSType))
     return QualType();
 
   // Handle complex types first (C99 6.3.1.8p1).
   if (LHSType->isComplexType() || RHSType->isComplexType())
     return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
-                                        IsCompAssign);
+                                        ACK == ACK_CompAssign);
 
   // Now handle "real" floating types (i.e. float, double, long double).
   if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
     return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
-                                 IsCompAssign);
+                                 ACK == ACK_CompAssign);
 
   // Handle GCC complex int extension.
   if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
     return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
-                                      IsCompAssign);
+                                      ACK == ACK_CompAssign);
 
   if (LHSType->isFixedPointType() || RHSType->isFixedPointType())
     return handleFixedPointConversion(*this, LHSType, RHSType);
 
   // Finally, we have two differing integer types.
   return handleIntegerConversion<doIntegralCast, doIntegralCast>
-           (*this, LHS, RHS, LHSType, RHSType, IsCompAssign);
+           (*this, LHS, RHS, LHSType, RHSType, ACK == ACK_CompAssign);
 }
 
 //===----------------------------------------------------------------------===//
 //  Semantic Analysis for various Expression Types
 //===----------------------------------------------------------------------===//
 
 
 ExprResult
QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
 
   // Now check the two expressions.
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType())
     return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
                                /*AllowBothBool*/true,
                                /*AllowBoolConversions*/false);
 
-  QualType ResTy = UsualArithmeticConversions(LHS, RHS);
+  QualType ResTy =
+      UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   QualType LHSTy = LHS.get()->getType();
   QualType RHSTy = RHS.get()->getType();
 
   // Diagnose attempts to convert between __float128 and long double where
   // such conversions currently can't be handled.
QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
   checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
 
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType())
     return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                /*AllowBothBool*/getLangOpts().AltiVec,
                                /*AllowBoolConversions*/false);
 
-  QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
+  QualType compType = UsualArithmeticConversions(
+      LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
 
   if (compType.isNull() || !compType->isArithmeticType())
     return InvalidOperands(Loc, LHS, RHS);
   if (IsDiv) {
     DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, IsDiv);
if (LHS.get()->getType()->isVectorType() ||
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                  /*AllowBothBool*/getLangOpts().AltiVec,
                                  /*AllowBoolConversions*/false);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
-  QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
+  QualType compType = UsualArithmeticConversions(
+      LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   if (compType.isNull() || !compType->isIntegerType())
     return InvalidOperands(Loc, LHS, RHS);
   DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, false /* IsDiv */);
   return compType;
 }
if (LHS.get()->getType()->isVectorType() ||
     QualType compType = CheckVectorOperands(
         LHS, RHS, Loc, CompLHSTy,
         /*AllowBothBool*/getLangOpts().AltiVec,
         /*AllowBoolConversions*/getLangOpts().ZVector);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
-  QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
+  QualType compType = UsualArithmeticConversions(
+      LHS, RHS, Loc, CompLHSTy ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   // Diagnose "string literal" '+' int and string '+' "char literal".
   if (Opc == BO_Add) {
     diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get());
     diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get());
   }
if (LHS.get()->getType()->isVectorType() ||
     QualType compType = CheckVectorOperands(
         LHS, RHS, Loc, CompLHSTy,
         /*AllowBothBool*/getLangOpts().AltiVec,
         /*AllowBoolConversions*/getLangOpts().ZVector);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
-  QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
+  QualType compType = UsualArithmeticConversions(
+      LHS, RHS, Loc, CompLHSTy ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   // Enforce type constraints: C99 6.5.6p3.
 
   // Handle the common case first (both operands are arithmetic).
   if (!compType.isNull() && compType->isArithmeticType()) {
     if (CompLHSTy) *CompLHSTy = compType;
QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS,
   }
   // Sanity-check shift operands
   DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType);
 
   // "The type of the result is that of the promoted left operand."
   return LHSType;
 }
 
-/// If two different enums are compared, raise a warning.
-static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS,
-                                Expr *RHS) {
-  QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType();
-  QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType();
-
-  const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>();
-  if (!LHSEnumType)
-    return;
-  const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>();
-  if (!RHSEnumType)
-    return;
-
-  // Ignore anonymous enums.
-  if (!LHSEnumType->getDecl()->getIdentifier() &&
-      !LHSEnumType->getDecl()->getTypedefNameForAnonDecl())
-    return;
-  if (!RHSEnumType->getDecl()->getIdentifier() &&
-      !RHSEnumType->getDecl()->getTypedefNameForAnonDecl())
-    return;
-
-  if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType))
-    return;
-
-  S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types)
-      << LHSStrippedType << RHSStrippedType
-      << LHS->getSourceRange() << RHS->getSourceRange();
-}
-
 /// Diagnose bad pointer comparisons.
 static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc,
                                               ExprResult &LHS, ExprResult &RHS,
                                               bool IsError) {
   S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
                       : diag::ext_typecheck_comparison_of_distinct_pointers)
     << LHS.get()->getType() << RHS.get()->getType()
     << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
   // Used for indexing into %select in warn_comparison_always
   enum {
     AlwaysConstant,
     AlwaysTrue,
     AlwaysFalse,
     AlwaysEqual, // std::strong_ordering::equal from operator<=>
   };
 
+  // C++2a [depr.array.comp]:
+  //   Equality and relational comparisons ([expr.eq], [expr.rel]) between two
+  //   operands of array type are deprecated.
+  if (S.getLangOpts().CPlusPlus2a && LHSStripped->getType()->isArrayType() &&
+      RHSStripped->getType()->isArrayType()) {
+    S.Diag(Loc, diag::warn_depr_array_comparison)
+        << LHS->getSourceRange() << RHS->getSourceRange()
+        << LHSStripped->getType() << RHSStripped->getType();
+    // Carry on to produce the tautological comparison warning, if this
+    // expression is potentially-evaluated, we can resolve the array to a
+    // non-weak declaration, and so on.
+  }
+
   if (!LHS->getBeginLoc().isMacroID() && !RHS->getBeginLoc().isMacroID()) {
     if (Expr::isSameComparisonOperand(LHS, RHS)) {
       unsigned Result;
       switch (Opc) {
       case BO_EQ:
       case BO_LE:
       case BO_GE:
         Result = AlwaysTrue;
static QualType checkArithmeticOrEnumeralThreeWayCompare(Sema &S,
 
   // C++2a [expr.spaceship]p3: If one of the operands is of type bool and the
   // other is not, the program is ill-formed.
   if (LHSStrippedType->isBooleanType() != RHSStrippedType->isBooleanType()) {
     S.InvalidOperands(Loc, LHSStripped, RHSStripped);
     return QualType();
   }
 
+  // FIXME: Consider combining this with checkEnumArithmeticConversions.
   int NumEnumArgs = (int)LHSStrippedType->isEnumeralType() +
                     RHSStrippedType->isEnumeralType();
   if (NumEnumArgs == 1) {
     bool LHSIsEnum = LHSStrippedType->isEnumeralType();
     QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
     if (OtherTy->hasFloatingRepresentation()) {
       S.InvalidOperands(Loc, LHSStripped, RHSStripped);
       return QualType();
if (NumEnumArgs == 2) {
 
     LHS = S.ImpCastExprToType(LHS.get(), IntType, CK_IntegralCast);
     RHS = S.ImpCastExprToType(RHS.get(), IntType, CK_IntegralCast);
     LHSType = RHSType = IntType;
   }
 
   // C++2a [expr.spaceship]p4: If both operands have arithmetic types, the
   // usual arithmetic conversions are applied to the operands.
-  QualType Type = S.UsualArithmeticConversions(LHS, RHS);
+  QualType Type =
+      S.UsualArithmeticConversions(LHS, RHS, Loc, Sema::ACK_Comparison);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
   if (Type.isNull())
     return S.InvalidOperands(Loc, LHS, RHS);
   assert(Type->isArithmeticType() || Type->isEnumeralType());
 
   // FIXME: Reject complex types, consistent with P1959R0.
 

 static QualType checkArithmeticOrEnumeralCompare(Sema &S, ExprResult &LHS,
                                                  ExprResult &RHS,
                                                  SourceLocation Loc,
                                                  BinaryOperatorKind Opc) {
   if (Opc == BO_Cmp)
     return checkArithmeticOrEnumeralThreeWayCompare(S, LHS, RHS, Loc);
 
   // C99 6.5.8p3 / C99 6.5.9p4
-  QualType Type = S.UsualArithmeticConversions(LHS, RHS);
+  QualType Type =
+      S.UsualArithmeticConversions(LHS, RHS, Loc, Sema::ACK_Comparison);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
   if (Type.isNull())
     return S.InvalidOperands(Loc, LHS, RHS);
   assert(Type->isArithmeticType() || Type->isEnumeralType());
 
-  checkEnumComparison(S, Loc, LHS.get(), RHS.get());
-
   if (Type->isAnyComplexType() && BinaryOperator::isRelationalOp(Opc))
     return S.InvalidOperands(Loc, LHS, RHS);
 
   // Check for comparisons of floating point operands using != and ==.
   if (Type->hasFloatingRepresentation() && BinaryOperator::isEqualityOp(Opc))
     S.CheckFloatComparison(Loc, LHS.get(), RHS.get());
 
   // The result of comparisons is 'bool' in C++, 'int' in C.
if (LHS.get()->getType()->hasIntegerRepresentation() &&
                         /*AllowBothBool*/true,
                         /*AllowBoolConversions*/getLangOpts().ZVector);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
   if (Opc == BO_And)
     diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
 
+  if (LHS.get()->getType()->hasFloatingRepresentation() ||
+      RHS.get()->getType()->hasFloatingRepresentation())
+    return InvalidOperands(Loc, LHS, RHS);
+
   ExprResult LHSResult = LHS, RHSResult = RHS;
-  QualType compType = UsualArithmeticConversions(LHSResult, RHSResult,
-                                                 IsCompAssign);
+  QualType compType = UsualArithmeticConversions(
+      LHSResult, RHSResult, Loc, IsCompAssign ? ACK_CompAssign : ACK_BitwiseOp);
   if (LHSResult.isInvalid() || RHSResult.isInvalid())
     return QualType();
   LHS = LHSResult.get();
   RHS = RHSResult.get();
 
   if (Opc == BO_Xor)
     diagnoseXorMisusedAsPow(*this, LHS, RHS, Loc);
 

clang/lib/Sema/SemaExprCXX.cpp

if (LTy->isVectorType() || RTy->isVectorType())
     return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
                                /*AllowBothBool*/true,
                                /*AllowBoolConversions*/false);
 
   //   -- The second and third operands have arithmetic or enumeration type;
   //      the usual arithmetic conversions are performed to bring them to a
   //      common type, and the result is of that type.
   if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
-    QualType ResTy = UsualArithmeticConversions(LHS, RHS);
+    QualType ResTy =
+        UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
     if (LHS.isInvalid() || RHS.isInvalid())
       return QualType();
     if (ResTy.isNull()) {
       Diag(QuestionLoc,
            diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
       return QualType();
     }

clang/test/CXX/expr/expr.arith.conv/p2.cpp

+// RUN: %clang_cc1 -verify %s -std=c++17 -Weverything -Wno-deprecated -Wno-float-equal
+// RUN: %clang_cc1 -verify %s -std=c++2a -Wdeprecated
+
+static enum E1 {} e1, e1b;
+static enum E2 {} e2;
+static double d;
+extern void f();
+extern bool b;
+
+void f() {
+  void(e1 * e1);
+  void(e1 * e2); // expected-warning {{arithmetic between different enumeration types}}
+  void(e1 * d); // expected-warning {{arithmetic between enumeration type 'enum E1' and floating-point type 'double'}}
+  void(d * e1); // expected-warning {{arithmetic between floating-point type 'double' and enumeration type 'enum E1'}}
+
+  void(e1 + e1);
+  void(e1 + e2); // expected-warning {{arithmetic between different enumeration types}}
+  void(e1 + d); // expected-warning {{arithmetic between enumeration type 'enum E1' and floating-point type 'double'}}
+  void(d + e1); // expected-warning {{arithmetic between floating-point type 'double' and enumeration type 'enum E1'}}
+
+#if __cplusplus > 201703L
+  void(e1 <=> e1b); // expected-error {{include <compare>}}
+  void(e1 <=> e2); // expected-error {{invalid operands}}
+  void(e1 <=> d); // expected-error {{invalid operands}}
+  void(d <=> e1); // expected-error {{invalid operands}}
+#endif
+
+  void(e1 < e1b);
+  void(e1 < e2); // expected-warning {{comparison of different enumeration types}}
+  void(e1 < d); // expected-warning {{comparison of enumeration type 'enum E1' with floating-point type 'double'}}
+  void(d < e1); // expected-warning {{comparison of floating-point type 'double' with enumeration type 'enum E1'}}
+
+  void(e1 == e1b);
+  void(e1 == e2); // expected-warning {{comparison of different enumeration types}}
+  void(e1 == d); // expected-warning {{comparison of enumeration type 'enum E1' with floating-point type 'double'}}
+  void(d == e1); // expected-warning {{comparison of floating-point type 'double' with enumeration type 'enum E1'}}
+
+  void(b ? e1 : e1b);
+  void(b ? e1 : e2); // expected-warning {{conditional expression between different enumeration types}}
+  void(b ? e1 : d); // expected-warning {{conditional expression between enumeration type 'enum E1' and floating-point type 'double'}}
+  void(b ? d : e1); // expected-warning {{conditional expression between floating-point type 'double' and enumeration type 'enum E1'}}
+
+  void(e1 = e1b);
+  void(e1 = e2); // expected-error {{incompatible}}
+  void(e1 = d); // expected-error {{incompatible}}
+  void(d = e1); // FIXME: Should we warn on this?
+
+  void(e1 += e1b); // expected-error {{incompatible}}
+  void(e1 += e2); // expected-error {{incompatible}}
+  void(e1 += d); // expected-error {{incompatible}}
+  void(d += e1); // expected-warning {{compound assignment of floating-point type 'double' from enumeration type 'enum E1'}}
+}

clang/test/Sema/switch.c

 static const enum ExtendedEnum1_unrelated EE1_d = 101;
 
 void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) {
   switch(e) {
   case EE1_a: break;
   case EE1_b: break;
   case EE1_c: break; // no-warning
   case EE1_d: break; // expected-warning {{case value not in enumerated type 'enum ExtendedEnum1'}}
-  // expected-warning@-1 {{comparison of two values with different enumeration types in switch statement ('enum ExtendedEnum1' and 'enum ExtendedEnum1_unrelated')}}
+  // expected-warning@-1 {{comparison of different enumeration types in switch statement ('enum ExtendedEnum1' and 'enum ExtendedEnum1_unrelated')}}
   }
 }
 
 void PR11778(char c, int n, long long ll) {
   // Do not reject this; we don't have duplicate case values because we
   // check for duplicates in the promoted type.
   switch (c) case 1: case 257: ; // expected-warning {{overflow}}
 
   switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
   switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
   switch ((long long)n) case 0x100000001LL: case 1: ;
   switch (ll) case 0x100000001LL: case 1: ;
 }

clang/test/Sema/warn-conditional-emum-types-mismatch.c

 enum ExtendedStatusCodes {
   STATUS_SOMETHING_INTERESTING = MAX_BASE_STATUS_CODE + 1000,
 };
 
 
 int get_flag(int cond) {
   return cond ? A : B; 
   #ifdef __cplusplus
-  // expected-warning@-2 {{enumeration type mismatch in conditional expression ('ro' and 'rw')}}
+  // expected-warning@-2 {{conditional expression between different enumeration types ('ro' and 'rw')}}
   #else 
   // expected-no-diagnostics
   #endif
 }
 
 // In the following cases we purposefully differ from GCC and dont warn because
 // this code pattern is quite sensitive and we dont want to produce so many false positives.
 
 int get_flag_anon_enum(int cond) {
   return cond ? A : C;
 }
 
 int foo(int c) {
   return c ? STATUS_SOMETHING_INTERESTING : STATUS_SUCCESS;
 }

clang/test/SemaCXX/deprecated.cpp

-// RUN: %clang_cc1 -std=c++98 %s -Wno-parentheses -Wdeprecated -verify -triple x86_64-linux-gnu
-// RUN: %clang_cc1 -std=c++11 %s -Wno-parentheses -Wdeprecated -verify -triple x86_64-linux-gnu
-// RUN: %clang_cc1 -std=c++14 %s -Wno-parentheses -Wdeprecated -verify -triple x86_64-linux-gnu
-// RUN: %clang_cc1 -std=c++17 %s -Wno-parentheses -Wdeprecated -verify -triple x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++98 %s -Wno-parentheses -Wdeprecated -verify=expected,not-cxx20 -triple x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++11 %s -Wno-parentheses -Wdeprecated -verify=expected,not-cxx20 -triple x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++14 %s -Wno-parentheses -Wdeprecated -verify=expected,not-cxx20 -triple x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++17 %s -Wno-parentheses -Wdeprecated -verify=expected,not-cxx20 -triple x86_64-linux-gnu
 // RUN: %clang_cc1 -std=c++2a %s -Wno-parentheses -Wdeprecated -verify=expected,cxx20 -triple x86_64-linux-gnu
 
-// RUN: %clang_cc1 -std=c++14 %s -Wno-parentheses -Wdeprecated -verify -triple x86_64-linux-gnu -Wno-deprecated-register -DNO_DEPRECATED_FLAGS
+// RUN: %clang_cc1 -std=c++14 %s -Wno-parentheses -Wdeprecated -verify=expected,not-cxx20 -triple x86_64-linux-gnu -Wno-deprecated-register -DNO_DEPRECATED_FLAGS
 
 #include "Inputs/register.h"
 
 namespace std {
   struct type_info {};
 }
 
 void g() throw();
#endif
   void h(UDT a) {
     volatile UDT b = a;
     volatile UDT c = b;
     a = c = a;
     b += a;
   }
 }
 
+namespace ArithConv {
+  enum E { e } e2;
+  enum F { f };
+  bool b1 = e == e2;
+  bool b2 = e == f; // not-cxx20-warning-re {{different enumeration types ('ArithConv::E' and 'ArithConv::F'){{$}}}} cxx20-warning {{F') is deprecated}}
+  bool b3 = e == 0.0; // cxx20-warning {{comparison of enumeration type 'ArithConv::E' with floating-point type 'double' is deprecated}}
+  bool b4 = 0.0 == f; // cxx20-warning {{comparison of floating-point type 'double' with enumeration type 'ArithConv::F' is deprecated}}
+  int n1 = true ? e : f; // cxx20-warning {{conditional expression between different enumeration types ('ArithConv::E' and 'ArithConv::F') is deprecated}}
+  int n2 = true ? e : 0.0; // cxx20-warning {{conditional expression between enumeration type 'ArithConv::E' and floating-point type 'double' is deprecated}}
+}
+
+namespace ArrayComp {
+  int arr1[3], arr2[4];
+  bool b1 = arr1 == arr2; // expected-warning {{array comparison always evaluates to false}} cxx20-warning {{comparison between two arrays is deprecated}}
+  bool b2 = arr1 < arr2; // expected-warning {{array comparison always evaluates to a constant}} cxx20-warning {{comparison between two arrays is deprecated}}
+  __attribute__((weak)) int arr3[3];
+  bool b3 = arr1 == arr3; // cxx20-warning {{comparison between two arrays is deprecated}}
+  bool b4 = arr1 < arr3; // cxx20-warning {{comparison between two arrays is deprecated}}
+#if __cplusplus > 201703L
+  bool b5 = arr1 <=> arr2; // cxx20-error {{invalid operands}}
+#endif
+
+  int (&f())[3];
+  bool b6 = arr1 == f(); // cxx20-warning {{comparison between two arrays is deprecated}}
+  bool b7 = arr1 == +f();
+}
+
 # 1 "/usr/include/system-header.h" 1 3
 void system_header_function(void) throw();

clang/test/SemaCXX/self-comparison.cpp

 
 struct A {
   int x;
   X x2;
   int a[3];
   int b[3];
   bool f() { return x == x; } // expected-warning {{self-comparison always evaluates to true}}
   bool g() { return x2 == x2; } // no-warning
-  bool h() { return a == b; } // expected-warning {{array comparison always evaluates to false}}
+  bool h() { return a == b; } // expected-warning {{array comparison always evaluates to false}} expected-warning {{deprecated}}
   bool i() {
     int c[3];
-    return a == c; // expected-warning {{array comparison always evaluates to false}}
+    return a == c; // expected-warning {{array comparison always evaluates to false}} expected-warning {{deprecated}}
   }
 };
 
 namespace NA { extern "C" int x[3]; }
 namespace NB { extern "C" int x[3]; }
-bool k = NA::x == NB::x; // expected-warning {{self-comparison always evaluates to true}}
+bool k = NA::x == NB::x; // expected-warning {{self-comparison always evaluates to true}} expected-warning {{deprecated}}
 
 template<typename T> struct Y { static inline int n; };
 bool f() {
   return
     Y<int>::n == Y<int>::n || // expected-warning {{self-comparison always evaluates to true}}
     Y<void>::n == Y<int>::n;
 }
 template<typename T, typename U>
struct T {
   S s;
 };
 
 int struct_test(S s1, S s2, S *s3, T t) {
   return s1.field == s1.field;  // expected-warning {{self-comparison always evaluates to true}}
   return s2.field == s2.field;  // expected-warning {{self-comparison always evaluates to true}}
   return s1.static_field == s2.static_field;  // expected-warning {{self-comparison always evaluates to true}}
   return S::static_field == s1.static_field;  // expected-warning {{self-comparison always evaluates to true}}
-  return s1.array == s1.array;  // expected-warning {{self-comparison always evaluates to true}}
+  return s1.array == s1.array;  // expected-warning {{self-comparison always evaluates to true}} expected-warning {{deprecated}}
   return t.s.static_field == S::static_field;  // expected-warning {{self-comparison always evaluates to true}}
   return s3->field == s3->field;  // expected-warning {{self-comparison always evaluates to true}}
   return s3->static_field == S::static_field;  // expected-warning {{self-comparison always evaluates to true}}
   return s1.array[0] == s1.array[0];  // expected-warning {{self-comparison always evaluates to true}}
   return s1.array[0] == s1.array[0ull];  // expected-warning {{self-comparison always evaluates to true}}
   return s1.array[I1] == s1.array[I1];  // expected-warning {{self-comparison always evaluates to true}}
   return s1.array[s2.array[0]] == s1.array[s2.array[0]];  // expected-warning {{self-comparison always evaluates to true}}
   return s3->array[t.field] == s3->array[t.field];  // expected-warning {{self-comparison always evaluates to true}}
 
   // Try all operators
   return t.field == t.field;  // expected-warning {{self-comparison always evaluates to true}}
   return t.field <= t.field;  // expected-warning {{self-comparison always evaluates to true}}
   return t.field >= t.field;  // expected-warning {{self-comparison always evaluates to true}}
 
   return t.field != t.field;  // expected-warning {{self-comparison always evaluates to false}}
   return t.field < t.field;  // expected-warning {{self-comparison always evaluates to false}}
   return t.field > t.field;  // expected-warning {{self-comparison always evaluates to false}}
 
   // no warning
   return s1.field == s2.field;
-  return s2.array == s1.array;
+  return s2.array == s1.array; // FIXME: This always evaluates to false. expected-warning {{deprecated}}
   return s2.array[0] == s1.array[0];
   return s1.array[I1] == s1.array[I2];
 
   return s1.static_field == t.static_field;
 };
 
 struct U {
   bool operator!=(const U&);

clang/test/SemaCXX/warn-enum-compare.cpp

#endif
   while ((((((B1))))) == (((name1::B2))));
   while (B2 == ((((((name2::B1)))))));
 
   while (td == Anon1);
 #ifndef MSABI
   while (td == AnonAA);  // expected-warning {{comparison of constant 'AnonAA' (42) with expression of type 'TD' is always false}}
 #endif
 
-  while (B1 == B2); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-  while (name1::B2 == name2::B3); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-  while (z == name2::B2); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-
-  while (((((B1)))) == B2); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-  while (name1::B2 == (name2::B3)); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-  while (z == ((((name2::B2))))); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-
-  while ((((B1))) == (((B2)))); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-  while ((name1::B2) == (((name2::B3)))); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-  while ((((z))) == (name2::B2)); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}}
-
-  while (x == a); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'name1::Foo')}}
-  while (x == b); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'oneFoo' (aka 'name1::Foo'))}}
-  while (x == c); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'twoFoo' (aka 'name1::Foo'))}}
-
-  while (x == y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x != y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x >= y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x <= y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x > y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x < y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (FooB == y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB != y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB >= y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB <= y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB > y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB < y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (FooB == BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB != BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB >= BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB <= BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB > BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB < BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (x == BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x != BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x >= BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x <= BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x > BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x < BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (getFoo() == y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() != y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() >= y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() <= y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() > y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() < y); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (getFoo() == BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() != BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() >= BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() <= BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() > BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() < BarD); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (getFoo() == getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() != getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() >= getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() <= getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() > getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (getFoo() < getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (FooB == getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB != getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB >= getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB <= getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB > getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (FooB < getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-  while (x == getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x != getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x >= getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x <= getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x > getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-  while (x < getBar()); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
-
-
-
-  while (y == x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y != x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y >= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y <= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y > x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y < x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (y == FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y != FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y >= FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y <= FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y > FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y < FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (BarD == FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD != FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD >= FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD <= FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD > FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD <FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (BarD == x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD != x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD >= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD <= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD < x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD > x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (y == getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y != getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y >= getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y <= getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y > getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (y < getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (BarD == getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD != getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD >= getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD <= getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD > getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (BarD < getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (getBar() == getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() != getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() >= getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() <= getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() > getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() < getFoo()); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (getBar() == FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() != FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() >= FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() <= FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() > FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() < FooB); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (getBar() == x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() != x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() >= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() <= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() > x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-  while (getBar() < x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
-
-  while (td == FooA); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'Foo')}}
-  while (td == BarD); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'Bar')}}
-  while (name1::F1 == td); // expected-warning  {{comparison of two values with different enumeration types ('name1::Foo' and 'TD')}}
-  while (name2::B1 == td); // expected-warning  {{comparison of two values with different enumeration types ('name2::Baz' and 'TD')}}
-  while (td == a); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'name1::Foo')}}
-  while (td == b); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'oneFoo' (aka 'name1::Foo'))}}
-  while (td == c); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'twoFoo' (aka 'name1::Foo'))}}
-  while (td == x); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'Foo')}}
-  while (td == y); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'Bar')}}
-  while (td == z); // expected-warning  {{comparison of two values with different enumeration types ('TD' and 'name1::Baz')}}
-
-  while (a == TD1); // expected-warning  {{comparison of two values with different enumeration types ('name1::Foo' and 'TD')}}
-  while (b == TD2); // expected-warning  {{comparison of two values with different enumeration types ('oneFoo' (aka 'name1::Foo') and 'TD')}}
-  while (c == TD1); // expected-warning  {{comparison of two values with different enumeration types ('twoFoo' (aka 'name1::Foo') and 'TD')}}
-  while (x == TD2); // expected-warning  {{comparison of two values with different enumeration types ('Foo' and 'TD')}}
-  while (y == TD1); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'TD')}}
-  while (z == TD2); // expected-warning  {{comparison of two values with different enumeration types ('name1::Baz' and 'TD')}}
+  while (B1 == B2); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+  while (name1::B2 == name2::B3); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+  while (z == name2::B2); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+
+  while (((((B1)))) == B2); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+  while (name1::B2 == (name2::B3)); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+  while (z == ((((name2::B2))))); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+
+  while ((((B1))) == (((B2)))); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+  while ((name1::B2) == (((name2::B3)))); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+  while ((((z))) == (name2::B2)); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'name2::Baz')}}
+
+  while (x == a); // expected-warning  {{comparison of different enumeration types ('Foo' and 'name1::Foo')}}
+  while (x == b); // expected-warning  {{comparison of different enumeration types ('Foo' and 'oneFoo' (aka 'name1::Foo'))}}
+  while (x == c); // expected-warning  {{comparison of different enumeration types ('Foo' and 'twoFoo' (aka 'name1::Foo'))}}
+
+  while (x == y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x != y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x >= y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x <= y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x > y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x < y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (FooB == y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB != y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB >= y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB <= y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB > y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB < y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (FooB == BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB != BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB >= BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB <= BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB > BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB < BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (x == BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x != BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x >= BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x <= BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x > BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x < BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (getFoo() == y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() != y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() >= y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() <= y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() > y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() < y); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (getFoo() == BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() != BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() >= BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() <= BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() > BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() < BarD); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (getFoo() == getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() != getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() >= getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() <= getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() > getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (getFoo() < getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (FooB == getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB != getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB >= getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB <= getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB > getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (FooB < getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+  while (x == getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x != getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x >= getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x <= getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x > getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+  while (x < getBar()); // expected-warning  {{comparison of different enumeration types ('Foo' and 'Bar')}}
+
+
+
+  while (y == x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y != x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y >= x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y <= x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y > x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y < x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (y == FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y != FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y >= FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y <= FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y > FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y < FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (BarD == FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD != FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD >= FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD <= FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD > FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD <FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (BarD == x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD != x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD >= x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD <= x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD < x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD > x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (y == getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y != getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y >= getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y <= getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y > getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (y < getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (BarD == getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD != getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD >= getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD <= getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD > getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (BarD < getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (getBar() == getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() != getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() >= getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() <= getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() > getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() < getFoo()); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (getBar() == FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() != FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() >= FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() <= FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() > FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() < FooB); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (getBar() == x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() != x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() >= x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() <= x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() > x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+  while (getBar() < x); // expected-warning  {{comparison of different enumeration types ('Bar' and 'Foo')}}
+
+  while (td == FooA); // expected-warning  {{comparison of different enumeration types ('TD' and 'Foo')}}
+  while (td == BarD); // expected-warning  {{comparison of different enumeration types ('TD' and 'Bar')}}
+  while (name1::F1 == td); // expected-warning  {{comparison of different enumeration types ('name1::Foo' and 'TD')}}
+  while (name2::B1 == td); // expected-warning  {{comparison of different enumeration types ('name2::Baz' and 'TD')}}
+  while (td == a); // expected-warning  {{comparison of different enumeration types ('TD' and 'name1::Foo')}}
+  while (td == b); // expected-warning  {{comparison of different enumeration types ('TD' and 'oneFoo' (aka 'name1::Foo'))}}
+  while (td == c); // expected-warning  {{comparison of different enumeration types ('TD' and 'twoFoo' (aka 'name1::Foo'))}}
+  while (td == x); // expected-warning  {{comparison of different enumeration types ('TD' and 'Foo')}}
+  while (td == y); // expected-warning  {{comparison of different enumeration types ('TD' and 'Bar')}}
+  while (td == z); // expected-warning  {{comparison of different enumeration types ('TD' and 'name1::Baz')}}
+
+  while (a == TD1); // expected-warning  {{comparison of different enumeration types ('name1::Foo' and 'TD')}}
+  while (b == TD2); // expected-warning  {{comparison of different enumeration types ('oneFoo' (aka 'name1::Foo') and 'TD')}}
+  while (c == TD1); // expected-warning  {{comparison of different enumeration types ('twoFoo' (aka 'name1::Foo') and 'TD')}}
+  while (x == TD2); // expected-warning  {{comparison of different enumeration types ('Foo' and 'TD')}}
+  while (y == TD1); // expected-warning  {{comparison of different enumeration types ('Bar' and 'TD')}}
+  while (z == TD2); // expected-warning  {{comparison of different enumeration types ('name1::Baz' and 'TD')}}
 
   switch (a) {
     case name1::F1: break;
     case name1::F3: break;
-    case name2::B2: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('name1::Foo' and 'name2::Baz')}}
+    case name2::B2: break; // expected-warning {{comparison of different enumeration types in switch statement ('name1::Foo' and 'name2::Baz')}}
   }
 
   switch (x) {
     case FooB: break;
     case FooC: break;
-    case BarD: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('Foo' and 'Bar')}}
+    case BarD: break; // expected-warning {{comparison of different enumeration types in switch statement ('Foo' and 'Bar')}}
   }
 
   switch(getBar()) {
     case BarE: break;
     case BarF: break;
-    case FooA: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('Bar' and 'Foo')}}
+    case FooA: break; // expected-warning {{comparison of different enumeration types in switch statement ('Bar' and 'Foo')}}
   }
 
   switch(x) {
     case AnonAA: break; // expected-warning {{case value not in enumerated type 'Foo'}}
     case FooA: break;
     case FooB: break;
     case FooC: break;
   }
 
   switch (td) {
     case TD1: break;
-    case FooB: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('TD' and 'Foo')}}
-    case BarF: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('TD' and 'Bar')}}
+    case FooB: break; // expected-warning {{comparison of different enumeration types in switch statement ('TD' and 'Foo')}}
+    case BarF: break; // expected-warning {{comparison of different enumeration types in switch statement ('TD' and 'Bar')}}
     // expected-warning@-1 {{case value not in enumerated type 'TD'}}
     case AnonAA: break; // expected-warning {{case value not in enumerated type 'TD'}}
   }
 
   switch (td) {
     case Anon1: break;
     case TD2: break;
   }
 
   switch (a) {
-    case TD1: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('name1::Foo' and 'TD')}}
-    case TD2: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('name1::Foo' and 'TD')}}
+    case TD1: break; // expected-warning {{comparison of different enumeration types in switch statement ('name1::Foo' and 'TD')}}
+    case TD2: break; // expected-warning {{comparison of different enumeration types in switch statement ('name1::Foo' and 'TD')}}
     case name1::F3: break;
   }
 }

clang/www/cxx_status.html

</tr>
     <tr>
       <td><tt>const</tt> mismatch with defaulted copy constructor</td>
       <td><a href="https://wg21.link/p0641r2">P0641R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td rowspan="8">Consistent comparison (<tt>operator&lt;=&gt;</tt>)</td>
       <td><a href="https://wg21.link/p0515r3">P0515R3</a></td>
-      <td rowspan="2" class="svn" align="center">SVN</td>
+      <td rowspan="7" class="svn" align="center">SVN</td>
     </tr>
       <tr> <!-- from Jacksonville -->
         <td><a href="https://wg21.link/p0905r1">P0905R1</a></td>
       </tr>
       <tr> <!-- from Rapperswil -->
         <td><a href="https://wg21.link/p1120r0">P1120R0</a></td>
-        <td class="partial" align="center">Partial</td>
       </tr>
       <tr> <!-- from Kona 2019 -->
         <td><a href="https://wg21.link/p1185r2">P1185R2</a></td>
-        <td rowspan="4" class="svn" align="center">SVN</td>
       </tr>
       <tr> <!-- from Cologne -->
         <td><a href="https://wg21.link/p1186r3">P1186R3</a></td>
       </tr>
       <tr>
         <td><a href="https://wg21.link/p1630r1">P1630R1</a></td>
       </tr>
       <tr> <!-- from Belfast -->