[clang] Fix constant evaluation about static member function

[yaxunl]

Summary

Currently, clang does not allow static constexpr member
functions called through a reference of an object
in constant expression, e.g. the following code

class static_multimap{
    public:
        static constexpr int size() noexcept{
            return 8;
        }
};

template <typename Map>
void test_non_shmem_pair_retrieve(Map& map){
    auto constexpr cg_size = map.size();
}

int main(){
    static_multimap map;
    test_non_shmem_pair_retrieve(map);
    return 0;
}

fails to compile with clang. (https://godbolt.org/z/T17vTWYcs)

This does not make sense since the evaluation of map.size
does not rely on map. The same code compiles with GCC.

[yaxunl]

ping

[tra]

@rsmith Richard, PTAL. This needs your language lawyering expertise.

[rsmith]

Clang was correct here until fairly recently; P2280 (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2280r4.html) changed the language rules. It was applied as a DR, so we should make that change retroactively rather than only in C++23 mode. See https://github.com/llvm/llvm-project/issues/63139, which tracks implementation of that language change.

I don't think we should be applying an ad-hoc patch like this which doesn't follow either the old or the new language rule, and should instead implement the new rule from P2280.

clang/lib/AST/ExprConstant.cpp

public:
 
   /// Visit a value which is evaluated, but whose value is ignored.
   void VisitIgnoredValue(const Expr *E) {
     EvaluateIgnoredValue(Info, E);
   }
 
   /// Potentially visit a MemberExpr's base expression.
   void VisitIgnoredBaseExpression(const Expr *E) {
+    // If E is a reference, and if so, there is no side effect.
+    if (const DeclRefExpr *DRE =
+            dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
+      if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
+        if (VD->getType()->isReferenceType()) {
+          return;
+        }
+      }
+    }
     // While MSVC doesn't evaluate the base expression, it does diagnose the
     // presence of side-effecting behavior.
     if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
       return;
     VisitIgnoredValue(E);
   }
 };
 

clang/test/SemaCXX/constant-expression-cxx11.cpp

 
 namespace array_size {
   template<int N> struct array {
     static constexpr int size() { return N; }
   };
   template<typename T> void f1(T t) {
     constexpr int k = t.size();
   }
-  template<typename T> void f2(const T &t) { // expected-note 2{{declared here}}
-    constexpr int k = t.size(); // expected-error 2{{constant}} expected-note 2{{function parameter 't' with unknown value cannot be used in a constant expression}}
+  template<typename T> void f2a(const T &t) {
+    constexpr int k1 = t.size();
+    constexpr int k2 = (t).size();
+  }
+  template<typename T> void f2b(const T &t) { // expected-note {{declared here}}
+    constexpr int k = t.size(); // expected-error {{constant}} expected-note {{function parameter 't' with unknown value cannot be used in a constant expression}}
   }
   template<typename T> void f3(const T &t) {
     constexpr int k = T::size();
   }
   void g(array<3> a) {
     f1(a);
-    f2(a); // expected-note {{instantiation of}}
+    f2a(a);
     f3(a);
   }
 
   template<int N> struct array_nonstatic {
     constexpr int size() const { return N; }
   };
   void h(array_nonstatic<3> a) {
     f1(a);
-    f2(a); // expected-note {{instantiation of}}
+    f2b(a); // expected-note {{instantiation of}}
   }
 }
 
 namespace flexible_array {
   struct A { int x; char arr[]; }; // expected-warning {{C99}} expected-note {{here}}
   constexpr A a = {1};
   static_assert(a.x == 1, "");
   static_assert(&a.arr != nullptr, "");