[Sema] add warning for comparisons like 'x<=y<=z'

[vabridgers]

Summary

This changes add a new warning named -Wcompare-op-parentheses that's
part of the -Wparentheses diagnostic group. This diagnostic produces a
warning when a pattern like 'x<=y<=z' is found. When this pattern is not
qualified by parentheses, it's equivalent to '(x<=y ? 1 : 0) <= z',
which is a different interpretation from that of ordinary mathematical
notation.

[vabridgers]

This is an implementation in the CFE, after submitting and getting comments on https://reviews.llvm.org/D84898.

[• Quuxplusone]

clang/docs/DiagnosticsReference.rst

2853

s/-no-/-op-/

9885

s/-no-/-op-/
And what's going on with all these trailing underscores? If they're important, you're missing one.

clang/include/clang/Basic/DiagnosticSemaKinds.td

6135

Why is this x<=y<=z instead of the simpler x<y<z or even x<=y<z (the "half-open range" common case)?
IMHO you should mention the name "chained comparisons" here, since I think that's what people coming from such languages will understand.

clang/test/Sema/warn-compare-op-parentheses.c

2

These are some great test cases, but I think they would benefit from being exhaustive.

int tests(int p1, int p2, int p3) {
    bool b;
    b = (p1 < p2 < p3);  // expected-warning{{comparisons like 'x<y<z' are interpreted}} expected-note{{place parentheses}}
    b = (p1 < p2 <= p3);  // expected-warning{{comparisons like 'x<y<z' are interpreted}} expected-note{{place parentheses}}
    b = (p1 < p2 > p3);  // expected-warning{{comparisons like 'x<y<z' are interpreted}} expected-note{{place parentheses}}
    b = (p1 < p2 >= p3);  // expected-warning{{comparisons like 'x<y<z' are interpreted}} expected-note{{place parentheses}}
    b = (p1 <= p2 < p3);  // expected-warning{{comparisons like 'x<y<z' are interpreted}} expected-note{{place parentheses}}
    b = (p1 <= p2 <= p3);  // expected-warning{{comparisons like 'x<y<z' are interpreted}} expected-note{{place parentheses}}

etc. etc.
I don't see any downside to being systematic here.

130

I would like to see explicit (and preferably exhaustive or at least systematic) test cases for the "no warning intended" case:

if ((p1 < p2) < p3)
if (p1 < (p2 < p3))
if (0 <= (p1 < p2))  // this should already trigger a constant-comparison-result warning, yes?

I would like to see explicit (and preferably exhaustive or at least systematic) test cases for mixed relational and equality comparisons:

if (p1 == p2 < p3)  // maybe intentional, but definitely deserving of a warning
if (p1 == p2 == p3)  // definitely buggy and deserving of a warning
if (p1 != p2 != p3)  // definitely buggy and deserving of a warning
if (p1 < p2 == p3 < p4)  // maybe intentional, but definitely deserving of a warning
if (p1 == p2 < p3 == p4)  // definitely buggy and deserving of a warning

[lebedev.ri]

Thank you! I strongly prefer this path forward.

clang/lib/Sema/SemaExpr.cpp

14010

Should we also suggest the fix to rewrite into what user likely intended?
(x op1 y) && (y op2 z)

[• Quuxplusone]

Btw, this is an awesome patch! I'm looking forward to getting to use it.

[vabridgers]

Thank you for the comments @lebedev.ri and @Quuxplusone. I'll abandon the tidy approach (https://reviews.llvm.org/D84898) and work towards satisfying these review comments (and any others), driving towards acceptance. Best!

[vabridgers]

Address simpler issues brought up during review so far.
Tests to be refactored, and a fixit added.

[vabridgers]

Thanks for the comments. I posted an update for the simpler issues, working on refactoring the test cases and creating a fixit. Thanks for the good and actionable review comments!

clang/docs/DiagnosticsReference.rst

2853

fixed, thank you!

9885

missed that, thank you!

clang/include/clang/Basic/DiagnosticSemaKinds.td

6135

Thanks Arthur. I modeled the warning message after gcc's warning message. We found internally that while gcc detected this, clang did not. See https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#Warning-Options ...
<q>
-Wparentheses
Warn if parentheses are omitted in certain contexts, such as when there is an assignment in a context where a truth value is expected, or when operators are nested whose precedence people often get confused about.

Also warn if a comparison like x<=y<=z appears; this is equivalent to (x<=y ? 1 : 0) <= z, which is a different interpretation from that of ordinary mathematical notation.
...
</q>
While this is the gcc documentation, we can craft whatever message we see fit at this point in time :) I'll add "chained" comparison for this next update, we can tailor the message as we see fit. Thanks!

