No public description

BUILD

@@ -49,6 +49,7 @@ cc_library(
         "//implementation:global_string",
         "//implementation:id",
         "//implementation:id_type",
+        "//implementation:inheritance",
         "//implementation:jni_type",
         "//implementation:jvm",
         "//implementation:jvm_ref",

implementation/BUILD

@@ -438,6 +438,28 @@ cc_library(
     ],
 )
 
+################################################################################
+# Inheritance.
+################################################################################
+cc_library(
+    name = "inheritance",
+    hdrs = ["inheritance.h"],
+    deps = [
+        ":id_type",
+    ],
+)
+
+cc_test(
+    name = "inheritance_test",
+    srcs = ["inheritance_test.cc"],
+    deps = [
+        "//:jni_bind",
+        "//:jni_test",
+        "//testing/base/public:gunit_for_library",
+        "@googletest//:gtest_main",
+    ],
+)
+
 ################################################################################
 # LocalArray.
 ################################################################################
@@ -920,6 +942,7 @@ cc_library(
         ":id_type",
         ":jni_type",
         ":method_selection",
+        ":no_class_specified",
         ":no_idx",
         ":ref_base",
         "//:jni_dep",

implementation/inheritance.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JNI_BIND_IMPLEMENTATION_INHERITANCE_H_
+#define JNI_BIND_IMPLEMENTATION_INHERITANCE_H_
+
+// IWYU pragma: private, include "third_party/jni_wrapper/jni_bind.h"
+
+#include <type_traits>
+
+#include "implementation/id_type.h"
+
+namespace jni {
+
+struct Inheritance {
+  template <typename IdT, typename Enable = void>
+  struct Helper {
+    static_assert(false,
+                  "You must use an overload set or field for `Inheritance`.");
+  };
+
+  template <typename IdT>
+  struct Helper<IdT, std::enable_if_t<IdT::kIDType == IdType::OVERLOAD_SET>> {
+    using type = void;
+  };
+
+  template <typename IdT>
+  using type = typename Helper<IdT>::type;
+};
+
+}  // namespace jni
+
+#endif  // JNI_BIND_IMPLEMENTATION_INHERITANCE_H_

implementation/inheritance_test.cc

@@ -0,0 +1,24 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "jni_bind.h"
+#include "jni_test.h"
+
+namespace {
+
+using ::jni::test::JniTest;
+
+constexpr jni::Class c1{
+    "c1", jni::Method{"Foo", jni::Return<int>{}, jni::Params<int>{}}};
+
+constexpr jni::Class c2{
+    "c2", jni::Extends{c1},
+    jni::Method{"Bar", jni::Return<int>{}, jni::Params<int>{}}};
+
+TEST_F(JniTest, Inhertance_CallsSuper) {
+  // jni::LocalObject<c1> local_object{};
+  // jni::LocalObject<c2> local_object{};
+  // local_object("Bar", 123);
+  // local_object("Foo", 123);
+}
+
+}  // namespace

implementation/jni_type.h

@@ -55,6 +55,8 @@ struct JniT<SpanType_, class_v_, class_loader_v_, jvm_v_, kRank_, class_idx_,
   // `kDepthInAncestors` will recursively calculate depth, but always starts
   // with a base value of 1, which this -1 will counterbalance.
   static constexpr std::size_t kDepthInAncestors = -1;
+
+  static constexpr bool kIsRoot = true;
 };
 
 // Represents some JNI type, possibly as an index into a classloader, or
