Index: test/SemaCXX/warn-logical-not-compare.cpp
===================================================================
--- test/SemaCXX/warn-logical-not-compare.cpp	(revision 0)
+++ test/SemaCXX/warn-logical-not-compare.cpp	(revision 0)
@@ -0,0 +1,69 @@
+// RUN: %clang_cc1 -fsyntax-only -Wlogical-not-compare -verify %s
+
+bool getBool();
+int getInt();
+
+bool test1(int i1, int i2, bool b1, bool b2) {
+  bool ret;
+
+  ret = !i1 == i2; // \
+// expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = !i1 != i2; // \
+//expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = !i1 < i2; // \
+//expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = !i1 > i2; // \
+//expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = !i1 <= i2; // \
+//expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = !i1 >= i2; // \
+//expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = i1 == i2;
+  ret = i1 != i2;
+  ret = i1 < i2;
+  ret = i1 > i2;
+  ret = i1 <= i2;
+  ret = i1 >= i2;
+
+  // Warning silenced by parens.
+  ret = (!i1) == i2;
+  ret = (!i1) != i2;
+  ret = (!i1) < i2;
+  ret = (!i1) > i2;
+  ret = (!i1) <= i2;
+  ret = (!i1) >= i2;
+
+  ret = !b1 == b2;
+  ret = !b1 != b2;
+  ret = !b1 < b2;
+  ret = !b1 > b2;
+  ret = !b1 <= b2;
+  ret = !b1 >= b2;
+
+  ret = !getInt() == i1; // \
+// expected-warning{{logical not is only applied to the left hand side of this comparison}} \
+// expected-note{{add parentheses after the '!' to evaluate the condition first}} \
+// expected-note{{add parentheses around left hand side expression to silence}}
+
+  ret = (!getInt()) == i1;
+  ret = !getBool() == b1;
+  return ret;
+}
Index: include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- include/clang/Basic/DiagnosticSemaKinds.td	(revision 165753)
+++ include/clang/Basic/DiagnosticSemaKinds.td	(working copy)
@@ -4117,6 +4117,13 @@
   "comparison between NULL and non-pointer "
   "%select{(%1 and NULL)|(NULL and %1)}0">,
   InGroup<DiagGroup<"null-arithmetic">>;
+def warn_logical_not_on_lhs_of_comparison : Warning<
+  "logical not is only applied to the left hand side of this comparison">,
+  InGroup<DiagGroup<"logical-not-compare">>;
+def note_logical_not_fix : Note<
+  "add parentheses after the '!' to evaluate the condition first">;
+def note_logical_not_silence_with_parens : Note<
+  "add parentheses around left hand side expression to silence">;
 
 def err_invalid_this_use : Error<
   "invalid use of 'this' outside of a non-static member function">;
Index: lib/Sema/SemaExpr.cpp
===================================================================
--- lib/Sema/SemaExpr.cpp	(revision 165753)
+++ lib/Sema/SemaExpr.cpp	(working copy)
@@ -6924,6 +6924,45 @@
   }
 }
 
+static void diagnoseLogicalNotOnLHSofComparison(Sema &S, ExprResult &LHS,
+                                                ExprResult &RHS,
+                                                SourceLocation Loc,
+                                                unsigned OpaqueOpc) {
+  // This checking requires bools.
+  if (!S.getLangOpts().Bool) return;
+
+  // Only check if the right hand side is non-bool arithmetic type.
+  if (RHS.get()->getType()->isBooleanType()) return;
+
+  // Check that left hand side is !something.
+  UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get());
+  if (!UO || UO->getOpcode() != UO_LNot) return;
+
+  // Make sure that the something in !something is not bool.
+  Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
+  if (SubExpr->getType()->isBooleanType()) return;
+
+  // Emit warning.
+  S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_comparison)
+      << Loc;
+
+  // First note suggest !(x < y)
+  SourceLocation FirstOpen = SubExpr->getLocStart();
+  SourceLocation FirstClose = RHS.get()->getSourceRange().getEnd();
+  FirstClose = S.getPreprocessor().getLocForEndOfToken(FirstClose);
+  S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
+      << FixItHint::CreateInsertion(FirstOpen, "(")
+      << FixItHint::CreateInsertion(FirstClose, ")");
+
+  // Second note suggests (!x) < y
+  SourceLocation SecondOpen = LHS.get()->getLocStart();
+  SourceLocation SecondClose = LHS.get()->getSourceRange().getEnd();
+  SecondClose = S.getPreprocessor().getLocForEndOfToken(SecondClose);
+  S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens)
+      << FixItHint::CreateInsertion(SecondOpen, "(")
+      << FixItHint::CreateInsertion(SecondClose, ")");
+}
+
 // C99 6.5.8, C++ [expr.rel]
 QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
                                     SourceLocation Loc, unsigned OpaqueOpc,
@@ -6944,6 +6983,7 @@
   Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts();
 
   checkEnumComparison(*this, Loc, LHS, RHS);
+  diagnoseLogicalNotOnLHSofComparison(*this, LHS, RHS, Loc, OpaqueOpc);
 
   if (!LHSType->hasFloatingRepresentation() &&
       !(LHSType->isBlockPointerType() && IsRelational) &&