clang/lib/Sema/SemaExpr.cpp

14010

I'll work on this, post in a next update. Thank you!

clang/test/Sema/warn-compare-op-parentheses.c

2

I'll address in a future update. Thank you!

130

Great suggestions, I'll address in a future update. Thank you!

[vabridgers]

clang/test/Misc/warning-wall.c

100

oh my, I didn't intend for this to happen. I'll address.

[vabridgers]

back out last unwanted changes from clang-format

[vabridgers]

clang/lib/Sema/SemaExpr.cpp

14010

Hi @lebedev.ri , the warning emits a note that says "place parentheses around the '<op>' expression to silence this warning" (see the test cases below). Is this sufficient, or are you looking for something else?

[vabridgers]

refactor test cases per comment from Arthur

[vabridgers]

I believe I've addressed all comments so far. Looks like Arthur suggested some particular cases that are not currently covered, and are not covered by this change since I think addressing those issues are our of scope of my original intent. If this patch is otherwise acceptable, would the reviewers be ok accepting this patch on the condition of creating a bugzilla report to track those issues?

[• Quuxplusone]

clang/lib/Sema/SemaExpr.cpp

14010

https://godbolt.org/z/d1dG1o
For the very similar situation (x & 1 == 0), Clang suggests two different fixits, and I believe Roman was suggesting that you should do the same kind of thing here.

<source>:3:16: warning: & has lower precedence than ==; == will be evaluated first [-Wparentheses]
    int y = (x & 1 == 0);
               ^~~~~~~~
<source>:3:16: note: place parentheses around the '==' expression to silence this warning
    int y = (x & 1 == 0);
               ^
                 (     )
<source>:3:16: note: place parentheses around the & expression to evaluate it first
    int y = (x & 1 == 0);
               ^
             (    )

For our situation here it would be something like

<source>:3:16: warning: chained comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z' [-Wcompare-op-parentheses]
    int w = (x < y < z);
               ^~~~~~~~
<source>:3:16: note: place parentheses around the first '<' expression to silence this warning
    int w = (x < y < z);
             ^
             (    )
<source>:3:16: note: separate the expression into two clauses to give it the mathematical meaning
    int y = (x < y < z);
               ^
             (    ) && (y    )

Watch out that you don't suggest a wrong fixit for (0 <= sideeffect() < 10), though. I seem to recall another warning that recently had a lot of trouble phrasing its fixit in a way that wouldn't invoke UB or change the behavior of the code in corner cases, but I forget the details.

[• Quuxplusone]

clang/lib/Sema/SemaExpr.cpp

14113

Same precedence as what?
I think this should just be called isRelationalOperator, and I would bet money that such a classifier function already exists somewhere in the codebase.

[njames93]

clang/lib/Sema/SemaExpr.cpp

14010

Surely you'd just need to check y for side effects before creating the fix-it.

14113

isRelationalOp and its a member function of BinaryOperator so there is no need to even access the OperatorKind.

[vabridgers]

isRelationalOp

[vabridgers]

fix misc test formatting

[vabridgers]

clang/lib/Sema/SemaExpr.cpp

14010

Still working on these, thanks

14010

still working on these, thanks

14113

Fixed, thanks

14113

Fixed, thanks

[vabridgers]

added prototype fixits for review.
added additional RUN test case.
filed https://bugs.llvm.org/show_bug.cgi?id=47010 for other
warnings improvement post landing of this patch, after lgtm

[vabridgers]

I added prototype fixits per request by Roman, updated the LIT test, and added an additional RUN line (one for -Wparentheses and one for -Wcompare-op-parentheses). Also filed https://bugs.llvm.org/show_bug.cgi?id=47010 to follow up on the FIXME cases at the bottom of the LIT since they are out of scope for this change. Thanks for the feedback and comments so far, I look forward to driving this change to completion.

[njames93]

Also with a name like compare op parenthesis. It sounds like this would consider == and !=

clang/lib/Sema/SemaExpr.cpp

