Teardown proxied args lifetimes

.clang-format

@@ -0,0 +1,12 @@
+BasedOnStyle: Google
+IndentWidth: 2
+ColumnLimit: 80
+AllowShortFunctionsOnASingleLine: Empty
+DerivePointerAlignment: false
+PointerAlignment: Left
+BreakBeforeBraces: Attach
+AllowShortIfStatementsOnASingleLine: false
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+Cpp11BracedListStyle: true
+Standard: Latest

.gitignore

@@ -1,5 +1,9 @@
 bazel*
-.vscode
+.vscode/
+.clwb/
+.ijwb/
+.idea/
+.vscode/
 MODULE.bazel.lock
 cmake_build
-cmake_install
+cmake_install

implementation/BUILD

@@ -294,6 +294,7 @@ cc_library(
     name = "field_ref",
     hdrs = ["field_ref.h"],
     deps = [
+        ":proxy_temporary",
         ":default_class_loader",
         ":field_selection",
         ":id",
@@ -788,6 +789,7 @@ cc_library(
     name = "method_ref",
     hdrs = ["overload_ref.h"],
     deps = [
+        ":proxy_temporary",
         ":configuration",
         ":id_type",
         ":promotion_mechanics_tags",
@@ -1052,6 +1054,7 @@ cc_library(
     name = "proxy_definitions_string",
     hdrs = ["proxy_definitions_string.h"],
     deps = [
+        ":proxy_temporary",
         ":default_class_loader",
         ":forward_declarations",
         ":jvm",
@@ -1076,6 +1079,14 @@ cc_test(
     ],
 )
 
+################################################################################
+# ProxyTemporary.
+################################################################################
+cc_library(
+    name = "proxy_temporary",
+    hdrs = ["proxy_temporary.h"],
+)
+
 ################################################################################
 # RefBase.
 ################################################################################

implementation/field_ref.h

@@ -22,8 +22,10 @@
 #include <cstddef>
 #include <type_traits>
 #include <utility>
+#include <utility>
 #include <vector>
 
+#include "implementation/proxy_temporary.h"
 #include "implementation/default_class_loader.h"
 #include "implementation/field_selection.h"
 #include "implementation/id.h"
@@ -113,10 +115,13 @@ class FieldRef {
 
   template <typename T>
   void Set(T&& value) {
+    fprintf(stderr, "pre field set\n");
     FieldHelper<CDecl_t<typename IdT::RawValT>, IdT::kRank,
                 IdT::kIsStatic>::SetValue(SelfVal(), GetFieldID(class_ref_),
-                                          Proxy_t<T>::ProxyAsArg(
-                                              std::forward<T>(value)));
+                                          ForwardWithRefStrip(
+                                              Proxy_t<T>::ProxyAsArg(
+                                                  std::forward<T>(value))));
+    fprintf(stderr, "post field set\n");
   }
 
  private:

implementation/jni_helper/field_value.h

@@ -53,7 +53,7 @@ struct FieldHelper<jboolean, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jboolean&& value) {
+                              const jfieldID field_ref_, jboolean value) {
     Trace(metaprogramming::LambdaToStr(STR("GetBooleanValue")), object_ref,
           field_ref_);
 
@@ -79,7 +79,7 @@ struct FieldHelper<jbyte, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jbyte&& value) {
+                              const jfieldID field_ref_, jbyte value) {
     Trace(metaprogramming::LambdaToStr(STR("SetByteValue")), object_ref,
           field_ref_);
 
@@ -105,7 +105,7 @@ struct FieldHelper<jchar, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jchar&& value) {
+                              const jfieldID field_ref_, jchar value) {
     Trace(metaprogramming::LambdaToStr(STR("SetCharValue")), object_ref,
           field_ref_);
 
@@ -131,7 +131,7 @@ struct FieldHelper<jshort, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jshort&& value) {
+                              const jfieldID field_ref_, jshort value) {
     Trace(metaprogramming::LambdaToStr(STR("SetShortValue")), object_ref,
           field_ref_);
 
@@ -157,7 +157,7 @@ struct FieldHelper<jint, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jint&& value) {
+                              const jfieldID field_ref_, jint value) {
     Trace(metaprogramming::LambdaToStr(STR("SetIntValue")), object_ref,
           field_ref_);
 
@@ -183,7 +183,7 @@ struct FieldHelper<jlong, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jlong&& value) {
+                              const jfieldID field_ref_, jlong value) {
     Trace(metaprogramming::LambdaToStr(STR("SetLongField")), object_ref,
           field_ref_);
 
@@ -209,7 +209,7 @@ struct FieldHelper<jfloat, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jfloat&& value) {
+                              const jfieldID field_ref_, jfloat value) {
     Trace(metaprogramming::LambdaToStr(STR("SetFloatField")), object_ref,
           field_ref_);
 
@@ -235,7 +235,7 @@ struct FieldHelper<jdouble, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jdouble&& value) {
+                              const jfieldID field_ref_, jdouble value) {
     Trace(metaprogramming::LambdaToStr(STR("SetDoubleField")), object_ref,
           field_ref_);
 
@@ -261,7 +261,7 @@ struct FieldHelper<jobject, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jobject&& new_value) {
+                              const jfieldID field_ref_, jobject new_value) {
     Trace(metaprogramming::LambdaToStr(STR("SetObjectField")), object_ref,
           field_ref_);
 
@@ -288,7 +288,7 @@ struct FieldHelper<jstring, 0, false, void> {
   }
 
   static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jstring&& new_value) {
+                              const jfieldID field_ref_, jstring new_value) {
     Trace(metaprogramming::LambdaToStr(STR("SetObjectField")), object_ref,
           field_ref_);
 

implementation/overload_ref.h

@@ -41,9 +41,9 @@
 #include "jni_dep.h"
 #include "metaprogramming/double_locked_value.h"
 #include "metaprogramming/string_concatenate.h"
+#include "implementation/id.h"
 
 namespace jni {
-
 // Transforms a OverloadRef IdT into a fully qualified ID. Storage is keyed
 // against these IDs to reduce excess MethodID lookups.
 template <typename IdT>
@@ -56,7 +56,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 +68,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 (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 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);
@@ -100,32 +100,42 @@ struct OverloadRef {
     const jmethodID mthd = OverloadRef::GetMethodID(clazz);
 
     if constexpr (std::is_same_v<ReturnProxied, void>) {
-      return InvokeHelper<void, kRank, kStatic>::Invoke(
+      fprintf(stderr, "pre invoke void \n");
+      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) {
+      fprintf(stderr, "pre constructor invoke\n");
       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 {
+      fprintf(stderr, "pre non-constructor invoke\n");
       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))...)};
+        return 
+        InvokeHelper<typename ReturnIdT::CDecl, kRank, kStatic>::Invoke(
+            object, clazz, mthd,
+            ForwardWithRefStrip(
+                Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params)))
+            ...);
+        //fprintf(stderr, "post invoke");
       } else {
+        fprintf(stderr, "pre non-refbase invoke\n");
         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

implementation/proxy_definitions_string.h

@@ -32,12 +32,12 @@
 #include "implementation/jni_helper/lifecycle_string.h"
 #include "implementation/jvm.h"
 #include "implementation/proxy.h"
+#include "implementation/proxy_temporary.h"
 #include "implementation/proxy_convenience_aliases.h"
 #include "implementation/ref_base.h"
 #include "jni_dep.h"
 
 namespace jni {
-
 template <typename JString>
 struct Proxy<JString,
              typename std::enable_if_t<std::is_same_v<JString, jstring>>>
@@ -68,22 +68,39 @@ struct Proxy<JString,
       IsConvertibleKey<T>::template value<std::string_view> ||
       std::is_same_v<T, LocalString> || std::is_same_v<T, GlobalString>;
 
+  static constexpr auto DeleteLambda = [](const jstring& s) {
+    JniEnv::GetEnv()->DeleteLocalRef(static_cast<jobject>(s));
+  };
+
+  struct DeleteLocalRef {
+    static void Call(const jstring& s) {
+      JniEnv::GetEnv()->DeleteLocalRef(static_cast<jobject>(s));
+    }
+  };
+
   // These leak local instances of strings.  Usually, RAII mechanisms would
   // 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 ProxyTemporary<jstring, DeleteLocalRef> ProxyAsArg(jstring s) {
+  static jstring ProxyAsArg(jstring s) {
+    //LocalObject<kJavaLangString, kDefaultClassLoader, kDefaultJvm> obj{"afsd"};
+
+    //return {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 jstring ProxyAsArg(T s) {
+ static ProxyTemporary<jstring, DeleteLocalRef> 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 +118,6 @@ struct Proxy<JString,
     return t.Release();
   }
 };
-
-}  // namespace jni
+} // namespace jni
 
 #endif  // JNI_BIND_IMPLEMENTATION_PROXY_DEFINITIONS_STRING_H_