Proxying now returns RefBase objects.

Author: jwhpryor

implementation/overload_ref.h

@@ -41,8 +41,31 @@
 #include "jni_dep.h"
 #include "metaprogramming/double_locked_value.h"
 #include "metaprogramming/string_concatenate.h"
+#include "implementation/id.h"
 
 namespace jni {
+namespace detail {
+template <typename T>
+auto ForwardWithRefStripImpl(T&& t, std::true_type /* is_ref_base */) {
+  using U = std::remove_reference_t<T>;
+  using CastT = RefBaseStorageT_t<U>;
+  return CastT(std::forward<T>(t)); // return by value, move or copy
+}
+
+template <typename T>
+decltype(auto) ForwardWithRefStripImpl(
+    T&& t, std::false_type /* not ref base */) {
+  return std::forward<T>(t); // perfect forward
+}
+} // namespace detail
+
+template <typename T>
+decltype(auto) ForwardWithRefStrip(T&& t) {
+  using U = std::remove_reference_t<T>;
+  return detail::ForwardWithRefStripImpl(
+      std::forward<T>(t),
+      std::is_base_of<RefBaseBase, U>{});
+}
 
 // Transforms a OverloadRef IdT into a fully qualified ID. Storage is keyed
 // against these IDs to reduce excess MethodID lookups.
@@ -56,7 +79,7 @@ struct OverloadRefUniqueId {
   // Dashes are solely for readability in debugging.
   static constexpr std::string_view TypeName() {
     return metaprogramming::StringConcatenate_v<
-        kClassQualifier, kDash, kOverloadName, kDash, Signature_v<IdT>>;
+      kClassQualifier, kDash, kOverloadName, kDash, Signature_v<IdT>>;
   }
 };
 
@@ -68,25 +91,25 @@ struct OverloadRef {
   using SelfIdT = typename IdT::template ChangeIdType<IdType::CLASS>;
 
   using ReturnProxied = std::conditional_t<
-      ReturnIdT::kIsSelf,
-      Return_t<typename SelfIdT::MaterializeCDeclT, SelfIdT>,
-      Return_t<typename ReturnIdT::MaterializeCDeclT, ReturnIdT>>;
+    ReturnIdT::kIsSelf,
+    Return_t<typename SelfIdT::MaterializeCDeclT, SelfIdT>,
+    Return_t<typename ReturnIdT::MaterializeCDeclT, ReturnIdT>>;
 
   static jmethodID GetMethodID(jclass clazz) {
     static auto get_lambda =
         [clazz](metaprogramming::DoubleLockedValue<jmethodID>* storage) {
-          if (kConfiguration.release_method_ids_on_teardown_) {
-            DefaultRefs<jmethodID>().push_back(storage);
-          }
-
-          if constexpr (IdT::kIsStatic) {
-            return jni::JniHelper::GetStaticMethodID(clazz, IdT::Name(),
-                                                     Signature_v<IdT>.data());
-          } else {
-            return jni::JniHelper::GetMethodID(clazz, IdT::Name(),
-                                               Signature_v<IdT>.data());
-          }
-        };
+      if (kConfiguration.release_method_ids_on_teardown_) {
+        DefaultRefs<jmethodID>().push_back(storage);
+      }
+
+      if constexpr (IdT::kIsStatic) {
+        return jni::JniHelper::GetStaticMethodID(clazz, IdT::Name(),
+                                                 Signature_v<IdT>.data());
+      } else {
+        return jni::JniHelper::GetMethodID(clazz, IdT::Name(),
+                                           Signature_v<IdT>.data());
+      }
+    };
 
     return RefStorage<decltype(get_lambda), OverloadRefUniqueId<IdT>>::Get(
         get_lambda);
@@ -102,30 +125,36 @@ struct OverloadRef {
     if constexpr (std::is_same_v<ReturnProxied, void>) {
       return InvokeHelper<void, kRank, kStatic>::Invoke(
           object, clazz, mthd,
-          Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...);
+          ForwardWithRefStrip(Proxy_t<Params>::ProxyAsArg(
+              std::forward<Params>(params)))...);
     } else if constexpr (IdT::kIsConstructor) {
       return ReturnProxied{
           AdoptLocal{},
           LifecycleHelper<jobject, LifecycleType::LOCAL>::Construct(
               clazz, mthd,
-              Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...)};
+              ForwardWithRefStrip(
+                  Proxy_t<Params>::ProxyAsArg(
+                      std::forward<Params>(params)))...)};
     } else {
       if constexpr (std::is_base_of_v<RefBaseBase, ReturnProxied>) {
         return ReturnProxied{
             AdoptLocal{},
             InvokeHelper<typename ReturnIdT::CDecl, kRank, kStatic>::Invoke(
                 object, clazz, mthd,
-                Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...)};
+                ForwardWithRefStrip(
+                    Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params)))
+                ...)};
       } else {
         return static_cast<ReturnProxied>(
-            InvokeHelper<typename ReturnIdT::CDecl, kRank, kStatic>::Invoke(
-                object, clazz, mthd,
-                Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...));
+          InvokeHelper<typename ReturnIdT::CDecl, kRank, kStatic>::Invoke(
+              object, clazz, mthd,
+              ForwardWithRefStrip(
+                  Proxy_t<Params>::ProxyAsArg(
+                      std::forward<Params>(params)))...));
       }
     }
   }
 };
