Use reflect_invoke metafunction to invoke a member function

clang/include/clang/Basic/DiagnosticMetafnKinds.td

@@ -59,6 +59,15 @@ def metafn_returns_non_structural_type : Note<
   "represented as a reflection">;
 def metafn_invocation_not_constant_expr : Note<
   "invocation is not a constant expression">;
+def metafn_first_argument_is_not_object : Note<
+  "expected related object reflection as a first argument for invoking "
+  "non-static member function">;
+def metafn_function_is_not_member_of_object : Note<
+   "method is not a member of "
+   "given object reflection">;
+def metafn_function_returns_void : Note<
+   "cannot invoke reflection of void function">;
+
 
 // Extraction.
 def metafn_cannot_extract : Note<

clang/lib/Sema/Metafunctions.cpp

@@ -4420,6 +4420,25 @@ bool reflect_result(APValue &Result, Sema &S, EvalFn Evaluator,
   return SetAndSucceed(Result, APValue(RV));
 }
 
+bool is_nonstatic_member_function(ValueDecl *FD) {
+  if (!FD) {
+    return false;
+  }
+
+  if (dyn_cast<CXXConstructorDecl>(FD)) {
+    return false;
+  }
+
+  // todo: check that method is not special??
+
+  auto *MD = dyn_cast<CXXMethodDecl>(FD);
+  if (!MD) {
+    return false;
+  }
+
+  return !MD->isStatic();
+}
+
 bool reflect_invoke(APValue &Result, Sema &S, EvalFn Evaluator,
                     DiagFn Diagnoser, QualType ResultTy, SourceRange Range,
                     ArrayRef<Expr *> Args) {
@@ -4572,10 +4591,18 @@ bool reflect_invoke(APValue &Result, Sema &S, EvalFn Evaluator,
     {
       sema::TemplateDeductionInfo Info(Args[0]->getExprLoc(),
                                        FTD->getTemplateDepth());
+
+      bool exclude_first_arg =
+          is_nonstatic_member_function(FTD->getTemplatedDecl()) &&
+          ArgExprs.size() > 0;
+
       TemplateDeductionResult Result = S.DeduceTemplateArguments(
-            FTD, &ExplicitTAListInfo, ArgExprs, Specialization, Info, false,
-            true, QualType(), Expr::Classification(),
-            [](ArrayRef<QualType>) { return false; });
+          FTD, &ExplicitTAListInfo,
+          exclude_first_arg
+              ? SmallVector<Expr *, 4>(ArgExprs.begin() + 1, ArgExprs.end())
+              : ArgExprs,
+          Specialization, Info, false, true, QualType(), Expr::Classification(),
+          [](ArrayRef<QualType>) { return false; });
       if (Result != TemplateDeductionResult::Success)
         return Diagnoser(Range.getBegin(), diag::metafn_no_specialization_found)
             << FTD << Range;
@@ -4595,20 +4622,83 @@ bool reflect_invoke(APValue &Result, Sema &S, EvalFn Evaluator,
   ExprResult ER;
   {
     EnterExpressionEvaluationContext Context(
-            S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-    if (auto *DRE = dyn_cast<DeclRefExpr>(FnRefExpr);
-        DRE && dyn_cast<CXXConstructorDecl>(DRE->getDecl())) {
-      auto *CtorD = cast<CXXConstructorDecl>(DRE->getDecl());
+        S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
+    auto *DRE = dyn_cast<DeclRefExpr>(FnRefExpr);
+    if (DRE && dyn_cast<CXXConstructorDecl>(DRE->getDecl())) {
+      auto *CtorD = cast<CXXConstructorDecl>(DRE->getDecl());
       ER = S.BuildCXXConstructExpr(
-            Range.getBegin(), QualType(CtorD->getParent()->getTypeForDecl(), 0),
-            CtorD, false, ArgExprs, false, false, false, false,
-            CXXConstructionKind::Complete, Range);
+          Range.getBegin(), QualType(CtorD->getParent()->getTypeForDecl(), 0),
+          CtorD, false, ArgExprs, false, false, false, false,
+          CXXConstructionKind::Complete, Range);
     } else {
-      ER = S.ActOnCallExpr(S.getCurScope(), FnRefExpr, Range.getBegin(),
-                           ArgExprs, Range.getEnd(), /*ExecConfig=*/nullptr);
+      auto *FnExpr = FnRefExpr;
+      auto FnArgExprs = ArgExprs;
+
+      if (DRE && is_nonstatic_member_function(DRE->getDecl())) {
+        auto *MD = cast<CXXMethodDecl>(DRE->getDecl());
+
+        if (ArgExprs.size() < 1) {
+          // need to have object as a first argument
+          return Diagnoser(Range.getBegin(),
+                           diag::metafn_first_argument_is_not_object)
+                 << Range;
+        }
+
+        auto ObjExpr = ArgExprs[0];
+        auto ObjType = ObjExpr->getType();
+
+        if (ObjType->isPointerType()) {
+          ObjType = ObjType->getPointeeType();
+        }
+
+        if (!ObjType->getAsCXXRecordDecl()) {
+          // first argument is not an object
+          return Diagnoser(Range.getBegin(),
+                           diag::metafn_first_argument_is_not_object)
+                 << Range;
+        }
+
+        // check that method belongs to class
+        if (ObjType->getAsCXXRecordDecl()->getDeclName() !=
+            MD->getParent()->getDeclName()) {
+          return Diagnoser(Range.getBegin(),
+                           diag::metafn_function_is_not_member_of_object)
+                 << Range;
+        }
+
+        if (MD->getReturnType()->isVoidType()) {
+          // void return type is not supported
+          return Diagnoser(Range.getBegin(), diag::metafn_function_returns_void)
+                 << Range;
+        }
+
+        SourceLocation ObjLoc = ObjExpr->getExprLoc();
+        UnqualifiedId Name;
+        Name.setIdentifier(MD->getIdentifier(), ObjLoc);
+
+        CXXScopeSpec SS;
+        SourceLocation TemplateKWLoc;
+
+        ExprResult MemberAccessResult = S.ActOnMemberAccessExpr(
+            S.getCurScope(), S.MakeFullExpr(ObjExpr).get(), ObjLoc,
+            ObjExpr->getType()->isPointerType() ? tok::arrow : tok::period, SS,
+            TemplateKWLoc, Name, nullptr);
+
+        if (MemberAccessResult.isInvalid()) {
+          return true;
+        }
+
+        FnExpr = MemberAccessResult.get();
+        // exclude first argument because it's an object
+        FnArgExprs = {ArgExprs.begin() + 1, ArgExprs.end()};
+      }
+
+      ER = S.ActOnCallExpr(S.getCurScope(), FnExpr, Range.getBegin(),
+                           FnArgExprs, Range.getEnd(), /*ExecConfig=*/nullptr);
     }
   }
+
   if (ER.isInvalid())
     return Diagnoser(Range.getBegin(), diag::metafn_invalid_call_expr) << Range;
   Expr *ResultExpr = ER.get();

libcxx/test/std/experimental/reflection/reflect-invoke.pass.cpp

@@ -62,8 +62,6 @@ static_assert([:reflect_invoke(^Cls::fn, {std::meta::reflect_value(4)}):] == 16)
 // With reflection of constexpr variable as an argument.
 static constexpr int five = 5;
 static_assert([:reflect_invoke(^fn1, {^five}):] == 47);
-
-// TODO(P2996): Support nonstatic member functions.
 }  // namespace basic_functions
 
                               // =================
@@ -241,4 +239,44 @@ static_assert(
                          std::views::transform(std::meta::reflect_value<int>)));
 }  // namespace with_non_contiguous_ranges
 
+namespace non_static_member_functions {
+
+class Number {
+public:
+  constexpr Number(int v) : value(v) {}
+
+  consteval int plus(int a) const { return plus_impl(a); }
+
+  consteval int get_value() const { return value; }
+
+  template <typename T>
+  consteval T multiply(T x) const {
+    return value * x;
+  }
+
+private:
+  consteval int plus_impl(int a) const {
+    return value + a;
+  }
+
+  const int value;
+};
+
+constexpr Number num{42};
+constexpr auto num_ref = &num;
+
+static_assert(std::meta::reflect_value(84) ==
+              reflect_invoke(^Number::plus,
+                             {^num, std::meta::reflect_value(42)}));
+static_assert(std::meta::reflect_value(42) ==
+              reflect_invoke(^Number::get_value, {^num}));
+
+static_assert(std::meta::reflect_value(42) ==
+              reflect_invoke(^Number::get_value, {^num_ref}));
+
+static_assert(std::meta::reflect_value(84) ==
+              reflect_invoke(^Number::multiply, {^int},
+                             {^num, std::meta::reflect_value(2)}));
+} // namespace non_static_member_functions
+
 int main() { }