14034

You don't want to insert y but the source code for y

[vabridgers]

clang/lib/Sema/SemaExpr.cpp

14034

Gotcha, I'll address.

[• Quuxplusone]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6139

Both in the string and in the identifier, s/seperate/separate/.
I would also s/sides/clauses/ or s/sides/expression/ just to avoid giving too many different names to the same entity.

clang/lib/Sema/SemaExpr.cpp

14010

My understanding is that option (2) (x <= (y <= z)) is never suggested. It's reasonable not to suggest it, because it is neither "what the compiler sees, elucidated for the human reader" nor "what the programmer meant, corrected for the compiler." However, as it's not suggested, it shouldn't be documented in this comment.

14034

Please make sure to add at least one regression test to catch this (i.e. some test that tests the wording of the fixit and uses a name for the middle term that is not y). I don't know how to test a fixit, but there must be a way.

14261

FWIW, I would s/loosely/such as/.

clang/test/Misc/warning-wall.c

86

My impression is that you (Vincent) are tending toward just adding x == y == z and x <= y == z to this same -Wcompare-op-parentheses. That's also my preference (except that I wish it could be done all together in one big pull request instead of being split up and perhaps deferred). Have we conclusively established that everyone's on board for this?

An alternative (but IMHO a poor alternative) would be to have two or three more granular warnings, e.g. -Wrelational-op-parentheses and -Wequality-op-parentheses (and -Wmixed-relational-equality-op-parentheses?!). If we were to foresee that happening, then -Wcompare-op-parentheses would be the wrong name for this warning option today.

[rsmith]

The diagnostic we get for the case of three or more comparison operators here doesn't seem ideal. Perhaps we could do this check as part of the SemaChecking pass over the completed expression rather than doing it as we form the individual comparisons? That way we'll have the contextual information necessary to find the complete chained comparison; we'd also be able to detect the special case where the operator sequence is the operand of an &/|/^ so that we need parentheses in the fixit.

clang/docs/DiagnosticsReference.rst

1–5

Please note this :)

You can revert the changes to this file; it's auto-generated. (We only check in a version because the clang website infrastructure isn't yet able to generate it on-demand.)

clang/include/clang/Basic/DiagnosticSemaKinds.td

6135

