[Sema] Warn about unused variables if we can constant evaluate the initializer.

[bkramer]

Summary

If the variable construction can be constant evaluated it doesn't have
side effects, so removing it is always safe. We only try to evaluate
variables that are unused, there should be no impact on compile time.

[rsmith]

Cunning, I like it :)

[chapuni]

Excuse me, I have reverted it in rL315806. check-libcxx dislikes it.

See also; http://bb9.pgr.jp/#/builders/20/builds/111

[sylvestre.ledru]

For the record, this found 5 actual useless variables in Firefox code.

lib/Sema/SemaDecl.cpp

if (const TagType *TT = Ty->getAs<TagType>()) {
         if (const Expr *Init = VD->getInit()) {
           if (const ExprWithCleanups *Cleanups =
                   dyn_cast<ExprWithCleanups>(Init))
             Init = Cleanups->getSubExpr();
           const CXXConstructExpr *Construct =
             dyn_cast<CXXConstructExpr>(Init);
           if (Construct && !Construct->isElidable()) {
             CXXConstructorDecl *CD = Construct->getConstructor();
-            if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>())
+            if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
+                !VD->evaluateValue())
               return false;
           }
         }
       }
     }
 
     // TODO: __attribute__((unused)) templates?
   }

test/SemaCXX/warn-unused-variables.cpp

 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify -std=c++11 %s
 template<typename T> void f() {
   T t;
   t = 17;
 }
 
 // PR5407
 struct A { A(); };
 struct B { ~B(); };

 }
 
 void test() {
   foo(10);
   bar<2>();
 }
 
 }
+
+#if __cplusplus >= 201103L
+namespace with_constexpr {
+template <typename T>
+struct Literal {
+  T i;
+  Literal() = default;
+  constexpr Literal(T i) : i(i) {}
+};
+
+struct NoLiteral {
+  int i;
+  NoLiteral() = default;
+  constexpr NoLiteral(int i) : i(i) {}
+  ~NoLiteral() {}
+};
+
+static Literal<int> gl1;          // expected-warning {{unused variable 'gl1'}}
+static Literal<int> gl2(1);       // expected-warning {{unused variable 'gl2'}}
+static const Literal<int> gl3(0); // expected-warning {{unused variable 'gl3'}}
+
+template <typename T>
+void test(int i) {
+  Literal<int> l1;     // expected-warning {{unused variable 'l1'}}
+  Literal<int> l2(42); // expected-warning {{unused variable 'l2'}}
+  Literal<int> l3(i);  // no-warning
+  Literal<T> l4(0);    // no-warning
+  NoLiteral nl1;       // no-warning
+  NoLiteral nl2(42);   // no-warning
+}
+}
+#endif