+} // namespace jni
 
-}  // namespace jni
-
-#endif  // JNI_BIND_OVERLOAD_REF_H
+#endif  // JNI_BIND_OVERLOAD_REF_H

implementation/proxy_definitions_string.h

@@ -37,7 +37,6 @@
 #include "jni_dep.h"
 
 namespace jni {
-
 template <typename JString>
 struct Proxy<JString,
              typename std::enable_if_t<std::is_same_v<JString, jstring>>>
@@ -72,18 +71,20 @@ struct Proxy<JString,
   // correctly release local instances, but here we are stripping that so it can
   // be used in a method.  This could be obviated by wrapping the calling scope
   // in a local stack frame.
-  static jstring ProxyAsArg(jstring s) { return s; }
+  static RefBase<jstring> ProxyAsArg(jstring s) {
+    return {s};
+  }
 
   template <typename T,
             typename = std::enable_if_t<std::is_same_v<T, const char*> ||
                                         std::is_same_v<T, std::string> ||
                                         std::is_same_v<T, std::string_view>>>
-  static jstring ProxyAsArg(T s) {
+  static RefBase<jstring> ProxyAsArg(T s) {
     if constexpr (std::is_same_v<T, const char*>) {
-      return LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(s);
+      return {LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(s)};
     } else {
-      return LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(
-          s.data());
+      return {LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(
+          s.data())};
     }
   }
 
@@ -101,7 +102,6 @@ struct Proxy<JString,
     return t.Release();
   }
 };
-
-}  // namespace jni
+} // namespace jni
 
 #endif  // JNI_BIND_IMPLEMENTATION_PROXY_DEFINITIONS_STRING_H_

implementation/ref_base.h

@@ -30,13 +30,15 @@ struct RefBaseBase {};
 // Used to detect RefBase in type proxying.
 // This is useful, e.g. when you want to say "an object that might be passed"
 // but the object's type (i.e. full name + loader information) is unknown.
-template <typename StorageType>
+template <typename StorageType_>
 class RefBase : public RefBaseBase {
  public:
   template <typename Base, LifecycleType lifecycleType, typename JniT,
             typename ViableSpan>
   friend struct EntryBase;
 
+  using StorageType = StorageType_;
+
   RefBase(StorageType object) : object_ref_(object) {}
 
   RefBase(const RefBase& rhs) = delete;
@@ -67,6 +69,9 @@ class RefBase : public RefBaseBase {
 template <typename T>
 using RefBaseT_t = typename T::RefBaseT;
 
+template <typename T>
+using RefBaseStorageT_t = typename T::StorageType;
+
 }  // namespace jni
 
 #endif  // JNI_BIND_REF_BASE_H_