Per our diagnostic best practices (http://clang.llvm.org/docs/InternalsManual.html#the-format-string), don't repeat the code in the diagnostic (or even an analogy of it such as 'x<=y<=z'); instead, consider underlining the chained comparison operators in the snippet. Also keep in mind that the developer will see the diagnostic and the notes together; you can use the notes to help clarify the meaning of the diagnostic:

error: chained comparison does not have its mathematical meaning
  if (a <= b < c)
         ^~   ~
note: perform two separate comparisons to compare the same operand twice
  if (a <= b < c)
             ^
             && b
note: place parentheses around the first comparison to compare against its 'bool' result and silence this warning
  if (a <= b < c)
      ^
      (     )

6137

If you're going to quote the operator here, you should prepend "first" or similar if both operators are the same.

6139

Don't say "intended". We don't know the intent.

clang/lib/Sema/SemaExpr.cpp

14008–14010

Why not also == and != here? a < b == c < d is a perfectly reasonable mathematical equation (modulo the spelling of ==), and it would seem sensible to catch that with the same diagnostic.

14031

I think we should consider omitting the fixit if the y expression is long or has side-effects.

14032–14035

The parentheses here clutter and distract from the point of the fixit (adding the && y). We usually don't need them, and in the cases where we do need them, the parens you added here aren't correct.

For example, cond1 && a + b < c < d + e && cond2 doesn't need any parens, and a | b < c < d needs parens around the entire rewritten b < c && c < d expression, not around the individual terms.

If you want the rewrite to always be correct, you should add a ( at the start, an ) at the end, and a && y before the second operator (or a y && after the first operator). If you're OK with it being wrong in the weird case of an & / | / ^ operator adjacent to the chained comparison, then no parens are needed at all. But there's no need to parenthesize the individual operands of the &&.

[vabridgers]

use source from expression in fixit
s/seperate/separate/
address some chained comparison ambiguities outside of original scope of changes

[vabridgers]

Thanks for the recent comments. I just pushed a few improvements over the last patch that didn't comprehend latest comments from @rsmith and @Quuxplusone. I'll read through those carefully and address those.

[lebedev.ri]

In D85097#2201609, @vabridgers wrote:

Thanks for the recent comments. I just pushed a few improvements over the last patch that didn't comprehend latest comments from @rsmith and @Quuxplusone. I'll read through those carefully and address those.

Reverse-ping, thanks. I think this is a worthwhile warning.

[xbolva00]

clang/test/Sema/warn-compare-op-parentheses.c

49

Not very user friendly warning text..

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

clang/docs/DiagnosticsReference.rst

 ..
   -------------------------------------------------------------------
   NOTE: This file is automatically generated by running clang-tblgen
   -gen-diag-docs. Do not edit this file by hand!!
   -------------------------------------------------------------------
 
 .. Add custom CSS to output. FIXME: This should be put into <head> rather
    than the start of <body>.
 .. raw:: html
 
     <style>
     table.docutils {
       width: 1px;

 
 **Diagnostic text:**
 
 +---------------------------------------------------------------------------+
 |:warning:`warning:` |nbsp| :diagtext:`comparison of distinct pointer types`|
 +---------------------------------------------------------------------------+
 
 
+-Wcompare-op-parentheses
+--------------------------------
+**Diagnostic text:**
+
++----------------------------------------------------------------------------------------------------------+
+|:warning:`warning:` |nbsp| :diagtext:`comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'`|
++----------------------------------------------------------------------------------------------------------+
+
+
 -Wcomplex-component-init
 ------------------------
 **Diagnostic text:**
 
 +----------------------------------------------------------------------------------------------------------------------+
 |:warning:`warning:` |nbsp| :diagtext:`complex initialization specifying real and imaginary components is an extension`|
 +----------------------------------------------------------------------------------------------------------------------+
 

 |                                                                                                                                      |+----------------+|+-------------+|                                         |
 +--------------------------------------------------------------------------------------------------------------------------------------+------------------+---------------+-----------------------------------------+
 
 
 -Wparentheses
 -------------
 Some of the diagnostics controlled by this flag are enabled by default.
 
-Also controls `-Wbitwise-conditional-parentheses`_, `-Wbitwise-op-parentheses`_, `-Wdangling-else`_, `-Wlogical-not-parentheses`_, `-Wlogical-op-parentheses`_, `-Woverloaded-shift-op-parentheses`_, `-Wparentheses-equality`_, `-Wshift-op-parentheses`_.
+Also controls `-Wbitwise-conditional-parentheses`_, `-Wbitwise-op-parentheses`_, `-Wcompare-op-parentheses`_, `-Wdangling-else`_, `-Wlogical-not-parentheses`_, `-Wlogical-op-parentheses`_, `-Woverloaded-shift-op-parentheses`_, `-Wparentheses-equality`_, `-Wshift-op-parentheses`_.
 
 **Diagnostic text:**
 
 +-----------------------------------------------------------------------------------------------------------+
 |:warning:`warning:` |nbsp| :diagtext:`using the result of an assignment as a condition without parentheses`|
 +-----------------------------------------------------------------------------------------------------------+
 
 +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

clang/include/clang/Basic/DiagnosticGroups.td

 def : DiagGroup<"c++2a-compat-pedantic", [CXX20CompatPedantic]>;
 
 def ExitTimeDestructors : DiagGroup<"exit-time-destructors">;
 def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">;
 def FourByteMultiChar : DiagGroup<"four-char-constants">;
 def GlobalConstructors : DiagGroup<"global-constructors">;
 def BitwiseConditionalParentheses: DiagGroup<"bitwise-conditional-parentheses">;
 def BitwiseOpParentheses: DiagGroup<"bitwise-op-parentheses">;
+def CompareOpParentheses: DiagGroup<"compare-op-parentheses">;
 def LogicalOpParentheses: DiagGroup<"logical-op-parentheses">;
 def LogicalNotParentheses: DiagGroup<"logical-not-parentheses">;
 def ShiftOpParentheses: DiagGroup<"shift-op-parentheses">;
 def OverloadedShiftOpParentheses: DiagGroup<"overloaded-shift-op-parentheses">;
 def DanglingElse: DiagGroup<"dangling-else">;
 def DanglingField : DiagGroup<"dangling-field">;
 def DanglingInitializerList : DiagGroup<"dangling-initializer-list">;
 def DanglingGsl : DiagGroup<"dangling-gsl">;
def : DiagGroup<"address", [PointerBoolConversion,
                             TautologicalPointerCompare]>;
 
 // -Widiomatic-parentheses contains warnings about 'idiomatic'
 // missing parentheses;  it is off by default.  We do not include it
 // in -Wparentheses because most users who use -Wparentheses explicitly
 // do not want these warnings.
 def ParenthesesOnEquality : DiagGroup<"parentheses-equality">;
 def Parentheses : DiagGroup<"parentheses",
-                            [LogicalOpParentheses,
+                            [CompareOpParentheses,
+                             LogicalOpParentheses,
                              LogicalNotParentheses,
                              BitwiseConditionalParentheses,
                              BitwiseOpParentheses,
                              ShiftOpParentheses,
                              OverloadedShiftOpParentheses,
                              ParenthesesOnEquality,
                              DanglingElse]>;
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_logical_instead_of_bitwise_change_operator : Note<
   "use '%0' for a bitwise operation">;
 def note_logical_instead_of_bitwise_remove_constant : Note<
   "remove constant to silence this warning">;
 
 def warn_bitwise_op_in_bitwise_op : Warning<
   "'%0' within '%1'">, InGroup<BitwiseOpParentheses>, DefaultIgnore;
 
+def warn_compare_parentheses : Warning<
+  "chained comparisons may need parentheses for clarity">,
+  InGroup<CompareOpParentheses>, DefaultIgnore;
+
+def warn_relation_parentheses : Warning<
+  "chained comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'">,
+  InGroup<CompareOpParentheses>, DefaultIgnore;
+def note_compare_with_parens : Note<
+  "place parentheses around the '%0' comparison to silence this warning">;
+def note_compare_separate_sides : Note<
+  "separate the expression into two clauses to give it the intended mathematical meaning">;
+
 def warn_logical_and_in_logical_or : Warning<
   "'&&' within '||'">, InGroup<LogicalOpParentheses>, DefaultIgnore;
 
 def warn_overloaded_shift_in_comparison :Warning<
   "overloaded operator %select{>>|<<}0 has higher precedence than "
   "comparison operator">,
   InGroup<OverloadedShiftOpParentheses>;
 def note_evaluate_comparison_first :Note<

clang/lib/Sema/SemaExpr.cpp

SuggestParentheses(Self, OpLoc,
     Self.PDiag(diag::note_precedence_silence) << OpStr,
     (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
   SuggestParentheses(Self, OpLoc,
     Self.PDiag(diag::note_precedence_bitwise_first)
       << BinaryOperator::getOpcodeStr(Opc),
     ParensRange);
 }
 
+// Emit diagnostics for ambiguous compares, loosely x<=y<=z, or
+// more precisely...
+//
+// Accepts (x ['<'|'<='|'>'|'>='] y ['<'|'<='|'>'|'>='] z), suggests:
+// 1) ((x ['<'|'<='|'>'|'>='] y) ['<'|'<='|'>'|'>='] z), or
+// 2) (x ['<'|'<='|'>'|'>='] (y ['<'|'<='|'>'|'>='] z)). or
+// 3) (x ['<'|'<='|'>'|'>='] y) && (y ['<'|'<='|'>'|'>='] z)
+static void EmitDiagnosticForAmbiguousRelationOp(Sema &Self,
+                                                 BinaryOperatorKind Opc,
+                                                 SourceLocation OpLoc,
+                                                 Expr *LHSExpr, Expr *RHSExpr) {
+  BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr);
+
+  SourceRange DiagRange = SourceRange(LHSExpr->getBeginLoc(), OpLoc);
+
+  Self.Diag(OpLoc, diag::warn_relation_parentheses) << DiagRange << OpLoc;
+  SuggestParentheses(Self, LHSExpr->getBeginLoc(),
+                     Self.PDiag(diag::note_compare_with_parens)
+                         << LHSBO->getOpcodeStr(),
+                     SourceRange(LHSExpr->getBeginLoc(), LHSExpr->getEndLoc()));
+  SuggestParentheses(
+      Self, OpLoc,
+      Self.PDiag(diag::note_compare_with_parens)
+          << BinaryOperator::getOpcodeStr(Opc),
+      SourceRange(LHSBO->getRHS()->getBeginLoc(), RHSExpr->getEndLoc()));
+
+  std::string LHSLOpStr = "xyz"; // = LHSBO->getRHS()->getName();//"xyz";
+
+  Expr *lhs = LHSBO->getRHS();
+  if (DeclRefExpr *DRE =
+          dyn_cast<DeclRefExpr>(lhs->IgnoreImplicit()->IgnoreParens())) {
+    if (VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
+      LHSLOpStr = VD->getQualifiedNameAsString();
+    }
+  }
+
+  Self.Diag(LHSExpr->getBeginLoc(), diag::note_compare_separate_sides)
+      << FixItHint::CreateInsertion(LHSExpr->getBeginLoc(), "(")
+      << FixItHint::CreateInsertion(LHSExpr->getEndLoc(), ") && ")
+      << FixItHint::CreateInsertion(LHSBO->getRHS()->getBeginLoc(),
+                                    "( " + LHSLOpStr)
+      << FixItHint::CreateInsertion(RHSExpr->getEndLoc(), ")");
+}
+
+static void EmitDiagnosticForAmbiguousCompareOp(Sema &Self,
+                                                BinaryOperatorKind Opc,
+                                                SourceLocation OpLoc,
+                                                Expr *LHSExpr, Expr *RHSExpr) {
+  BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr);
+  BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr);
+
+  bool isLeftCompare = LHSBO && LHSBO->isComparisonOp();
+  bool isRightCompare = RHSBO && RHSBO->isComparisonOp();
+
+  SourceRange DiagRange = isLeftCompare
+                              ? SourceRange(LHSExpr->getBeginLoc(), OpLoc)
+                              : SourceRange(OpLoc, RHSExpr->getEndLoc());
+
+  StringRef OpStr =
+      isLeftCompare ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr();
+  SourceRange ParensRange =
+      isLeftCompare
+          ? SourceRange(LHSBO->getRHS()->getBeginLoc(), RHSExpr->getEndLoc())
+          : SourceRange(LHSExpr->getBeginLoc(), RHSBO->getLHS()->getEndLoc());
+
+  Self.Diag(OpLoc, diag::warn_compare_parentheses) << DiagRange << OpLoc;
+  // see line 13980 ... for reference
+  SuggestParentheses(Self, OpLoc,
+                     Self.PDiag(diag::note_compare_with_parens) << OpStr,
+                     DiagRange);
+
+  SuggestParentheses(Self, OpLoc,
+                     Self.PDiag(diag::note_compare_with_parens)
+                         << BinaryOperator::getOpcodeStr(Opc),
+                     DiagRange);
+}
+
 /// It accepts a '&&' expr that is inside a '||' one.
 /// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
 /// in parentheses.
 static void
 EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
                                        BinaryOperator *Bop) {
   assert(Bop->getOpcode() == BO_LAnd);
   Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)

 /// Returns true if the given expression can be evaluated as a constant
 /// 'false'.
 static bool EvaluatesAsFalse(Sema &S, Expr *E) {
   bool Res;
   return !E->isValueDependent() &&
          E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res;
 }
 
