Fix incorrect -Wtautological-constant-out-of-range warnings with enums

[ibadawi]

Summary

This is a proposed fix for bug 16154 (https://llvm.org/bugs/show_bug.cgi?id=16154) -- it was tentatively fixed in r183084 but had the fix was backed out in r183575 because the approach taken wrongly affected the behavior or other warnings.

[ibadawi]

Remove extra blank line added by accident

[ibadawi]

Restore the test lost in patch #2. Really sorry for the noise...

[ibadawi]

Abandoning for now -- might submit another patch later according to new discussion on https://llvm.org/bugs/show_bug.cgi?id=16154

lib/Sema/SemaChecking.cpp

static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) {
     }
 
     const BuiltinType *BT = cast<BuiltinType>(T);
     assert(BT->isInteger());
 
     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
   }
 
+  /// Returns the "target" range of a given integral type.
+  static IntRange forTargetOfType(ASTContext &C, QualType T) {
+    return forTargetOfCanonicalType(C,
+                                    T->getCanonicalTypeInternal().getTypePtr());
+  }
+
   /// Returns the "target" range of a canonical integral type, i.e.
   /// the range of values expressible in the type.
   ///
   /// This matches forValueOfCanonicalType except that enums have the
   /// full range of their type, not the range of their enumerators.
   static IntRange forTargetOfCanonicalType(ASTContext &C, const Type *T) {
     assert(T->isCanonicalUnqualified());
 
void DiagnoseOutOfRangeComparison(Sema &S, BinaryOperator *E, Expr *Constant,
   if (!S.ActiveTemplateInstantiations.empty())
     return;
 
   // TODO: Investigate using GetExprRange() to get tighter bounds
   // on the bit ranges.
   QualType OtherT = Other->getType();
   if (const auto *AT = OtherT->getAs<AtomicType>())
     OtherT = AT->getValueType();
-  IntRange OtherRange = IntRange::forValueOfType(S.Context, OtherT);
+  IntRange OtherRange = S.getLangOpts().CPlusPlus
+                            ? IntRange::forValueOfType(S.Context, OtherT)
+                            : IntRange::forTargetOfType(S.Context, OtherT);
   unsigned OtherWidth = OtherRange.Width;
 
   bool OtherIsBooleanType = Other->isKnownToHaveBooleanValue();
 
   // 0 values are handled later by CheckTrivialUnsignedComparison().
   if ((Value == 0) && (!OtherIsBooleanType))
     return;
 

test/Sema/outof-range-constant-compare.c

int main()
     };
     enum E e;
 
     if (e == 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'enum E' is always false}}
       return 0;
 
     return 1;
 }
+
+typedef enum {
+  alpha = 0,
+  bravo,
+  charlie,
+  delta,
+  echo
+} named_t;
+
+static int bar(named_t foo) {
+  return foo > 42;
+}