[Sema] Fix decltype of static data members

[miyuki]

Summary

According to the C++11 standard [dcl.type.simple]p4:

The type denoted by decltype(e) is defined as follows:
- if e is an unparenthesized id-expression or an unparenthesized
  class member access (5.2.5), decltype(e) is the type of the entity
  named by e.

Currently Clang handles the 'member access' case incorrectly for
static data members (decltype returns T& instead of T). This patch
fixes the issue.

[rogfer01]

This LGTM. Thanks for fixing this.

Wait a couple of days before committing in case there are other comments.

lib/Sema/SemaType.cpp

static QualType getDecltypeForExpr(Sema &S, Expr *E) {
   //       by e. If there is no such entity, or if e names a set of overloaded
   //       functions, the program is ill-formed;
   //
   // We apply the same rules for Objective-C ivar and property references.
   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
     if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl()))
       return VD->getType();
   } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
-    if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
-      return FD->getType();
+    if (const ValueDecl *VD = ME->getMemberDecl())
+      if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
+        return VD->getType();
   } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) {
     return IR->getDecl()->getType();
   } else if (const ObjCPropertyRefExpr *PR = dyn_cast<ObjCPropertyRefExpr>(E)) {
     if (PR->isExplicitProperty())
       return PR->getExplicitProperty()->getType();
   } else if (auto *PE = dyn_cast<PredefinedExpr>(E)) {
     return PE->getType();
   }

test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.simple/p4-cxx0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
 template<typename T, typename U>
 struct is_same {
   static const bool value = false;
 };
 
 template<typename T>
 struct is_same<T, T> {
   static const bool value = true;
 };
 
 const int&& foo();
 int i;
-struct A { double x; };
+struct A {
+  double x;
+  static int y;
+};
 const A* a = new A();
 
 static_assert(is_same<decltype(foo()), const int&&>::value, "");
 static_assert(is_same<decltype(i), int>::value, "");
 static_assert(is_same<decltype(a->x), double>::value, "");
 static_assert(is_same<decltype((a->x)), const double&>::value, "");
+static_assert(is_same<decltype(a->y), int>::value, "");
+static_assert(is_same<decltype((a->y)), int&>::value, "");
 static_assert(is_same<decltype(static_cast<int&&>(i)), int&&>::value, "");
 
 int f0(int); // expected-note{{possible target}}
 float f0(float); // expected-note{{possible target}}
 
 decltype(f0) f0_a; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}