+// Finds ambiguous compares, loosely x<=y<=z, and emits diagnostics if found.
+static void DiagnoseAmbiguousComparison(Sema &S, BinaryOperatorKind Opc,
+                                        SourceLocation OpLoc, Expr *LHSExpr,
+                                        Expr *RHSExpr) {
+  BinaryOperator *LBop = dyn_cast<BinaryOperator>(LHSExpr);
+  BinaryOperator *RBop = dyn_cast<BinaryOperator>(RHSExpr);
+  bool isRelationOp =
+      (LBop && LBop->isRelationalOp()) || (RBop && RBop->isRelationalOp());
+  bool isCompareOp =
+      (LBop && LBop->isComparisonOp()) || (RBop && RBop->isComparisonOp());
+  if (isRelationOp && BinaryOperator::isRelationalOp(Opc)) {
+    return EmitDiagnosticForAmbiguousRelationOp(S, Opc, OpLoc, LHSExpr,
+                                                RHSExpr);
+  } else if (isCompareOp) {
+    return EmitDiagnosticForAmbiguousCompareOp(S, Opc, OpLoc, LHSExpr, RHSExpr);
+  }
+}
+
 /// Look for '&&' in the left hand of a '||' expr.
 static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc,
                                              Expr *LHSExpr, Expr *RHSExpr) {
   if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) {
     if (Bop->getOpcode() == BO_LAnd) {
       // If it's "a && b || 0" don't warn since the precedence doesn't matter.
       if (EvaluatesAsFalse(S, RHSExpr))
         return;
if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
       || Opc == BO_Shr) {
     StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
     DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
     DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
   }
 
   // Warn on overloaded shift operators and comparisons, such as:
   // cout << 5 == 4;
-  if (BinaryOperator::isComparisonOp(Opc))
+  if (BinaryOperator::isComparisonOp(Opc)) {
     DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr);
+    // Warn on ambiguous compares, loosely x<=y<=z
+    DiagnoseAmbiguousComparison(Self, Opc, OpLoc, LHSExpr, RHSExpr);
+  }
+
+  // Warn on ambiguous compares, loosely x<=y<=z
+  // if (BinaryOperator::isRelationalOp(Opc))
+  //  DiagnoseAmbiguousComparison(Self, Opc, OpLoc, LHSExpr, RHSExpr);
 }
 
 // Binary Operators.  'Tok' is the token for the operator.
 ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
                             tok::TokenKind Kind,
                             Expr *LHSExpr, Expr *RHSExpr) {
   BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
   assert(LHSExpr && "ActOnBinOp(): missing left expression");

clang/test/Misc/warning-wall.c

 CHECK-NEXT:    -Wobjc-designated-initializers
 CHECK-NEXT:    -Wobjc-flexible-array
 CHECK-NEXT:    -Woverloaded-virtual
 CHECK-NEXT:    -Wprivate-extern
 CHECK-NEXT:    -Wcast-of-sel-type
 CHECK-NEXT:    -Wextern-c-compat
 CHECK-NEXT:    -Wuser-defined-warnings
 CHECK-NEXT:  -Wparentheses
+CHECK-NEXT:    -Wcompare-op-parentheses
 CHECK-NEXT:    -Wlogical-op-parentheses
 CHECK-NEXT:    -Wlogical-not-parentheses
 CHECK-NEXT:    -Wbitwise-conditional-parentheses
 CHECK-NEXT:    -Wbitwise-op-parentheses
 CHECK-NEXT:    -Wshift-op-parentheses
 CHECK-NEXT:    -Woverloaded-shift-op-parentheses
 CHECK-NEXT:    -Wparentheses-equality
 CHECK-NEXT:    -Wdangling-else
 CHECK-NEXT:  -Wswitch
 CHECK-NEXT:  -Wswitch-bool
 CHECK-NEXT:  -Wmisleading-indentation
 
 
 CHECK-NOT:-W

clang/test/Sema/warn-compare-op-parentheses.c

+// RUN: %clang_cc1 -fsyntax-only -Wcompare-op-parentheses -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wparentheses -verify %s
+
+int tests(int p1, int p2, int p3, int p4, int p5, int p6) {
+  int b = 0;
+  b = p1 < p2 < p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 < p2 <= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 <= p2 <= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 <= p2 < p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 > p2 > p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 > p2 >= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 >= p2 >= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 >= p2 > p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 > p2 < p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1<p2> p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 > p2 <= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 < p2 >= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 >= p2 < p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 <= p2 > p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 >= p2 <= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 <= p2 >= p3;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 < p2 < p3 < p4;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  // expected-warning@-5 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-6 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-7 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-8 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = (p1 < p2) < p3 < p4;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 < (p2 < p3) < p4;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 < p2 < (p3 < p4);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = (p1 < p2 < p3) < p4;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = p1 < (p2 < p3 < p4);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = p1 < p2 <= p3 < p4;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  // expected-warning@-5 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-6 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-7 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-8 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = (p1 < p2) < p3;   // no warning
+  b = p1 < (p2 < p3);   // no warning
+  b = (p1 < p2) <= p3;  // no warning
+  b = p1 < (p2 <= p3);  // no warning
+  b = (p1 <= p2) <= p3; // no warning
+  b = p1 <= (p2 <= p3); // no warning
+  b = (p1 <= p2) < p3;  // no warning
+  b = p1 <= (p2 < p3);  // no warning
+  b = (p1 > p2) > p3;   // no warning
+  b = p1 > (p2 > p3);   // no warning
+  b = (p1 > p2) >= p3;  // no warning
+  b = p1 > (p2 >= p3);  // no warning
+  b = (p1 >= p2) >= p3; // no warning
+  b = p1 >= (p2 >= p3); // no warning
+  b = (p1 >= p2) > p3;  // no warning
+  b = p1 >= (p2 > p3);  // no warning
+  b = (p1 > p2) < p3;   // no warning
+  b = p1 > (p2 < p3);   // no warning
+  b = (p1 < p2) > p3;   // no warning
+  b = p1 < (p2 > p3);   // no warning
+  b = (p1 > p2) <= p3;  // no warning
+  b = p1 > (p2 <= p3);  // no warning
+  b = (p1 < p2) >= p3;  // no warning
+  b = p1 < (p2 >= p3);  // no warning
+  b = (p1 >= p2) < p3;  // no warning
+  b = p1 >= (p2 < p3);  // no warning
+  b = (p1 <= p2) > p3;  // no warning
+  b = p1 <= (p2 > p3);  // no warning
+  b = (p1 >= p2) <= p3; // no warning
+  b = p1 >= (p2 <= p3); // no warning
+  b = (p1 <= p2) >= p3; // no warning
+  b = p1 <= (p2 >= p3); // no warning
+
+  b = (p1 < p2) < (p3 < p4); // no warning
+  b = p1 < ((p2 < p3) < p4); // no warning
+  b = ((p1 < p2) < p3) < p4; // no warning
+
+  b = (p1 < p2) <= (p3 < p4); // no warning
+
+  b = (p1 < p2 < p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = ((p1 < p2) && (p2 < p3)); // no warning
+  b = ((p1 < p2) && (p2));      // no warning
+  b = ((p1) && (p3 < p2));      // no warning
+  b = (p1 < p2) < p3 < p1;
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = (p1 <= p2 < p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = (p1 < p2 <= p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+  b = (p1 <= p2 <= p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = (p1 > p2 < p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = (p1 > p2 > p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = (p1 >= p2 > p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = (p1 >= p2 >= p3);
+  // expected-warning@-1 {{comparisons like 'x<=y<=z' are interpreted as '(x<=y ? 1 : 0) <= z'}}
+  // expected-note@-2 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '>=' comparison to silence this warning}}
+  // expected-note@-4 {{separate the expression into two clauses to give it the intended mathematical meaning}}
+
+  b = (p1 >= p2 || p3); // no warning
+  b = (p1 && p3 < p2);  // no warning
+  b = ((p1 < p2) < p3); // no warning
+  b = (p1 < (p2 < p3)); // no warning
+
+  b = (0 <= (p1 < p2));
+  // expected-warning@-1 {{result of comparison of constant 0 with boolean expression is always true}}
+
+  // FIXME - These do not currently trigger any warnings
+  b = (p1 == p2 < p3); // maybe intentional, but definitely deserving of a warning
+  // expected-warning@-1 {{chained comparisons may need parentheses for clarity}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '==' comparison to silence this warning}}
+  b = (p1 == p2 == p3); // definitely buggy and deserving of a warning
+  // expected-warning@-1 {{chained comparisons may need parentheses for clarity}}
+  // expected-note@-2 {{place parentheses around the '==' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '==' comparison to silence this warning}}
+  b = (p1 != p2 != p3); // definitely buggy and deserving of a warning
+  // expected-warning@-1 {{chained comparisons may need parentheses for clarity}}
+  // expected-note@-2 {{place parentheses around the '!=' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '!=' comparison to silence this warning}}
+  b = (p1 < p2 == p3 < p4); // maybe intentional, but definitely deserving of a warning
+  // expected-warning@-1 {{chained comparisons may need parentheses for clarity}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '==' comparison to silence this warning}}
+  b = (p1 == p2 < p3 == p4); // definitely buggy and deserving of a warning
+  // expected-warning@-1 {{chained comparisons may need parentheses for clarity}}
+  // expected-note@-2 {{place parentheses around the '<' comparison to silence this warning}}
+  // expected-note@-3 {{place parentheses around the '==' comparison to silence this warning}}
+  // expected-warning@-4 {{chained comparisons may need parentheses for clarity}}
+  // expected-note@-5 {{place parentheses around the '==' comparison to silence this warning}}
+  // expected-note@-6 {{place parentheses around the '==' comparison to silence this warning}}
+
+  return b;
+}