@@ -66,6 +68,8 @@ struct JniT<SpanType_, class_v_, class_loader_v_, jvm_v_, kRank_, class_idx_,
             class_loader_idx_,
             std::enable_if_t<!std::is_same_v<std::decay_t<decltype(class_v_)>,
                                              RootObject>>> {
+  static constexpr bool kIsRoot = false;
+
   static constexpr std::size_t kRank = kRank_;
   static_assert(kRank != -1);
 

implementation/jni_type_test.cc

@@ -159,12 +159,24 @@ using GrandparentJniT = JniT<jobject, kParent>;
 using ParentJniT = JniT<jobject, kChild>;
 using ChildJniT = JniT<jobject, kGrandchild>;
 
+static_assert(GrandparentJniT::ParentJniT::kIsRoot);
+static_assert(!GrandparentJniT::kIsRoot);
+static_assert(!ParentJniT::kIsRoot);
+static_assert(!ChildJniT::kIsRoot);
+
+static_assert(JniTEqual_v<ChildJniT, ChildJniT>);
+static_assert(JniTEqual_v<ParentJniT, ChildJniT::ParentJniT>);
+static_assert(JniTEqual_v<GrandparentJniT, ChildJniT::ParentJniT::ParentJniT>);
+
+// Why const differs on localstring?
 static_assert(
     std::is_same_v<decltype(GrandparentJniT::kParent), const jni::RootObject>);
 
+static_assert(!JniT<jstring, jni::kJavaLangString>::kIsRoot);
+static_assert(JniT<jstring, jni::kJavaLangString>::ParentJniT::kIsRoot);
+
 static_assert(
     std::is_same_v<std::decay_t<decltype(jni::kObject)>, jni::RootObject>);
-;
 
 static_assert(GrandparentJniT::kDepthInAncestors == 0);
 static_assert(ParentJniT::kDepthInAncestors == 1);

implementation/object_ref.h

@@ -30,6 +30,7 @@
 #include "implementation/jni_helper/lifecycle.h"
 #include "implementation/jni_type.h"
 #include "implementation/method_selection.h"
+#include "implementation/no_class_specified.h"
 #include "implementation/no_idx.h"
 #include "implementation/ref_base.h"
 #include "jni_dep.h"
@@ -39,6 +40,34 @@
 
 namespace jni {
 
+template <typename JniT>
+class ObjectRef;
+
+template <typename JniT_, typename ParentJniT, typename Enable = void>
+struct InheritanceProxy;
+
+// non root
+template <typename JniT_, typename ParentJniT>
+struct InheritanceProxy<JniT_, ParentJniT,
+                        std::enable_if_t<!ParentJniT::kIsRoot>> {
+  static_assert(std::is_same_v<typename JniT_::StorageType,
+                               typename ParentJniT::StorageType>);
+  using type = ObjectRef<ParentJniT>;
+  // using type = RootObject;
+};
+
+// root
+template <typename JniT_, typename ParentJniT>
+struct InheritanceProxy<JniT_, ParentJniT,
+                        std::enable_if_t<ParentJniT::kIsRoot>> {
+  static_assert(std::is_same_v<typename JniT_::StorageType,
+                               typename ParentJniT::StorageType>);
+  using type = RefBase<typename JniT_::StorageType>;
+};
+
+template <typename JniT>
+class ObjectRef;
+
 // Represents a runtime instance of a JNI Object.  Instead of using this class
 // directly, instead the more specialised types such as LocalObject,
 // GlobalObject, etc.
@@ -53,7 +82,13 @@ class ObjectRef
       public metaprogramming::QueryableMap_t<
           ObjectRef<JniT>, JniT::stripped_class_v, &JniT::ClassT::fields_>,
       public RefBase<typename JniT::StorageType> {
+  // public InheritanceProxy<JniT, typename JniT::ParentJniT>::type {
  protected:
+  static_assert(std::is_same_v<typename JniT::StorageType, jstring> ||
+                // std::is_same_v< typename JniT::ParentJniT::StorageType,
+                // jobject> std::is_same_v< void,  typename JniT::ParentJniT>
+                std::is_same_v<void, decltype(JniT::GetClass().parent_)>);
+
   static_assert(
       JniT::class_loader_v
           .template SupportedDirectlyOrIndirectly<JniT::class_v>(),

implementation/ref_base.h

@@ -59,7 +59,7 @@ class RefBase : public RefBaseBase {
 
   explicit operator StorageType() const { return object_ref_; }
 
- protected:
+  // protected:
   StorageType object_ref_ = nullptr;
 };
 

javatests/com/jnibind/test/global_object_test_jni.cc

@@ -22,8 +22,12 @@
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
+constexpr jni::Class kBase{
+    "kBase", jni::Method{"toString", jni::Return<jstring>{}, jni::Params{}}};
+
 constexpr jni::Class kGlobalObjectTestClass{
     "com/jnibind/test/GlobalObjectTest",
+    jni::Extends{kBase},
     jni::Method{"methodTakesGlobalObjectReturnsNewObject",
                 jni::Return{kObjectTestHelperClass},
                 jni::Params{kObjectTestHelperClass}},
@@ -63,9 +67,11 @@ Java_com_jnibind_test_GlobalObjectTest_jniBuildNewObjectsFromExistingObjects(
     JNIEnv* env, jclass, jobject test_helper_object, jobject object_to_mutate) {
   jni::LocalObject<kObjectTestHelperClass> helper_obj{object_to_mutate};
 
-  return jni::LocalObject<kGlobalObjectTestClass>{test_helper_object}(
-             "methodTakesGlobalObjectReturnsNewObject", helper_obj)
-      .Release();
+  auto a = jni::LocalObject<kGlobalObjectTestClass>{test_helper_object}(
+      "methodTakesGlobalObjectReturnsNewObject", helper_obj);
+  // a("toString");
+
+  return a.Release();
 }
 
 JNIEXPORT jobject JNICALL

jni_bind.h

@@ -63,6 +63,7 @@ static constexpr Configuration kConfig{
 #include "implementation/forward_declarations.h"
 #include "implementation/id.h"
 #include "implementation/id_type.h"
+#include "implementation/inheritance.h"
 #include "implementation/jni_type.h"
 #include "implementation/jvm.h"
 #include "implementation/loaded_by.h"