diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d2c0b759..abb213ce 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,12 +10,13 @@ permissions:
   contents: read
 
 jobs:
+  # These jobs are legacy but needed for CopyBara to pass tests.
   ubuntu-latest-cpp17:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
     - name: test
-      run: bazel query --output=label 'kind("...", //...) except attr("tags", "cpp20", "//...")' | xargs bazel test --cxxopt='-Werror' --cxxopt='-std=c++17' --repo_env=CC=clang --test_output=errors 
+      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++17' --repo_env=CC=clang --test_output=errors //implementation/legacy/...
 
   ubuntu-latest-cpp20:
     runs-on: ubuntu-latest
@@ -29,7 +30,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: test
-      run: bazel query --output=label 'kind("...", //...) except attr(tags, "cpp20", //...)' | xargs bazel test --cxxopt='-Werror' --cxxopt='-std=c++17' --repo_env=CC=clang --test_output=errors 
+      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++17' --repo_env=CC=clang --test_output=errors //implementation/legacy/...
 
   macos-latest-cpp20:
     runs-on: macos-latest
@@ -37,3 +38,41 @@ jobs:
     - uses: actions/checkout@v4
     - name: test
       run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++20' --repo_env=CC=clang --test_output=errors ...
+
+  # These are the new jobs that will be migrated to.
+  ubuntu-latest-cpp17-clang:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: test
+      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++17' --repo_env=CC=clang --test_output=errors //implementation/legacy/...
+
+  ubuntu-latest-cpp20-clang:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: test
+      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++20' --repo_env=CC=clang --test_output=errors ...
+
+  # Commented out because for some reason Github's action runner seems to be
+  # forcing C++14 which I can't reproduce locally.
+  #  ubuntu-latest-cpp20-gcc:
+  #    runs-on: ubuntu-latest
+  #    steps:
+  #    - uses: actions/checkout@v4
+  #    - name: test
+  #      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++20' --repo_env=CC=gcc --test_output=errors ... -- -//implementation/legacy/...
+
+  macos-latest-cpp17-clang:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: test
+      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++17' --repo_env=CC=clang --test_output=errors //implementation/legacy/...
+
+  macos-latest-cpp20-clang:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: test
+      run: bazel test --cxxopt='-Werror' --cxxopt='-std=c++20' --repo_env=CC=clang --test_output=errors ...
diff --git a/BUILD b/BUILD
index 7949e520..f3d79daf 100644
--- a/BUILD
+++ b/BUILD
@@ -82,6 +82,7 @@ cc_library(
         "//implementation/jni_helper:static_field_value",
         "//metaprogramming:corpus",
         "//metaprogramming:corpus_tag",
+        "//metaprogramming:string_literal",
     ],
 )
 
diff --git a/implementation/BUILD b/implementation/BUILD
index 32f82380..096ae00a 100644
--- a/implementation/BUILD
+++ b/implementation/BUILD
@@ -41,21 +41,15 @@ cc_library(
     name = "array_ref",
     hdrs = ["array_ref.h"],
     deps = [
-        ":array",
         ":array_view",
-        ":class",
         ":class_ref",
-        ":default_class_loader",
         ":forward_declarations",
-        ":jni_type",
         ":local_object",
-        ":object_ref",
+        ":no_idx",
         ":promotion_mechanics_tags",
-        ":ref_base",
         "//:jni_dep",
         "//implementation/jni_helper:jni_array_helper",
         "//implementation/jni_helper:lifecycle",
-        "//implementation/jni_helper:lifecycle_object",
     ],
 )
 
@@ -186,14 +180,17 @@ cc_library(
     hdrs = ["class_loader_ref.h"],
     deps = [
         ":class_loader",
+        ":class_ref",
         ":default_class_loader",
         ":global_object",
         ":id",
         ":id_type",
         ":jni_type",
+        ":jvm",
         ":local_object",
         ":no_idx",
         ":promotion_mechanics",
+        ":promotion_mechanics_tags",
         "//:jni_dep",
         "//class_defs:java_lang_classes",
         "//implementation/jni_helper:jni_env",
diff --git a/implementation/array_ref.h b/implementation/array_ref.h
index 168b6a26..17563e43 100644
--- a/implementation/array_ref.h
+++ b/implementation/array_ref.h
@@ -19,7 +19,9 @@
 
 // IWYU pragma: private, include "third_party/jni_wrapper/jni_bind.h"
 
+#include <atomic>
 #include <cstddef>
+#include <type_traits>
 
 #include "implementation/array_view.h"
 #include "implementation/class_ref.h"
@@ -27,6 +29,7 @@
 #include "implementation/jni_helper/jni_array_helper.h"
 #include "implementation/jni_helper/lifecycle.h"
 #include "implementation/local_object.h"
+#include "implementation/no_idx.h"
 #include "implementation/promotion_mechanics_tags.h"
 #include "jni_dep.h"
 
@@ -50,10 +53,6 @@ class ArrayRef : public ScopedArrayImpl<JniT> {
       : Base(AdoptLocal{},
              JniArrayHelper<SpanType, JniT::kRank>::NewArray(size)) {}
 
-  template <typename T>
-  ArrayRef(const ArrayViewHelper<T>& array_view_helper)
-      : Base(AdoptLocal{}, array_view_helper.val) {}
-
   explicit ArrayRef(int size) : ArrayRef(static_cast<std::size_t>(size)) {}
 
   ArrayView<SpanType, JniT::kRank> Pin(bool copy_on_completion = true) {
@@ -133,9 +132,9 @@ class ArrayRef<
   // e.g.
   //  LocalArray arr { 5, LocalObject<kClass> {args...} };
   //  LocalArray arr { 5, GlobalObject<kClass> {args...} };
-  template <template <const auto&, const auto&, const auto&>
-            class ObjectContainer,
-            const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
+  template <
+      template <const auto&, const auto&, const auto&> class ObjectContainer,
+      const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
   ArrayRef(std::size_t size,
            const ObjectContainer<class_v, class_loader_v, jvm_v>& obj)
       : ArrayRef(size, static_cast<jobject>(obj)) {}
diff --git a/implementation/array_view.h b/implementation/array_view.h
index 4e7a0df0..8609c9be 100644
--- a/implementation/array_view.h
+++ b/implementation/array_view.h
@@ -121,6 +121,22 @@ class ArrayView {
   const std::size_t size_;
 };
 
+// Metafunction that returns the type after a single dereference.
+template <typename SpanType, std::size_t>
+struct PinHelper {
+  using type = jobjectArray;
+};
+
+template <typename SpanType>
+struct PinHelper<SpanType, 2> {
+  using type = RegularToArrayTypeMap_t<SpanType>;
+};
+
+template <typename SpanType>
+struct PinHelper<SpanType, 1> {
+  using type = jobject;
+};
+
 // Object arrays, or arrays with rank > 1 (which are object arrays), or strings.
 template <typename SpanType_, std::size_t kRank>
 class ArrayView<
@@ -130,21 +146,7 @@ class ArrayView<
  public:
   using SpanType = SpanType_;
 
-  // Metafunction that returns the type after a single dereference.
-  template <std::size_t>
-  struct PinHelper {
-    using type = jobjectArray;
-  };
-  template <>
-  struct PinHelper<2> {
-    using type = RegularToArrayTypeMap_t<SpanType>;
-  };
-  template <>
-  struct PinHelper<1> {
-    using type = jobject;
-  };
-
-  using PinHelper_t = typename PinHelper<kRank>::type;
+  using PinHelper_t = typename PinHelper<SpanType_, kRank>::type;
 
   struct Iterator {
     using iterator_category = std::random_access_iterator_tag;
diff --git a/implementation/array_view_test.cc b/implementation/array_view_test.cc
index 66496d2f..2403b8fc 100644
--- a/implementation/array_view_test.cc
+++ b/implementation/array_view_test.cc
@@ -318,7 +318,7 @@ TEST_F(JniTest, ArrayView_RichObjectsAreIterable) {
   int fake_result = 123;
   for (LocalObject<kClass> obj : obj_view) {
     EXPECT_CALL(*env_, CallIntMethodV).WillOnce(::testing::Return(fake_result));
-    EXPECT_EQ(obj("Foo"), fake_result);
+    EXPECT_EQ(obj.Call<"Foo">(), fake_result);
     fake_result++;
   }
 }
diff --git a/implementation/class_loader_ref.h b/implementation/class_loader_ref.h
index 7bc295bd..3a2ce23d 100644
--- a/implementation/class_loader_ref.h
+++ b/implementation/class_loader_ref.h
@@ -21,6 +21,7 @@
 
 #include "class_defs/java_lang_classes.h"
 #include "implementation/class_loader.h"
+#include "implementation/class_ref.h"
 #include "implementation/default_class_loader.h"
 #include "implementation/global_object.h"
 #include "implementation/id.h"
@@ -29,9 +30,11 @@
 #include "implementation/jni_helper/lifecycle.h"
 #include "implementation/jni_helper/lifecycle_object.h"
 #include "implementation/jni_type.h"
+#include "implementation/jvm.h"
 #include "implementation/local_object.h"
 #include "implementation/no_idx.h"
 #include "implementation/promotion_mechanics.h"
+#include "implementation/promotion_mechanics_tags.h"
 #include "jni_dep.h"
 
 namespace jni {
@@ -73,10 +76,19 @@ class ClassLoaderRef : public ClassLoaderImpl<lifecycleType> {
                   kDefaultClassLoader) {
       ClassRef_t<JniT<jobject, class_v, class_loader_v_, jvm_v_,
                       0>>::PrimeJClassFromClassLoader([&]() {
-        // Prevent the object (which is a runtime instance of a class) from
-        // falling out of scope so it is not released.
+      // Prevent the object (which is a runtime instance of a class) from
+      // falling out of scope so it is not released.
+
+#if __cplusplus >= 202002L
+        LocalObject loaded_class =
+            (*this).template Call<"loadClass">(IdClassT::kNameUsingDots);
+#elif __clang__
         LocalObject loaded_class =
             (*this)("loadClass", IdClassT::kNameUsingDots);
+#else
+        static_assert(
+            false, "JNI Bind requires C++20 (or later) or C++17 with clang.");
+#endif
 
         // We only want to create global references if we are actually going
         // to use them so that they do not leak.
diff --git a/implementation/class_loader_ref_second_test.cc b/implementation/class_loader_ref_second_test.cc
index 50424733..de27b6dc 100644
--- a/implementation/class_loader_ref_second_test.cc
+++ b/implementation/class_loader_ref_second_test.cc
@@ -91,7 +91,7 @@ TEST_F(JniTestWithNoDefaultJvmRef,
   auto second_custom_loader_object =
       class_loader.BuildLocalObject<kClass>(jint{2});
 
-  EXPECT_EQ(custom_loader_object("methodNoCrossTalk", jint{2}), 123);
+  EXPECT_EQ(custom_loader_object.Call<"methodNoCrossTalk">(jint{2}), 123);
 
   TearDown();
 }
diff --git a/implementation/class_loader_ref_test.cc b/implementation/class_loader_ref_test.cc
index 66388550..c743b2fb 100644
--- a/implementation/class_loader_ref_test.cc
+++ b/implementation/class_loader_ref_test.cc
@@ -118,7 +118,7 @@ TEST_F(JniTest, LocalObject_SupportsPassingAnObjectWithAClassLoader) {
   // LocalObject<kClass2, kClassLoader> a{}; // doesn't compile (good).
   LocalObject<kClass1, kClassLoader> a{Fake<jobject>()};
   LocalObject<kClass2> b{};
-  b("Foo", a);
+  b.Call<"Foo">(a);
 
   default_globals_made_that_should_be_released_.clear();
 }
@@ -130,7 +130,7 @@ TEST_F(JniTestForClassLoaders,
   LocalClassLoader<kClassLoader> local_class_loader{Fake<jobject>()};
   auto a = local_class_loader.BuildLocalObject<kClass1>();
   LocalObject<kClass2> b{a};
-  b("Foo", a);
+  b.Call<"Foo">(a);
 
   default_globals_made_that_should_be_released_.clear();
   TearDown();
@@ -143,7 +143,7 @@ TEST_F(JniTestForClassLoaders,
   LocalClassLoader<kClassLoader> local_class_loader{Fake<jobject>()};
   auto a = local_class_loader.BuildGlobalObject<kClass1>();
   LocalObject<kClass2> b{a};
-  b("Foo", a);
+  b.Call<"Foo">(a);
 
   default_globals_made_that_should_be_released_.clear();
   TearDown();
@@ -160,7 +160,7 @@ TEST_F(JniTestForClassLoaders,
   LocalObject<kClass1, kClassLoader> a =
       local_class_loader.BuildLocalObject<kClass1>();
   LocalObject<kClass2> b{a};
-  b("Foo", a);
+  b.Call<"Foo">(a);
 
   TearDown();
 }
@@ -172,7 +172,7 @@ TEST_F(JniTestForClassLoaders, ClassLoaderRefTest_ConstructsFromRValue) {
   LocalObject<kClass1, kClassLoader, kJvm> b{
       local_class_loader.BuildLocalObject<kClass1>()};
 
-  LocalObject<kClass2, kClassLoader, kJvm> c{b("Foo")};
+  LocalObject<kClass2, kClassLoader, kJvm> c{b.Call<"Foo">()};
 
   TearDown();
 }
@@ -186,7 +186,7 @@ TEST_F(JniTestForClassLoaders,
   LocalObject<kClass1> a{};
   LocalObject<kClass2, kClassLoader, kJvm> b =
       local_class_loader.BuildLocalObject<kClass2>(a);
-  b("Foo", a);
+  b.Call<"Foo">(a);
 
   TearDown();
 }
@@ -235,7 +235,7 @@ TEST_F(JniTestWithNoDefaultJvmRef,
   LocalObject<kClass1, kClassLoader, kJvm> a =
       local_class_loader.BuildLocalObject<kClass1>();
   LocalObject<kClass2> b{};
-  b("Foo", a);
+  b.Call<"Foo">(a);
 
   TearDown();
 }
@@ -309,7 +309,7 @@ TEST_F(JniTestWithNoDefaultJvmRef,
                                                kDefaultConfiguration};
   jni::LocalObject<class_under_test, class_loader, atypical_jvm_definition>
       obj1{AdoptLocal{}, Fake<jobject>(1)};
-  obj1("Foo");
+  obj1.Call<"Foo">();
 
   this->TearDown();
 }
diff --git a/implementation/field_ref_test.cc b/implementation/field_ref_test.cc
index 1aa5244a..2ae6be6f 100644
--- a/implementation/field_ref_test.cc
+++ b/implementation/field_ref_test.cc
@@ -59,8 +59,8 @@ TEST_F(JniTest, Field_SimpleGetAndSet) {
                                                Field("SomeField", jint{})};
 
   GlobalObject<java_class_under_test> obj{};
-  EXPECT_EQ(999, obj["SomeField"].Get());
-  obj["SomeField"].Set(123);
+  EXPECT_EQ(999, obj.Access<"SomeField">().Get());
+  obj.Access<"SomeField">().Set(123);
 }
 
 TEST_F(JniTest, Field_BooleanField) {
@@ -68,8 +68,8 @@ TEST_F(JniTest, Field_BooleanField) {
   EXPECT_CALL(*env_, SetBooleanField);
 
   LocalObject<java_class_under_test> obj{};
-  obj["booleanField"].Get();
-  obj["booleanField"].Set(true);
+  obj.Access<"booleanField">().Get();
+  obj.Access<"booleanField">().Set(true);
 }
 
 TEST_F(JniTest, Field_ByteField) {
@@ -77,8 +77,8 @@ TEST_F(JniTest, Field_ByteField) {
   EXPECT_CALL(*env_, SetByteField);
 
   LocalObject<java_class_under_test> obj{};
-  obj["byteField"].Get();
-  obj["byteField"].Set(jbyte{123});
+  obj.Access<"byteField">().Get();
+  obj.Access<"byteField">().Set(jbyte{123});
 }
 
 TEST_F(JniTest, Field_CharField) {
@@ -86,8 +86,8 @@ TEST_F(JniTest, Field_CharField) {
   EXPECT_CALL(*env_, SetCharField);
 
   LocalObject<java_class_under_test> obj{};
-  obj["charField"].Get();
-  obj["charField"].Set(jchar{'a'});
+  obj.Access<"charField">().Get();
+  obj.Access<"charField">().Set(jchar{'a'});
 }
 
 TEST_F(JniTest, Field_ShortField) {
@@ -95,8 +95,8 @@ TEST_F(JniTest, Field_ShortField) {
   EXPECT_CALL(*env_, SetShortField);
 
   LocalObject<java_class_under_test> obj{};
-  obj["shortField"].Get();
-  obj["shortField"].Set(jshort{123});
+  obj.Access<"shortField">().Get();
+  obj.Access<"shortField">().Set(jshort{123});
 }
 
 TEST_F(JniTest, Field_intField) {
@@ -104,8 +104,8 @@ TEST_F(JniTest, Field_intField) {
   EXPECT_CALL(*env_, SetIntField);
 
   LocalObject<java_class_under_test> obj{};
-  obj["intField"].Get();
-  obj["intField"].Set(123);
+  obj.Access<"intField">().Get();
+  obj.Access<"intField">().Set(123);
 }
 
 TEST_F(JniTest, Field_longField) {
@@ -113,24 +113,24 @@ TEST_F(JniTest, Field_longField) {
   EXPECT_CALL(*env_, SetLongField);
 
   LocalObject<java_class_under_test> obj{};
-  obj["longField"].Get();
-  obj["longField"].Set(123);
+  obj.Access<"longField">().Get();
+  obj.Access<"longField">().Set(123);
 }
 
 TEST_F(JniTest, Field_floatField) {
   LocalObject<java_class_under_test> obj{};
   EXPECT_CALL(*env_, GetFloatField);
   EXPECT_CALL(*env_, SetFloatField);
-  obj["floatField"].Get();
-  obj["floatField"].Set(123.f);
+  obj.Access<"floatField">().Get();
+  obj.Access<"floatField">().Set(123.f);
 }
 
 TEST_F(JniTest, Field_doubleField) {
   LocalObject<java_class_under_test> obj{};
   EXPECT_CALL(*env_, GetDoubleField);
   EXPECT_CALL(*env_, SetDoubleField);
-  obj["doubleField"].Get();
-  obj["doubleField"].Set(123.);
+  obj.Access<"doubleField">().Get();
+  obj.Access<"doubleField">().Set(123.);
 }
 
 TEST_F(JniTest, Field_ObjectGet) {
@@ -144,7 +144,7 @@ TEST_F(JniTest, Field_ObjectGet) {
   static constexpr Class kClass2{"kClass2"};
 
   LocalObject<kClass> obj{};
-  LocalObject<kClass2> obj2 = obj["classField"].Get();
+  LocalObject<kClass2> obj2 = obj.Access<"classField">().Get();
 }
 
 TEST_F(JniTest, Field_ObjectSet) {
@@ -161,10 +161,11 @@ TEST_F(JniTest, Field_ObjectSet) {
 
   LocalObject<kClass> obj{};
   LocalObject<kClass2> some_obj{AdoptLocal{}, Fake<jobject>()};
-  obj["classField"].Set(Fake<jobject>());
-  obj["classField"].Set(LocalObject<kClass2>{AdoptLocal{}, Fake<jobject>()});
-  obj["classField"].Set(some_obj);
-  obj["classField"].Set(std::move(some_obj));
+  obj.Access<"classField">().Set(Fake<jobject>());
+  obj.Access<"classField">().Set(
+      LocalObject<kClass2>{AdoptLocal{}, Fake<jobject>()});
+  obj.Access<"classField">().Set(some_obj);
+  obj.Access<"classField">().Set(std::move(some_obj));
 }
 
 }  // namespace
diff --git a/implementation/find_class_fallback.h b/implementation/find_class_fallback.h
index ca68bf24..6125a248 100644
--- a/implementation/find_class_fallback.h
+++ b/implementation/find_class_fallback.h
@@ -39,7 +39,15 @@ inline jclass FindClassFallback(const char* class_name) {
   GlobalClassLoader<kDefaultClassLoader> loader{AdoptGlobal{},
                                                 FallbackLoader()};
 
+#if __cplusplus >= 202002L
+  jni::LocalObject loaded_class = loader.Call<"loadClass">(class_name);
+#elif __clang__
   jni::LocalObject loaded_class = loader("loadClass", class_name);
+#else
+  static_assert(false,
+                "JNI Bind requires C++20 (or later) or C++17 with clang.");
+#endif
+
   jclass ret{static_cast<jclass>(static_cast<jobject>(loaded_class.Release()))};
 
   loader.Release();
diff --git a/implementation/global_object_test.cc b/implementation/global_object_test.cc
index 3d5af1df..5ce2829f 100644
--- a/implementation/global_object_test.cc
+++ b/implementation/global_object_test.cc
@@ -200,15 +200,15 @@ TEST_F(JniTest, GlobalObject_ValuesWorkAfterMoveConstructor) {
       Method{"Foo", jni::Return<jint>{}, Params<jint>{}},
       Field{"BarField", jint{}}};
   GlobalObject<kClass> global_object_1{AdoptGlobal{}, Fake<jobject>(1)};
-  global_object_1("Foo", 1);
-  global_object_1("Foo", 2);
-  global_object_1["BarField"].Set(1);
+  global_object_1.Call<"Foo">(1);
+  global_object_1.Call<"Foo">(2);
+  global_object_1.Access<"BarField">().Set(1);
 
   GlobalObject<kClass> global_object_2{std::move(global_object_1)};
-  global_object_2("Foo", 3);
-  global_object_2["BarField"].Set(2);
-  global_object_2["BarField"].Set(3);
-  global_object_2["BarField"].Set(4);
+  global_object_2.Call<"Foo">(3);
+  global_object_2.Access<"BarField">().Set(2);
+  global_object_2.Access<"BarField">().Set(3);
+  global_object_2.Access<"BarField">().Set(4);
 
   GlobalObject<kClass> global_object_3{AdoptGlobal{}, Fake<jobject>(1)};
 }
@@ -245,10 +245,10 @@ TEST_F(JniTest, GlobalObject_ObjectReturnsInstanceMethods) {
              Params<jint, jfloat, jint, jfloat, jdouble>{}}};
 
   GlobalObject<java_class_under_test> global_object{};
-  global_object("Foo", 1);
-  global_object("Baz", 2.f);
-  global_object(
-      "AMethodWithAReallyLongNameThatWouldPossiblyBeHardForTemplatesToHandle",
+  global_object.Call<"Foo">(1);
+  global_object.Call<"Baz">(2.f);
+  global_object.Call<
+      "AMethodWithAReallyLongNameThatWouldPossiblyBeHardForTemplatesToHandle">(
       int{}, float{}, int{}, float{}, double{});
 }
 
@@ -268,7 +268,7 @@ TEST_F(JniTest, GlobalObject_SupportsPassingAPrvalue) {
 
   GlobalObject<kTestClass1> a{};
   GlobalObject<kTestClass2> b{};
-  b("Foo", std::move(a));
+  b.Call<"Foo">(std::move(a));
 }
 
 TEST_F(JniTest, GlobalObjects_PromoteRValuesFromEmittedLValues) {
@@ -277,9 +277,9 @@ TEST_F(JniTest, GlobalObjects_PromoteRValuesFromEmittedLValues) {
       "TestClass2", Method{"Foo", jni::Return{kClass1}, jni::Params{}}};
 
   LocalObject<kClass2> b{};
-  GlobalObject<kClass1> a{b("Foo")};
+  GlobalObject<kClass1> a{b.Call<"Foo">()};
 
-  a = b("Foo");
+  a = b.Call<"Foo">();
 }
 
 }  // namespace
diff --git a/implementation/id.h b/implementation/id.h
index 22d8b8cd..d1688551 100644
--- a/implementation/id.h
+++ b/implementation/id.h
@@ -36,10 +36,10 @@ template <typename JniT_, IdType kIdType_, std::size_t idx,
           std::size_t secondary_idx, std::size_t tertiary_idx,
           std::size_t ancestry_idx>
 struct Id {
-  using JniT = JniT_;
+  using _JniT = JniT_;
   static constexpr IdType kIdType = kIdType_;
 
-  static constexpr auto Class() { return JniT::GetClass(); }
+  static constexpr auto Class() { return _JniT::GetClass(); }
 
   static constexpr std::size_t kIdx = idx;
   static constexpr std::size_t kSecondaryIdx = secondary_idx;
@@ -58,10 +58,10 @@ struct Id {
 
   template <IdType new_id_type>
   using ChangeIdType =
-      Id<JniT, new_id_type, idx, secondary_idx, tertiary_idx, ancestry_idx>;
+      Id<_JniT, new_id_type, idx, secondary_idx, tertiary_idx, ancestry_idx>;
 
   template <std::size_t kIdxToChange, std::size_t kNewValue>
-  using ChangeIdx = Id<JniT, kIdType, (kIdxToChange == 0 ? kNewValue : idx),
+  using ChangeIdx = Id<_JniT, kIdType, (kIdxToChange == 0 ? kNewValue : idx),
                        (kIdxToChange == 1 ? kNewValue : secondary_idx),
                        (kIdxToChange == 2 ? kNewValue : tertiary_idx),
                        (kIdxToChange == 3 ? kNewValue : ancestry_idx)>;
@@ -148,7 +148,7 @@ struct Id {
     }
   }
 
-  using ParentIdT = Id<typename JniT::ParentJniT, kIdType_, idx, secondary_idx,
+  using ParentIdT = Id<typename _JniT::ParentJniT, kIdType_, idx, secondary_idx,
                        tertiary_idx, ancestry_idx - 1>;
 
   static constexpr auto Val() {
@@ -199,7 +199,7 @@ struct Id {
     } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
       return Val().name_;
     } else if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
-      return Id<JniT, IdType::STATIC_OVERLOAD_SET, idx, secondary_idx,
+      return Id<_JniT, IdType::STATIC_OVERLOAD_SET, idx, secondary_idx,
                 tertiary_idx, ancestry_idx>::Name();
     } else if constexpr (kIdType == IdType::STATIC_FIELD) {
       return std::get<idx>(Class().static_.fields_).name_;
@@ -208,7 +208,7 @@ struct Id {
     } else if constexpr (kIdType == IdType::OVERLOAD_SET) {
       return Val().name_;
     } else if constexpr (kIdType == IdType::OVERLOAD) {
-      return Id<JniT, IdType::OVERLOAD_SET, idx, secondary_idx, tertiary_idx,
+      return Id<_JniT, IdType::OVERLOAD_SET, idx, secondary_idx, tertiary_idx,
                 ancestry_idx>::Name();
     } else if constexpr (kIdType == IdType::FIELD) {
       return std::get<idx>(Class().fields_).name_;
diff --git a/implementation/jvm_ref.h b/implementation/jvm_ref.h
index a924983e..7e30cd4b 100644
--- a/implementation/jvm_ref.h
+++ b/implementation/jvm_ref.h
@@ -163,8 +163,17 @@ class JvmRef : public JvmRefBase {
   // Sets a "fallback" loader for use when default Jvm classes fail to load.
   // `host_object *must* be local and will *not* be released.
   void SetFallbackClassLoaderFromJObject(jobject host_object) {
+#if __cplusplus >= 202002L
+    SetFallbackClassLoader(LocalObject<kJavaLangObject>{host_object}
+                               .Call<"getClass">()
+                               .Call<"getClassLoader">());
+#elif __clang__
     SetFallbackClassLoader(LocalObject<kJavaLangObject>{host_object}(
         "getClass")("getClassLoader"));
+#else
+    static_assert(false,
+                  "JNI Bind requires C++20 (or later) or C++17 with clang.");
+#endif
   }
 
  private:
diff --git a/implementation/jvm_test.cc b/implementation/jvm_test.cc
index 66008e7e..9c44aee3 100644
--- a/implementation/jvm_test.cc
+++ b/implementation/jvm_test.cc
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <cstddef>
+
 #include <gtest/gtest.h>
 #include "jni_bind.h"
 
@@ -39,16 +41,19 @@ TEST(Jni, JvmStaticClassLoaderLookupsWork) {
                                              SupportedClassSet{}};
 
   static constexpr Jvm kJvm1{kClassLoader1};
-  static_assert(kJvm1.IdxOfClassLoader<kUnusedLoader>() == -1);
+  static_assert(kJvm1.IdxOfClassLoader<kUnusedLoader>() ==
+                static_cast<size_t>(-1));
   static_assert(kJvm1.IdxOfClassLoader<kClassLoader1>() == 0);
 
   static constexpr Jvm kJvm2{kClassLoader1, kClassLoader2};
-  static_assert(kJvm2.IdxOfClassLoader<kUnusedLoader>() == -1);
+  static_assert(kJvm2.IdxOfClassLoader<kUnusedLoader>() ==
+                static_cast<size_t>(-1));
   static_assert(kJvm2.IdxOfClassLoader<kClassLoader1>() == 0);
   static_assert(kJvm2.IdxOfClassLoader<kClassLoader2>() == 1);
 
   static constexpr Jvm kJvm3{kClassLoader1, kClassLoader2, kClassLoader3};
-  static_assert(kJvm3.IdxOfClassLoader<kUnusedLoader>() == -1);
+  static_assert(kJvm3.IdxOfClassLoader<kUnusedLoader>() ==
+                static_cast<size_t>(-1));
   static_assert(kJvm3.IdxOfClassLoader<kClassLoader1>() == 0);
   static_assert(kJvm3.IdxOfClassLoader<kClassLoader2>() == 1);
   static_assert(kJvm3.IdxOfClassLoader<kClassLoader3>() == 2);
diff --git a/implementation/local_array.h b/implementation/local_array.h
index 5a291bfa..b6355d29 100644
--- a/implementation/local_array.h
+++ b/implementation/local_array.h
@@ -56,7 +56,7 @@ class LocalArray
   using RawValT = std::conditional_t<std::is_same_v<jobject, SpanType>,
                                      std::decay_t<decltype(kClass)>, SpanType>;
 
-  using JniT_ = JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>;
+  using _JniT = JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>;
 
   using Base =
       ArrayRef<JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>>;
@@ -68,7 +68,7 @@ class LocalArray
   LocalArray(std::size_t size, RefTag arr)
       : Base(AdoptLocal{}, JniArrayHelper<jobject, kRank_>::NewArray(
                                size,
-                               ClassRef_t<JniT_>::GetAndMaybeLoadClassRef(
+                               ClassRef_t<_JniT>::GetAndMaybeLoadClassRef(
                                    static_cast<jobject>(arr)),
                                arr)) {}
 
@@ -103,7 +103,7 @@ class LocalArray
       const ObjectContainer<class_v, class_loader_v, jvm_v>& local_object)
       : Base(JniArrayHelper<jobject, kRank_>::NewArray(
             size,
-            ClassRef_t<JniT_>::GetAndMaybeLoadClassRef(
+            ClassRef_t<_JniT>::GetAndMaybeLoadClassRef(
                 static_cast<jobject>(local_object)),
             static_cast<jobject>(local_object))) {}
 
diff --git a/implementation/local_array_field_multidimensional_test.cc b/implementation/local_array_field_multidimensional_test.cc
index b4a977ed..f9668afa 100644
--- a/implementation/local_array_field_multidimensional_test.cc
+++ b/implementation/local_array_field_multidimensional_test.cc
@@ -72,23 +72,23 @@ TEST_F(JniTest, LocalArrayField_Rank2) {
 
   LocalObject<kRank2> obj{AdoptLocal{}, Fake<jobject>()};
 
-  EXPECT_EQ(static_cast<jobjectArray>(obj["BooleanArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"BooleanArray">().Get()),
             Fake<jobjectArray>(1));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ByteArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ByteArray">().Get()),
             Fake<jobjectArray>(2));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["CharArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"CharArray">().Get()),
             Fake<jobjectArray>(3));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ShortArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ShortArray">().Get()),
             Fake<jobjectArray>(4));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["IntArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"IntArray">().Get()),
             Fake<jobjectArray>(5));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["FloatArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"FloatArray">().Get()),
             Fake<jobjectArray>(6));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["DoubleArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"DoubleArray">().Get()),
             Fake<jobjectArray>(7));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["LongArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"LongArray">().Get()),
             Fake<jobjectArray>(8));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ObjectArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ObjectArray">().Get()),
             Fake<jobjectArray>(9));
 }
 
@@ -129,23 +129,23 @@ TEST_F(JniTest, LocalArrayField_Rank3) {
 
   LocalObject<kRank3> obj{AdoptLocal{}, Fake<jobject>()};
 
-  EXPECT_EQ(static_cast<jobjectArray>(obj["BooleanArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"BooleanArray">().Get()),
             Fake<jobjectArray>(1));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ByteArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ByteArray">().Get()),
             Fake<jobjectArray>(2));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["CharArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"CharArray">().Get()),
             Fake<jobjectArray>(3));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ShortArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ShortArray">().Get()),
             Fake<jobjectArray>(4));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["IntArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"IntArray">().Get()),
             Fake<jobjectArray>(5));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["FloatArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"FloatArray">().Get()),
             Fake<jobjectArray>(6));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["DoubleArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"DoubleArray">().Get()),
             Fake<jobjectArray>(7));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["LongArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"LongArray">().Get()),
             Fake<jobjectArray>(8));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ObjectArray"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ObjectArray">().Get()),
             Fake<jobjectArray>(9));
 }
 
diff --git a/implementation/local_array_field_test.cc b/implementation/local_array_field_test.cc
index e20f60a1..eecb24bb 100644
--- a/implementation/local_array_field_test.cc
+++ b/implementation/local_array_field_test.cc
@@ -69,7 +69,7 @@ TEST_F(JniTest, ArrayField_Object_Iteration_Rank_1) {
 
   int i = 100;
   LocalObject<kFieldClass> obj{Fake<jobject>()};
-  for (LocalObject<kClass2> a : obj["ObjectArrayRank1"].Get().Pin()) {
+  for (LocalObject<kClass2> a : obj.Access<"ObjectArrayRank1">().Get().Pin()) {
     EXPECT_EQ(static_cast<jobject>(a), Fake<jobject>(i));
     i++;
   }
@@ -87,7 +87,7 @@ TEST_F(JniTest, ArrayField_Object_Iteration_Rank_2) {
   int i = 100;
   LocalObject<kFieldClass> obj{Fake<jobject>(1)};
   for (LocalArray<jobject, 1, kClass2> a :
-       obj["ObjectArrayRank2"].Get().Pin()) {
+       obj.Access<"ObjectArrayRank2">().Get().Pin()) {
     EXPECT_EQ(static_cast<jobject>(a), Fake<jobject>(i));
     i++;
   }
@@ -124,26 +124,27 @@ TEST_F(JniTest, Array_FieldTests) {
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
 
-  EXPECT_EQ(static_cast<jbooleanArray>(obj["BooleanArray"].Get()),
+  EXPECT_EQ(static_cast<jbooleanArray>(obj.Access<"BooleanArray">().Get()),
             Fake<jbooleanArray>());
-  EXPECT_EQ(static_cast<jbyteArray>(obj["ByteArray"].Get()),
+  EXPECT_EQ(static_cast<jbyteArray>(obj.Access<"ByteArray">().Get()),
             Fake<jbyteArray>());
-  EXPECT_EQ(static_cast<jcharArray>(obj["CharArray"].Get()),
+  EXPECT_EQ(static_cast<jcharArray>(obj.Access<"CharArray">().Get()),
             Fake<jcharArray>());
-  EXPECT_EQ(static_cast<jshortArray>(obj["ShortArray"].Get()),
+  EXPECT_EQ(static_cast<jshortArray>(obj.Access<"ShortArray">().Get()),
             Fake<jshortArray>());
-  EXPECT_EQ(static_cast<jintArray>(obj["IntArray"].Get()), Fake<jintArray>());
-  EXPECT_EQ(static_cast<jfloatArray>(obj["FloatArray"].Get()),
+  EXPECT_EQ(static_cast<jintArray>(obj.Access<"IntArray">().Get()),
+            Fake<jintArray>());
+  EXPECT_EQ(static_cast<jfloatArray>(obj.Access<"FloatArray">().Get()),
             Fake<jfloatArray>());
-  EXPECT_EQ(static_cast<jdoubleArray>(obj["DoubleArray"].Get()),
+  EXPECT_EQ(static_cast<jdoubleArray>(obj.Access<"DoubleArray">().Get()),
             Fake<jdoubleArray>());
-  EXPECT_EQ(static_cast<jlongArray>(obj["LongArray"].Get()),
+  EXPECT_EQ(static_cast<jlongArray>(obj.Access<"LongArray">().Get()),
             Fake<jlongArray>());
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ObjectArrayRank1"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ObjectArrayRank1">().Get()),
             Fake<jobjectArray>(1));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ObjectArrayRank2"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ObjectArrayRank2">().Get()),
             Fake<jobjectArray>(2));
-  EXPECT_EQ(static_cast<jobjectArray>(obj["ObjectArrayRank3"].Get()),
+  EXPECT_EQ(static_cast<jobjectArray>(obj.Access<"ObjectArrayRank3">().Get()),
             Fake<jobjectArray>(3));
 }
 
@@ -166,16 +167,18 @@ TEST_F(JniTest, Array_Field_Boolean_Test) {
                                           fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jboolean> arr{obj["BooleanArray"].Get()};
+  LocalArray<jboolean> arr{obj.Access<"BooleanArray">().Get()};
   LocalArray<jboolean> arr2{AdoptLocal{}, Fake<jbooleanArray>()};
-  obj["BooleanArray"].Set(Fake<jbooleanArray>());
-  obj["BooleanArray"].Set(
+  obj.Access<"BooleanArray">().Set(Fake<jbooleanArray>());
+  obj.Access<"BooleanArray">().Set(
       LocalArray<jboolean>{AdoptLocal{}, Fake<jbooleanArray>()});
-  obj["BooleanArray"].Set(arr2);
-  obj["BooleanArray"].Set(obj["BooleanArray"].Get());
+  obj.Access<"BooleanArray">().Set(arr2);
+  obj.Access<"BooleanArray">().Set(obj.Access<"BooleanArray">().Get());
 
-  EXPECT_EQ(obj["BooleanArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["BooleanArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"BooleanArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"BooleanArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Byte_Test) {
@@ -197,14 +200,17 @@ TEST_F(JniTest, Array_Field_Byte_Test) {
                                        fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jbyte> arr{obj["ByteArray"].Get()};
+  LocalArray<jbyte> arr{obj.Access<"ByteArray">().Get()};
   LocalArray<jbyte> arr2{AdoptLocal{}, Fake<jbyteArray>()};
-  obj["ByteArray"].Set(Fake<jbyteArray>());
-  obj["ByteArray"].Set(LocalArray<jbyte>{AdoptLocal{}, Fake<jbyteArray>()});
-  obj["ByteArray"].Set(arr2);
-  obj["ByteArray"].Set(obj["ByteArray"].Get());
-  EXPECT_EQ(obj["ByteArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["ByteArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"ByteArray">().Set(Fake<jbyteArray>());
+  obj.Access<"ByteArray">().Set(
+      LocalArray<jbyte>{AdoptLocal{}, Fake<jbyteArray>()});
+  obj.Access<"ByteArray">().Set(arr2);
+  obj.Access<"ByteArray">().Set(obj.Access<"ByteArray">().Get());
+  EXPECT_EQ(obj.Access<"ByteArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"ByteArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Char_Test) {
@@ -226,14 +232,17 @@ TEST_F(JniTest, Array_Field_Char_Test) {
                                        fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jchar> arr{obj["CharArray"].Get()};
+  LocalArray<jchar> arr{obj.Access<"CharArray">().Get()};
   LocalArray<jchar> arr2{AdoptLocal{}, Fake<jcharArray>()};
-  obj["CharArray"].Set(Fake<jcharArray>());
-  obj["CharArray"].Set(LocalArray<jchar>{AdoptLocal{}, Fake<jcharArray>()});
-  obj["CharArray"].Set(arr2);
-  obj["CharArray"].Set(obj["CharArray"].Get());
-  EXPECT_EQ(obj["CharArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["CharArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"CharArray">().Set(Fake<jcharArray>());
+  obj.Access<"CharArray">().Set(
+      LocalArray<jchar>{AdoptLocal{}, Fake<jcharArray>()});
+  obj.Access<"CharArray">().Set(arr2);
+  obj.Access<"CharArray">().Set(obj.Access<"CharArray">().Get());
+  EXPECT_EQ(obj.Access<"CharArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"CharArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Short_Test) {
@@ -255,14 +264,17 @@ TEST_F(JniTest, Array_Field_Short_Test) {
                                         fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jshort> arr{obj["ShortArray"].Get()};
+  LocalArray<jshort> arr{obj.Access<"ShortArray">().Get()};
   LocalArray<jshort> arr2{AdoptLocal{}, Fake<jshortArray>()};
-  obj["ShortArray"].Set(Fake<jshortArray>());
-  obj["ShortArray"].Set(LocalArray<jshort>{AdoptLocal{}, Fake<jshortArray>()});
-  obj["ShortArray"].Set(arr2);
-  obj["ShortArray"].Set(obj["ShortArray"].Get());
-  EXPECT_EQ(obj["ShortArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["ShortArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"ShortArray">().Set(Fake<jshortArray>());
+  obj.Access<"ShortArray">().Set(
+      LocalArray<jshort>{AdoptLocal{}, Fake<jshortArray>()});
+  obj.Access<"ShortArray">().Set(arr2);
+  obj.Access<"ShortArray">().Set(obj.Access<"ShortArray">().Get());
+  EXPECT_EQ(obj.Access<"ShortArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"ShortArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Int_Test) {
@@ -283,14 +295,16 @@ TEST_F(JniTest, Array_Field_Int_Test) {
                          Fake<jintArray>(), fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jint> arr{obj["IntArray"].Get()};
+  LocalArray<jint> arr{obj.Access<"IntArray">().Get()};
   LocalArray<jint> arr2{AdoptLocal{}, Fake<jintArray>()};
-  obj["IntArray"].Set(Fake<jintArray>());
-  obj["IntArray"].Set(LocalArray<jint>{AdoptLocal{}, Fake<jintArray>()});
-  obj["IntArray"].Set(arr2);
-  obj["IntArray"].Set(obj["IntArray"].Get());
-  EXPECT_EQ(obj["IntArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["IntArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"IntArray">().Set(Fake<jintArray>());
+  obj.Access<"IntArray">().Set(
+      LocalArray<jint>{AdoptLocal{}, Fake<jintArray>()});
+  obj.Access<"IntArray">().Set(arr2);
+  obj.Access<"IntArray">().Set(obj.Access<"IntArray">().Get());
+  EXPECT_EQ(obj.Access<"IntArray">().Get().Pin().ptr(), fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"IntArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Float_Test) {
@@ -312,14 +326,17 @@ TEST_F(JniTest, Array_Field_Float_Test) {
                                         fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jfloat> arr{obj["FloatArray"].Get()};
+  LocalArray<jfloat> arr{obj.Access<"FloatArray">().Get()};
   LocalArray<jfloat> arr2{AdoptLocal{}, Fake<jfloatArray>()};
-  obj["FloatArray"].Set(Fake<jfloatArray>());
-  obj["FloatArray"].Set(LocalArray<jfloat>{AdoptLocal{}, Fake<jfloatArray>()});
-  obj["FloatArray"].Set(arr2);
-  obj["FloatArray"].Set(obj["FloatArray"].Get());
-  EXPECT_EQ(obj["FloatArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["FloatArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"FloatArray">().Set(Fake<jfloatArray>());
+  obj.Access<"FloatArray">().Set(
+      LocalArray<jfloat>{AdoptLocal{}, Fake<jfloatArray>()});
+  obj.Access<"FloatArray">().Set(arr2);
+  obj.Access<"FloatArray">().Set(obj.Access<"FloatArray">().Get());
+  EXPECT_EQ(obj.Access<"FloatArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"FloatArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Double_Test) {
@@ -341,15 +358,17 @@ TEST_F(JniTest, Array_Field_Double_Test) {
                                          fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jdouble> arr{obj["DoubleArray"].Get()};
+  LocalArray<jdouble> arr{obj.Access<"DoubleArray">().Get()};
   LocalArray<jdouble> arr2{AdoptLocal{}, Fake<jdoubleArray>()};
-  obj["DoubleArray"].Set(Fake<jdoubleArray>());
-  obj["DoubleArray"].Set(
+  obj.Access<"DoubleArray">().Set(Fake<jdoubleArray>());
+  obj.Access<"DoubleArray">().Set(
       LocalArray<jdouble>{AdoptLocal{}, Fake<jdoubleArray>()});
-  obj["DoubleArray"].Set(arr2);
-  obj["DoubleArray"].Set(obj["DoubleArray"].Get());
-  EXPECT_EQ(obj["DoubleArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["DoubleArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"DoubleArray">().Set(arr2);
+  obj.Access<"DoubleArray">().Set(obj.Access<"DoubleArray">().Get());
+  EXPECT_EQ(obj.Access<"DoubleArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"DoubleArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Long_Test) {
@@ -371,14 +390,17 @@ TEST_F(JniTest, Array_Field_Long_Test) {
                                        fake_storage_ptr.get(), JNI_ABORT));
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
-  LocalArray<jlong> arr{obj["LongArray"].Get()};
+  LocalArray<jlong> arr{obj.Access<"LongArray">().Get()};
   LocalArray<jlong> arr2{AdoptLocal{}, Fake<jlongArray>()};
-  obj["LongArray"].Set(Fake<jlongArray>());
-  obj["LongArray"].Set(LocalArray<jlong>{AdoptLocal{}, Fake<jlongArray>()});
-  obj["LongArray"].Set(arr2);
-  obj["LongArray"].Set(obj["LongArray"].Get());
-  EXPECT_EQ(obj["LongArray"].Get().Pin().ptr(), fake_storage_ptr.get());
-  EXPECT_EQ(obj["LongArray"].Get().Pin(false).ptr(), fake_storage_ptr.get());
+  obj.Access<"LongArray">().Set(Fake<jlongArray>());
+  obj.Access<"LongArray">().Set(
+      LocalArray<jlong>{AdoptLocal{}, Fake<jlongArray>()});
+  obj.Access<"LongArray">().Set(arr2);
+  obj.Access<"LongArray">().Set(obj.Access<"LongArray">().Get());
+  EXPECT_EQ(obj.Access<"LongArray">().Get().Pin().ptr(),
+            fake_storage_ptr.get());
+  EXPECT_EQ(obj.Access<"LongArray">().Get().Pin(false).ptr(),
+            fake_storage_ptr.get());
 }
 
 TEST_F(JniTest, Array_Field_Object_Test) {
@@ -394,13 +416,13 @@ TEST_F(JniTest, Array_Field_Object_Test) {
 
   LocalObject<kFieldClass> obj{AdoptLocal{}, Fake<jobject>()};
   LocalArray<jobject, 1, kClass2> arr2{AdoptLocal{}, Fake<jobjectArray>()};
-  LocalArray<jobject, 1, kClass2> arr{obj["ObjectArrayRank1"].Get()};
-  obj["ObjectArrayRank1"].Set(Fake<jobjectArray>());
-  obj["ObjectArrayRank1"].Set(
+  LocalArray<jobject, 1, kClass2> arr{obj.Access<"ObjectArrayRank1">().Get()};
+  obj.Access<"ObjectArrayRank1">().Set(Fake<jobjectArray>());
+  obj.Access<"ObjectArrayRank1">().Set(
       LocalArray<jobject, 1, kClass2>{AdoptLocal{}, Fake<jobjectArray>()});
-  obj["ObjectArrayRank1"].Set(arr2);
-  obj["ObjectArrayRank1"].Set(obj["ObjectArrayRank1"].Get());
-  obj["ObjectArrayRank1"].Get().Get(2);
+  obj.Access<"ObjectArrayRank1">().Set(arr2);
+  obj.Access<"ObjectArrayRank1">().Set(obj.Access<"ObjectArrayRank1">().Get());
+  obj.Access<"ObjectArrayRank1">().Get().Get(2);
 }
 
 TEST_F(JniTest, Array_Field_HandlesLValueLocalObject_Rank_1) {
@@ -414,7 +436,7 @@ TEST_F(JniTest, Array_Field_HandlesLValueLocalObject_Rank_1) {
   EXPECT_CALL(*env_, GetFieldID(_, StrEq("Foo"), StrEq("[LkClass2;")));
 
   LocalObject<kClass> obj{Fake<jobject>()};
-  LocalArray<jobject, 1, kClass2>{obj["Foo"].Get()};
+  LocalArray<jobject, 1, kClass2>{obj.Access<"Foo">().Get()};
 }
 
 TEST_F(JniTest, Array_Field_HandlesLValueLocalObject_Rank_2) {
@@ -428,7 +450,7 @@ TEST_F(JniTest, Array_Field_HandlesLValueLocalObject_Rank_2) {
   EXPECT_CALL(*env_, GetFieldID(_, StrEq("Foo"), StrEq("[[LkClass2;")));
 
   LocalObject<kClass> obj{Fake<jobject>()};
-  LocalArray<jobject, 2, kClass2> arr_from_field{obj["Foo"].Get()};
+  LocalArray<jobject, 2, kClass2> arr_from_field{obj.Access<"Foo">().Get()};
 }
 
 TEST_F(JniTest, Array_Field_HandlesLValueLocalObject_Rank_2_Iteration) {
@@ -471,7 +493,7 @@ TEST_F(JniTest, Array_Field_HandlesLValueLocalObject_Rank_2_Iteration) {
 
   LocalObject<kClass> obj{AdoptLocal{}, Fake<jobject>(1)};
   int i = 100;
-  for (LocalArray<jobject> obj : obj["Foo"].Get().Pin()) {
+  for (LocalArray<jobject> obj : obj.Access<"Foo">().Get().Pin()) {
     EXPECT_EQ(static_cast<jobject>(obj), Fake<jobject>(i));
     i++;
   }
diff --git a/implementation/local_array_method_multidimensional_test.cc b/implementation/local_array_method_multidimensional_test.cc
index f10f97dd..21671b6a 100644
--- a/implementation/local_array_method_multidimensional_test.cc
+++ b/implementation/local_array_method_multidimensional_test.cc
@@ -48,7 +48,7 @@ TEST_F(JniTest, V_2I) {
   EXPECT_CALL(*env_, GetMethodID(_, StrEq("I"), StrEq("()[[I")));
 
   LocalObject<kClass> obj{Fake<jobject>()};
-  obj("I");
+  obj.Call<"I">();
 }
 
 TEST_F(JniTest, V_2LkClass) {
@@ -58,7 +58,7 @@ TEST_F(JniTest, V_2LkClass) {
   EXPECT_CALL(*env_, GetMethodID(_, StrEq("Foo"), StrEq("()[[LkClass2;")));
 
   LocalObject<kClass> obj{Fake<jobject>()};
-  obj("Foo");
+  obj.Call<"Foo">();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -77,7 +77,7 @@ TEST_F(JniTest, 3I1D_2LkClass) {
               GetMethodID(_, StrEq("Bar"), StrEq("([[[I[D)[[LkClass3;")));
 
   LocalObject<kArrClass> obj{Fake<jobject>()};
-  obj("Bar", Fake<jobjectArray>(), Fake<jdoubleArray>());
+  obj.Call<"Bar">(Fake<jobjectArray>(), Fake<jdoubleArray>());
 }
 
 TEST_F(JniTest, 2I_I) {
@@ -88,8 +88,8 @@ TEST_F(JniTest, 2I_I) {
 
   LocalObject<kClass> obj{Fake<jobject>()};
   // obj("I", jintArray{nullptr}); // doesn't compile (good).
-  obj("I", Fake<jobjectArray>());
-  obj("I", LocalArray<jint, 2>{Fake<jobjectArray>()});
+  obj.Call<"I">(Fake<jobjectArray>());
+  obj.Call<"I">(LocalArray<jint, 2>{Fake<jobjectArray>()});
 }
 
 TEST_F(JniTest, 3I_1LkClass) {
@@ -103,8 +103,7 @@ TEST_F(JniTest, 3I_1LkClass) {
 
   // TODO(b/143908983): CTAD is failing.
   // LocalArray ret = obj("Baz", jobjectArray{nullptr});
-
-  LocalArray<jobject, 1, kClass2> ret = obj("Baz", Fake<jobjectArray>());
+  LocalArray<jobject, 1, kClass2> ret = obj.Call<"Baz">(Fake<jobjectArray>());
   static_assert(std::is_same_v<decltype(ret), LocalArray<jobject, 1, kClass2>>);
 }
 
@@ -113,7 +112,7 @@ TEST_F(JniTest, 3I1D_1LkClass) {
               GetMethodID(_, StrEq("Bar"), StrEq("([[[I[D)[[LkClass3;")));
 
   LocalObject<kArrClass> obj{Fake<jobject>()};
-  obj("Bar", Fake<jobjectArray>(), Fake<jdoubleArray>());
+  obj.Call<"Bar">(Fake<jobjectArray>(), Fake<jdoubleArray>());
 }
 
 }  // namespace
diff --git a/implementation/local_array_method_test.cc b/implementation/local_array_method_test.cc
index 24e27609..b5332474 100644
--- a/implementation/local_array_method_test.cc
+++ b/implementation/local_array_method_test.cc
@@ -78,31 +78,31 @@ TEST_F(JniTest, ReturnSmokeTest) {
   EXPECT_CALL(*env_,
               GetMethodID(_, StrEq("ObjectArray"), StrEq("()[LkClass2;")));
 
-  LocalArray<jboolean> bool_array{obj("BooleanArray")};
+  LocalArray<jboolean> bool_array{obj.Call<"BooleanArray">()};
   EXPECT_EQ((static_cast<jbooleanArray>(bool_array)), (Fake<jbooleanArray>()));
 
-  LocalArray<jbyte> byte_array{obj("ByteArray")};
+  LocalArray<jbyte> byte_array{obj.Call<"ByteArray">()};
   EXPECT_EQ((static_cast<jbyteArray>(byte_array)), (Fake<jbyteArray>()));
 
-  LocalArray<jchar> char_array{obj("CharArray")};
+  LocalArray<jchar> char_array{obj.Call<"CharArray">()};
   EXPECT_EQ((static_cast<jcharArray>(char_array)), (Fake<jcharArray>()));
 
-  LocalArray<jshort> short_array{obj("ShortArray")};
+  LocalArray<jshort> short_array{obj.Call<"ShortArray">()};
   EXPECT_EQ((static_cast<jshortArray>(short_array)), (Fake<jshortArray>()));
 
-  LocalArray<jint> int_array{obj("IntArray")};
+  LocalArray<jint> int_array{obj.Call<"IntArray">()};
   EXPECT_EQ((static_cast<jintArray>(int_array)), (Fake<jintArray>()));
 
-  LocalArray<jlong> long_array{obj("LongArray")};
+  LocalArray<jlong> long_array{obj.Call<"LongArray">()};
   EXPECT_EQ((static_cast<jlongArray>(long_array)), (Fake<jlongArray>()));
 
-  LocalArray<jfloat> float_array{obj("FloatArray")};
+  LocalArray<jfloat> float_array{obj.Call<"FloatArray">()};
   EXPECT_EQ((static_cast<jfloatArray>(float_array)), (Fake<jfloatArray>()));
 
-  LocalArray<jdouble> double_array{obj("DoubleArray")};
+  LocalArray<jdouble> double_array{obj.Call<"DoubleArray">()};
   EXPECT_EQ((static_cast<jdoubleArray>(double_array)), (Fake<jdoubleArray>()));
 
-  LocalArray<jobject, 1, kClass2> object_array{obj("ObjectArray")};
+  LocalArray<jobject, 1, kClass2> object_array{obj.Call<"ObjectArray">()};
   EXPECT_EQ((static_cast<jobjectArray>(object_array)), (Fake<jobjectArray>()));
 }
 
@@ -135,15 +135,16 @@ TEST_F(JniTest, ParamsSmokeTest) {
   EXPECT_CALL(*env_,
               GetMethodID(_, StrEq("ObjectArray"), StrEq("([LkClass2;)V")));
 
-  obj("BooleanArray", LocalArray<jboolean>{Fake<jbooleanArray>()});
-  obj("ByteArray", LocalArray<jbyte>{Fake<jbyteArray>()});
-  obj("CharArray", LocalArray<jchar>{Fake<jcharArray>()});
-  obj("ShortArray", LocalArray<jshort>{Fake<jshortArray>()});
-  obj("IntArray", LocalArray<jint>{Fake<jintArray>()});
-  obj("FloatArray", LocalArray<jfloat>{Fake<jfloatArray>()});
-  obj("DoubleArray", LocalArray<jdouble>{Fake<jdoubleArray>()});
-  obj("LongArray", LocalArray<jlong>{Fake<jlongArray>()});
-  obj("ObjectArray", LocalArray<jobject, 1, kClass2>{Fake<jobjectArray>()});
+  obj.Call<"BooleanArray">(LocalArray<jboolean>{Fake<jbooleanArray>()});
+  obj.Call<"ByteArray">(LocalArray<jbyte>{Fake<jbyteArray>()});
+  obj.Call<"CharArray">(LocalArray<jchar>{Fake<jcharArray>()});
+  obj.Call<"ShortArray">(LocalArray<jshort>{Fake<jshortArray>()});
+  obj.Call<"IntArray">(LocalArray<jint>{Fake<jintArray>()});
+  obj.Call<"FloatArray">(LocalArray<jfloat>{Fake<jfloatArray>()});
+  obj.Call<"DoubleArray">(LocalArray<jdouble>{Fake<jdoubleArray>()});
+  obj.Call<"LongArray">(LocalArray<jlong>{Fake<jlongArray>()});
+  obj.Call<"ObjectArray">(
+      LocalArray<jobject, 1, kClass2>{Fake<jobjectArray>()});
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -189,39 +190,39 @@ TEST_F(JniTest, ComplexSmokeTest) {
                                  StrEq("([LkClass2;)[LkClass2;")));
 
   LocalArray<jboolean> bool_array{
-      obj("BooleanArray", LocalArray<jboolean>{Fake<jbooleanArray>()})};
+      obj.Call<"BooleanArray">(LocalArray<jboolean>{Fake<jbooleanArray>()})};
   EXPECT_EQ((static_cast<jbooleanArray>(bool_array)), (Fake<jbooleanArray>()));
 
   LocalArray<jbyte> byte_array{
-      obj("ByteArray", LocalArray<jbyte>{Fake<jbyteArray>()})};
+      obj.Call<"ByteArray">(LocalArray<jbyte>{Fake<jbyteArray>()})};
   EXPECT_EQ((static_cast<jbyteArray>(byte_array)), (Fake<jbyteArray>()));
 
   LocalArray<jchar> char_array{
-      obj("CharArray", LocalArray<jchar>{Fake<jcharArray>()})};
+      obj.Call<"CharArray">(LocalArray<jchar>{Fake<jcharArray>()})};
   EXPECT_EQ((static_cast<jcharArray>(char_array)), (Fake<jcharArray>()));
 
   LocalArray<jshort> short_array{
-      obj("ShortArray", LocalArray<jshort>{Fake<jshortArray>()})};
+      obj.Call<"ShortArray">(LocalArray<jshort>{Fake<jshortArray>()})};
   EXPECT_EQ((static_cast<jshortArray>(short_array)), (Fake<jshortArray>()));
 
   LocalArray<jint> int_array{
-      obj("IntArray", LocalArray<jint>{Fake<jintArray>()})};
+      obj.Call<"IntArray">(LocalArray<jint>{Fake<jintArray>()})};
   EXPECT_EQ((static_cast<jintArray>(int_array)), (Fake<jintArray>()));
 
   LocalArray<jfloat> float_array{
-      obj("FloatArray", LocalArray<jfloat>{Fake<jfloatArray>()})};
+      obj.Call<"FloatArray">(LocalArray<jfloat>{Fake<jfloatArray>()})};
   EXPECT_EQ((static_cast<jfloatArray>(float_array)), (Fake<jfloatArray>()));
 
   LocalArray<jdouble> double_array{
-      obj("DoubleArray", LocalArray<jdouble>{Fake<jdoubleArray>()})};
+      obj.Call<"DoubleArray">(LocalArray<jdouble>{Fake<jdoubleArray>()})};
   EXPECT_EQ((static_cast<jdoubleArray>(double_array)), (Fake<jdoubleArray>()));
 
   LocalArray<jlong> long_array{
-      obj("LongArray", LocalArray<jlong>{Fake<jlongArray>()})};
+      obj.Call<"LongArray">(LocalArray<jlong>{Fake<jlongArray>()})};
   EXPECT_EQ((static_cast<jlongArray>(long_array)), (Fake<jlongArray>()));
 
-  LocalArray<jobject, 1, kClass2> object_array{obj(
-      "ObjectArray", LocalArray<jobject, 1, kClass2>{Fake<jobjectArray>()})};
+  LocalArray<jobject, 1, kClass2> object_array{obj.Call<"ObjectArray">(
+      LocalArray<jobject, 1, kClass2>{Fake<jobjectArray>()})};
   EXPECT_EQ((static_cast<jobjectArray>(object_array)), (Fake<jobjectArray>()));
 }
 
diff --git a/implementation/local_array_string_test.cc b/implementation/local_array_string_test.cc
index b0990e20..3bcf7d21 100644
--- a/implementation/local_array_string_test.cc
+++ b/implementation/local_array_string_test.cc
@@ -72,7 +72,7 @@ TEST_F(JniTest, Array_CorrectSignatureForStringParams) {
 
   LocalObject<kClass> obj{jobject{nullptr}};
   LocalArray<jstring> arr{3};
-  obj("StringArray", arr);
+  obj.Call<"StringArray">(arr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -128,7 +128,7 @@ TEST_F(JniTest, Array_CorrectReturnSignatureForStrings) {
   LocalObject<kClass> obj{Fake<jobject>()};
   EXPECT_CALL(*env_, GetMethodID(_, StrEq("StringArray"),
                                  StrEq("()[Ljava/lang/String;")));
-  LocalArray<jstring> arr = obj("StringArray");
+  LocalArray<jstring> arr = obj.Call<"StringArray">();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -144,7 +144,7 @@ TEST_F(JniTest, Array_CorrectParamSignatureForStrings) {
   EXPECT_CALL(*env_, GetMethodID(_, StrEq("StringArray"),
                                  StrEq("([Ljava/lang/String;)V")));
   LocalArray<jstring> arr{2};
-  obj("StringArray", arr);
+  obj.Call<"StringArray">(arr);
 }
 
 TEST_F(JniTest, LocalStringArray_ConstructsObjectsForLValues) {
@@ -196,9 +196,9 @@ TEST_F(JniTest, Array_CorrectFieldSignatureForStrings) {
   EXPECT_CALL(*env_, GetFieldID(_, StrEq("StringArrayRank3"),
                                 StrEq("[[[Ljava/lang/String;")));
 
-  LocalArray<jstring> arr1 = obj["StringArrayRank1"].Get();
-  LocalArray<jstring, 2> arr2 = obj["StringArrayRank2"].Get();
-  LocalArray<jstring, 3> arr3 = obj["StringArrayRank3"].Get();
+  LocalArray<jstring> arr1 = obj.Access<"StringArrayRank1">().Get();
+  LocalArray<jstring, 2> arr2 = obj.Access<"StringArrayRank2">().Get();
+  LocalArray<jstring, 3> arr3 = obj.Access<"StringArrayRank3">().Get();
 }
 
 }  // namespace
diff --git a/implementation/local_object_test.cc b/implementation/local_object_test.cc
index ef193ac3..c0e2ea38 100644
--- a/implementation/local_object_test.cc
+++ b/implementation/local_object_test.cc
@@ -124,9 +124,10 @@ TEST_F(JniTest, LocalObject_ObjectReturnsInstanceMethods) {
   EXPECT_CALL(*env_, DeleteLocalRef(Fake<jobject>())).Times(1);
 
   LocalObject<kClass> obj{};
-  obj("Foo", 12345);
-  obj("Baz", 12345.f);
-  obj("AMethodWithAReallyLongNameThatWouldPossiblyBeHardForTemplatesToHandle",
+  obj.Call<"Foo">(12345);
+  obj.Call<"Baz">(12345.f);
+  obj.Call<
+      "AMethodWithAReallyLongNameThatWouldPossiblyBeHardForTemplatesToHandle">(
       12345, 12345.f, 12345, 12345.f, jdouble{12345});
 }
 
@@ -164,15 +165,15 @@ TEST_F(JniTest, LocalObject_ValuesWorkAfterMoveConstructor) {
   EXPECT_CALL(*env_, SetIntField).Times(4);
 
   LocalObject<kClass> obj_1{Fake<jobject>()};
-  obj_1("Foo", 1);
-  obj_1("Foo", 2);
-  obj_1["BarField"].Set(1);
+  obj_1.Call<"Foo">(1);
+  obj_1.Call<"Foo">(2);
+  obj_1.Access<"BarField">().Set(1);
 
   LocalObject<kClass> obj_2{std::move(obj_1)};
-  obj_2("Foo", 3);
-  obj_2["BarField"].Set(2);
-  obj_2["BarField"].Set(3);
-  obj_2["BarField"].Set(4);
+  obj_2.Call<"Foo">(3);
+  obj_2.Access<"BarField">().Set(2);
+  obj_2.Access<"BarField">().Set(3);
+  obj_2.Access<"BarField">().Set(4);
 }
 
 TEST_F(JniTest, LocalObject_ReleasesLocalsForAlternateConstructors) {
@@ -249,7 +250,7 @@ TEST_F(JniTest, LocalObject_SupportsPassingAnObjectAsAnLvalue) {
 
   LocalObject<kClass> a{};
   LocalObject<kClass2> b{};
-  b("Foo", a);
+  b.Call<"Foo">(a);
 }
 
 TEST_F(JniTest, LocalObject_SupportsReturningAClass) {
@@ -257,7 +258,7 @@ TEST_F(JniTest, LocalObject_SupportsReturningAClass) {
       "Class1", Method{"Foo", jni::Return{kClass2}, jni::Params{}}};
 
   LocalObject<kClass> a{};
-  a("Foo");
+  a.Call<"Foo">();
 }
 
 TEST_F(JniTest, LocalObject_SupportsReturningAString) {
@@ -265,13 +266,13 @@ TEST_F(JniTest, LocalObject_SupportsReturningAString) {
       "Class1", Method{"Foo", jni::Return<jstring>{}, jni::Params{}}};
 
   LocalObject<kClass> a{};
-  a("Foo");
+  a.Call<"Foo">();
 }
 
 jobject ReturnOutputOfMethod() {
   static constexpr Class kClass2{"Class2", Method{"Foo", jni::Return{kClass}}};
 
-  return LocalObject<kClass2>{}("Foo").Release();
+  return LocalObject<kClass2>{}.Call<"Foo">().Release();
 }
 
 TEST_F(JniTest, LocalObject_CompilesWhenReturnReleasing) {
@@ -284,7 +285,7 @@ TEST_F(JniTest, LocalObject_SupportsPassingAnObjectAsAnPrvalue) {
 
   LocalObject<kClass> a{};
   LocalObject<kClass2> b{};
-  b("Foo", std::move(a));
+  b.Call<"Foo">(std::move(a));
 }
 
 TEST_F(JniTest, LocalObject_SupportsPassingAnObjectAsAnXvalue) {
@@ -292,7 +293,7 @@ TEST_F(JniTest, LocalObject_SupportsPassingAnObjectAsAnXvalue) {
       "Class2", Method{"Foo", jni::Return{}, jni::Params{kClass}}};
 
   LocalObject<kClass2> b{};
-  b("Foo", LocalObject<kClass>{});
+  b.Call<"Foo">(LocalObject<kClass>{});
 }
 
 TEST_F(JniTest, LocalObject_MovesInContainerStruct) {
@@ -320,8 +321,8 @@ TEST_F(JniTest, LocalObject_DoesntCrossTalkOverClassMethodIds) {
   LocalObject<kClass2> obj_2{Fake<jobject>(2)};
 
   // These are different method IDs (they are different classes).
-  obj_1("Foo", 1);
-  obj_2("Foo", 1);
+  obj_1.Call<"Foo">(1);
+  obj_2.Call<"Foo">(1);
 }
 
 }  // namespace
diff --git a/implementation/method_ref_test.cc b/implementation/method_ref_test.cc
index 65c907ef..3406428a 100644
--- a/implementation/method_ref_test.cc
+++ b/implementation/method_ref_test.cc
@@ -193,7 +193,7 @@ TEST_F(JniTest, MethodRef_ReturnsObjects) {
   EXPECT_CALL(*env_, NewObjectV).WillOnce(testing::Return(Fake<jobject>()));
 
   GlobalObject<kClass> global_object{};
-  LocalObject<c1> new_obj{global_object("Foo", 5)};
+  LocalObject<c1> new_obj{global_object.Call<"Foo">(5)};
 }
 
 TEST_F(JniTest, MethodRef_PassesObjects) {
@@ -209,7 +209,7 @@ TEST_F(JniTest, MethodRef_PassesObjects) {
   EXPECT_CALL(*env_,
               GetMethodID(_, StrEq("Foo"), StrEq("(Lcom/google/Bazz;)I")));
 
-  global_object("Foo", local_object);
+  global_object.Call<"Foo">(local_object);
 }
 
 TEST_F(JniTest, MethodRef_PassesAndReturnsMultipleObjects) {
@@ -229,7 +229,7 @@ TEST_F(JniTest, MethodRef_PassesAndReturnsMultipleObjects) {
   LocalObject<c4> obj4{Fake<jobject>(4)};
   LocalObject<class_under_test> object_under_test{Fake<jobject>(5)};
 
-  LocalObject<c1> obj5{object_under_test("Foo", obj1, obj2, obj3, obj4)};
+  LocalObject<c1> obj5{object_under_test.Call<"Foo">(obj1, obj2, obj3, obj4)};
 }
 
 TEST_F(JniTest, MethodRef_SupportsForwardDefines) {
@@ -255,20 +255,21 @@ TEST_F(JniTest, MethodRef_SupportsForwardDefines) {
   LocalObject<kClass2> c2_obj1{Fake<jobject>(3)};
   LocalObject<kClass2> c2_obj2{Fake<jobject>(4)};
 
-  c1_obj1("m1", c1_obj1);
-  c1_obj1("m2", c2_obj1);
-  c1_obj1("m1", c1_obj1("m3"));
-  c1_obj1("m2", c1_obj1("m4"));
+  c1_obj1.Call<"m1">(c1_obj1);
+  c1_obj1.Call<"m2">(c2_obj1);
+  c1_obj1.Call<"m1">(c1_obj1.Call<"m3">());
+  c1_obj1.Call<"m2">(c1_obj1.Call<"m4">());
 
-  c2_obj1("m1", c1_obj1);
-  c2_obj1("m2", c2_obj2);
-  c2_obj1("m2", std::move(std::move(c2_obj2)));
+  c2_obj1.Call<"m1">(c1_obj1);
+  c2_obj1.Call<"m2">(c2_obj2);
+  c2_obj1.Call<"m2">(std::move(std::move(c2_obj2)));
 
-  c1_obj1("m2", std::move(c2_obj1));
+  c1_obj1.Call<"m2">(std::move(c2_obj1));
 
-  // c2_obj1("m1", c1_obj1); // illegal! triggers warnings (post move read).
-  // c2_obj1("m2", c2_obj2); // illegal! triggers warnings (post move read).
-  // c2_obj1("m2", std::move(c2_obj2));  // illegal! triggers warnings (post
+  // c2_obj1.Call<"m1">(c1_obj1); // illegal! triggers warnings (post move
+  // read). c2_obj1.Call<"m2">(c2_obj2); // illegal! triggers warnings (post
+  // move read). c2_obj1.Call<"m2">(std::move(c2_obj2));  // illegal! triggers
+  // warnings (post
   // move read).
 }
 
@@ -281,9 +282,9 @@ TEST_F(JniTest, MethodRef_SupportsStrings) {
   };
 
   LocalObject<class_under_test> obj1{Fake<jobject>()};
-  obj1("Foo", "This is a method.");
-  obj1("Bar", "This is a method.", "It takes strings");
-  obj1("Baz");
+  obj1.Call<"Foo">("This is a method.");
+  obj1.Call<"Bar">("This is a method.", "It takes strings");
+  obj1.Call<"Baz">();
 }
 
 TEST_F(JniTest, MethodRef_SupportsArrays) {
@@ -295,7 +296,7 @@ TEST_F(JniTest, MethodRef_SupportsArrays) {
 
   LocalArray<jobject, 1, kClass> local_array{nullptr};
   LocalObject<class_under_test> obj1{Fake<jobject>()};
-  obj1("Foo", local_array);
+  obj1.Call<"Foo">(local_array);
 }
 
 }  // namespace
diff --git a/implementation/method_selection.h b/implementation/method_selection.h
index 03157c56..976f474e 100644
--- a/implementation/method_selection.h
+++ b/implementation/method_selection.h
@@ -87,12 +87,12 @@ template <typename IdT_, IdType kIDType = IdType::OVERLOAD,
           IdType kReturnIDType = IdType::OVERLOAD_PARAM>
 struct MethodSelection {
   using IdT = IdT_;
-  using JniT = typename IdT::JniT;
+  using _JniT = typename IdT::_JniT;
 
   template <std::size_t I, typename... Ts>
   struct Helper {
     using type = metaprogramming::Val_t<OverloadSelection<
-        Id<JniT, kIDType, IdT::kIdx, I, kNoIdx, 0>,
+        Id<_JniT, kIDType, IdT::kIdx, I, kNoIdx, 0>,
         kReturnIDType>::template OverloadIdxIfViable<Ts...>()>;
   };
 
@@ -103,7 +103,8 @@ struct MethodSelection {
 
   template <typename... Ts>
   using FindOverloadSelection = OverloadSelection<
-      Id<JniT, kIDType, IdT::kIdx, kIdxForTs<Ts...>, kNoIdx, 0>, kReturnIDType>;
+      Id<_JniT, kIDType, IdT::kIdx, kIdxForTs<Ts...>, kNoIdx, 0>,
+      kReturnIDType>;
 
   template <typename... Ts>
   static constexpr bool ArgSetViable() {
@@ -116,8 +117,8 @@ struct OverloadSelector {
   using OverloadSelectionForArgs = typename MethodSelection<
       IdT, kIDType, kReturnIDType>::template FindOverloadSelection<Args...>;
 
-  using OverloadRef =
-      OverloadRef<Id<typename IdT::JniT, kIDType, IdT::kIdx,
+  using _OverloadRef =
+      OverloadRef<Id<typename IdT::_JniT, kIDType, IdT::kIdx,
                      OverloadSelectionForArgs::IdT::kSecondaryIdx, kNoIdx, 0>,
                   kReturnIDType>;
 
diff --git a/implementation/multi_type_test.cc b/implementation/multi_type_test.cc
index 3aceb6b0..b926bdbb 100644
--- a/implementation/multi_type_test.cc
+++ b/implementation/multi_type_test.cc
@@ -71,13 +71,13 @@ TEST_F(JniTest, MultiTypeTest_SimpleSmokeTestForSingleObject) {
   EXPECT_CALL(*env_, DeleteGlobalRef(Fake<jclass>(2))).Times(1);
 
   jni::GlobalObject<object> obj{};
-  obj("Foo", 1, 2.f);
-  obj("Baz", 1.f);
-  obj("Baz", 1.f);
-  obj("Baz", 2.f);
-  obj("Baz", 3.f);
-  obj("Bar");
-  obj["SomeField"].Get();
+  obj.Call<"Foo">(1, 2.f);
+  obj.Call<"Baz">(1.f);
+  obj.Call<"Baz">(1.f);
+  obj.Call<"Baz">(2.f);
+  obj.Call<"Baz">(3.f);
+  obj.Call<"Bar">();
+  obj.Access<"SomeField">().Get();
 }
 
 TEST_F(JniTest, MultiTypeTest_MethodsOfSameNameButDifferentClassAreUnique) {
@@ -94,21 +94,21 @@ TEST_F(JniTest, MultiTypeTest_MethodsOfSameNameButDifferentClassAreUnique) {
 
   jni::LocalObject<c1> obj1{Fake<jobject>(1)};
   jni::LocalObject<c2> obj2{Fake<jobject>(2)};
-  obj1("Foo", 12345);
-  obj2("Foo", 12345);
+  obj1.Call<"Foo">(12345);
+  obj2.Call<"Foo">(12345);
 
   // All of these calls ought not query for a method ID again.
-  obj1("Foo", 12345);
-  obj1("Foo", 12345);
-  obj1("Foo", 12345);
-  obj1("Foo", 12345);
-  obj2("Foo", 12345);
-  obj2("Foo", 12345);
-  obj2("Foo", 12345);
+  obj1.Call<"Foo">(12345);
+  obj1.Call<"Foo">(12345);
+  obj1.Call<"Foo">(12345);
+  obj1.Call<"Foo">(12345);
+  obj2.Call<"Foo">(12345);
+  obj2.Call<"Foo">(12345);
+  obj2.Call<"Foo">(12345);
 
   jni::LocalObject<c1> obj3{Fake<jobject>(3)};
-  obj3("Foo", 12345);
-  obj3("Foo", 12345);
+  obj3.Call<"Foo">(12345);
+  obj3.Call<"Foo">(12345);
 }
 
 }  // namespace
diff --git a/implementation/object_ref.h b/implementation/object_ref.h
index 420ad6f9..2685d752 100644
--- a/implementation/object_ref.h
+++ b/implementation/object_ref.h
@@ -53,14 +53,17 @@ class ObjectRef
     // C++17 augmentations.
     : public metaprogramming::InvocableMap<
           ObjectRef<JniT>, JniT::stripped_class_v, typename JniT::ClassT,
-          &JniT::ClassT::methods_>,
+          decltype(&JniT::ClassT::methods_), &JniT::ClassT::methods_>,
       public metaprogramming::QueryableMap_t<
-          ObjectRef<JniT>, JniT::stripped_class_v, &JniT::ClassT::fields_>,
+          ObjectRef<JniT>, JniT::stripped_class_v,
+          decltype(&JniT::ClassT::fields_), &JniT::ClassT::fields_>,
       // C++ 20 augmentations.
-      public metaprogramming::InvocableMap20_t<
-          ObjectRef<JniT>, JniT::stripped_class_v, &JniT::ClassT::methods_>,
-      public metaprogramming::QueryableMap20_t<
-          ObjectRef<JniT>, JniT::stripped_class_v, &JniT::ClassT::fields_>,
+      public metaprogramming::InvocableMap20<
+          ObjectRef<JniT>, JniT::stripped_class_v, ObjectRef<JniT>,
+          decltype(&JniT::ClassT::methods_), &JniT::ClassT::methods_>,
+      public metaprogramming::QueryableMap20<
+          ObjectRef<JniT>, JniT::stripped_class_v, ObjectRef<JniT>,
+          decltype(&JniT::ClassT::fields_), &JniT::ClassT::fields_>,
       public RefBase<typename JniT::StorageType> {
  protected:
   static_assert(
@@ -109,7 +112,7 @@ class ObjectRef
     static_assert(MethodSelectionForArgs::kIsValidArgSet,
                   "JNI Error: Invalid argument set.");
 
-    return MethodSelectionForArgs::OverloadRef::Invoke(
+    return MethodSelectionForArgs::_OverloadRef::Invoke(
         GetJClass(), RefBaseT::object_ref_, std::forward<Args>(args)...);
   }
 
@@ -139,7 +142,7 @@ class ObjectRef
     static_assert(MethodSelectionForArgs::kIsValidArgSet,
                   "JNI Error: Invalid argument set.");
 
-    return MethodSelectionForArgs::OverloadRef::Invoke(
+    return MethodSelectionForArgs::_OverloadRef::Invoke(
         GetJClass(), RefBaseT::object_ref_, std::forward<Args>(args)...);
   }
 
@@ -187,7 +190,7 @@ class ConstructorValidator : public ObjectRef<JniT> {
                                     int>::type = 0>
   ConstructorValidator(Args&&... args)
       : Base(static_cast<typename JniT::StorageType>(
-            Permutation_t<Args...>::OverloadRef::Invoke(
+            Permutation_t<Args...>::_OverloadRef::Invoke(
                 Base::GetJClass(), Base::object_ref_,
                 std::forward<Args>(args)...)
                 .Release())) {
@@ -196,8 +199,8 @@ class ConstructorValidator : public ObjectRef<JniT> {
   }
 
   ConstructorValidator()
-      : Base(Permutation_t<>::OverloadRef::Invoke(Base::GetJClass(),
-                                                  Base::object_ref_)
+      : Base(Permutation_t<>::_OverloadRef::Invoke(Base::GetJClass(),
+                                                   Base::object_ref_)
                  .Release()) {}
 };
 
diff --git a/implementation/overload_ref_test.cc b/implementation/overload_ref_test.cc
index b42e71e6..d452b9b3 100644
--- a/implementation/overload_ref_test.cc
+++ b/implementation/overload_ref_test.cc
@@ -40,7 +40,7 @@ TEST_F(JniTest, MethodRef_AsksForCorrectMethods1) {
   EXPECT_CALL(*env_,
               GetMethodID(_, StrEq("Foo"), StrEq("(Ljava/lang/String;)V")));
 
-  obj("Foo", "test");
+  obj.Call<"Foo">("test");
 }
 
 TEST_F(JniTest, MethodRef_AsksForCorrectMethods2) {
@@ -54,9 +54,9 @@ TEST_F(JniTest, MethodRef_AsksForCorrectMethods2) {
   EXPECT_CALL(*env_,
               GetMethodID(_, StrEq("Foo"), StrEq("(Ljava/lang/String;)V")));
 
-  obj("Foo", 1);
-  // obj("Foo", 2.f); doesn't compile (good).
-  obj("Foo", "test");
+  obj.Call<"Foo">(1);
+  // obj.Call<"Foo">(2.f); doesn't compile (good).
+  obj.Call<"Foo">("test");
 }
 
 TEST_F(JniTest, MethodRef_AsksForCorrectMethods3) {
@@ -77,11 +77,11 @@ TEST_F(JniTest, MethodRef_AsksForCorrectMethods3) {
               GetMethodID(_, StrEq("Foo"),
                           StrEq("(Ljava/lang/String;Ljava/lang/String;)V")));
 
-  obj("Foo", 1);
-  // obj("Foo", 2.f); // doesn't compile (good).
-  obj("Foo", "test");
-  obj("Foo", "test1", "test2");
-  obj("Foo", "this_doesnt", "trigger_method_lookup");
+  obj.Call<"Foo">(1);
+  // obj.Call<"Foo">(2.f); // doesn't compile (good).
+  obj.Call<"Foo">("test");
+  obj.Call<"Foo">("test1", "test2");
+  obj.Call<"Foo">("this_doesnt", "trigger_method_lookup");
 }
 
 TEST_F(JniTest, MethodRef_AsksForCorrectMethodsWhenMultiplePresent4) {
@@ -113,14 +113,14 @@ TEST_F(JniTest, MethodRef_AsksForCorrectMethodsWhenMultiplePresent4) {
                           StrEq("(Ljava/lang/String;Ljava/lang/String;)V")));
   EXPECT_CALL(*env_, GetMethodID(_, StrEq("Baz"), StrEq("(FF)V")));
 
-  obj("Foo", 1);
-  // obj("Foo", 2.f); // doesn't compile (good).
-  obj("Foo", "test");
-  obj("Foo", "test1", "test2");
-  obj("Foo", "this_doesnt", "trigger_method_lookup");
-  obj("Baz", 1);
-  obj("Baz", "test3", "test4");
-  obj("Baz", 1234.f, 5678.f);
+  obj.Call<"Foo">(1);
+  // obj.Call<"Foo">(2.f); // doesn't compile (good).
+  obj.Call<"Foo">("test");
+  obj.Call<"Foo">("test1", "test2");
+  obj.Call<"Foo">("this_doesnt", "trigger_method_lookup");
+  obj.Call<"Baz">(1);
+  obj.Call<"Baz">("test3", "test4");
+  obj.Call<"Baz">(1234.f, 5678.f);
 }
 
 }  // namespace
diff --git a/implementation/proxy_definitions.h b/implementation/proxy_definitions.h
index cd81c70b..9a5b0a1a 100644
--- a/implementation/proxy_definitions.h
+++ b/implementation/proxy_definitions.h
@@ -160,7 +160,7 @@ struct Proxy<JObject,
   template <typename Id>
   struct Helper {
     static constexpr auto kClass{Id::Val()};
-    static constexpr auto kClassLoader{Id::JniT::GetClassLoader()};
+    static constexpr auto kClassLoader{Id::_JniT::GetClassLoader()};
 
     // TODO(b/174272629): Class loaders should also be enforced.
     using type = LocalObject<kClass, kClassLoader, kDefaultJvm>;
@@ -200,7 +200,7 @@ struct Proxy<SelfType,
   template <typename Id>
   struct Helper {
     static constexpr auto kClass{Id::Val()};
-    static constexpr auto kClassLoader{Id::JniT::GetClassLoader()};
+    static constexpr auto kClassLoader{Id::_JniT::GetClassLoader()};
 
     // TODO(b/174272629): Class loaders should also be enforced.
     using type = LocalObject<kClass, kClassLoader, kDefaultJvm>;
diff --git a/implementation/proxy_test.cc b/implementation/proxy_test.cc
index 50652843..3a9a15e5 100644
--- a/implementation/proxy_test.cc
+++ b/implementation/proxy_test.cc
@@ -191,28 +191,28 @@ TEST_F(JniTest, MaterializationTests) {
 
   // Objects can be rvalues (here an x-value).
   LocalObject<kClass2> generator_obj{};
-  LocalObject<kClass> local_1{generator_obj("ReturnsObj")};
+  LocalObject<kClass> local_1{generator_obj.Call<"ReturnsObj">()};
 
   // Objects can also be described with no actual class definition.
   // These objects won't be usable, but they are "name-safe".
-  LocalObject local_2{generator_obj("ReturnsObj")};
+  LocalObject local_2{generator_obj.Call<"ReturnsObj">()};
 
   // doesn't compile because of invalid class (good).
-  // LocalObject<kClass2> local_3 { generator_obj("ReturnsObj") }; }
+  // LocalObject<kClass2> local_3 { generator_obj.Call<"ReturnsObj">() }; }
 
   // Globals can be built from locals.
-  GlobalObject<kClass> global_1{generator_obj("ReturnsObj")};
-  global_1("Bar");
+  GlobalObject<kClass> global_1{generator_obj.Call<"ReturnsObj">()};
+  global_1.Call<"Bar">();
 
   // Globals can be built from expiring locals without a full type.
-  GlobalObject global_2{generator_obj("ReturnsObj")};
+  GlobalObject global_2{generator_obj.Call<"ReturnsObj">()};
 
   // But they lack sufficient definition to have any invocation!
-  // global_2("Bar");
+  // global_2.Call<"Bar">();
 
   // They can be promoted however, and thus restore their type info.
   GlobalObject<kClass> global_3{std::move(global_2)};
-  global_3("Bar");
+  global_3.Call<"Bar">();
 }
 
 }  // namespace jni
diff --git a/implementation/selector_static_info.h b/implementation/selector_static_info.h
index 91093e50..be2275ce 100644
--- a/implementation/selector_static_info.h
+++ b/implementation/selector_static_info.h
@@ -57,6 +57,22 @@ struct Ancestor<IdT, 0> {
 template <typename IdT, std::size_t I>
 using Ancestor_t = typename Ancestor<IdT, I>::type;
 
+template <std::size_t I>
+struct IthRawTypeMember {
+  template <typename T>
+  static constexpr const auto& Val(const T& val) {
+    return IthRawTypeMember<I - 1>::Val(val.raw_);
+  }
+};
+
+template <>
+struct IthRawTypeMember<0> {
+  template <typename T>
+  static constexpr const auto& Val(const T& val) {
+    return val;
+  }
+};
+
 // Helper to generate full signature information for a "selected" value, and
 // possibly some container information.  Here, |Selector| is |MethodSelection|,
 // |FieldSelection|, etc.
@@ -73,22 +89,6 @@ struct SelectorStaticInfo {
   using Selector =
       ParentIfSelf_t<kIsSelf, Ancestor_t<SelectorIn, SelectorIn::kAncestorIdx>>;
 
-  template <std::size_t I>
-  struct IthRawTypeMember {
-    template <typename T>
-    static constexpr const auto& Val(const T& val) {
-      return IthRawTypeMember<I - 1>::Val(val.raw_);
-    }
-  };
-
-  template <>
-  struct IthRawTypeMember<0> {
-    template <typename T>
-    static constexpr const auto& Val(const T& val) {
-      return val;
-    }
-  };
-
   // Strangely, the compiler refuses to peer through Val and loses the
   // constexpr-ness (i.e std::decay_t<decltype(Val())>; is not a constant
   // expression).
diff --git a/implementation/self_test.cc b/implementation/self_test.cc
index 68e81d25..d2fd2e81 100644
--- a/implementation/self_test.cc
+++ b/implementation/self_test.cc
@@ -44,7 +44,7 @@ TEST_F(JniTest, SelfCanBeUsedAsAReturnValue) {
                                  StrEq("()LBuilder;")));
 
   LocalObject<kClass> obj{Fake<jobject>()};
-  obj("build");
+  obj.Call<"build">();
 }
 
 TEST_F(JniTest, SelfCanBeUsedAsAReturnValueAndMaintainsRichDecoration) {
@@ -52,7 +52,7 @@ TEST_F(JniTest, SelfCanBeUsedAsAReturnValueAndMaintainsRichDecoration) {
   EXPECT_CALL(*env_, GetMethodID(_, StrEq("build"), StrEq("()LBuilder;")));
 
   LocalObject<kClass> obj{Fake<jobject>()};
-  obj("build")("build")("build");
+  obj.Call<"build">().Call<"build">().Call<"build">();
 }
 
 TEST_F(JniTest, SelfCanBeUsedAsParam) {
@@ -62,7 +62,7 @@ TEST_F(JniTest, SelfCanBeUsedAsParam) {
   LocalObject<kClass> obj_1{Fake<jobject>(1)};
   LocalObject<kClass> obj_2{Fake<jobject>(2)};
 
-  obj_1("takesBuilder", obj_2);
+  obj_1.Call<"takesBuilder">(obj_2);
 }
 
 }  // namespace
diff --git a/implementation/signature_method_test.cc b/implementation/signature_method_test.cc
index f23f383d..c51164e5 100644
--- a/implementation/signature_method_test.cc
+++ b/implementation/signature_method_test.cc
@@ -81,7 +81,7 @@ static constexpr auto Sig_v =
 ////////////////////////////////////////////////////////////////////////////////
 using kSelf1 = Id<JT, IdType::CLASS, kNoIdx, 0, kNoIdx, 0>;
 using JniSelfT =
-    JniTSelector<jni::LocalArray<jobject, 3, kClass1>::JniT_, -1, 0>;
+    JniTSelector<jni::LocalArray<jobject, 3, kClass1>::_JniT, -1, 0>;
 using StaticSelectorInfoSelf = SelectorStaticInfo<JniSelfT>;
 
 static_assert(std::string_view{"LkClass1;"} ==
diff --git a/implementation/static_ref.h b/implementation/static_ref.h
index 3aa22f82..0b78ec3f 100644
--- a/implementation/static_ref.h
+++ b/implementation/static_ref.h
@@ -42,22 +42,28 @@ namespace jni {
 template <typename CrtpBase_, const auto& class_v_, const auto& class_loader_v_,
           const auto& jvm_v_>
 struct StaticRefHelper {
-  using JniT = JniT<jobject, class_v_, class_loader_v_, jvm_v_>;
+  using _JniT = JniT<jobject, class_v_, class_loader_v_, jvm_v_>;
 
   // C++17 augmentations.
-  using MethodMapT = metaprogramming::InvocableMap<CrtpBase_, JniT::static_v,
-                                                   typename JniT::StaticT,
-                                                   &JniT::StaticT::methods_>;
-  using FieldMapT = metaprogramming::QueryableMap_t<CrtpBase_, JniT::static_v,
-                                                    &JniT::StaticT::fields_>;
+  using MethodMapT = metaprogramming::InvocableMap<
+      CrtpBase_, _JniT::static_v, typename _JniT::StaticT,
+      decltype(&_JniT::StaticT::methods_), &_JniT::StaticT::methods_>;
+  using FieldMapT =
+      metaprogramming::QueryableMap_t<CrtpBase_, _JniT::static_v,
+
+                                      decltype(&_JniT::StaticT::fields_),
+                                      &_JniT::StaticT::fields_>;
 
   // C++ 20 augmentations.
-  using MethodMap20T =
-      metaprogramming::InvocableMap20_t<CrtpBase_, JniT::static_v,
-                                        &JniT::StaticT::methods_>;
-  using FieldMap20T =
-      metaprogramming::QueryableMap20_t<CrtpBase_, JniT::static_v,
-                                        &JniT::StaticT::fields_>;
+  using MethodMap20T = metaprogramming::InvocableMap20<
+      CrtpBase_, _JniT::static_v,
+      StaticRefHelper<CrtpBase_, class_v_, class_loader_v_, jvm_v_>,
+      decltype(&_JniT::StaticT::methods_), &_JniT::StaticT::methods_>;
+
+  using FieldMap20T = metaprogramming::QueryableMap20<
+      CrtpBase_, _JniT::static_v,
+      StaticRefHelper<CrtpBase_, class_v_, class_loader_v_, jvm_v_>,
+      decltype(&_JniT::StaticT::fields_), &_JniT::StaticT::fields_>;
 };
 
 // C++17 augmentations.
@@ -100,10 +106,10 @@ struct StaticRef
                                    class_v_, class_loader_v_, jvm_v_>,
       StaticRefHelperFieldMap20_t<StaticRef<class_v_, class_loader_v_, jvm_v_>,
                                   class_v_, class_loader_v_, jvm_v_> {
-  using JniT = JniT<jobject, class_v_, class_loader_v_, jvm_v_>;
+  using _JniT = JniT<jobject, class_v_, class_loader_v_, jvm_v_>;
 
   jclass GetJClass() const {
-    return ClassRef_t<JniT>::GetAndMaybeLoadClassRef(nullptr);
+    return ClassRef_t<_JniT>::GetAndMaybeLoadClassRef(nullptr);
   }
 
   ////////////////////////////////////////////////////////////////////////////////
@@ -114,7 +120,7 @@ struct StaticRef
 #if __clang__
   template <size_t I, typename... Args>
   auto InvocableMapCall(const char* key, Args&&... args) const {
-    using IdT = Id<JniT, IdType::STATIC_OVERLOAD_SET, I, kNoIdx, kNoIdx, 0>;
+    using IdT = Id<_JniT, IdType::STATIC_OVERLOAD_SET, I, kNoIdx, kNoIdx, 0>;
     using MethodSelectionForArgs =
         OverloadSelector<IdT, IdType::STATIC_OVERLOAD,
                          IdType::STATIC_OVERLOAD_PARAM, Args...>;
@@ -122,13 +128,13 @@ struct StaticRef
     static_assert(MethodSelectionForArgs::kIsValidArgSet,
                   "JNI Error: Invalid argument set.");
 
-    return MethodSelectionForArgs::OverloadRef::Invoke(
+    return MethodSelectionForArgs::_OverloadRef::Invoke(
         GetJClass(), nullptr, std::forward<Args>(args)...);
   }
 
   template <size_t I>
   auto QueryableMapCall(const char* key) const {
-    return FieldRef<JniT, IdType::STATIC_FIELD, I>{GetJClass(), nullptr};
+    return FieldRef<_JniT, IdType::STATIC_FIELD, I>{GetJClass(), nullptr};
   }
 #endif  // __clang__
 
@@ -137,7 +143,7 @@ struct StaticRef
   template <size_t I, metaprogramming::StringLiteral key_literal,
             typename... Args>
   auto InvocableMap20Call(Args&&... args) const {
-    using IdT = Id<JniT, IdType::STATIC_OVERLOAD_SET, I, kNoIdx, kNoIdx, 0>;
+    using IdT = Id<_JniT, IdType::STATIC_OVERLOAD_SET, I, kNoIdx, kNoIdx, 0>;
     using MethodSelectionForArgs =
         OverloadSelector<IdT, IdType::STATIC_OVERLOAD,
                          IdType::STATIC_OVERLOAD_PARAM, Args...>;
@@ -145,14 +151,14 @@ struct StaticRef
     static_assert(MethodSelectionForArgs::kIsValidArgSet,
                   "JNI Error: Invalid argument set.");
 
-    return MethodSelectionForArgs::OverloadRef::Invoke(
+    return MethodSelectionForArgs::_OverloadRef::Invoke(
         GetJClass(), nullptr, std::forward<Args>(args)...);
   }
 
   // Invoked through CRTP from QueryableMap20, C++20 only.
   template <size_t I, metaprogramming::StringLiteral key_literal>
   auto QueryableMap20Call() const {
-    return FieldRef<JniT, IdType::STATIC_FIELD, I>{GetJClass(), nullptr};
+    return FieldRef<_JniT, IdType::STATIC_FIELD, I>{GetJClass(), nullptr};
   }
 #endif  // __cplusplus >= 202002L
 };
diff --git a/implementation/static_ref_test.cc b/implementation/static_ref_test.cc
index 2a560458..27ce5d4b 100644
--- a/implementation/static_ref_test.cc
+++ b/implementation/static_ref_test.cc
@@ -73,8 +73,8 @@ TEST_F(JniTest, StaticBooleanField) {
   EXPECT_CALL(*env_, SetStaticBooleanField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["booleanField"].Get());
-  StaticRef<kClass>{}["booleanField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"booleanField">().Get());
+  StaticRef<kClass>{}.Access<"booleanField">().Set(true);
 }
 
 TEST_F(JniTest, StaticByteField) {
@@ -85,8 +85,8 @@ TEST_F(JniTest, StaticByteField) {
   EXPECT_CALL(*env_, SetStaticByteField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["byteField"].Get());
-  StaticRef<kClass>{}["byteField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"byteField">().Get());
+  StaticRef<kClass>{}.Access<"byteField">().Set(true);
 }
 
 TEST_F(JniTest, StaticCharField) {
@@ -97,8 +97,8 @@ TEST_F(JniTest, StaticCharField) {
   EXPECT_CALL(*env_, SetStaticCharField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["charField"].Get());
-  StaticRef<kClass>{}["charField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"charField">().Get());
+  StaticRef<kClass>{}.Access<"charField">().Set(true);
 }
 
 TEST_F(JniTest, StaticShortField) {
@@ -109,8 +109,8 @@ TEST_F(JniTest, StaticShortField) {
   EXPECT_CALL(*env_, SetStaticShortField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["shortField"].Get());
-  StaticRef<kClass>{}["shortField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"shortField">().Get());
+  StaticRef<kClass>{}.Access<"shortField">().Set(true);
 }
 
 TEST_F(JniTest, StaticIntField) {
@@ -121,8 +121,8 @@ TEST_F(JniTest, StaticIntField) {
   EXPECT_CALL(*env_, SetStaticIntField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["intField"].Get());
-  StaticRef<kClass>{}["intField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"intField">().Get());
+  StaticRef<kClass>{}.Access<"intField">().Set(true);
 }
 
 TEST_F(JniTest, StaticLongField) {
@@ -133,8 +133,8 @@ TEST_F(JniTest, StaticLongField) {
   EXPECT_CALL(*env_, SetStaticLongField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["longField"].Get());
-  StaticRef<kClass>{}["longField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"longField">().Get());
+  StaticRef<kClass>{}.Access<"longField">().Set(true);
 }
 
 TEST_F(JniTest, StaticFloatField) {
@@ -145,8 +145,8 @@ TEST_F(JniTest, StaticFloatField) {
   EXPECT_CALL(*env_, SetStaticFloatField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["floatField"].Get());
-  StaticRef<kClass>{}["floatField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"floatField">().Get());
+  StaticRef<kClass>{}.Access<"floatField">().Set(true);
 }
 
 TEST_F(JniTest, StaticDoubleField) {
@@ -157,8 +157,8 @@ TEST_F(JniTest, StaticDoubleField) {
   EXPECT_CALL(*env_, SetStaticDoubleField(_, Fake<jfieldID>(), true));
 
   LocalObject<kClass> obj;
-  EXPECT_TRUE(StaticRef<kClass>{}["doubleField"].Get());
-  StaticRef<kClass>{}["doubleField"].Set(true);
+  EXPECT_TRUE(StaticRef<kClass>{}.Access<"doubleField">().Get());
+  StaticRef<kClass>{}.Access<"doubleField">().Set(true);
 }
 
 TEST_F(JniTest, StaticField_ObjectGet) {
@@ -168,7 +168,8 @@ TEST_F(JniTest, StaticField_ObjectGet) {
   EXPECT_CALL(*env_, GetStaticObjectField(_, Fake<jfieldID>()))
       .WillOnce(Return(Fake<jobject>()));
 
-  jni::LocalObject<kClass2> obj = StaticRef<kClass>{}["classField"].Get();
+  jni::LocalObject<kClass2> obj =
+      StaticRef<kClass>{}.Access<"classField">().Get();
 }
 
 TEST_F(JniTest, StaticField_StringSet) {
@@ -178,7 +179,7 @@ TEST_F(JniTest, StaticField_StringSet) {
   EXPECT_CALL(*env_,
               SetStaticObjectField(_, Fake<jfieldID>(), Fake<jstring>()));
 
-  StaticRef<kClass>{}["stringField"].Set(
+  StaticRef<kClass>{}.Access<"stringField">().Set(
       LocalString{AdoptLocal{}, Fake<jstring>()});
 }
 
@@ -189,7 +190,7 @@ TEST_F(JniTest, StaticField_ObjectSet) {
   EXPECT_CALL(*env_,
               SetStaticObjectField(_, Fake<jfieldID>(), Fake<jobject>()));
 
-  StaticRef<kClass>{}["classField"].Set(
+  StaticRef<kClass>{}.Access<"classField">().Set(
       LocalObject<kClass2>{AdoptLocal{}, Fake<jobject>()});
 }
 
@@ -199,7 +200,8 @@ TEST_F(JniTest, StaticField_SelfGet) {
   EXPECT_CALL(*env_, GetStaticObjectField(_, Fake<jfieldID>()))
       .WillOnce(Return(Fake<jobject>()));
 
-  jni::LocalObject<kClass> obj = StaticRef<kClass>{}["selfField"].Get();
+  jni::LocalObject<kClass> obj =
+      StaticRef<kClass>{}.Access<"selfField">().Get();
 }
 
 TEST_F(JniTest, StaticField_SelfSet) {
@@ -208,7 +210,7 @@ TEST_F(JniTest, StaticField_SelfSet) {
   EXPECT_CALL(*env_,
               SetStaticObjectField(_, Fake<jfieldID>(), Fake<jobject>()));
 
-  StaticRef<kClass>{}["selfField"].Set(
+  StaticRef<kClass>{}.Access<"selfField">().Set(
       LocalObject<kClass>{AdoptLocal{}, Fake<jobject>()});
 }
 
@@ -276,21 +278,21 @@ TEST_F(JniTest, StaticExerciseAllReturns) {
 
   EXPECT_CALL(*env_, CallStaticObjectMethodV).Times(5);
 
-  StaticRef<kMethodClass>{}("booleanMethod");
-  StaticRef<kMethodClass>{}("byteMethod");
-  StaticRef<kMethodClass>{}("charMethod");
-  StaticRef<kMethodClass>{}("shortMethod");
-  StaticRef<kMethodClass>{}("intMethod");
-  StaticRef<kMethodClass>{}("longMethod");
-  StaticRef<kMethodClass>{}("floatMethod");
-  StaticRef<kMethodClass>{}("doubleMethod");
-  StaticRef<kMethodClass>{}("stringMethod");
-
-  StaticRef<kMethodClass>{}("objectMethod");
-  StaticRef<kMethodClass>{}("rank1ArrayMethod");
-  StaticRef<kMethodClass>{}("rank2ArrayMethod");
-
-  LocalObject<kClass> self_ret = StaticRef<kMethodClass>{}("selfMethod");
+  StaticRef<kMethodClass>{}.Call<"booleanMethod">();
+  StaticRef<kMethodClass>{}.Call<"byteMethod">();
+  StaticRef<kMethodClass>{}.Call<"charMethod">();
+  StaticRef<kMethodClass>{}.Call<"shortMethod">();
+  StaticRef<kMethodClass>{}.Call<"intMethod">();
+  StaticRef<kMethodClass>{}.Call<"longMethod">();
+  StaticRef<kMethodClass>{}.Call<"floatMethod">();
+  StaticRef<kMethodClass>{}.Call<"doubleMethod">();
+  StaticRef<kMethodClass>{}.Call<"stringMethod">();
+
+  StaticRef<kMethodClass>{}.Call<"objectMethod">();
+  StaticRef<kMethodClass>{}.Call<"rank1ArrayMethod">();
+  StaticRef<kMethodClass>{}.Call<"rank2ArrayMethod">();
+
+  LocalObject<kClass> self_ret = StaticRef<kMethodClass>{}.Call<"selfMethod">();
 }
 
 // clang-format off
@@ -339,23 +341,23 @@ TEST_F(JniTest, StaticExerciseAllTypesThroughSingleParam) {
 
   EXPECT_CALL(*env_, CallStaticVoidMethodV).Times(13);
 
-  StaticRef<kMethodClassSingleParam>{}("booleanMethod", jboolean{true});
-  StaticRef<kMethodClassSingleParam>{}("byteMethod", jbyte{1});
-  StaticRef<kMethodClassSingleParam>{}("charMethod", jchar{'a'});
-  StaticRef<kMethodClassSingleParam>{}("shortMethod", jshort{1});
-  StaticRef<kMethodClassSingleParam>{}("intMethod", jint{123});
-  StaticRef<kMethodClassSingleParam>{}("longMethod", jlong{456});
-  StaticRef<kMethodClassSingleParam>{}("floatMethod", jfloat{789.f});
-  StaticRef<kMethodClassSingleParam>{}("doubleMethod", jdouble{101.});
-  StaticRef<kMethodClassSingleParam>{}("stringMethod", "test");
+  StaticRef<kMethodClassSingleParam>{}.Call<"booleanMethod">(jboolean{true});
+  StaticRef<kMethodClassSingleParam>{}.Call<"byteMethod">(jbyte{1});
+  StaticRef<kMethodClassSingleParam>{}.Call<"charMethod">(jchar{'a'});
+  StaticRef<kMethodClassSingleParam>{}.Call<"shortMethod">(jshort{1});
+  StaticRef<kMethodClassSingleParam>{}.Call<"intMethod">(jint{123});
+  StaticRef<kMethodClassSingleParam>{}.Call<"longMethod">(jlong{456});
+  StaticRef<kMethodClassSingleParam>{}.Call<"floatMethod">(jfloat{789.f});
+  StaticRef<kMethodClassSingleParam>{}.Call<"doubleMethod">(jdouble{101.});
+  StaticRef<kMethodClassSingleParam>{}.Call<"stringMethod">("test");
 
   // It would be more complete to exercise all types here.
-  StaticRef<kMethodClassSingleParam>{}("objectMethod", Fake<jobject>());
-  StaticRef<kMethodClassSingleParam>{}("rank1ArrayMethod",
-                                       Fake<jobjectArray>());
-  StaticRef<kMethodClassSingleParam>{}("rank2ArrayMethod",
-                                       Fake<jobjectArray>());
-  StaticRef<kMethodClassSingleParam>{}("selfMethod", Fake<jobject>());
+  StaticRef<kMethodClassSingleParam>{}.Call<"objectMethod">(Fake<jobject>());
+  StaticRef<kMethodClassSingleParam>{}.Call<"rank1ArrayMethod">(
+      Fake<jobjectArray>());
+  StaticRef<kMethodClassSingleParam>{}.Call<"rank2ArrayMethod">(
+      Fake<jobjectArray>());
+  StaticRef<kMethodClassSingleParam>{}.Call<"selfMethod">(Fake<jobject>());
 }
 
 TEST_F(JniTest, StaticExerciseComplexSetOfParams) {
@@ -365,9 +367,9 @@ TEST_F(JniTest, StaticExerciseComplexSetOfParams) {
   EXPECT_CALL(*env_, GetStaticMethodID(_, StrEq("complexFunc"),
                                        StrEq("([[LkClass2;IFLkClass3;)F")));
 
-  StaticRef<kMethodClass>{}("simpleFunc", 123.f);
-  StaticRef<kMethodClass>{}("complexFunc", jobjectArray{nullptr}, 123, 456.f,
-                            jobject{nullptr});
+  StaticRef<kMethodClass>{}.Call<"simpleFunc">(123.f);
+  StaticRef<kMethodClass>{}.Call<"complexFunc">(jobjectArray{nullptr}, 123,
+                                                456.f, jobject{nullptr});
 }
 
 }  // namespace
diff --git a/implementation/string_ref_test.cc b/implementation/string_ref_test.cc
index 08156c61..f9ab2920 100644
--- a/implementation/string_ref_test.cc
+++ b/implementation/string_ref_test.cc
@@ -91,7 +91,7 @@ TEST_F(JniTest, LocalString_CopiesFromJString) {
 
 TEST_F(JniTest, LocalString_ConstructsFromOutputOfMethod) {
   LocalObject<kClass> obj{};
-  LocalString str{obj("Foo")};
+  LocalString str{obj.Call<"Foo">()};
 }
 
 TEST_F(JniTest, LocalString_ConstructsFromByteArray) {
@@ -151,12 +151,12 @@ TEST_F(JniTest, LocalString_PinsAndUnpinsMemoryForLocals) {
 TEST_F(JniTest, LocalString_AllowsLValueLocalString) {
   LocalObject<kClass> obj{};
   LocalString local_string{"abcde"};
-  obj("TakesStrParam", local_string);
+  obj.Call<"TakesStrParam">(local_string);
 }
 
 TEST_F(JniTest, LocalString_AllowsRValueLocalString) {
   LocalObject<kClass> obj{};
-  obj("TakesStrParam", LocalString{"abcde"});
+  obj.Call<"TakesStrParam">(LocalString{"abcde"});
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -180,7 +180,7 @@ TEST_F(JniTest, GlobalString_GlobalsReleaseWithGlobalMechanism) {
 
 TEST_F(JniTest, GlobalString_ConstructsFromOutputOfMethod) {
   LocalObject<kClass> obj{};
-  GlobalString str{obj("Foo")};
+  GlobalString str{obj.Call<"Foo">()};
 }
 
 TEST_F(JniTest, GlobalString_ConstructsFromByteArray) {
@@ -227,12 +227,12 @@ TEST_F(JniTest, GlobalString_PinsAndUnpinsMemoryForLocals) {
 TEST_F(JniTest, GlobalString_AllowsLValueGlobalString) {
   LocalObject<kClass> obj{};
   GlobalString global_string{"abcde"};
-  obj("TakesStrParam", global_string);
+  obj.Call<"TakesStrParam">(global_string);
 }
 
 TEST_F(JniTest, GlobalString_AllowsRValueGlobalString) {
   LocalObject<kClass> obj{};
-  obj("TakesStrParam", GlobalString{"abcde"});
+  obj.Call<"TakesStrParam">(GlobalString{"abcde"});
 }
 
 }  // namespace
diff --git a/implementation/thread_guard_test.cc b/implementation/thread_guard_test.cc
index 4ecd1ab2..5d054c44 100644
--- a/implementation/thread_guard_test.cc
+++ b/implementation/thread_guard_test.cc
@@ -99,7 +99,7 @@ TEST_F(JniTest, AllowsMoveCtorIntoLambdaWithThreadGuardUsage) {
 
   std::thread worker{[gobj{std::move(global_obj)}]() mutable {
     ThreadGuard thread_guard{};
-    gobj["intVal1"].Get();
+    gobj.Access<"intVal1">().Get();
   }};
 
   worker.join();
diff --git a/java/com/google/main.cc b/java/com/google/main.cc
index de5ea5ea..df9fca2f 100644
--- a/java/com/google/main.cc
+++ b/java/com/google/main.cc
@@ -46,7 +46,7 @@ void RunIterationsToCompletion(jni::JvmRef<jni::kDefaultJvm> *jvm_ref) {
 
   for (int i = 0; i < kNumIterations; ++i) {
     printf("Iteration %i: %s\n", i,
-           random_string("format").Pin().ToString().data());
+           random_string.Call<"format">().Pin().ToString().data());
   }
 }
 
diff --git a/javatests/com/jnibind/android/array_test_jni.cc b/javatests/com/jnibind/android/array_test_jni.cc
index e193bf68..864f8c6b 100644
--- a/javatests/com/jnibind/android/array_test_jni.cc
+++ b/javatests/com/jnibind/android/array_test_jni.cc
@@ -55,11 +55,11 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeBooleanTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jboolean> local_arr{boolean_array};
-  rjni_test_helper("rJniBooleanArray", false, local_arr);
+  rjni_test_helper.Call<"rJniBooleanArray">(false, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniBooleanArray", false,
-                   LocalArray<jboolean>{boolean_array});
+  rjni_test_helper.Call<"rJniBooleanArray">(
+      false, LocalArray<jboolean>{boolean_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jboolean> new_array{8};
@@ -69,7 +69,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeBooleanTests(
       array_view.ptr()[i] = true;
     }
   }
-  rjni_test_helper("rJniBooleanArray", true, new_array);
+  rjni_test_helper.Call<"rJniBooleanArray">(true, new_array);
 
   // You can pull the view multiple times.
   {
@@ -78,7 +78,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeBooleanTests(
       array_view.ptr()[i] = true;
     }
   }
-  rjni_test_helper("rJniBooleanArray", true, new_array);
+  rjni_test_helper.Call<"rJniBooleanArray">(true, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeByteTests(
@@ -87,10 +87,11 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeByteTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jbyte> local_arr{byte_array};
-  rjni_test_helper("rJniByteArray", jbyte{0}, local_arr);
+  rjni_test_helper.Call<"rJniByteArray">(jbyte{0}, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniByteArray", jbyte{0}, LocalArray<jbyte>{byte_array});
+  rjni_test_helper.Call<"rJniByteArray">(jbyte{0},
+                                         LocalArray<jbyte>{byte_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jbyte> new_array{8};
@@ -100,7 +101,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeByteTests(
       array_view.ptr()[i] = static_cast<jbyte>(i);
     }
   }
-  rjni_test_helper("rJniByteArray", jbyte{0}, new_array);
+  rjni_test_helper.Call<"rJniByteArray">(jbyte{0}, new_array);
 
   // You can pull the view multiple times.
   {
@@ -109,7 +110,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeByteTests(
       array_view.ptr()[i] += 5;
     }
   }
-  rjni_test_helper("rJniByteArray", jbyte{5}, new_array);
+  rjni_test_helper.Call<"rJniByteArray">(jbyte{5}, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeCharTests(
@@ -118,10 +119,11 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeCharTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jchar> local_arr{char_array};
-  rjni_test_helper("rJniCharArray", jchar{0}, local_arr);
+  rjni_test_helper.Call<"rJniCharArray">(jchar{0}, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniCharArray", jchar{0}, LocalArray<jchar>{char_array});
+  rjni_test_helper.Call<"rJniCharArray">(jchar{0},
+                                         LocalArray<jchar>{char_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jchar> new_array{8};
@@ -131,7 +133,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeCharTests(
       array_view.ptr()[i] = static_cast<jchar>(i);
     }
   }
-  rjni_test_helper("rJniCharArray", jchar{0}, new_array);
+  rjni_test_helper.Call<"rJniCharArray">(jchar{0}, new_array);
 
   // You can pull the view multiple times.
   {
@@ -140,7 +142,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeCharTests(
       array_view.ptr()[i] += 5;
     }
   }
-  rjni_test_helper("rJniCharArray", jchar{5}, new_array);
+  rjni_test_helper.Call<"rJniCharArray">(jchar{5}, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeShortTests(
@@ -149,11 +151,11 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeShortTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jshort> local_arr{short_array};
-  rjni_test_helper("rJniShortArray", jshort{0}, local_arr);
+  rjni_test_helper.Call<"rJniShortArray">(jshort{0}, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniShortArray", jshort{0},
-                   LocalArray<jshort>{short_array});
+  rjni_test_helper.Call<"rJniShortArray">(jshort{0},
+                                          LocalArray<jshort>{short_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jshort> new_array{8};
@@ -163,7 +165,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeShortTests(
       array_view.ptr()[i] = static_cast<jshort>(i);
     }
   }
-  rjni_test_helper("rJniShortArray", jshort{0}, new_array);
+  rjni_test_helper.Call<"rJniShortArray">(jshort{0}, new_array);
 
   // You can pull the view multiple times.
   {
@@ -172,7 +174,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeShortTests(
       array_view.ptr()[i] += 5;
     }
   }
-  rjni_test_helper("rJniShortArray", jshort{5}, new_array);
+  rjni_test_helper.Call<"rJniShortArray">(jshort{5}, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeIntTests(
@@ -181,10 +183,10 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeIntTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jint> local_arr{int_array};
-  rjni_test_helper("rJniIntArray", 0, local_arr);
+  rjni_test_helper.Call<"rJniIntArray">(0, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniIntArray", 0, LocalArray<jint>{int_array});
+  rjni_test_helper.Call<"rJniIntArray">(0, LocalArray<jint>{int_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jint> new_array{8};
@@ -194,7 +196,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeIntTests(
       array_view.ptr()[i] = i;
     }
   }
-  rjni_test_helper("rJniIntArray", 0, new_array);
+  rjni_test_helper.Call<"rJniIntArray">(0, new_array);
 
   // You can pull the view multiple times.
   {
@@ -203,7 +205,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeIntTests(
       array_view.ptr()[i] += 5;
     }
   }
-  rjni_test_helper("rJniIntArray", 5, new_array);
+  rjni_test_helper.Call<"rJniIntArray">(5, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeLongTests(
@@ -212,10 +214,11 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeLongTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jlong> local_arr{long_array};
-  rjni_test_helper("rJniLongArray", jlong{0}, local_arr);
+  rjni_test_helper.Call<"rJniLongArray">(jlong{0}, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniLongArray", jlong{0}, LocalArray<jlong>{long_array});
+  rjni_test_helper.Call<"rJniLongArray">(jlong{0},
+                                         LocalArray<jlong>{long_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jlong> new_array{8};
@@ -225,7 +228,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeLongTests(
       array_view.ptr()[i] = static_cast<jlong>(i);
     }
   }
-  rjni_test_helper("rJniLongArray", jlong{0}, new_array);
+  rjni_test_helper.Call<"rJniLongArray">(jlong{0}, new_array);
 
   // You can pull the view multiple times.
   {
@@ -234,7 +237,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeLongTests(
       array_view.ptr()[i] += 5;
     }
   }
-  rjni_test_helper("rJniLongArray", jlong{5}, new_array);
+  rjni_test_helper.Call<"rJniLongArray">(jlong{5}, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeFloatTests(
@@ -242,7 +245,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeFloatTests(
   LocalObject<kArrayTest> rjni_test_helper{test_fixture};
 
   LocalArray<jfloat> local_arr{float_array};
-  rjni_test_helper("rJniFloatArray", 0.f, local_arr);
+  rjni_test_helper.Call<"rJniFloatArray">(0.f, local_arr);
 
   {
     ArrayView array_view{local_arr.Pin(true)};
@@ -250,7 +253,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeFloatTests(
       array_view.ptr()[i] += 2.5f;
     }
   }
-  rjni_test_helper("rJniFloatArray", 2.5f, local_arr);
+  rjni_test_helper.Call<"rJniFloatArray">(2.5f, local_arr);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeDoubleTests(
@@ -259,11 +262,11 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeDoubleTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jdouble> local_arr{double_array};
-  rjni_test_helper("rJniDoubleArray", jdouble{0}, local_arr);
+  rjni_test_helper.Call<"rJniDoubleArray">(jdouble{0}, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniDoubleArray", jdouble{0},
-                   LocalArray<jdouble>{double_array});
+  rjni_test_helper.Call<"rJniDoubleArray">(jdouble{0},
+                                           LocalArray<jdouble>{double_array});
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jdouble> new_array{8};
@@ -273,7 +276,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeDoubleTests(
       array_view.ptr()[i] = static_cast<jdouble>(i);
     }
   }
-  rjni_test_helper("rJniDoubleArray", jdouble{0}, new_array);
+  rjni_test_helper.Call<"rJniDoubleArray">(jdouble{0}, new_array);
 
   // You can pull the view multiple times.
   {
@@ -282,7 +285,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeDoubleTests(
       array_view.ptr()[i] += 5;
     }
   }
-  rjni_test_helper("rJniDoubleArray", jdouble{5}, new_array);
+  rjni_test_helper.Call<"rJniDoubleArray">(jdouble{5}, new_array);
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeObjectTests(
@@ -291,12 +294,12 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeObjectTests(
 
   // Simple lvalue pass through works as expected.
   LocalArray<jobject, 1, kObjectTestHelperClass> local_arr{object_array};
-  rjni_test_helper("rJniObjectArray", 0, local_arr);
+  rjni_test_helper.Call<"rJniObjectArray">(0, local_arr);
 
   // Simple rvalue pass through works as expected.
-  rjni_test_helper("rJniObjectArray", 5,
-                   LocalArray<jobject, 1, kObjectTestHelperClass>{
-                       1, LocalObject<kObjectTestHelperClass>{5, 5, 5}});
+  rjni_test_helper.Call<"rJniObjectArray">(
+      5, LocalArray<jobject, 1, kObjectTestHelperClass>{
+             1, LocalObject<kObjectTestHelperClass>{5, 5, 5}});
 
   // Building a new array, and setting all the values by hand works.
   LocalObject<kObjectTestHelperClass> obj{0, 0, 0};
@@ -307,17 +310,17 @@ JNIEXPORT void JNICALL Java_com_jnibind_android_ArrayTest_nativeObjectTests(
           i, LocalObject<kObjectTestHelperClass>{jint{i}, jint{i}, jint{i}});
     }
   }
-  rjni_test_helper("rJniObjectArray", 0, new_array);
+  rjni_test_helper.Call<"rJniObjectArray">(0, new_array);
 
   // You can pull the view multiple times.
   {
     for (int i = 0; i < new_array.Length(); ++i) {
-      new_array.Set(i,
-                    LocalObject<kObjectTestHelperClass>{2, 2, 2}(
-                        "returnNewObjectWithFieldSetToSum", new_array.Get(i)));
+      new_array.Set(
+          i, LocalObject<kObjectTestHelperClass>{2, 2, 2}
+                 .Call<"returnNewObjectWithFieldSetToSum">(new_array.Get(i)));
     }
   }
-  rjni_test_helper("rJniObjectArray", 2, new_array);
+  rjni_test_helper.Call<"rJniObjectArray">(2, new_array);
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/android/class_loader_test_jni.cc b/javatests/com/jnibind/android/class_loader_test_jni.cc
index 83f84975..9a8da85b 100644
--- a/javatests/com/jnibind/android/class_loader_test_jni.cc
+++ b/javatests/com/jnibind/android/class_loader_test_jni.cc
@@ -74,8 +74,8 @@ Java_com_jnibind_android_ClassLoaderTest_jniBuildNewObjectsFromClassLoader(
   LocalObject helper_obj =
       class_loader.BuildLocalObject<kObjectTestHelperClass>(1, 2, 3);
   return LocalObject<kClassLoaderTestClass, kTestClassLoader,
-                     kJvmWithCustomClassLoaderSupport>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject", helper_obj)
+                     kJvmWithCustomClassLoaderSupport>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(helper_obj)
       .Release();
 }
 
@@ -85,8 +85,8 @@ Java_com_jnibind_android_ClassLoaderTest_jniBuildNewObjectsFromDefaultClassLoade
   GlobalClassLoader<kLiteTestClassLoader, kJvmWithCustomClassLoaderSupport>
       class_loader{PromoteToGlobal{}, jclass_loader_obj};
   LocalObject<kObjectTestHelperClass> helper_obj{2, 3, 4};
-  return LocalObject<kClassLoaderTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject", helper_obj)
+  return LocalObject<kClassLoaderTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(helper_obj)
       .Release();
 }
 
@@ -101,9 +101,9 @@ Java_com_jnibind_android_ClassLoaderTest_jniBuildsRemoteSubclassFromClassLoader(
           jint{value});
   LocalObject<kClassLoaderHelperClass, kCustomClassLoader,
               kJvmWithCustomClassLoaderSupport>
-      parent_obj{helper_obj("castToParent")};
+      parent_obj{helper_obj.Call<"castToParent">()};
 
-  return parent_obj("getValue");
+  return parent_obj.Call<"getValue">();
 }
 
 JNIEXPORT jint JNICALL
@@ -116,7 +116,7 @@ Java_com_jnibind_android_ClassLoaderTest_jniBuildsRemoteClassFromClassLoader(
       helper_obj =
           class_loader.BuildLocalObject<kClassLoaderHelperClass>(jint{value});
 
-  return helper_obj("getValue");
+  return helper_obj.Call<"getValue">();
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/android/context_test_jni.cc b/javatests/com/jnibind/android/context_test_jni.cc
index 6ae2de6e..faef1225 100644
--- a/javatests/com/jnibind/android/context_test_jni.cc
+++ b/javatests/com/jnibind/android/context_test_jni.cc
@@ -39,15 +39,16 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_android_ContextTest_DoSetup(JNIEnv* env,
-                                                                 jclass) {
+                                                                    jclass) {
   jvm.reset(new jni::JvmRef<jni::kDefaultJvm>{env});
 }
 
 JNIEXPORT jlong JNICALL
-Java_com_jnibind_android_ContextTest_CreateNativeContextObject(JNIEnv* env, jclass,
-                                                            jint val) {
+Java_com_jnibind_android_ContextTest_CreateNativeContextObject(JNIEnv* env,
+                                                               jclass,
+                                                               jint val) {
   auto* ctx_struct = new ContextStruct{GlobalObject<kObjectTestHelperClass>{}};
-  ctx_struct->obj["intVal1"].Set(jint{val});
+  ctx_struct->obj.Access<"intVal1">().Set(jint{val});
 
   return reinterpret_cast<jlong>(ctx_struct);
 }
@@ -57,25 +58,28 @@ Java_com_jnibind_android_ContextTest_CreateNativeContextObjectSetValToSum(
     JNIEnv* env, jclass, jint val1, jint val2) {
   // Creates a temporary test helper, calls its member method, and releases the
   // returned object across the C API boundary (then destroys the temporary).
-  return jni::LocalObject<kObjectTestHelperClass>{}(
-             "returnNewObjectWithFieldSetToSum", val1, val2)
+  return jni::LocalObject<kObjectTestHelperClass>{}
+      .Call<"returnNewObjectWithFieldSetToSum">(val1, val2)
       .Release();
 }
 
-JNIEXPORT jobject JNICALL Java_com_jnibind_android_ContextTest_QueryNativeObject(
-    JNIEnv* env, jclass, void* ctx_void_ptr) {
+JNIEXPORT jobject JNICALL
+Java_com_jnibind_android_ContextTest_QueryNativeObject(JNIEnv* env, jclass,
+                                                       void* ctx_void_ptr) {
   ContextStruct* ctx_struct = static_cast<ContextStruct*>(ctx_void_ptr);
   return jobject{ctx_struct->obj};
 }
 
-JNIEXPORT jobject JNICALL Java_com_jnibind_android_ContextTest_ExtractNativeObject(
-    JNIEnv* env, jclass, void* ctx_void_ptr) {
+JNIEXPORT jobject JNICALL
+Java_com_jnibind_android_ContextTest_ExtractNativeObject(JNIEnv* env, jclass,
+                                                         void* ctx_void_ptr) {
   ContextStruct* ctx_struct = static_cast<ContextStruct*>(ctx_void_ptr);
   return ctx_struct->obj.Release();
 }
 
-JNIEXPORT void JNICALL Java_com_jnibind_android_ContextTest_DestroyNativeContext(
-    JNIEnv* env, jclass, void* ctx_void_ptr) {
+JNIEXPORT void JNICALL
+Java_com_jnibind_android_ContextTest_DestroyNativeContext(JNIEnv* env, jclass,
+                                                          void* ctx_void_ptr) {
   delete static_cast<ContextStruct*>(ctx_void_ptr);
 }
 
diff --git a/javatests/com/jnibind/android/field_test_jni.cc b/javatests/com/jnibind/android/field_test_jni.cc
index 0b7fcc0a..569b5672 100644
--- a/javatests/com/jnibind/android/field_test_jni.cc
+++ b/javatests/com/jnibind/android/field_test_jni.cc
@@ -42,22 +42,22 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 JNIEXPORT jint JNICALL Java_com_jnibind_android_FieldTest_jniIntField(
     JNIEnv* env, jclass, jobject object, jint val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["intField"].Set(jint{val});
-  return rjni_test_helper["intField"].Get();
+  rjni_test_helper.Access<"intField">().Set(jint{val});
+  return rjni_test_helper.Access<"intField">().Get();
 }
 
 JNIEXPORT jfloat JNICALL Java_com_jnibind_android_FieldTest_jniFloatField(
     JNIEnv* env, jclass, jobject object, jfloat val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["floatField"].Set(jfloat{val});
-  return rjni_test_helper["floatField"].Get();
+  rjni_test_helper.Access<"floatField">().Set(jfloat{val});
+  return rjni_test_helper.Access<"floatField">().Get();
 }
 
 JNIEXPORT jdouble JNICALL Java_com_jnibind_android_FieldTest_jniDoubleField(
     JNIEnv* env, jclass, jobject object, jdouble val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["doubleField"].Set(jdouble{val});
-  return rjni_test_helper["doubleField"].Get();
+  rjni_test_helper.Access<"doubleField">().Set(jdouble{val});
+  return rjni_test_helper.Access<"doubleField">().Get();
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/android/global_object_test_jni.cc b/javatests/com/jnibind/android/global_object_test_jni.cc
index aa296ff1..6808682d 100644
--- a/javatests/com/jnibind/android/global_object_test_jni.cc
+++ b/javatests/com/jnibind/android/global_object_test_jni.cc
@@ -32,7 +32,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 }
 
 JNIEXPORT jobject JNICALL
-Java_com_jnibind_android_GlobalObjectTest_jniCreateNewObject(JNIEnv* env, jclass) {
+Java_com_jnibind_android_GlobalObjectTest_jniCreateNewObject(JNIEnv* env,
+                                                             jclass) {
   return jni::GlobalObject<kObjectTestHelperClass>{1, 2, 3}.Release();
 }
 
@@ -46,8 +47,8 @@ JNIEXPORT jobject JNICALL
 Java_com_jnibind_android_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)
+  return jni::LocalObject<kGlobalObjectTestClass>{test_helper_object}
+      .Call<"methodTakesGlobalObjectReturnsNewObject">(helper_obj)
       .Release();
 }
 
@@ -55,17 +56,17 @@ JNIEXPORT jobject JNICALL
 Java_com_jnibind_android_GlobalObjectTest_jniManipulateNewGlobalObjectSetIntVal238(
     JNIEnv* env, jclass, jobject jtest_obj) {
   jni::GlobalObject<kObjectTestHelperClass> helper_obj{2, 3, 8};
-  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}(
-             "methodTakesGlobalObjectReturnsNewObject", std::move(helper_obj))
+  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesGlobalObjectReturnsNewObject">(std::move(helper_obj))
       .Release();
 }
 
 JNIEXPORT jobject JNICALL
 Java_com_jnibind_android_GlobalObjectTest_jniMaterializeNewGlobalObjectSetIntVal159(
     JNIEnv* env, jclass, jobject jtest_obj) {
-  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}(
-             "methodTakesGlobalObjectReturnsNewObject",
-             jni::GlobalObject<kObjectTestHelperClass>{1, 5, 9})
+  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesGlobalObjectReturnsNewObject">(
+          jni::GlobalObject<kObjectTestHelperClass>{1, 5, 9})
       .Release();
 }
 
diff --git a/javatests/com/jnibind/android/local_object_test_jni.cc b/javatests/com/jnibind/android/local_object_test_jni.cc
index 0ce67f13..9897466f 100644
--- a/javatests/com/jnibind/android/local_object_test_jni.cc
+++ b/javatests/com/jnibind/android/local_object_test_jni.cc
@@ -32,7 +32,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 }
 
 JNIEXPORT jobject JNICALL
-Java_com_jnibind_android_LocalObjectTest_jniCreateNewObject(JNIEnv* env, jclass) {
+Java_com_jnibind_android_LocalObjectTest_jniCreateNewObject(JNIEnv* env,
+                                                            jclass) {
   return jni::LocalObject<kObjectTestHelperClass>{1, 2, 3}.Release();
 }
 
@@ -53,8 +54,8 @@ JNIEXPORT jobject JNICALL
 Java_com_jnibind_android_LocalObjectTest_jniBuildNewObjectsFromExistingObjects(
     JNIEnv* env, jclass, jobject jtest_obj, jobject jhelper_obj) {
   jni::LocalObject<kObjectTestHelperClass> helper_obj{jhelper_obj};
-  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject", helper_obj)
+  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(helper_obj)
       .Release();
 }
 
@@ -62,17 +63,17 @@ JNIEXPORT jobject JNICALL
 Java_com_jnibind_android_LocalObjectTest_jniManipulateNewLocalObjectSetIntVal238(
     JNIEnv* env, jclass, jobject jtest_obj) {
   jni::LocalObject<kObjectTestHelperClass> helper_obj{2, 3, 8};
-  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject", std::move(helper_obj))
+  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(std::move(helper_obj))
       .Release();
 }
 
 JNIEXPORT jobject JNICALL
 Java_com_jnibind_android_LocalObjectTest_jniMaterializeNewLocalObjectSetIntVal159(
     JNIEnv* env, jclass, jobject jtest_obj) {
-  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject",
-             jni::LocalObject<kObjectTestHelperClass>{1, 5, 9})
+  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(
+          jni::LocalObject<kObjectTestHelperClass>{1, 5, 9})
       .Release();
 }
 
diff --git a/javatests/com/jnibind/android/method_test_jni.cc b/javatests/com/jnibind/android/method_test_jni.cc
index b558a0a1..d4337188 100644
--- a/javatests/com/jnibind/android/method_test_jni.cc
+++ b/javatests/com/jnibind/android/method_test_jni.cc
@@ -78,42 +78,39 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 JNIEXPORT void JNICALL Java_com_jnibind_android_MethodTest_jniVoidMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  rjni_test_helper("voidMethod");
+  rjni_test_helper.Call<"voidMethod">();
 }
 
 JNIEXPORT void JNICALL
-Java_com_jnibind_android_MethodTest_jniVoidMethodTakesOneInt(JNIEnv* env, jclass,
-                                                          jobject object,
-                                                          jint i) {
+Java_com_jnibind_android_MethodTest_jniVoidMethodTakesOneInt(JNIEnv* env,
+                                                             jclass,
+                                                             jobject object,
+                                                             jint i) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  rjni_test_helper("voidMethodTakesOneInt", jint{i});
+  rjni_test_helper.Call<"voidMethodTakesOneInt">(jint{i});
 }
 
 JNIEXPORT void JNICALL
-Java_com_jnibind_android_MethodTest_jniVoidMethodTakesFiveInts(JNIEnv* env, jclass,
-                                                            jobject object,
-                                                            jint i1, jint i2,
-                                                            jint i3, jint i4,
-                                                            jint i5) {
+Java_com_jnibind_android_MethodTest_jniVoidMethodTakesFiveInts(
+    JNIEnv* env, jclass, jobject object, jint i1, jint i2, jint i3, jint i4,
+    jint i5) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  rjni_test_helper("voidMethodTakesFiveInts", jint{i1}, jint{i2}, jint{i3},
-                   jint{i4}, jint{i5});
+  rjni_test_helper.Call<"voidMethodTakesFiveInts">(jint{i1}, jint{i2}, jint{i3},
+                                                   jint{i4}, jint{i5});
 }
 
 /** Boolean Method Tests. */
 JNIEXPORT jboolean JNICALL Java_com_jnibind_android_MethodTest_jniBooleanMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("booleanMethod");
+  return rjni_test_helper.Call<"booleanMethod">();
 }
 
 JNIEXPORT jboolean JNICALL
-Java_com_jnibind_android_MethodTest_jniBooleanMethodTakesOneBoolean(JNIEnv* env,
-                                                                 jclass,
-                                                                 jobject object,
-                                                                 jboolean i) {
+Java_com_jnibind_android_MethodTest_jniBooleanMethodTakesOneBoolean(
+    JNIEnv* env, jclass, jobject object, jboolean i) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("booleanMethodTakesOneBoolean", jboolean{i});
+  return rjni_test_helper.Call<"booleanMethodTakesOneBoolean">(jboolean{i});
 }
 
 JNIEXPORT jboolean JNICALL
@@ -121,48 +118,48 @@ Java_com_jnibind_android_MethodTest_jniBooleanMethodTakesFiveBooleans(
     JNIEnv* env, jclass, jobject object, jboolean i1, jboolean i2, jboolean i3,
     jboolean i4, jboolean i5) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("booleanMethodTakesFiveBooleans", jboolean{i1},
-                          jboolean{i2}, jboolean{i3}, jboolean{i4},
-                          jboolean{i5});
+  return rjni_test_helper.Call<"booleanMethodTakesFiveBooleans">(
+      jboolean{i1}, jboolean{i2}, jboolean{i3}, jboolean{i4}, jboolean{i5});
 }
 
 /** Int Method Tests. */
 JNIEXPORT jint JNICALL Java_com_jnibind_android_MethodTest_jniIntMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("intMethod");
+  return rjni_test_helper.Call<"intMethod">();
 }
 
-JNIEXPORT jint JNICALL Java_com_jnibind_android_MethodTest_jniIntMethodTakesOneInt(
-    JNIEnv* env, jclass, jobject object, jint i) {
+JNIEXPORT jint JNICALL
+Java_com_jnibind_android_MethodTest_jniIntMethodTakesOneInt(JNIEnv* env, jclass,
+                                                            jobject object,
+                                                            jint i) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("intMethodTakesOneInt", jint{i});
+  return rjni_test_helper.Call<"intMethodTakesOneInt">(jint{i});
 }
 
 JNIEXPORT jint JNICALL
-Java_com_jnibind_android_MethodTest_jniIntMethodTakesFiveInts(JNIEnv* env, jclass,
-                                                           jobject object,
-                                                           jint i1, jint i2,
-                                                           jint i3, jint i4,
-                                                           jint i5) {
+Java_com_jnibind_android_MethodTest_jniIntMethodTakesFiveInts(
+    JNIEnv* env, jclass, jobject object, jint i1, jint i2, jint i3, jint i4,
+    jint i5) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("intMethodTakesFiveInts", jint{i1}, jint{i2},
-                          jint{i3}, jint{i4}, jint{i5});
+  return rjni_test_helper.Call<"intMethodTakesFiveInts">(
+      jint{i1}, jint{i2}, jint{i3}, jint{i4}, jint{i5});
 }
 
 /** Long Method Tests. */
 JNIEXPORT jlong JNICALL Java_com_jnibind_android_MethodTest_jniLongMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("longMethod");
+  return rjni_test_helper.Call<"longMethod">();
 }
 
 JNIEXPORT jlong JNICALL
-Java_com_jnibind_android_MethodTest_jniLongMethodTakesOneLong(JNIEnv* env, jclass,
-                                                           jobject object,
-                                                           jlong i) {
+Java_com_jnibind_android_MethodTest_jniLongMethodTakesOneLong(JNIEnv* env,
+                                                              jclass,
+                                                              jobject object,
+                                                              jlong i) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("longMethodTakesOneLong", jlong{i});
+  return rjni_test_helper.Call<"longMethodTakesOneLong">(jlong{i});
 }
 
 JNIEXPORT jlong JNICALL
@@ -170,24 +167,24 @@ Java_com_jnibind_android_MethodTest_jniLongMethodTakesFiveLongs(
     JNIEnv* env, jclass, jobject object, jlong i1, jlong i2, jlong i3, jlong i4,
     jlong i5) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("longMethodTakesFiveLongs", jlong{i1}, jlong{i2},
-                          jlong{i3}, jlong{i4}, jlong{i5});
+  return rjni_test_helper.Call<"longMethodTakesFiveLongs">(
+      jlong{i1}, jlong{i2}, jlong{i3}, jlong{i4}, jlong{i5});
 }
 
 /** Float Method Tests. */
 JNIEXPORT jfloat JNICALL Java_com_jnibind_android_MethodTest_jniFloatMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("floatMethod");
+  return rjni_test_helper.Call<"floatMethod">();
 }
 
 JNIEXPORT jfloat JNICALL
 Java_com_jnibind_android_MethodTest_jniFloatMethodTakesOneFloat(JNIEnv* env,
-                                                             jclass,
-                                                             jobject object,
-                                                             jfloat i) {
+                                                                jclass,
+                                                                jobject object,
+                                                                jfloat i) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("floatMethodTakesOneFloat", jfloat{i});
+  return rjni_test_helper.Call<"floatMethodTakesOneFloat">(jfloat{i});
 }
 
 JNIEXPORT jfloat JNICALL
@@ -195,24 +192,22 @@ Java_com_jnibind_android_MethodTest_jniFloatMethodTakesFiveFloats(
     JNIEnv* env, jclass, jobject object, jfloat i1, jfloat i2, jfloat i3,
     jfloat i4, jfloat i5) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("floatMethodTakesFiveFloats", jfloat{i1}, jfloat{i2},
-                          jfloat{i3}, jfloat{i4}, jfloat{i5});
+  return rjni_test_helper.Call<"floatMethodTakesFiveFloats">(
+      jfloat{i1}, jfloat{i2}, jfloat{i3}, jfloat{i4}, jfloat{i5});
 }
 
 /** Double Method Tests. */
 JNIEXPORT jdouble JNICALL Java_com_jnibind_android_MethodTest_jniDoubleMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("doubleMethod");
+  return rjni_test_helper.Call<"doubleMethod">();
 }
 
 JNIEXPORT jdouble JNICALL
-Java_com_jnibind_android_MethodTest_jniDoubleMethodTakesOneDouble(JNIEnv* env,
-                                                               jclass,
-                                                               jobject object,
-                                                               jdouble i) {
+Java_com_jnibind_android_MethodTest_jniDoubleMethodTakesOneDouble(
+    JNIEnv* env, jclass, jobject object, jdouble i) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("doubleMethodTakesOneDouble", jdouble{i});
+  return rjni_test_helper.Call<"doubleMethodTakesOneDouble">(jdouble{i});
 }
 
 JNIEXPORT jdouble JNICALL
@@ -220,27 +215,27 @@ Java_com_jnibind_android_MethodTest_jniDoubleMethodTakesFiveDoubles(
     JNIEnv* env, jclass, jobject object, jdouble i1, jdouble i2, jdouble i3,
     jdouble i4, jdouble i5) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("doubleMethodTakesFiveDoubles", jdouble{i1},
-                          jdouble{i2}, jdouble{i3}, jdouble{i4}, jdouble{i5});
+  return rjni_test_helper.Call<"doubleMethodTakesFiveDoubles">(
+      jdouble{i1}, jdouble{i2}, jdouble{i3}, jdouble{i4}, jdouble{i5});
 }
 
 /** Overload Method Tests. */
 JNIEXPORT int JNICALL Java_com_jnibind_android_MethodTest_jniCallFooOverload1(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("foo");
+  return rjni_test_helper.Call<"foo">();
 }
 
 JNIEXPORT int JNICALL Java_com_jnibind_android_MethodTest_jniCallFooOverload2(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("foo", 123.f);
+  return rjni_test_helper.Call<"foo">(123.f);
 }
 
 JNIEXPORT int JNICALL Java_com_jnibind_android_MethodTest_jniCallFooOverload3(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> rjni_test_helper{object};
-  return rjni_test_helper("foo", 123.f, 456.f);
+  return rjni_test_helper.Call<"foo">(123.f, 456.f);
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/android/string_test_jni.cc b/javatests/com/jnibind/android/string_test_jni.cc
index b75ae007..e440eed2 100644
--- a/javatests/com/jnibind/android/string_test_jni.cc
+++ b/javatests/com/jnibind/android/string_test_jni.cc
@@ -51,9 +51,10 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 
 /** Void return type tests. */
 JNIEXPORT void JNICALL
-Java_com_jnibind_android_StringTest_jniVoidMethodTakesString(JNIEnv* env, jclass,
-                                                          jobject object,
-                                                          jstring string) {
+Java_com_jnibind_android_StringTest_jniVoidMethodTakesString(JNIEnv* env,
+                                                             jclass,
+                                                             jobject object,
+                                                             jstring string) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
   // TODO(b/175083373):  The following (and below) should compile with overload
   // sets.
@@ -62,17 +63,17 @@ Java_com_jnibind_android_StringTest_jniVoidMethodTakesString(JNIEnv* env, jclass
   r_jni_string_test_helper.GetMethod("voidMethodTakesString",
       std::string{LocalString{string}.Pin().ToString()});
   */
-  r_jni_string_test_helper("voidMethodTakesString",
-                           std::string{LocalString{string}.Pin().ToString()});
+  r_jni_string_test_helper.Call<"voidMethodTakesString">(
+      std::string{LocalString{string}.Pin().ToString()});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_android_StringTest_jniVoidMethodTakesTwoStrings(
     JNIEnv* env, jclass, jobject object, jstring s1, jstring s2) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
-  r_jni_string_test_helper("voidMethodTakesTwoStrings",
-                           std::string{LocalString{s1}.Pin().ToString()},
-                           std::string{LocalString{s2}.Pin().ToString()});
+  r_jni_string_test_helper.Call<"voidMethodTakesTwoStrings">(
+      std::string{LocalString{s1}.Pin().ToString()},
+      std::string{LocalString{s2}.Pin().ToString()});
 }
 
 JNIEXPORT void JNICALL
@@ -80,26 +81,26 @@ Java_com_jnibind_android_StringTest_jniVoidMethodTakesFiveStrings(
     JNIEnv* env, jclass, jobject object, jstring s1, jstring s2, jstring s3,
     jstring s4, jstring s5) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
-  r_jni_string_test_helper("voidMethodTakesFiveStrings",
-                           std::string{LocalString{s1}.Pin().ToString()},
-                           std::string{LocalString{s2}.Pin().ToString()},
-                           std::string{LocalString{s3}.Pin().ToString()},
-                           std::string{LocalString{s4}.Pin().ToString()},
-                           std::string{LocalString{s5}.Pin().ToString()});
+  r_jni_string_test_helper.Call<"voidMethodTakesFiveStrings">(
+      std::string{LocalString{s1}.Pin().ToString()},
+      std::string{LocalString{s2}.Pin().ToString()},
+      std::string{LocalString{s3}.Pin().ToString()},
+      std::string{LocalString{s4}.Pin().ToString()},
+      std::string{LocalString{s5}.Pin().ToString()});
 }
 
 /** String return type tests. */
 JNIEXPORT jstring JNICALL
-Java_com_jnibind_android_StringTest_jniStringMethodTakesString(JNIEnv* env, jclass,
-                                                            jobject object,
-                                                            jstring string) {
+Java_com_jnibind_android_StringTest_jniStringMethodTakesString(JNIEnv* env,
+                                                               jclass,
+                                                               jobject object,
+                                                               jstring string) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
 
-  // TODO(b/174272629):  This declaration is clumsy because Return<std::string> is
-  // an ObjectRef and thus not implicitly convertible to jstring.  The following
-  // needs to be simpler to express.
-  return LocalString{r_jni_string_test_helper(
-                         "stringMethodTakesString",
+  // TODO(b/174272629):  This declaration is clumsy because Return<std::string>
+  // is an ObjectRef and thus not implicitly convertible to jstring.  The
+  // following needs to be simpler to express.
+  return LocalString{r_jni_string_test_helper.Call<"stringMethodTakesString">(
                          std::string{LocalString{string}.Pin().ToString()})}
       .Release();
 }
@@ -109,9 +110,9 @@ Java_com_jnibind_android_StringTest_jniStringMethodTakesTwoStrings(
     JNIEnv* env, jclass, jobject object, jstring s1, jstring s2) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
   return LocalString{
-      r_jni_string_test_helper("stringMethodTakesTwoStrings",
-                               std::string{LocalString{s1}.Pin().ToString()},
-                               std::string{LocalString{s2}.Pin().ToString()})}
+      r_jni_string_test_helper.Call<"stringMethodTakesTwoStrings">(
+          std::string{LocalString{s1}.Pin().ToString()},
+          std::string{LocalString{s2}.Pin().ToString()})}
       .Release();
 }
 
@@ -121,12 +122,12 @@ Java_com_jnibind_android_StringTest_jniStringMethodTakesFiveStrings(
     jstring s4, jstring s5) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
   return LocalString{
-      r_jni_string_test_helper("stringMethodTakesFiveStrings",
-                               std::string{LocalString{s1}.Pin().ToString()},
-                               std::string{LocalString{s2}.Pin().ToString()},
-                               std::string{LocalString{s3}.Pin().ToString()},
-                               std::string{LocalString{s4}.Pin().ToString()},
-                               std::string{LocalString{s5}.Pin().ToString()})}
+      r_jni_string_test_helper.Call<"stringMethodTakesFiveStrings">(
+          std::string{LocalString{s1}.Pin().ToString()},
+          std::string{LocalString{s2}.Pin().ToString()},
+          std::string{LocalString{s3}.Pin().ToString()},
+          std::string{LocalString{s4}.Pin().ToString()},
+          std::string{LocalString{s5}.Pin().ToString()})}
       .Release();
 }
 
diff --git a/javatests/com/jnibind/android/thread_test_jni.cc b/javatests/com/jnibind/android/thread_test_jni.cc
index 992db5ba..305d07e0 100644
--- a/javatests/com/jnibind/android/thread_test_jni.cc
+++ b/javatests/com/jnibind/android/thread_test_jni.cc
@@ -62,7 +62,7 @@ Java_com_jnibind_android_ThreadTest_runsThreadedWorkOnObject(JNIEnv* env,
     ThreadGuard thread_guard{};
 
     // This will crash without fallback loader (`jclass` will be unknown).
-    fixture["objectTestHelper"].Get()("foo");
+    fixture.Access<"objectTestHelper">().Get().Call<"foo">();
   }};
 
   worker.join();
diff --git a/javatests/com/jnibind/test/BUILD b/javatests/com/jnibind/test/BUILD
index 8af8d7f6..1f95abc6 100644
--- a/javatests/com/jnibind/test/BUILD
+++ b/javatests/com/jnibind/test/BUILD
@@ -53,6 +53,7 @@ cc_library(
         ":object_test_helper_jni",
         "//:jni_bind",
         "//metaprogramming:lambda_string",
+        "//metaprogramming:string_literal",
     ],
     alwayslink = True,
 )
diff --git a/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc b/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc
index 21abf4c9..8bc52f48 100644
--- a/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc
+++ b/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc
@@ -33,6 +33,7 @@ using ::jni::LocalArray;
 using ::jni::LocalObject;
 using ::jni::LocalString;
 using ::jni::StaticRef;
+using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
@@ -58,17 +59,14 @@ static constexpr Class kArrayTestFieldRank1 {
 
 // Generic field test suitable for simple primitive types.
 // Strings are passed through lambdas as field indexing is compile time.
-template <typename SpanType, typename FieldNameLambda,
-          typename MethodNameLambda>
+template <typename SpanType, StringLiteral field_name_literal,
+          StringLiteral method_name_literal>
 void GenericFieldTest(LocalObject<kArrayTestFieldRank1> fixture,
-                      SpanType max_val, SpanType base, SpanType stride,
-                      FieldNameLambda field_name_lambda,
-                      MethodNameLambda method_name_lambda) {
+                      SpanType max_val, SpanType base, SpanType stride) {
   // Field starts in default state.
-  LocalArray<SpanType> arr{fixture[field_name_lambda()].Get()};
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{0},
-                                     SpanType{0},
-                                     fixture[field_name_lambda()].Get());
+  LocalArray<SpanType> arr{fixture.Access<field_name_literal>().Get()};
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      SpanType{0}, SpanType{0}, fixture.Access<field_name_literal>().Get());
 
   // Updating the field manually works.
   {
@@ -78,9 +76,8 @@ void GenericFieldTest(LocalObject<kArrayTestFieldRank1> fixture,
     }
   }
 
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{0},
-                                     SpanType{1},
-                                     fixture[field_name_lambda()].Get());
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      SpanType{0}, SpanType{1}, fixture.Access<field_name_literal>().Get());
 
   // Updating the field repeatedly works.
   {
@@ -89,13 +86,15 @@ void GenericFieldTest(LocalObject<kArrayTestFieldRank1> fixture,
       pin.ptr()[i] = base + static_cast<SpanType>(stride * i);
     }
   }
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, stride,
-                                     fixture[field_name_lambda()].Get());
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, stride, fixture.Access<field_name_literal>().Get());
 
   // Not pinning the value has no effect.
-  { std::memset(arr.Pin(false).ptr(), 0, arr.Length() * sizeof(SpanType)); }
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, stride,
-                                     fixture[field_name_lambda()].Get());
+  {
+    std::memset(arr.Pin(false).ptr(), 0, arr.Length() * sizeof(SpanType));
+  }
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, stride, fixture.Access<field_name_literal>().Get());
 }
 
 extern "C" {
@@ -113,64 +112,64 @@ JNIEXPORT void JNICALL Java_com_jnibind_test_ArrayTestFieldRank1_jniTearDown(
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeBooleanTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   jboolean{true}, jboolean{0}, jboolean{true},
-                   STR("booleanArrayField"), STR("assertBoolean1D"));
+  GenericFieldTest<jboolean, "booleanArrayField", "assertBoolean1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture}, jboolean{true},
+      jboolean{0}, jboolean{true});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeByteTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jbyte>::max(), jbyte{10}, jbyte{1},
-                   STR("byteArrayField"), STR("assertByte1D"));
+  GenericFieldTest<jbyte, "byteArrayField", "assertByte1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jbyte>::max(), jbyte{10}, jbyte{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeCharTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jchar>::max(), jchar{10}, jchar{1},
-                   STR("charArrayField"), STR("assertChar1D"));
+  GenericFieldTest<jchar, "charArrayField", "assertChar1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jchar>::max(), jchar{10}, jchar{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeShortTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jshort>::max(), jshort{10}, jshort{1},
-                   STR("shortArrayField"), STR("assertShort1D"));
+  GenericFieldTest<jshort, "shortArrayField", "assertShort1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jshort>::max(), jshort{10}, jshort{1});
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_test_ArrayTestFieldRank1_nativeIntTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jint>::max(), jint{10}, jint{1},
-                   STR("intArrayField"), STR("assertInt1D"));
+  GenericFieldTest<jint, "intArrayField", "assertInt1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jint>::max(), jint{10}, jint{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeLongTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jlong>::max(), jlong{10}, jlong{1},
-                   STR("longArrayField"), STR("assertLong1D"));
+  GenericFieldTest<jlong, "longArrayField", "assertLong1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jlong>::max(), jlong{10}, jlong{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeFloatTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jfloat>::max(), jfloat{10.f},
-                   jfloat{1.f}, STR("floatArrayField"), STR("assertFloat1D"));
+  GenericFieldTest<jfloat, "floatArrayField", "assertFloat1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jfloat>::max(), jfloat{10.f}, jfloat{1.f});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank1_nativeDoubleTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank1>{test_fixture},
-                   std::numeric_limits<jdouble>::max(), jdouble{10}, jdouble{1},
-                   STR("doubleArrayField"), STR("assertDouble1D"));
+  GenericFieldTest<jdouble, "doubleArrayField", "assertDouble1D">(
+      LocalObject<kArrayTestFieldRank1>{test_fixture},
+      std::numeric_limits<jdouble>::max(), jdouble{10}, jdouble{1});
 }
 
 JNIEXPORT void JNICALL
@@ -179,41 +178,43 @@ Java_com_jnibind_test_ArrayTestFieldRank1_nativeStringTests(
   LocalObject<kArrayTestFieldRank1> fixture{test_fixture};
 
   // Field starts in default state.
-  StaticRef<kArrayTestHelperClass>{}(
-      "assertString1D", fixture["stringArrayField"].Get(), jboolean{false});
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(
+      fixture.Access<"stringArrayField">().Get(), jboolean{false});
 
   // Updating the field manually works.
-  LocalArray<jstring> arr = fixture["stringArrayField"].Get();
+  LocalArray<jstring> arr = fixture.Access<"stringArrayField">().Get();
   arr.Set(0, LocalString{"Foo"});
   arr.Set(1, LocalString{"Baz"});
   arr.Set(2, LocalString{"Bar"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", arr, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(arr, true);
 
   // Updating the field repeatedly works.
   arr.Set(0, LocalString{"FAKE"});
   arr.Set(1, LocalString{"DEAD"});
   arr.Set(2, LocalString{"BEEF"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", arr, false);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(arr, false);
 
   // Updating the field repeatedly works.
   arr.Set(0, "Foo");
   const char* kBaz = "Baz";
   arr.Set(1, kBaz);
   arr.Set(2, std::string{"Bar"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", arr, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(arr, true);
 
   // Iterating over values works.
   static constexpr std::array vals{"Foo", "Baz", "Bar"};
   int i = 0;
   for (LocalString local_string : arr.Pin()) {
-    StaticRef<kArrayTestHelperClass>{}("assertString", local_string, vals[i]);
+    StaticRef<kArrayTestHelperClass>{}.Call<"assertString">(local_string,
+                                                            vals[i]);
     ++i;
   }
 
   // Iterating over passed values works.
   i = 0;
   for (LocalString local_string : LocalArray<jstring>{object_array}.Pin()) {
-    StaticRef<kArrayTestHelperClass>{}("assertString", local_string, vals[i]);
+    StaticRef<kArrayTestHelperClass>{}.Call<"assertString">(local_string,
+                                                            vals[i]);
     ++i;
   }
 }
@@ -223,12 +224,12 @@ Java_com_jnibind_test_ArrayTestFieldRank1_nativeObjectTests(
     JNIEnv* env, jclass, jobject test_fixture, jobjectArray) {
   LocalObject<kArrayTestFieldRank1> fixture{test_fixture};
   LocalArray<jobject, 1, kObjectTestHelperClass> arr =
-      fixture["objectArrayField"].Get();
+      fixture.Access<"objectArrayField">().Get();
 
   int i = 0;
   for (LocalObject<kObjectTestHelperClass> new_obj :
-       fixture["objectArrayField"].Get().Pin()) {
-    StaticRef<kArrayTestHelperClass>{}("assertObject", i, new_obj);
+       fixture.Access<"objectArrayField">().Get().Pin()) {
+    StaticRef<kArrayTestHelperClass>{}.Call<"assertObject">(i, new_obj);
     i++;
   }
 }
diff --git a/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc b/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc
index a645e6ef..db4c6f1a 100644
--- a/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc
+++ b/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc
@@ -23,6 +23,7 @@
 #include "object_test_helper_jni.h"
 #include "jni_bind.h"
 #include "metaprogramming/lambda_string.h"
+#include "metaprogramming/string_literal.h"
 
 using ::jni::Array;
 using ::jni::ArrayView;
@@ -33,6 +34,7 @@ using ::jni::LocalObject;
 using ::jni::Modulo;
 using ::jni::Rank;
 using ::jni::StaticRef;
+using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
@@ -58,18 +60,15 @@ static constexpr Class kArrayTestFieldRank2 {
 
 // Generic field test suitable for simple primitive types.
 // Strings are passed through lambdas as field indexing is compile time.
-template <typename SpanType, typename FieldNameLambda,
-          typename MethodNameLambda>
+template <typename SpanType, StringLiteral field_name_literal,
+          StringLiteral method_name_literal>
 void GenericFieldTest(LocalObject<kArrayTestFieldRank2> fixture,
-                      SpanType max_val, SpanType base, SpanType stride,
-                      FieldNameLambda field_name_lambda,
-                      MethodNameLambda method_name_lambda) {
-  LocalArray<SpanType, 2> arr{fixture[field_name_lambda()].Get()};
+                      SpanType max_val, SpanType base, SpanType stride) {
+  LocalArray<SpanType, 2> arr{fixture.Access<field_name_literal>().Get()};
 
   // Field starts in default state.
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{0},
-                                     SpanType{0},
-                                     fixture[field_name_lambda()].Get());
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      SpanType{0}, SpanType{0}, fixture.Access<field_name_literal>().Get());
 
   // Updating the field manually works.
   {
@@ -82,8 +81,8 @@ void GenericFieldTest(LocalObject<kArrayTestFieldRank2> fixture,
       }
     }
 
-    StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, SpanType{1},
-                                       fixture[field_name_lambda()].Get());
+    StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+        base, SpanType{1}, fixture.Access<field_name_literal>().Get());
   }
 
   // Updating the field repeatedly works.
@@ -101,8 +100,8 @@ void GenericFieldTest(LocalObject<kArrayTestFieldRank2> fixture,
           }
         }
       }
-      StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, stride,
-                                         fixture[field_name_lambda()].Get());
+      StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+          base, stride, fixture.Access<field_name_literal>().Get());
     }
   }
 
@@ -113,8 +112,8 @@ void GenericFieldTest(LocalObject<kArrayTestFieldRank2> fixture,
                   arr_rank_1.Length() * sizeof(SpanType));
     }
   }
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, stride,
-                                     fixture[field_name_lambda()].Get());
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, stride, fixture.Access<field_name_literal>().Get());
 }
 
 extern "C" {
@@ -132,68 +131,68 @@ JNIEXPORT void JNICALL Java_com_jnibind_test_ArrayTestFieldRank2_jniTearDown(
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeBooleanTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture}, jboolean{2},
-                   jboolean{0}, jboolean{1}, STR("booleanArrayField"),
-                   STR("assertBoolean2D"));
+  GenericFieldTest<jboolean, "booleanArrayField", "assertBoolean2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture}, jboolean{2}, jboolean{0},
+      jboolean{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeByteTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jbyte>::max(), jbyte{10}, jbyte{2},
-                   STR("byteArrayField"), STR("assertByte2D"));
+  GenericFieldTest<jbyte, "byteArrayField", "assertByte2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jbyte>::max(), jbyte{10}, jbyte{2});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeCharTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jchar>::max(), jchar{0}, jchar{1},
-                   STR("charArrayField"), STR("assertChar2D"));
+  GenericFieldTest<jchar, "charArrayField", "assertChar2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jchar>::max(), jchar{0}, jchar{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeShortTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jshort>::max(), jshort{0}, jshort{1},
-                   STR("shortArrayField"), STR("assertShort2D"));
+  GenericFieldTest<jshort, "shortArrayField", "assertShort2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jshort>::max(), jshort{0}, jshort{1});
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_test_ArrayTestFieldRank2_nativeIntTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jint>::max(), jint{0}, jint{1},
-                   STR("intArrayField"), STR("assertInt2D"));
+  GenericFieldTest<jint, "intArrayField", "assertInt2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jint>::max(), jint{0}, jint{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeLongTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jlong>::max(), jlong{0}, jlong{1},
-                   STR("longArrayField"), STR("assertLong2D"));
+  GenericFieldTest<jlong, "longArrayField", "assertLong2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jlong>::max(), jlong{0}, jlong{1});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeFloatTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jfloat>::max(), jfloat{0.f}, jfloat{1.f},
-                   STR("floatArrayField"), STR("assertFloat2D"));
+  GenericFieldTest<jfloat, "floatArrayField", "assertFloat2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jfloat>::max(), jfloat{0.f}, jfloat{1.f});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeDoubleTests(
     JNIEnv* env, jclass, jobject test_fixture) {
-  GenericFieldTest(LocalObject<kArrayTestFieldRank2>{test_fixture},
-                   std::numeric_limits<jdouble>::max(), jdouble{0}, jdouble{1},
-                   STR("doubleArrayField"), STR("assertDouble2D"));
+  GenericFieldTest<jdouble, "doubleArrayField", "assertDouble2D">(
+      LocalObject<kArrayTestFieldRank2>{test_fixture},
+      std::numeric_limits<jdouble>::max(), jdouble{0}, jdouble{1});
 }
 
 // TODO(b/143908983): This is broken, but using regular `jobject` works,
-// so there is still an alternative path to be take.
+// so there is still an alternative path to be taken.
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestFieldRank2_nativeStringTests(
     JNIEnv* env, jclass, jobject test_fixture) {
@@ -202,40 +201,43 @@ Java_com_jnibind_test_ArrayTestFieldRank2_nativeStringTests(
 
   // Field starts in default state.
   StaticRef<kArrayTestHelperClass>{}(
-      "assertString1D", fixture["stringArrayField"].Get(), jboolean{false});
+      "assertString1D", fixture.Access<"stringArrayField">().Get(),
+  jboolean{false});
 
   // Updating the field manually works.
-  LocalArray<jstring> arr = fixture["stringArrayField"].Get();
+  LocalArray<jstring> arr = fixture.Access<"stringArrayField">().Get();
   arr.Set(0, LocalString{"Foo"});
   arr.Set(1, LocalString{"Baz"});
   arr.Set(2, LocalString{"Bar"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", arr, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">( arr, true);
 
   // Updating the field repeatedly works.
   arr.Set(0, LocalString{"FAKE"});
   arr.Set(1, LocalString{"DEAD"});
   arr.Set(2, LocalString{"BEEF"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", arr, false);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">( arr, false);
 
   // Updating the field repeatedly works.
   arr.Set(0, "Foo");
   const char* kBaz = "Baz";
   arr.Set(1, kBaz);
   arr.Set(2, std::string{"Bar"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", arr, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">( arr, true);
 
   // Iterating over values works.
   static constexpr std::array vals{"Foo", "Baz", "Bar"};
   int i = 0;
   for (LocalString local_string : arr.Pin()) {
-    StaticRef<kArrayTestHelperClass>{}("assertString", local_string, vals[i]);
+    StaticRef<kArrayTestHelperClass>{}.Call<"assertString">( local_string,
+  vals[i]);
     ++i;
   }
 
   // Iterating over passed values works.
   i = 0;
   for (LocalString local_string : LocalArray<jstring>{object_array}.Pin()) {
-    StaticRef<kArrayTestHelperClass>{}("assertString", local_string, vals[i]);
+    StaticRef<kArrayTestHelperClass>{}.Call<"assertString">( local_string,
+  vals[i]);
     ++i;
   }
   */
@@ -245,29 +247,29 @@ void Java_com_jnibind_test_ArrayTestFieldRank2_nativeObjectTests(
     JNIEnv* env, jclass, jobject test_fixture) {
   LocalObject<kArrayTestFieldRank2> fixture{test_fixture};
   LocalArray<jobject, 2, kObjectTestHelperClass> arr =
-      fixture["objectArrayField"].Get();
+      fixture.Access<"objectArrayField">().Get();
 
   int i = 0;
   {
     for (LocalArray<jobject, 1, kObjectTestHelperClass> arr_rank_1 :
          arr.Pin()) {
       for (LocalObject<kObjectTestHelperClass> obj : arr_rank_1.Pin()) {
-        obj["intVal1"].Set(i);
+        obj.Access<"intVal1">().Set(i);
         i++;
-        obj["intVal2"].Set(i);
+        obj.Access<"intVal2">().Set(i);
         i++;
-        obj["intVal3"].Set(i);
+        obj.Access<"intVal3">().Set(i);
         i++;
       }
     }
   }
 
   // Object on fixture is already updated.
-  StaticRef<kArrayTestHelperClass>{}("assertObject2D", 0, 1,
-                                     fixture["objectArrayField"].Get());
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject2D">(
+      0, 1, fixture.Access<"objectArrayField">().Get());
 
   // But using local reference works too.
-  StaticRef<kArrayTestHelperClass>{}("assertObject2D", 0, 1, arr);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject2D">(0, 1, arr);
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc b/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc
index 42d85212..db6e8354 100644
--- a/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc
+++ b/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc
@@ -21,7 +21,6 @@
 #include "array_test_helpers_native.h"
 #include "object_test_helper_jni.h"
 #include "jni_bind.h"
-#include "metaprogramming/lambda_string.h"
 
 using ::jni::ArrayView;
 using ::jni::LocalArray;
@@ -29,21 +28,21 @@ using ::jni::LocalObject;
 using ::jni::LocalString;
 using ::jni::RegularToArrayTypeMap_t;
 using ::jni::StaticRef;
+using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
 // Generic method test suitable for simple primitive types.
 // Strings are passed through lambdas as method indexing is compile time.
-template <typename SpanType, typename MethodNameLambda>
-void GenericMethodTest(LocalArray<SpanType> local_arr, SpanType base,
-                       MethodNameLambda method_name_lambda) {
+template <typename SpanType, StringLiteral method_name_literal>
+void GenericMethodTest(LocalArray<SpanType> local_arr, SpanType base) {
   // Simple lvalue pass through works as expected.
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, SpanType{1},
-                                     local_arr);
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, SpanType{1}, local_arr);
 
   // Simple rvalue pass through works as expected.
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, SpanType{1},
-                                     std::move(local_arr));
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, SpanType{1}, std::move(local_arr));
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<SpanType> new_array{8};
@@ -53,8 +52,8 @@ void GenericMethodTest(LocalArray<SpanType> local_arr, SpanType base,
       array_view.ptr()[i] = base + static_cast<SpanType>(i);
     }
   }
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, SpanType{1},
-                                     new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, SpanType{1}, new_array);
 
   // You can pull the view multiple times.
   {
@@ -72,8 +71,8 @@ void GenericMethodTest(LocalArray<SpanType> local_arr, SpanType base,
     val = base + i;
     i++;
   }
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, SpanType{1},
-                                     new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, SpanType{1}, new_array);
 
   // You can build an array of null values and set the values manually.
   LocalArray<SpanType> arr_built_from_null{5};
@@ -84,8 +83,8 @@ void GenericMethodTest(LocalArray<SpanType> local_arr, SpanType base,
     val = base + j;
     j++;
   }
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), base, SpanType{1},
-                                     new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      base, SpanType{1}, new_array);
 }
 
 extern "C" {
@@ -103,57 +102,57 @@ JNIEXPORT void JNICALL Java_com_jnibind_test_ArrayTestMethodRank1_jniTearDown(
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeBooleanTests(
     JNIEnv* env, jclass, jbooleanArray boolean_array) {
-  GenericMethodTest(LocalArray<jboolean>{boolean_array}, jboolean{true},
-                    STR("assertBoolean1D"));
+  GenericMethodTest<jboolean, "assertBoolean1D">(
+      LocalArray<jboolean>{boolean_array}, jboolean{true});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeByteTests(
     JNIEnv* env, jclass, jbyteArray byte_array) {
-  GenericMethodTest(LocalArray<jbyte>{byte_array}, jbyte{0},
-                    STR("assertByte1D"));
+  GenericMethodTest<jbyte, "assertByte1D">(LocalArray<jbyte>{byte_array},
+                                           jbyte{0});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeCharTests(
     JNIEnv* env, jclass, jcharArray char_array) {
-  GenericMethodTest(LocalArray<jchar>{char_array}, jchar{0},
-                    STR("assertChar1D"));
+  GenericMethodTest<jchar, "assertChar1D">(LocalArray<jchar>{char_array},
+                                           jchar{0});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeShortTests(
     JNIEnv* env, jclass, jshortArray short_array) {
-  GenericMethodTest(LocalArray<jshort>{short_array}, jshort{0},
-                    STR("assertShort1D"));
+  GenericMethodTest<jshort, "assertShort1D">(LocalArray<jshort>{short_array},
+                                             jshort{0});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeIntTests(JNIEnv* env, jclass,
 
                                                           jintArray int_array) {
-  GenericMethodTest(LocalArray<jint>{int_array}, jint{0}, STR("assertInt1D"));
+  GenericMethodTest<jint, "assertInt1D">(LocalArray<jint>{int_array}, jint{0});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeLongTests(
     JNIEnv* env, jclass, jlongArray long_array) {
-  GenericMethodTest(LocalArray<jlong>{long_array}, jlong{0},
-                    STR("assertLong1D"));
+  GenericMethodTest<jlong, "assertLong1D">(LocalArray<jlong>{long_array},
+                                           jlong{0});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeFloatTests(
     JNIEnv* env, jclass, jfloatArray float_array) {
-  GenericMethodTest(LocalArray<jfloat>{float_array}, jfloat{0},
-                    STR("assertFloat1D"));
+  GenericMethodTest<jfloat, "assertFloat1D">(LocalArray<jfloat>{float_array},
+                                             jfloat{0});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank1_nativeDoubleTests(
     JNIEnv* env, jclass, jdoubleArray double_array) {
-  GenericMethodTest(LocalArray<jdouble>{double_array}, jdouble{0},
-                    STR("assertDouble1D"));
+  GenericMethodTest<jdouble, "assertDouble1D">(
+      LocalArray<jdouble>{double_array}, jdouble{0});
 }
 
 JNIEXPORT void JNICALL
@@ -161,7 +160,7 @@ Java_com_jnibind_test_ArrayTestMethodRank1_nativeStringTests(
     JNIEnv* env, jclass, jobjectArray object_array) {
   // Simple lvalue pass through works as expected.
   LocalArray<jstring> local_arr{object_array};
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", local_arr, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(local_arr, true);
 
   // TODO(b/143908983): Currently not possible to write.
   // Simple rvalue pass through works as expected.
@@ -177,7 +176,7 @@ Java_com_jnibind_test_ArrayTestMethodRank1_nativeStringTests(
   new_array.Set(0, LocalString{"Foo"});
   new_array.Set(1, LocalString{"Baz"});
   new_array.Set(2, LocalString{"Bar"});
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", new_array, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(new_array, true);
 
   // And it can be iterated over.
   std::size_t i = 0;
@@ -187,7 +186,8 @@ Java_com_jnibind_test_ArrayTestMethodRank1_nativeStringTests(
     i++;
   }
 
-  StaticRef<kArrayTestHelperClass>{}("assertString1D", validator_array, true);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertString1D">(validator_array,
+                                                            true);
 }
 
 JNIEXPORT void JNICALL
@@ -195,18 +195,17 @@ Java_com_jnibind_test_ArrayTestMethodRank1_nativeObjectTests(
     JNIEnv* env, jclass, jobjectArray object_array) {
   // Creating arrays of nulls with just size works.
   LocalArray<jobject, 1, kObjectTestHelperClass> local_arr_nulls{5};
-  StaticRef<kArrayTestHelperClass>{}("assertObjectArrayOfNulls1D",
-                                     local_arr_nulls);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObjectArrayOfNulls1D">(
+      local_arr_nulls);
 
   // Simple lvalue pass through works as expected.
   LocalArray<jobject, 1, kObjectTestHelperClass> local_arr{object_array};
-  StaticRef<kArrayTestHelperClass>{}("assertObject1D", 0, local_arr);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject1D">(0, local_arr);
 
   // Simple rvalue pass through works as expected.
-  StaticRef<kArrayTestHelperClass>{}(
-      "assertObject1D", 5,
-      LocalArray<jobject, 1, kObjectTestHelperClass>{
-          1, LocalObject<kObjectTestHelperClass>{5, 5, 5}});
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject1D">(
+      5, LocalArray<jobject, 1, kObjectTestHelperClass>{
+             1, LocalObject<kObjectTestHelperClass>{5, 5, 5}});
 
   // Building a new array, and setting all the values by hand works.
   LocalObject<kObjectTestHelperClass> obj{0, 0, 0};
@@ -217,14 +216,14 @@ Java_com_jnibind_test_ArrayTestMethodRank1_nativeObjectTests(
           i, LocalObject<kObjectTestHelperClass>{jint{i}, jint{i}, jint{i}});
     }
   }
-  StaticRef<kArrayTestHelperClass>{}("assertObject1D", 0, new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject1D">(0, new_array);
 
   // You can pull the view multiple times.
   {
     for (int i = 0; i < new_array.Length(); ++i) {
-      new_array.Set(i,
-                    LocalObject<kObjectTestHelperClass>{2, 2, 2}(
-                        "returnNewObjectWithFieldSetToSum", new_array.Get(i)));
+      new_array.Set(
+          i, LocalObject<kObjectTestHelperClass>{2, 2, 2}
+                 .Call<"returnNewObjectWithFieldSetToSum">(new_array.Get(i)));
     }
   }
 
@@ -233,12 +232,12 @@ Java_com_jnibind_test_ArrayTestMethodRank1_nativeObjectTests(
   //  is being iterated over, and upcast to a LocalObject.
   // Also note: Pin is not to contiguous memory, so no copyback bool either.
   for (LocalObject<kObjectTestHelperClass> val : new_array.Pin()) {
-    val["intVal1"].Set(val["intVal1"].Get() + 3);
-    val["intVal2"].Set(val["intVal2"].Get() + 3);
-    val["intVal3"].Set(val["intVal3"].Get() + 3);
+    val.Access<"intVal1">().Set(val.Access<"intVal1">().Get() + 3);
+    val.Access<"intVal2">().Set(val.Access<"intVal2">().Get() + 3);
+    val.Access<"intVal3">().Set(val.Access<"intVal3">().Get() + 3);
   }
 
-  StaticRef<kArrayTestHelperClass>{}("assertObject1D", 2 + 3, new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject1D">(2 + 3, new_array);
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc b/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc
index 6de4baa4..40d535f8 100644
--- a/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc
+++ b/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc
@@ -22,29 +22,29 @@
 #include "modulo.h"
 #include "javatests/com/jnibind/test/object_test_helper_jni.h"
 #include "jni_bind.h"
-#include "metaprogramming/lambda_string.h"
 
 using ::jni::LocalArray;
 using ::jni::LocalObject;
 using ::jni::Modulo;
 using ::jni::RegularToArrayTypeMap_t;
 using ::jni::StaticRef;
+using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
 // Generic method test suitable for simple primitive types.
 // Strings are passed through lambdas as method indexing is compile time.
-template <typename SpanType, typename MethodNameLambda>
+template <typename SpanType, StringLiteral method_name_literal>
 void GenericMethodTest(
-    MethodNameLambda method_name_lambda, LocalArray<SpanType, 2> arr,
+    LocalArray<SpanType, 2> arr,
     SpanType max_val = std::numeric_limits<SpanType>::max()) {
   // Simple lvalue pass through works as expected.
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{0},
-                                     SpanType{1}, arr);
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      SpanType{0}, SpanType{1}, arr);
 
   // Simple rvalue pass through works as expected.
-  StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{0},
-                                     SpanType{1}, std::move(arr));
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      SpanType{0}, SpanType{1}, std::move(arr));
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<SpanType, 2> new_array{3};
@@ -69,8 +69,8 @@ void GenericMethodTest(
     new_array.Set(1, row2);
     new_array.Set(2, row3);
 
-    StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{0},
-                                       SpanType{1}, new_array);
+    StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+        SpanType{0}, SpanType{1}, new_array);
   }
 
   // You can pull the view multiple times with iterators (each value ticked 1).
@@ -80,8 +80,8 @@ void GenericMethodTest(
         val = Modulo(1, val, max_val);
       }
     }
-    StaticRef<kArrayTestHelperClass>{}(method_name_lambda(), SpanType{1},
-                                       SpanType{1}, new_array);
+    StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+        SpanType{1}, SpanType{1}, new_array);
   }
 
   // You can pull the view multiple times with raw loops.
@@ -98,8 +98,8 @@ void GenericMethodTest(
   }
 
   // Each variant increments base by 1, so 2 is used here.
-  StaticRef<kArrayTestHelperClass>{}(
-      method_name_lambda(), Modulo(2, {0}, max_val), SpanType{1}, new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<method_name_literal>(
+      Modulo(2, {0}, max_val), SpanType{1}, new_array);
 }
 
 extern "C" {
@@ -118,53 +118,53 @@ JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeBooleanTests2D(
     JNIEnv*, jclass, jobjectArray arr) {
   // Boolean has a max of "2" which makes the generic moduloing logic work.
-  GenericMethodTest(STR("assertBoolean2D"), LocalArray<jboolean, 2>{arr},
-                    jboolean{2});
+  GenericMethodTest<jboolean, "assertBoolean2D">(LocalArray<jboolean, 2>{arr},
+                                                 jboolean{2});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeByteTests2D(JNIEnv*, jclass,
 
                                                              jobjectArray arr) {
-  GenericMethodTest(STR("assertByte2D"), LocalArray<jbyte, 2>{arr});
+  GenericMethodTest<jbyte, "assertByte2D">(LocalArray<jbyte, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeCharTests2D(JNIEnv*, jclass,
 
                                                              jobjectArray arr) {
-  GenericMethodTest(STR("assertChar2D"), LocalArray<jchar, 2>{arr});
+  GenericMethodTest<jchar, "assertChar2D">(LocalArray<jchar, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeShortTests2D(
     JNIEnv*, jclass, jobjectArray arr) {
-  GenericMethodTest(STR("assertShort2D"), LocalArray<jshort, 2>{arr});
+  GenericMethodTest<jshort, "assertShort2D">(LocalArray<jshort, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeIntTests2D(JNIEnv*, jclass,
 
                                                             jobjectArray arr) {
-  GenericMethodTest(STR("assertInt2D"), LocalArray<jint, 2>{arr});
+  GenericMethodTest<jint, "assertInt2D">(LocalArray<jint, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeLongTests2D(JNIEnv*, jclass,
                                                              jobjectArray arr) {
-  GenericMethodTest(STR("assertLong2D"), LocalArray<jlong, 2>{arr});
+  GenericMethodTest<jlong, "assertLong2D">(LocalArray<jlong, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeFloatTests2D(
     JNIEnv*, jclass, jobjectArray arr) {
-  GenericMethodTest(STR("assertFloat2D"), LocalArray<jfloat, 2>{arr});
+  GenericMethodTest<jfloat, "assertFloat2D">(LocalArray<jfloat, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_ArrayTestMethodRank2_nativeDoubleTests2D(
     JNIEnv*, jclass, jobjectArray arr) {
-  GenericMethodTest(STR("assertDouble2D"), LocalArray<jdouble, 2>{arr});
+  GenericMethodTest<jdouble, "assertDouble2D">(LocalArray<jdouble, 2>{arr});
 }
 
 JNIEXPORT void JNICALL
@@ -172,10 +172,11 @@ Java_com_jnibind_test_ArrayTestMethodRank2_nativeObjectTests2D(
     JNIEnv* env, jclass, jobjectArray arr_jobjectArray) {
   // Simple lvalue pass through works as expected.
   LocalArray<jobject, 2, kObjectTestHelperClass> arr{arr_jobjectArray};
-  StaticRef<kArrayTestHelperClass>{}("assertObject2D", 0, 1, arr);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject2D">(0, 1, arr);
 
   // Simple rvalue pass through works as expected.
-  StaticRef<kArrayTestHelperClass>{}("assertObject2D", 0, 1, std::move(arr));
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject2D">(0, 1,
+                                                            std::move(arr));
 
   // Building a new array, and setting all the values by hand works.
   LocalArray<jobject, 2, kObjectTestHelperClass> new_array{3, nullptr};
@@ -199,18 +200,18 @@ Java_com_jnibind_test_ArrayTestMethodRank2_nativeObjectTests2D(
   new_array.Set(1, row2);
   new_array.Set(2, row3);
 
-  StaticRef<kArrayTestHelperClass>{}("assertObject2D", 0, 1, new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject2D">(0, 1, new_array);
 
   // You can pull the view multiple times with iterators (each value ticked 1).
   {
     int i = 0;
     for (LocalArray<jobject, 1> inner_array : new_array.Pin()) {
       for (LocalObject<kObjectTestHelperClass> obj : inner_array.Pin()) {
-        obj["intVal1"].Set(i);
+        obj.Access<"intVal1">().Set(i);
         i++;
-        obj["intVal2"].Set(i);
+        obj.Access<"intVal2">().Set(i);
         i++;
-        obj["intVal3"].Set(i);
+        obj.Access<"intVal3">().Set(i);
         i++;
       }
     }
@@ -222,13 +223,13 @@ Java_com_jnibind_test_ArrayTestMethodRank2_nativeObjectTests2D(
     for (int i = 0; i < new_array.Length(); ++i) {
       LocalArray<jobject, 1, kObjectTestHelperClass> inn_arr{new_array.Get(i)};
       for (int j = 0; j < inn_arr.Length(); ++j) {
-        inn_arr.Get(j)("increment", 1);
+        inn_arr.Get(j).Call<"increment">(1);
       }
     }
   }
 
   // Each variant increments base by 1, so 2 is used here.
-  StaticRef<kArrayTestHelperClass>{}("assertObject2D", 1, 1, new_array);
+  StaticRef<kArrayTestHelperClass>{}.Call<"assertObject2D">(1, 1, new_array);
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/test/builder_jni.cc b/javatests/com/jnibind/test/builder_jni.cc
index a5719432..5f927494 100644
--- a/javatests/com/jnibind/test/builder_jni.cc
+++ b/javatests/com/jnibind/test/builder_jni.cc
@@ -56,8 +56,11 @@ JNI_BIND_EXPORT jint JNI_BIND_CALL JNI_OnLoad(JavaVM* pjvm, void* reserved) {
 JNI_MTHD(void, nativeJniTeardown) { jvm = nullptr; }
 
 JNI_MTHD(jobject, useBuilderToCreateObject) {
-  return LocalObject<kBuilder>{}("setOne", 111)("setTwo", 222)("setThree",
-                                                               333)("build")
+  return LocalObject<kBuilder>{}
+      .Call<"setOne">(111)
+      .Call<"setTwo">(222)
+      .Call<"setThree">(333)
+      .Call<"build">()
       .Release();
 }
 
diff --git a/javatests/com/jnibind/test/context_test_jni.cc b/javatests/com/jnibind/test/context_test_jni.cc
index 0786406c..54fb9366 100644
--- a/javatests/com/jnibind/test/context_test_jni.cc
+++ b/javatests/com/jnibind/test/context_test_jni.cc
@@ -55,7 +55,7 @@ JNIEXPORT void JNICALL Java_com_jnibind_test_ContextTest_DoSetup(JNIEnv* env,
 JNIEXPORT jlong JNICALL Java_com_jnibind_test_ContextTest_nativeCreateContext(
     JNIEnv* env, jclass, jint val) {
   auto* ctx_struct = new ContextStruct{GlobalObject<kObjectTestHelperClass>{}};
-  ctx_struct->obj["intVal1"].Set(jint{val});
+  ctx_struct->obj.Access<"intVal1">().Set(jint{val});
 
   return reinterpret_cast<jlong>(ctx_struct);
 }
@@ -82,8 +82,8 @@ Java_com_jnibind_test_ContextTest_nativeCreateContextSetValToSum(JNIEnv* env,
                                                                  jint val2) {
   // Creates a temporary test helper, calls its member method, and releases the
   // returned object across the C API boundary (then destroys the temporary).
-  return jni::LocalObject<kObjectTestHelperClass>{}(
-             "returnNewObjectWithFieldSetToSum", val1, val2)
+  return jni::LocalObject<kObjectTestHelperClass>{}
+      .Call<"returnNewObjectWithFieldSetToSum">(val1, val2)
       .Release();
 }
 
diff --git a/javatests/com/jnibind/test/field_test_jni.cc b/javatests/com/jnibind/test/field_test_jni.cc
index 349daa14..cfa09b08 100644
--- a/javatests/com/jnibind/test/field_test_jni.cc
+++ b/javatests/com/jnibind/test/field_test_jni.cc
@@ -60,33 +60,33 @@ Java_com_jnibind_test_FieldTest_jniTearDown(JavaVM* pjvm, void* reserved) {
 JNIEXPORT jint JNICALL Java_com_jnibind_test_FieldTest_jniIntField(
     JNIEnv* env, jclass, jobject object, jint val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["intField"].Set(jint{val});
+  rjni_test_helper.Access<"intField">().Set(jint{val});
 
-  return rjni_test_helper["intField"].Get();
+  return rjni_test_helper.Access<"intField">().Get();
 }
 
 JNIEXPORT jfloat JNICALL Java_com_jnibind_test_FieldTest_jniFloatField(
     JNIEnv* env, jclass, jobject object, jfloat val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["floatField"].Set(jfloat{val});
+  rjni_test_helper.Access<"floatField">().Set(jfloat{val});
 
-  return rjni_test_helper["floatField"].Get();
+  return rjni_test_helper.Access<"floatField">().Get();
 }
 
 JNIEXPORT jdouble JNICALL Java_com_jnibind_test_FieldTest_jniDoubleField(
     JNIEnv* env, jclass, jobject object, jdouble val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["doubleField"].Set(jdouble{val});
+  rjni_test_helper.Access<"doubleField">().Set(jdouble{val});
 
-  return rjni_test_helper["doubleField"].Get();
+  return rjni_test_helper.Access<"doubleField">().Get();
 }
 
 JNIEXPORT jstring JNICALL Java_com_jnibind_test_FieldTest_jniStringField(
     JNIEnv* env, jclass, jobject object, jstring val) {
   LocalObject<kFieldTestHelper> rjni_test_helper{object};
-  rjni_test_helper["stringField"].Set(val);
+  rjni_test_helper.Access<"stringField">().Set(val);
 
-  return rjni_test_helper["stringField"].Get().Release();
+  return rjni_test_helper.Access<"stringField">().Get().Release();
 }
 
 JNIEXPORT void JNICALL Java_com_jnibind_test_FieldTest_jniObjectFieldSet(
@@ -95,12 +95,15 @@ JNIEXPORT void JNICALL Java_com_jnibind_test_FieldTest_jniObjectFieldSet(
   LocalObject<kFieldTest> field_test{test_class};
   LocalObject<kFieldTestHelper> obj{intVal, floatVal, doubleVal};
 
-  field_test["fieldTestHelper"].Set(obj);
+  field_test.Access<"fieldTestHelper">().Set(obj);
 }
 
 JNIEXPORT jobject JNICALL Java_com_jnibind_test_FieldTest_jniObjectFieldGet(
     JNIEnv* env, jclass, jobject test_class) {
-  return LocalObject<kFieldTest>{test_class}["fieldTestHelper"].Get().Release();
+  return LocalObject<kFieldTest>{test_class}
+      .Access<"fieldTestHelper">()
+      .Get()
+      .Release();
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/test/global_object_test_jni.cc b/javatests/com/jnibind/test/global_object_test_jni.cc
index ee27b44d..97fe83b5 100644
--- a/javatests/com/jnibind/test/global_object_test_jni.cc
+++ b/javatests/com/jnibind/test/global_object_test_jni.cc
@@ -63,8 +63,8 @@ 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)
+  return jni::LocalObject<kGlobalObjectTestClass>{test_helper_object}
+      .Call<"methodTakesGlobalObjectReturnsNewObject">(helper_obj)
       .Release();
 }
 
@@ -73,17 +73,17 @@ Java_com_jnibind_test_GlobalObjectTest_jniManipulateNewGlobalObjectSetIntVal238(
     JNIEnv* env, jclass, jobject jtest_obj) {
   jni::GlobalObject<kObjectTestHelperClass> helper_obj{2, 3, 8};
 
-  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}(
-             "methodTakesGlobalObjectReturnsNewObject", std::move(helper_obj))
+  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesGlobalObjectReturnsNewObject">(std::move(helper_obj))
       .Release();
 }
 
 JNIEXPORT jobject JNICALL
 Java_com_jnibind_test_GlobalObjectTest_jniMaterializeNewGlobalObjectSetIntVal159(
     JNIEnv* env, jclass, jobject jtest_obj) {
-  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}(
-             "methodTakesGlobalObjectReturnsNewObject",
-             jni::GlobalObject<kObjectTestHelperClass>{1, 5, 9})
+  return jni::LocalObject<kGlobalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesGlobalObjectReturnsNewObject">(
+          jni::GlobalObject<kObjectTestHelperClass>{1, 5, 9})
       .Release();
 }
 
diff --git a/javatests/com/jnibind/test/local_object_test_jni.cc b/javatests/com/jnibind/test/local_object_test_jni.cc
index f2cf225e..fda520b4 100644
--- a/javatests/com/jnibind/test/local_object_test_jni.cc
+++ b/javatests/com/jnibind/test/local_object_test_jni.cc
@@ -65,8 +65,8 @@ Java_com_jnibind_test_LocalObjectTest_jniBuildNewObjectsFromExistingObjects(
     JNIEnv* env, jclass, jobject jtest_obj, jobject jhelper_obj) {
   jni::LocalObject<kObjectTestHelperClass> helper_obj{jhelper_obj};
 
-  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject", helper_obj)
+  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(helper_obj)
       .Release();
 }
 
@@ -75,17 +75,17 @@ Java_com_jnibind_test_LocalObjectTest_jniManipulateNewLocalObjectSetIntVal238(
     JNIEnv* env, jclass, jobject jtest_obj) {
   jni::LocalObject<kObjectTestHelperClass> helper_obj{2, 3, 8};
 
-  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject", std::move(helper_obj))
+  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(std::move(helper_obj))
       .Release();
 }
 
 JNIEXPORT jobject JNICALL
 Java_com_jnibind_test_LocalObjectTest_jniMaterializeNewLocalObjectSetIntVal159(
     JNIEnv* env, jclass, jobject jtest_obj) {
-  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}(
-             "methodTakesLocalObjectReturnsNewObject",
-             jni::LocalObject<kObjectTestHelperClass>{1, 5, 9})
+  return jni::LocalObject<kLocalObjectTestClass>{jtest_obj}
+      .Call<"methodTakesLocalObjectReturnsNewObject">(
+          jni::LocalObject<kObjectTestHelperClass>{1, 5, 9})
       .Release();
 }
 
diff --git a/javatests/com/jnibind/test/method_test_jni.cc b/javatests/com/jnibind/test/method_test_jni.cc
index f298c5b3..51928989 100644
--- a/javatests/com/jnibind/test/method_test_jni.cc
+++ b/javatests/com/jnibind/test/method_test_jni.cc
@@ -92,7 +92,7 @@ Java_com_jnibind_test_MethodTest_jniTearDown(JavaVM* pjvm, void* reserved) {
 JNIEXPORT void JNICALL Java_com_jnibind_test_MethodTest_jniVoidMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
-  gtest_helper("voidMethod");
+  gtest_helper.Call<"voidMethod">();
 }
 
 JNIEXPORT void JNICALL
@@ -100,7 +100,7 @@ Java_com_jnibind_test_MethodTest_jniVoidMethodTakesOneInt(JNIEnv* env, jclass,
                                                           jobject object,
                                                           jint i) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
-  gtest_helper("voidMethodTakesOneInt", jint{i});
+  gtest_helper.Call<"voidMethodTakesOneInt">(jint{i});
 }
 
 JNIEXPORT void JNICALL
@@ -110,8 +110,8 @@ Java_com_jnibind_test_MethodTest_jniVoidMethodTakesFiveInts(JNIEnv* env, jclass,
                                                             jint i3, jint i4,
                                                             jint i5) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
-  gtest_helper("voidMethodTakesFiveInts", jint{i1}, jint{i2}, jint{i3},
-               jint{i4}, jint{i5});
+  gtest_helper.Call<"voidMethodTakesFiveInts">(jint{i1}, jint{i2}, jint{i3},
+                                               jint{i4}, jint{i5});
 }
 
 /** Boolean Method Tests. */
@@ -119,7 +119,7 @@ JNIEXPORT jboolean JNICALL Java_com_jnibind_test_MethodTest_jniBooleanMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("booleanMethod");
+  return gtest_helper.Call<"booleanMethod">();
 }
 
 JNIEXPORT jboolean JNICALL
@@ -128,7 +128,7 @@ Java_com_jnibind_test_MethodTest_jniBooleanMethodTakesOneBoolean(JNIEnv* env,
                                                                  jobject object,
                                                                  jboolean i) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
-  return gtest_helper("booleanMethodTakesOneBoolean", jboolean{i});
+  return gtest_helper.Call<"booleanMethodTakesOneBoolean">(jboolean{i});
 }
 
 JNIEXPORT jboolean JNICALL
@@ -137,8 +137,8 @@ Java_com_jnibind_test_MethodTest_jniBooleanMethodTakesFiveBooleans(
     jboolean i4, jboolean i5) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("booleanMethodTakesFiveBooleans", jboolean{i1},
-                      jboolean{i2}, jboolean{i3}, jboolean{i4}, jboolean{i5});
+  return gtest_helper.Call<"booleanMethodTakesFiveBooleans">(
+      jboolean{i1}, jboolean{i2}, jboolean{i3}, jboolean{i4}, jboolean{i5});
 }
 
 /** Int Method Tests. */
@@ -146,14 +146,14 @@ JNIEXPORT jint JNICALL Java_com_jnibind_test_MethodTest_jniIntMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("intMethod");
+  return gtest_helper.Call<"intMethod">();
 }
 
 JNIEXPORT jint JNICALL Java_com_jnibind_test_MethodTest_jniIntMethodTakesOneInt(
     JNIEnv* env, jclass, jobject object, jint i) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("intMethodTakesOneInt", jint{i});
+  return gtest_helper.Call<"intMethodTakesOneInt">(jint{i});
 }
 
 JNIEXPORT jint JNICALL
@@ -164,8 +164,8 @@ Java_com_jnibind_test_MethodTest_jniIntMethodTakesFiveInts(JNIEnv* env, jclass,
                                                            jint i5) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("intMethodTakesFiveInts", jint{i1}, jint{i2}, jint{i3},
-                      jint{i4}, jint{i5});
+  return gtest_helper.Call<"intMethodTakesFiveInts">(
+      jint{i1}, jint{i2}, jint{i3}, jint{i4}, jint{i5});
 }
 
 /** Long Method Tests. */
@@ -173,7 +173,7 @@ JNIEXPORT jlong JNICALL Java_com_jnibind_test_MethodTest_jniLongMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("longMethod");
+  return gtest_helper.Call<"longMethod">();
 }
 
 JNIEXPORT jlong JNICALL
@@ -182,7 +182,7 @@ Java_com_jnibind_test_MethodTest_jniLongMethodTakesOneLong(JNIEnv* env, jclass,
                                                            jlong i) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("longMethodTakesOneLong", jlong{i});
+  return gtest_helper.Call<"longMethodTakesOneLong">(jlong{i});
 }
 
 JNIEXPORT jlong JNICALL
@@ -191,8 +191,8 @@ Java_com_jnibind_test_MethodTest_jniLongMethodTakesFiveLongs(
     jlong i5) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("longMethodTakesFiveLongs", jlong{i1}, jlong{i2},
-                      jlong{i3}, jlong{i4}, jlong{i5});
+  return gtest_helper.Call<"longMethodTakesFiveLongs">(
+      jlong{i1}, jlong{i2}, jlong{i3}, jlong{i4}, jlong{i5});
 }
 
 /** Float Method Tests. */
@@ -200,7 +200,7 @@ JNIEXPORT jfloat JNICALL Java_com_jnibind_test_MethodTest_jniFloatMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("floatMethod");
+  return gtest_helper.Call<"floatMethod">();
 }
 
 JNIEXPORT jfloat JNICALL
@@ -210,7 +210,7 @@ Java_com_jnibind_test_MethodTest_jniFloatMethodTakesOneFloat(JNIEnv* env,
                                                              jfloat i) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("floatMethodTakesOneFloat", jfloat{i});
+  return gtest_helper.Call<"floatMethodTakesOneFloat">(jfloat{i});
 }
 
 JNIEXPORT jfloat JNICALL
@@ -219,8 +219,8 @@ Java_com_jnibind_test_MethodTest_jniFloatMethodTakesFiveFloats(
     jfloat i4, jfloat i5) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("floatMethodTakesFiveFloats", jfloat{i1}, jfloat{i2},
-                      jfloat{i3}, jfloat{i4}, jfloat{i5});
+  return gtest_helper.Call<"floatMethodTakesFiveFloats">(
+      jfloat{i1}, jfloat{i2}, jfloat{i3}, jfloat{i4}, jfloat{i5});
 }
 
 /** Double Method Tests. */
@@ -228,7 +228,7 @@ JNIEXPORT jdouble JNICALL Java_com_jnibind_test_MethodTest_jniDoubleMethod(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("doubleMethod");
+  return gtest_helper.Call<"doubleMethod">();
 }
 
 JNIEXPORT jdouble JNICALL
@@ -238,7 +238,7 @@ Java_com_jnibind_test_MethodTest_jniDoubleMethodTakesOneDouble(JNIEnv* env,
                                                                jdouble i) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("doubleMethodTakesOneDouble", jdouble{i});
+  return gtest_helper.Call<"doubleMethodTakesOneDouble">(jdouble{i});
 }
 
 JNIEXPORT jdouble JNICALL
@@ -247,8 +247,8 @@ Java_com_jnibind_test_MethodTest_jniDoubleMethodTakesFiveDoubles(
     jdouble i4, jdouble i5) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("doubleMethodTakesFiveDoubles", jdouble{i1}, jdouble{i2},
-                      jdouble{i3}, jdouble{i4}, jdouble{i5});
+  return gtest_helper.Call<"doubleMethodTakesFiveDoubles">(
+      jdouble{i1}, jdouble{i2}, jdouble{i3}, jdouble{i4}, jdouble{i5});
 }
 
 /** Overload Method Tests. */
@@ -256,29 +256,29 @@ JNIEXPORT int JNICALL Java_com_jnibind_test_MethodTest_jniCallFooOverload1(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("foo");
+  return gtest_helper.Call<"foo">();
 }
 
 JNIEXPORT int JNICALL Java_com_jnibind_test_MethodTest_jniCallFooOverload2(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("foo", 123.f);
+  return gtest_helper.Call<"foo">(123.f);
 }
 
 JNIEXPORT int JNICALL Java_com_jnibind_test_MethodTest_jniCallFooOverload3(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
 
-  return gtest_helper("foo", 123.f, 456.f);
+  return gtest_helper.Call<"foo">(123.f, 456.f);
 }
 
 /** Overload int/double disambiguation. */
 JNIEXPORT void JNICALL Java_com_jnibind_test_MethodTest_jniCallFooOverload4(
     JNIEnv* env, jclass, jobject object) {
   LocalObject<kMethodTestHelper> gtest_helper{object};
-  gtest_helper("intDouble", 123, 456.);
-  gtest_helper("intDouble", 456., 123);
+  gtest_helper.Call<"intDouble">(123, 456.);
+  gtest_helper.Call<"intDouble">(456., 123);
 }
 
 }  // extern "C"
diff --git a/javatests/com/jnibind/test/modulo.h b/javatests/com/jnibind/test/modulo.h
index c4b1a3ad..c2f5e90e 100644
--- a/javatests/com/jnibind/test/modulo.h
+++ b/javatests/com/jnibind/test/modulo.h
@@ -13,7 +13,7 @@ T Modulo(std::size_t increment_count, T val = T{0},
          T max = std::numeric_limits<T>::max()) {
   T ret = val;
 
-  for (int i = 0; i < increment_count; ++i) {
+  for (std::size_t i = 0; i < increment_count; ++i) {
     ret += T{1};
     while (ret >= max) {
       ret -= max;
diff --git a/javatests/com/jnibind/test/static_test_jni.cc b/javatests/com/jnibind/test/static_test_jni.cc
index 26260150..558bdcda 100644
--- a/javatests/com/jnibind/test/static_test_jni.cc
+++ b/javatests/com/jnibind/test/static_test_jni.cc
@@ -73,49 +73,49 @@ Java_com_jnibind_test_StaticTest_jniTearDown(JavaVM* pjvm, void* reserved) {
 ////////////////////////////////////////////////////////////////////////////////
 JNIEXPORT void JNICALL Java_com_jnibind_test_StaticTest_voidMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  StaticRef<kClass>{}("voidFunc");
+  StaticRef<kClass>{}.Call<"voidFunc">();
 }
 
 JNIEXPORT jbyte JNICALL Java_com_jnibind_test_StaticTest_byteMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  return StaticRef<kClass>{}("byteFunc");
+  return StaticRef<kClass>{}.Call<"byteFunc">();
 }
 
 JNIEXPORT jchar JNICALL Java_com_jnibind_test_StaticTest_charMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  return StaticRef<kClass>{}("charFunc");
+  return StaticRef<kClass>{}.Call<"charFunc">();
 }
 
 JNIEXPORT jshort JNICALL Java_com_jnibind_test_StaticTest_shortMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  return StaticRef<kClass>{}("shortFunc");
+  return StaticRef<kClass>{}.Call<"shortFunc">();
 }
 
 JNIEXPORT jint JNICALL Java_com_jnibind_test_StaticTest_intMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  return StaticRef<kClass>{}("intFunc");
+  return StaticRef<kClass>{}.Call<"intFunc">();
 }
 
 JNIEXPORT jlong JNICALL Java_com_jnibind_test_StaticTest_longMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  return StaticRef<kClass>{}("longFunc");
+  return StaticRef<kClass>{}.Call<"longFunc">();
 }
 
 JNIEXPORT jfloat JNICALL Java_com_jnibind_test_StaticTest_floatMethodTestNative(
     JavaVM* pjvm, void* reserved) {
-  return StaticRef<kClass>{}("floatFunc");
+  return StaticRef<kClass>{}.Call<"floatFunc">();
 }
 
 JNIEXPORT jdouble JNICALL
 Java_com_jnibind_test_StaticTest_doubleMethodTestNative(JavaVM* pjvm,
                                                         void* reserved) {
-  return StaticRef<kClass>{}("doubleFunc");
+  return StaticRef<kClass>{}.Call<"doubleFunc">();
 }
 
 JNIEXPORT jobject JNICALL
 Java_com_jnibind_test_StaticTest_objectMethodTestNative(JavaVM* pjvm,
                                                         void* reserved) {
-  return StaticRef<kClass>{}("objectFunc").Release();
+  return StaticRef<kClass>{}.Call<"objectFunc">().Release();
 }
 
 JNIEXPORT jstring JNICALL
@@ -123,7 +123,7 @@ Java_com_jnibind_test_StaticTest_complexMethodTestNative(JavaVM* pjvm,
                                                          void* reserved, jint a,
                                                          jfloat b, jstring c,
                                                          jobjectArray d) {
-  return StaticRef<kClass>{}("complexFunc", a, b, c, d).Release();
+  return StaticRef<kClass>{}.Call<"complexFunc">(a, b, c, d).Release();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -131,57 +131,57 @@ Java_com_jnibind_test_StaticTest_complexMethodTestNative(JavaVM* pjvm,
 ////////////////////////////////////////////////////////////////////////////////
 JNIEXPORT bool JNICALL Java_com_jnibind_test_StaticTest_booleanFieldTestNative(
     JavaVM* pjvm, void* reserved, bool val) {
-  StaticRef<kClass>{}["booleanField"].Set(val);
-  return StaticRef<kClass>{}["booleanField"].Get();
+  StaticRef<kClass>{}.Access<"booleanField">().Set(val);
+  return StaticRef<kClass>{}.Access<"booleanField">().Get();
 }
 
 JNIEXPORT jbyte JNICALL Java_com_jnibind_test_StaticTest_byteFieldTestNative(
     JavaVM* pjvm, void* reserved, jbyte val) {
-  StaticRef<kClass>{}["byteField"].Set(val);
-  return StaticRef<kClass>{}["byteField"].Get();
+  StaticRef<kClass>{}.Access<"byteField">().Set(val);
+  return StaticRef<kClass>{}.Access<"byteField">().Get();
 }
 
 JNIEXPORT char JNICALL Java_com_jnibind_test_StaticTest_charFieldTestNative(
     JavaVM* pjvm, void* reserved, jchar val) {
-  StaticRef<kClass>{}["charField"].Set(val);
-  return StaticRef<kClass>{}["charField"].Get();
+  StaticRef<kClass>{}.Access<"charField">().Set(val);
+  return StaticRef<kClass>{}.Access<"charField">().Get();
 }
 
 JNIEXPORT short JNICALL Java_com_jnibind_test_StaticTest_shortFieldTestNative(
     JavaVM* pjvm, void* reserved, jshort val) {
-  StaticRef<kClass>{}["shortField"].Set(val);
-  return StaticRef<kClass>{}["shortField"].Get();
+  StaticRef<kClass>{}.Access<"shortField">().Set(val);
+  return StaticRef<kClass>{}.Access<"shortField">().Get();
 }
 
 JNIEXPORT int JNICALL Java_com_jnibind_test_StaticTest_intFieldTestNative(
     JavaVM* pjvm, void* reserved, jint val) {
-  StaticRef<kClass>{}["intField"].Set(val);
-  return StaticRef<kClass>{}["intField"].Get();
+  StaticRef<kClass>{}.Access<"intField">().Set(val);
+  return StaticRef<kClass>{}.Access<"intField">().Get();
 }
 
 JNIEXPORT long JNICALL Java_com_jnibind_test_StaticTest_longFieldTestNative(
     JavaVM* pjvm, void* reserved, jlong val) {
-  StaticRef<kClass>{}["longField"].Set(val);
-  return StaticRef<kClass>{}["longField"].Get();
+  StaticRef<kClass>{}.Access<"longField">().Set(val);
+  return StaticRef<kClass>{}.Access<"longField">().Get();
 }
 
 JNIEXPORT float JNICALL Java_com_jnibind_test_StaticTest_floatFieldTestNative(
     JavaVM* pjvm, void* reserved, jfloat val) {
-  StaticRef<kClass>{}["floatField"].Set(val);
-  return StaticRef<kClass>{}["floatField"].Get();
+  StaticRef<kClass>{}.Access<"floatField">().Set(val);
+  return StaticRef<kClass>{}.Access<"floatField">().Get();
 }
 
 JNIEXPORT double JNICALL Java_com_jnibind_test_StaticTest_doubleFieldTestNative(
     JavaVM* pjvm, void* reserved, jdouble val) {
-  StaticRef<kClass>{}["doubleField"].Set(val);
-  return StaticRef<kClass>{}["doubleField"].Get();
+  StaticRef<kClass>{}.Access<"doubleField">().Set(val);
+  return StaticRef<kClass>{}.Access<"doubleField">().Get();
 }
 
 JNIEXPORT jobject JNICALL
 Java_com_jnibind_test_StaticTest_objectFieldTestNative(JavaVM* pjvm,
                                                        void* reserved,
                                                        jobject val) {
-  StaticRef<kClass>{}["objectField"].Set(val);
-  return StaticRef<kClass>{}["objectField"].Get().Release();
+  StaticRef<kClass>{}.Access<"objectField">().Set(val);
+  return StaticRef<kClass>{}.Access<"objectField">().Get().Release();
 }
 }
diff --git a/javatests/com/jnibind/test/string_test_jni.cc b/javatests/com/jnibind/test/string_test_jni.cc
index d4aa07af..df33093f 100644
--- a/javatests/com/jnibind/test/string_test_jni.cc
+++ b/javatests/com/jnibind/test/string_test_jni.cc
@@ -71,15 +71,15 @@ Java_com_jnibind_test_StringTest_jniPassesStringsInManyWays(
   LocalString string_lval{input};
 
   const char* kSimpleTestString{"SimpleTestString"};
-  fixture("voidMethodTakesString", "SimpleTestString");
-  fixture("voidMethodTakesString", kSimpleTestString);
-  fixture("voidMethodTakesString", std::string_view{"SimpleTestString"});
-  fixture("voidMethodTakesString", std::string{"SimpleTestString"});
-  fixture("voidMethodTakesString", input);
-  fixture("voidMethodTakesString", string_lval);
-  fixture("voidMethodTakesString", global_string_lval);
-  fixture("voidMethodTakesString", LocalString{input});
-  fixture("voidMethodTakesString", GlobalString{PromoteToGlobal{}, input});
+  fixture.Call<"voidMethodTakesString">("SimpleTestString");
+  fixture.Call<"voidMethodTakesString">(kSimpleTestString);
+  fixture.Call<"voidMethodTakesString">(std::string_view{"SimpleTestString"});
+  fixture.Call<"voidMethodTakesString">(std::string{"SimpleTestString"});
+  fixture.Call<"voidMethodTakesString">(input);
+  fixture.Call<"voidMethodTakesString">(string_lval);
+  fixture.Call<"voidMethodTakesString">(global_string_lval);
+  fixture.Call<"voidMethodTakesString">(LocalString{input});
+  fixture.Call<"voidMethodTakesString">(GlobalString{PromoteToGlobal{}, input});
 }
 
 /** Void return type tests. */
@@ -89,15 +89,15 @@ Java_com_jnibind_test_StringTest_jniVoidMethodTakesString(JNIEnv* env, jclass,
                                                           jstring string) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
   LocalString lValue{string};
-  r_jni_string_test_helper("voidMethodTakesString", LocalString{string});
+  r_jni_string_test_helper.Call<"voidMethodTakesString">(LocalString{string});
 }
 
 JNIEXPORT void JNICALL
 Java_com_jnibind_test_StringTest_jniVoidMethodTakesTwoStrings(
     JNIEnv* env, jclass, jobject object, jstring s1, jstring s2) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
-  r_jni_string_test_helper("voidMethodTakesTwoStrings", LocalString{s1},
-                           LocalString{s2});
+  r_jni_string_test_helper.Call<"voidMethodTakesTwoStrings">(LocalString{s1},
+                                                             LocalString{s2});
 }
 
 JNIEXPORT void JNICALL
@@ -107,9 +107,9 @@ Java_com_jnibind_test_StringTest_jniVoidMethodTakesFiveStrings(
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
   std::string s4_string{LocalString{s4}.Pin().ToString()};
 
-  r_jni_string_test_helper("voidMethodTakesFiveStrings",
-                           LocalString{s1}.Pin().ToString(), LocalString{s2},
-                           s3, s4_string, LocalString{s5}.Pin().ToString());
+  r_jni_string_test_helper.Call<"voidMethodTakesFiveStrings">(
+      LocalString{s1}.Pin().ToString(), LocalString{s2}, s3, s4_string,
+      LocalString{s5}.Pin().ToString());
 }
 
 /** String return type tests. */
@@ -118,8 +118,8 @@ Java_com_jnibind_test_StringTest_jniStringMethodTakesString(JNIEnv* env, jclass,
                                                             jobject object,
                                                             jstring string) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
-  return r_jni_string_test_helper("stringMethodTakesString",
-                                  LocalString{string})
+  return r_jni_string_test_helper
+      .Call<"stringMethodTakesString">(LocalString{string})
       .Release();
 }
 
@@ -128,8 +128,8 @@ Java_com_jnibind_test_StringTest_jniStringMethodTakesTwoStrings(
     JNIEnv* env, jclass, jobject object, jstring s1, jstring s2) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
   return LocalString{
-      r_jni_string_test_helper("stringMethodTakesTwoStrings", LocalString{s1},
-                               std::string{LocalString{s2}.Pin().ToString()})}
+      r_jni_string_test_helper.Call<"stringMethodTakesTwoStrings">(
+          LocalString{s1}, std::string{LocalString{s2}.Pin().ToString()})}
       .Release();
 }
 
@@ -138,10 +138,10 @@ Java_com_jnibind_test_StringTest_jniStringMethodTakesFiveStrings(
     JNIEnv* env, jclass, jobject object, jstring s1, jstring s2, jstring s3,
     jstring s4, jstring s5) {
   LocalObject<kMethodTestHelper> r_jni_string_test_helper{object};
-  return LocalString{r_jni_string_test_helper("stringMethodTakesFiveStrings",
-                                              LocalString{s1}, LocalString{s2},
-                                              LocalString{s3}, LocalString{s4},
-                                              LocalString{s5})}
+  return LocalString{
+      r_jni_string_test_helper.Call<"stringMethodTakesFiveStrings">(
+          LocalString{s1}, LocalString{s2}, LocalString{s3}, LocalString{s4},
+          LocalString{s5})}
       .Release();
 }
 
diff --git a/javatests/com/jnibind/test/thread_test_jni.cc b/javatests/com/jnibind/test/thread_test_jni.cc
index 4ea7d098..f1d6072e 100644
--- a/javatests/com/jnibind/test/thread_test_jni.cc
+++ b/javatests/com/jnibind/test/thread_test_jni.cc
@@ -57,7 +57,7 @@ Java_com_jnibind_test_ThreadTest_RunsThreadedWorkOnObject(JNIEnv* env, jclass,
   std::thread worker{
       [global_object_lambda_scope{std::move(global_obj)}]() mutable {
         ThreadGuard thread_guard{};
-        global_object_lambda_scope("foo");
+        global_object_lambda_scope.Call<"foo">();
       }};
 
   worker.join();
diff --git a/jni_bind.h b/jni_bind.h
index 6c4c79c3..dfaca903 100644
--- a/jni_bind.h
+++ b/jni_bind.h
@@ -50,6 +50,7 @@ static constexpr Configuration kConfig{
 #include "implementation/jni_helper/jni_helper.h"
 #include "implementation/jni_helper/lifecycle.h"
 #include "implementation/jni_helper/static_field_value.h"
+#include "metaprogramming/string_literal.h"
 
 // Headers for static definitions.
 #include "implementation/array.h"
diff --git a/metaprogramming/BUILD b/metaprogramming/BUILD
index 7505ed81..7653892a 100644
--- a/metaprogramming/BUILD
+++ b/metaprogramming/BUILD
@@ -230,29 +230,6 @@ cc_test(
     ],
 )
 
-################################################################################
-# Conjunction.
-################################################################################
-cc_library(
-    name = "conjunction",
-    hdrs = ["conjunction.h"],
-    deps = [
-        ":invoke",
-        ":next",
-    ],
-)
-
-cc_test(
-    name = "conjunction_test",
-    srcs = ["conjunction_test.cc"],
-    deps = [
-        ":conjunction",
-        ":invoke",
-        ":next",
-        "@googletest//:gtest_main",
-    ],
-)
-
 ################################################################################
 # Contains.
 ################################################################################
@@ -345,27 +322,8 @@ cc_test(
 )
 
 ################################################################################
-# Deep Equal.
+# Deep Equal Diminished.
 ################################################################################
-cc_library(
-    name = "deep_equal",
-    hdrs = ["deep_equal.h"],
-    deps = [
-        ":pack_discriminator",
-        ":vals_equal",
-    ],
-)
-
-cc_test(
-    name = "deep_equal_test",
-    srcs = ["deep_equal_test.cc"],
-    deps = [
-        ":deep_equal",
-        ":pack_discriminator",
-        "@googletest//:gtest_main",
-    ],
-)
-
 cc_library(
     name = "deep_equal_diminished",
     hdrs = ["deep_equal_diminished.h"],
@@ -654,30 +612,6 @@ cc_test(
     ],
 )
 
-################################################################################
-# Lambda Compatible.
-################################################################################
-cc_library(
-    name = "lambda_compatible",
-    hdrs = ["lambda_compatible.h"],
-    deps = [
-        ":deep_equal",
-        ":tuple_manipulation",
-        ":type_of_nth_element",
-    ],
-)
-
-cc_test(
-    name = "lambda_compatible_test",
-    srcs = ["lambda_compatible_test.cc"],
-    deps = [
-        ":deep_equal",
-        ":lambda_compatible",
-        ":vals",
-        "@googletest//:gtest_main",
-    ],
-)
-
 ################################################################################
 # Lambda String.
 ################################################################################
@@ -746,30 +680,6 @@ cc_test(
     ],
 )
 
-################################################################################
-# Type Map.
-################################################################################
-cc_library(
-    name = "type_map",
-    hdrs = ["type_map.h"],
-    deps = [
-        ":interleave",
-        ":lambda_string",
-        ":tuple_from_size",
-        ":tuple_manipulation",
-        ":type_of_nth_element",
-    ],
-)
-
-cc_test(
-    name = "type_map_test",
-    srcs = ["type_map_test.cc"],
-    deps = [
-        ":type_map",
-        "@googletest//:gtest_main",
-    ],
-)
-
 ################################################################################
 # Type of nth Element.
 ################################################################################
@@ -967,6 +877,7 @@ cc_test(
 cc_library(
     name = "queryable_map",
     hdrs = ["queryable_map.h"],
+    tags = ["manual"],
     deps = [
         ":interleave",
         ":tuple_from_size",
@@ -975,15 +886,16 @@ cc_library(
     ],
 )
 
-cc_test(
-    name = "queryable_map_test",
-    srcs = ["queryable_map_test.cc"],
-    deps = [
-        ":lambda_string",
-        ":queryable_map",
-        "@googletest//:gtest_main",
-    ],
-)
+# Currently not running because of a bug in gcc C++20 on Github's Bazel.
+#cc_test(
+#    name = "queryable_map_test",
+#    srcs = ["queryable_map_test.cc"],
+#    deps = [
+#        ":lambda_string",
+#        ":queryable_map",
+#        "//testing/base/public:gunit_main",
+#    ],
+#)
 
 ################################################################################
 # Queryable Map 20.
diff --git a/metaprogramming/cartesian_product.h b/metaprogramming/cartesian_product.h
index dca70ea5..159e7d34 100644
--- a/metaprogramming/cartesian_product.h
+++ b/metaprogramming/cartesian_product.h
@@ -53,44 +53,46 @@ struct GenerateBitSequenceFromTupSets {
     };
   };
 
+  // Due to a gcc bug, this requires using a name that is *not* type.
   template <typename... Tups>
-  using type = typename Helper<Tups...>::template SequenceGenerator<
+  using generated_type = typename Helper<Tups...>::template SequenceGenerator<
       std::make_index_sequence<sizeof...(Tups)>>::type;
 };
 
 struct GenerateBitSequenceFromTupSetsFunc {
   template <typename... Tups>
-  using type = typename GenerateBitSequenceFromTupSets::template type<Tups...>;
+  using generated_type =
+      typename GenerateBitSequenceFromTupSets::template generated_type<Tups...>;
 };
 
 template <typename... Tups>
 using GenerateBitSequenceFromTupSets_t =
-    typename GenerateBitSequenceFromTupSets::template type<Tups...>;
+    typename GenerateBitSequenceFromTupSets::template generated_type<Tups...>;
 
-struct CartesianProduct {
-  template <typename... Tups>
-  struct CartesianProductHelper {
-    using NBitSequenceForTups = GenerateBitSequenceFromTupSets_t<Tups...>;
-    using AllTupsAsList = std::tuple<Tups...>;
-
-    template <typename>
-    struct SequenceGenerator {};
+template <typename... Tups>
+struct CartesianProductHelper {
+  using NBitSequenceForTups = GenerateBitSequenceFromTupSets_t<Tups...>;
+  using AllTupsAsList = std::tuple<Tups...>;
 
-    template <size_t... Is>
-    struct SequenceGenerator<std::index_sequence<Is...>> {
-      using type = std::tuple<typename Increment_t<
-          NBitSequenceForTups, Is>::TypeMask::template type<AllTupsAsList>...>;
-    };
+  template <typename>
+  struct SequenceGenerator {};
 
-    using type = typename SequenceGenerator<std::make_index_sequence<
-        NBitSequenceForTups::max_representable_size_>>::type;
+  template <size_t... Is>
+  struct SequenceGenerator<std::index_sequence<Is...>> {
+    using type = std::tuple<typename Increment_t<
+        NBitSequenceForTups, Is>::TypeMask::template type<AllTupsAsList>...>;
   };
 
-  template <>
-  struct CartesianProductHelper<> {
-    using type = std::tuple<>;
-  };
+  using type = typename SequenceGenerator<std::make_index_sequence<
+      NBitSequenceForTups::max_representable_size_>>::type;
+};
 
+template <>
+struct CartesianProductHelper<> {
+  using type = std::tuple<>;
+};
+
+struct CartesianProduct {
   template <typename... Tups>
   using type = typename CartesianProductHelper<Tups...>::type;
 };
diff --git a/metaprogramming/conjunction.h b/metaprogramming/conjunction.h
deleted file mode 100644
index fc099661..00000000
--- a/metaprogramming/conjunction.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef JNI_BIND_METAPROGRAMMING_CONJUNCTION_H_
-#define JNI_BIND_METAPROGRAMMING_CONJUNCTION_H_
-
-#include <type_traits>
-
-#include "metaprogramming/invoke.h"
-#include "metaprogramming/next.h"
-
-namespace jni::metaprogramming {
-
-template <typename Lambda>
-struct Conjunction;
-
-template <typename Lambda, bool cur_val, typename Iter1, typename Iter2>
-struct ConjunctionHelper {
-  static constexpr bool value =
-      cur_val && Invoke_t<Lambda, Iter1>::value &&
-      Conjunction<Lambda>::template value<Next_t<Iter1>, Iter2>;
-  using type = Invoke_t<Lambda, Iter1>;
-};
-
-template <typename Lambda, bool cur_val, typename IterEnd>
-struct ConjunctionHelper<Lambda, cur_val, IterEnd, IterEnd> {
-  static constexpr bool value = cur_val && Invoke_t<Lambda, IterEnd>::value;
-};
-
-template <typename Lambda>
-struct Conjunction {
-  template <typename Iter1, typename Iter2>
-  static constexpr bool value =
-      ConjunctionHelper<Lambda, true, Iter1, Iter2>::value;
-
-  template <typename Iter1, typename Iter2>
-  using type = std::bool_constant<value<Iter1, Iter2>>;
-};
-
-// Applies lambda from |Iter1| to |Iter2| inclusive.
-template <typename Lambda, typename Iter1, typename Iter2>
-static constexpr bool Conjunction_v =
-    Conjunction<Lambda>::template value<Iter1, Iter2>;
-
-}  // namespace jni::metaprogramming
-
-#endif  // JNI_BIND_METAPROGRAMMING_CONJUNCTION_H_
diff --git a/metaprogramming/conjunction_test.cc b/metaprogramming/conjunction_test.cc
deleted file mode 100644
index b3acbf2e..00000000
--- a/metaprogramming/conjunction_test.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-#include "metaprogramming/conjunction.h"
-
-#include <cstddef>
-#include <type_traits>
-
-#include "metaprogramming/invoke.h"
-#include "metaprogramming/next.h"
-
-namespace {
-
-using ::jni::metaprogramming::Conjunction_v;
-using ::jni::metaprogramming::Invoke_t;
-using ::jni::metaprogramming::NextVal;  // NOLINT
-
-template <std::size_t I>
-struct ValCounter {
-  static constexpr std::size_t value = I;
-};
-
-}  // namespace
-
-template <>
-struct NextVal<ValCounter> {
-  template <typename ValCounter>
-  struct Helper;
-
-  template <std::size_t I>
-  struct Helper<ValCounter<I>> {
-    using type = ValCounter<I + 1>;
-  };
-
-  template <typename T>
-  using type = typename Helper<T>::type;
-};
-
-struct Not3 {
-  template <typename T>
-  static constexpr bool value = T::value != 3;
-
-  template <typename T>
-  using type = std::bool_constant<value<T>>;
-};
-
-static_assert(Invoke_t<Not3, std::integral_constant<std::size_t, 0>>::value);
-static_assert(Invoke_t<Not3, std::integral_constant<std::size_t, 1>>::value);
-static_assert(Invoke_t<Not3, std::integral_constant<std::size_t, 2>>::value);
-static_assert(!Invoke_t<Not3, std::integral_constant<std::size_t, 3>>::value);
-static_assert(Invoke_t<Not3, std::integral_constant<std::size_t, 4>>::value);
-static_assert(Invoke_t<Not3, std::integral_constant<std::size_t, 5>>::value);
-
-using Iter1 = ValCounter<1>;
-using Iter2 = ValCounter<2>;
-using Iter3 = ValCounter<3>;
-using Iter4 = ValCounter<4>;
-using Iter5 = ValCounter<5>;
-
-// Iterators spanning 1 element.
-static_assert(Conjunction_v<Not3, Iter1, Iter1>);
-static_assert(Conjunction_v<Not3, Iter2, Iter2>);
-static_assert(!Conjunction_v<Not3, Iter3, Iter3>);
-static_assert(Conjunction_v<Not3, Iter4, Iter4>);
-static_assert(Conjunction_v<Not3, Iter5, Iter5>);
-
-// Iterators spanning multiple elements (starting at 1).
-static_assert(Conjunction_v<Not3, Iter1, Iter2>);
-static_assert(!Conjunction_v<Not3, Iter1, Iter3>);
-static_assert(!Conjunction_v<Not3, Iter1, Iter4>);
-static_assert(!Conjunction_v<Not3, Iter1, Iter5>);
-
-// Iterators spanning multiple elements (starting at 2).
-static_assert(!Conjunction_v<Not3, Iter2, Iter3>);
-static_assert(!Conjunction_v<Not3, Iter2, Iter4>);
-static_assert(!Conjunction_v<Not3, Iter2, Iter5>);
-
-// Iterators spanning multiple elements (starting at 3).
-static_assert(!Conjunction_v<Not3, Iter3, Iter4>);
-static_assert(!Conjunction_v<Not3, Iter3, Iter5>);
-
-// Iterators spanning multiple elements (starting at 4).
-static_assert(Conjunction_v<Not3, Iter4, Iter5>);
diff --git a/metaprogramming/deep_equal_diminished_test.cc b/metaprogramming/deep_equal_diminished_test.cc
index 1fce8af6..d37b3b4d 100644
--- a/metaprogramming/deep_equal_diminished_test.cc
+++ b/metaprogramming/deep_equal_diminished_test.cc
@@ -36,12 +36,6 @@ struct A {
 template <typename... Ts>
 struct Type {};
 
-template <const auto... Vs>
-struct Auto {};
-
-template <const auto... Vs>
-struct AutoRef {};
-
 template <const auto&... Vs>
 struct ConstAutoRef {};
 
@@ -65,43 +59,10 @@ static_assert(!DeepEqualDiminished_v<std::tuple<Type<int, int>>,
                                      std::tuple<std::tuple<int, int>>>);
 
 ////////////////////////////////////////////////////////////////////////////////
-// Autos.
-////////////////////////////////////////////////////////////////////////////////
-static_assert(
-    !DeepEqualDiminished_v<std::tuple<Type<int>>, std::tuple<Auto<'a'>>>);
-static_assert(
-    DeepEqualDiminished_v<std::tuple<Auto<'a'>>, std::tuple<Auto<'a'>>>);
-static_assert(
-    !DeepEqualDiminished_v<std::tuple<Auto<'a'>>, std::tuple<Auto<'b'>>>);
-static_assert(
-    !DeepEqualDiminished_v<std::tuple<Auto<'a'>>, std::tuple<Auto<'a', 'a'>>>);
-
-static_assert(DeepEqualDiminished_v<Auto<1>, Auto<1>>);
-static_assert(!DeepEqualDiminished_v<Auto<1>, Auto<2>>);
-static_assert(!DeepEqualDiminished_v<Auto<1>, Auto<1, 1>>);
-
-////////////////////////////////////////////////////////////////////////////////
-// Autos Refs.
+// Const Autos Refs.
 ////////////////////////////////////////////////////////////////////////////////
 const auto a = 'a';
 const auto b = 'b';
-
-static_assert(
-    !DeepEqualDiminished_v<std::tuple<Type<int>>, std::tuple<AutoRef<a>>>);
-static_assert(
-    DeepEqualDiminished_v<std::tuple<AutoRef<a>>, std::tuple<AutoRef<a>>>);
-static_assert(
-    !DeepEqualDiminished_v<std::tuple<AutoRef<a>>, std::tuple<AutoRef<b>>>);
-static_assert(
-    !DeepEqualDiminished_v<std::tuple<AutoRef<a>>, std::tuple<AutoRef<a, a>>>);
-
-static_assert(DeepEqualDiminished_v<AutoRef<a>, AutoRef<a>>);
-static_assert(!DeepEqualDiminished_v<AutoRef<a>, AutoRef<b>>);
-static_assert(!DeepEqualDiminished_v<AutoRef<a>, AutoRef<a, a>>);
-
-////////////////////////////////////////////////////////////////////////////////
-// Const Autos Refs.
-////////////////////////////////////////////////////////////////////////////////
 static_assert(
     !DeepEqualDiminished_v<std::tuple<Type<int>>, std::tuple<ConstAutoRef<a>>>);
 static_assert(DeepEqualDiminished_v<std::tuple<ConstAutoRef<a>>,
diff --git a/metaprogramming/even_odd.h b/metaprogramming/even_odd.h
index 85554525..4fe516ca 100644
--- a/metaprogramming/even_odd.h
+++ b/metaprogramming/even_odd.h
@@ -23,35 +23,35 @@
 
 namespace jni::metaprogramming {
 
-// Metafunction to return only even elements.
-struct Even {
-  template <typename... Ts>
-  struct EvenHelper {};
+template <typename... Ts>
+struct EvenHelper {};
 
-  template <>
-  struct EvenHelper<std::tuple<>> {
-    using type = std::tuple<>;
-  };
+template <>
+struct EvenHelper<std::tuple<>> {
+  using type = std::tuple<>;
+};
 
-  template <typename... Ts>
-  struct OddHelper {};
+template <typename... Ts>
+struct OddHelper {};
 
-  template <>
-  struct OddHelper<std::tuple<>> {
-    using type = std::tuple<>;
-  };
+template <>
+struct OddHelper<std::tuple<>> {
+  using type = std::tuple<>;
+};
 
-  template <typename T, typename... Ts>
-  struct OddHelper<std::tuple<T, Ts...>> {
-    using type = typename EvenHelper<std::tuple<Ts...>>::type;
-  };
+template <typename T, typename... Ts>
+struct EvenHelper<std::tuple<T, Ts...>> {
+  using type = ConcatenateTup_t<std::tuple<T>,
+                                typename OddHelper<std::tuple<Ts...>>::type>;
+};
 
-  template <typename T, typename... Ts>
-  struct EvenHelper<std::tuple<T, Ts...>> {
-    using type = ConcatenateTup_t<std::tuple<T>,
-                                  typename OddHelper<std::tuple<Ts...>>::type>;
-  };
+template <typename T, typename... Ts>
+struct OddHelper<std::tuple<T, Ts...>> {
+  using type = typename EvenHelper<std::tuple<Ts...>>::type;
+};
 
+// Metafunction to return only even elements.
+struct Even {
   template <typename... Ts>
   using type = typename EvenHelper<std::tuple<Ts...>>::type;
 };
@@ -61,16 +61,6 @@ using Even_t = typename Even::template type<Ts...>;
 
 // Metafunction to return only odd elements.
 struct Odd {
-  template <typename... Ts>
-  struct OddHelper {
-    using type = std::tuple<>;
-  };
-
-  template <typename T, typename... Ts>
-  struct OddHelper<std::tuple<T, Ts...>> {
-    using type = Even_t<Ts...>;
-  };
-
   template <typename... Ts>
   using type = typename OddHelper<std::tuple<Ts...>>::type;
 };
diff --git a/metaprogramming/invocable_map.h b/metaprogramming/invocable_map.h
index 40badde6..831bd682 100644
--- a/metaprogramming/invocable_map.h
+++ b/metaprogramming/invocable_map.h
@@ -25,10 +25,6 @@
 
 namespace jni::metaprogramming {
 
-template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member>
-class InvocableMap;
-
 // This is an interface that can be inherited from to expose an operator(...).
 // It provides compile time string index lookup with no macros although it is
 // dependent on a clang extension.
@@ -54,36 +50,38 @@ class InvocableMap;
 // the the const char cannot be propagated without losing its constexpr-ness,
 // and so the clang extension can no longer restrict function candidates.
 template <typename CrtpBase, const auto& tup_container_v,
-          const auto std::decay_t<decltype(tup_container_v)>::* nameable_member>
-using InvocableMap_t =
-    InvocableMap<CrtpBase, tup_container_v,
-                 std::decay_t<decltype(tup_container_v)>, nameable_member>;
+          typename TupContainerT, typename MemberT, MemberT nameable_member>
+class InvocableMap;
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
           std::size_t I>
 class InvocableMapEntry;
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
           typename IndexSequenceType>
 class InvocableMapBase {};
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
+
           std::size_t... idxs>
-class InvocableMapBase<CrtpBase, tup_container_v, TupContainerT,
+class InvocableMapBase<CrtpBase, tup_container_v, TupContainerT, MemberT,
                        nameable_member, std::index_sequence<idxs...>>
     : public InvocableMapEntry<CrtpBase, tup_container_v, TupContainerT,
-                               nameable_member, idxs>... {
+                               MemberT, nameable_member, idxs>... {
  public:
-  using InvocableMapEntry<CrtpBase, tup_container_v, TupContainerT,
+#if __clang__
+  using InvocableMapEntry<CrtpBase, tup_container_v, TupContainerT, MemberT,
                           nameable_member, idxs>::
   operator()...;
+#endif  // __clang__
 };
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
+
           std::size_t I>
 class InvocableMapEntry {
  public:
@@ -109,18 +107,15 @@ class InvocableMapEntry {
         .template InvocableMapCall<I, Args...>(key,
                                                std::forward<Args>(args)...);
   }
-#else
-  static_assert(false,
-                "This container requires clang for compile time strings.");
-#endif
+#endif  // __clang__
 };
 
 //==============================================================================
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member>
+          typename TupContainerT, typename MemberT, MemberT nameable_member>
 class InvocableMap
     : public InvocableMapBase<
-          CrtpBase, tup_container_v, TupContainerT, nameable_member,
+          CrtpBase, tup_container_v, TupContainerT, MemberT, nameable_member,
           std::make_index_sequence<std::tuple_size_v<
               std::decay_t<decltype(tup_container_v.*nameable_member)>>>> {};
 
diff --git a/metaprogramming/invocable_map_20.h b/metaprogramming/invocable_map_20.h
index 4162b87c..2e280f47 100644
--- a/metaprogramming/invocable_map_20.h
+++ b/metaprogramming/invocable_map_20.h
@@ -50,12 +50,16 @@ namespace jni::metaprogramming {
 // |tup_container_v| is a static instance of an object whose |nameable_member|
 //   contains a public field called name_.  It might seem strange not to
 //   directly pass a const auto&, however, this prevents accessing subobjects.
+// |TupContainerT| is the type of the container for the member.
+// |MemberT| is the type of a *pointer to member* in the container, *not* the
+//   actual type of the member itself.
+// |nameable_member| is pointer to member of the nameable type.
 //
 // The motivation for using inheritance as opposed to a simple member is that
 // the the const char cannot be propagated without losing its constexpr-ness,
 // and so the clang extension can no longer restrict function candidates.
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member>
+          typename TupContainerT, typename MemberT, MemberT nameable_member>
 class InvocableMap20 {
 #if __cplusplus >= 202002L
  public:
@@ -89,12 +93,6 @@ class InvocableMap20 {
 #endif  // __cplusplus >= 202002L
 };
 
-template <typename CrtpBase, const auto& tup_container_v,
-          const auto std::decay_t<decltype(tup_container_v)>::* nameable_member>
-using InvocableMap20_t =
-    InvocableMap20<CrtpBase, tup_container_v,
-                   std::decay_t<decltype(tup_container_v)>, nameable_member>;
-
 }  // namespace jni::metaprogramming
 
 #endif  // JNI_BIND_METAPROGRAMMING_INVOCABLE_MAP_20_H
diff --git a/metaprogramming/invocable_map_20_test.cc b/metaprogramming/invocable_map_20_test.cc
index c8eb7856..703c662d 100644
--- a/metaprogramming/invocable_map_20_test.cc
+++ b/metaprogramming/invocable_map_20_test.cc
@@ -24,7 +24,7 @@
 #include "string_literal.h"
 #include <gtest/gtest.h>
 
-using jni::metaprogramming::InvocableMap20_t;
+using jni::metaprogramming::InvocableMap20;
 using jni::metaprogramming::StringLiteral;
 
 struct Str {
@@ -44,11 +44,13 @@ constexpr NameContainer name_container{
 
 ////////////////////////////////////////////////////////////////////////////////
 class SampleClassNowExposingCallOperator1
-    : public InvocableMap20_t<SampleClassNowExposingCallOperator1,
-                              name_container, &NameContainer::container1_> {
+    : public InvocableMap20<
+          SampleClassNowExposingCallOperator1, name_container, NameContainer,
+          decltype(&NameContainer::container1_), &NameContainer::container1_> {
  protected:
-  friend InvocableMap20_t<SampleClassNowExposingCallOperator1, name_container,
-                          &NameContainer::container1_>;
+  friend InvocableMap20<SampleClassNowExposingCallOperator1, name_container,
+                        NameContainer, decltype(&NameContainer::container1_),
+                        &NameContainer::container1_>;
 
   template <size_t I, StringLiteral key_literal, typename... Args>
   auto InvocableMap20Call(Args&&... ts) {
diff --git a/metaprogramming/invocable_map_test.cc b/metaprogramming/invocable_map_test.cc
index 792bfaf1..afd6eeae 100644
--- a/metaprogramming/invocable_map_test.cc
+++ b/metaprogramming/invocable_map_test.cc
@@ -16,6 +16,7 @@
 
 #include "invocable_map.h"
 
+#include <cstddef>
 #include <string_view>
 #include <tuple>
 #include <type_traits>
@@ -24,7 +25,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::InvocableMap_t;
+using ::jni::metaprogramming::InvocableMap;
 
 struct Str {
   const char* name_;
@@ -43,11 +44,12 @@ constexpr NameContainer name_container{
 
 ////////////////////////////////////////////////////////////////////////////////
 class SampleClassNowExposingCallOperator1
-    : public InvocableMap_t<SampleClassNowExposingCallOperator1, name_container,
-                            &NameContainer::container1_> {
+    : public InvocableMap<SampleClassNowExposingCallOperator1, name_container,
+                          NameContainer, decltype(&NameContainer::container1_),
+                          &NameContainer::container1_> {
  protected:
   template <typename CrtpBase, const auto& tup_container_v,
-            typename TupContainerT, const auto TupContainerT::*nameable_member,
+            typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
   friend class jni::metaprogramming::InvocableMapEntry;
 
@@ -70,6 +72,8 @@ class SampleClassNowExposingCallOperator1
   }
 };
 
+#if __clang__
+
 TEST(InvocableMapTest1, HasCorrectTypesAndForwardsCalls) {
   SampleClassNowExposingCallOperator1 val;
   val("Foo", 1);
@@ -80,13 +84,17 @@ TEST(InvocableMapTest1, HasCorrectTypesAndForwardsCalls) {
   // val("BazNar", 7, 8, 9);
 }
 
+#endif  // __clang__
+
 ////////////////////////////////////////////////////////////////////////////////
 class SampleClassNowExposingCallOperator2
-    : public InvocableMap_t<SampleClassNowExposingCallOperator2, name_container,
-                            &NameContainer::container2_> {
+    : public InvocableMap<SampleClassNowExposingCallOperator2, name_container,
+
+                          NameContainer, decltype(&NameContainer::container1_),
+                          &NameContainer::container2_> {
  public:
   template <typename CrtpBase, const auto& tup_container_v,
-            typename TupContainerT, const auto TupContainerT::*nameable_member,
+            typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
   friend class jni::metaprogramming::InvocableMapEntry;
 
@@ -109,6 +117,8 @@ class SampleClassNowExposingCallOperator2
   }
 };
 
+#if __clang__
+
 TEST(InvocableMapTest2, HasCorrectTypesAndForwardsCalls) {
   SampleClassNowExposingCallOperator2 val;
   val("Fizz", 1);
@@ -119,4 +129,6 @@ TEST(InvocableMapTest2, HasCorrectTypesAndForwardsCalls) {
   // val("BazNar", 7, 8, 9);
 }
 
+#endif  // __clang__
+
 }  // namespace
diff --git a/metaprogramming/lambda_compatible.h b/metaprogramming/lambda_compatible.h
deleted file mode 100644
index 21fd34f5..00000000
--- a/metaprogramming/lambda_compatible.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2023 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_METAPROGRAMMING_LAMBDA_COMPATIBLE_H_
-#define JNI_BIND_METAPROGRAMMING_LAMBDA_COMPATIBLE_H_
-
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "deep_equal.h"
-#include "type_of_nth_element.h"
-
-namespace jni::metaprogramming {
-
-// Allows lambda argument comparison with deep equality.
-// Iff arg lists are equal, and each element is pointwise equal, `val` is true.
-template <const auto& lambda>
-struct LambdaCompatible {
-  template <const auto& query, typename IndexSequence>
-  struct Helper;
-
-  using LambdaT = std::decay_t<decltype(std::declval<decltype(lambda())>())>;
-  static constexpr std::size_t kNumArgs = std::tuple_size_v<LambdaT>;
-
-  template <const auto& query, size_t... Is>
-  struct Helper<query, std::index_sequence<Is...>> {
-    using QueryT = std::decay_t<decltype(query())>;
-    static constexpr std::size_t kNumQueryArgs = std::tuple_size_v<QueryT>;
-
-    // Sizes aren't equal.
-    template <const auto&, bool>
-    struct InnerHelper {
-      static constexpr bool val = false;
-    };
-
-    // Sizes are equal, deep comparison (templated to defer compilatino).
-    template <const auto& query_inner>
-    struct InnerHelper<query_inner, true> {
-      static constexpr bool val =
-          (DeepEqual_v<TypeOfNthTupleElement_t<Is, LambdaT>,
-                       TypeOfNthTupleElement_t<Is, QueryT>> &&
-           ...);
-    };
-
-    static constexpr bool val =
-        InnerHelper<query, kNumArgs == kNumQueryArgs>::val;
-  };
-
-  template <const auto& query>
-  static constexpr bool val =
-      Helper<query, std::make_index_sequence<kNumArgs>>::val;
-};
-
-template <const auto& lambda, const auto& query>
-static constexpr bool LambdaCompatible_v =
-    LambdaCompatible<lambda>::template val<query>;
-
-}  // namespace jni::metaprogramming
-
-#endif  // JNI_BIND_METAPROGRAMMING_LAMBDA_COMPATIBLE_H_
diff --git a/metaprogramming/lambda_compatible_test.cc b/metaprogramming/lambda_compatible_test.cc
deleted file mode 100644
index 3569c892..00000000
--- a/metaprogramming/lambda_compatible_test.cc
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright 2023 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.
- */
-
-#include "metaprogramming/lambda_compatible.h"
-
-#include <tuple>
-
-#include "metaprogramming/vals.h"
-
-using ::jni::metaprogramming::LambdaCompatible_v;
-using ::jni::metaprogramming::Vals;
-
-namespace {
-
-constexpr auto l1{[]() { return std::tuple{'a'}; }};
-constexpr auto l1_prime{[]() { return std::tuple{'a'}; }};
-constexpr auto l2{[]() { return std::tuple{'a', 'a', 'a'}; }};
-
-static_assert(LambdaCompatible_v<l1, l1>);
-static_assert(LambdaCompatible_v<l1, l1_prime>);
-static_assert(!LambdaCompatible_v<l1, l2>);
-static_assert(LambdaCompatible_v<l2, l2>);
-static_assert(!LambdaCompatible_v<l2, l1>);
-
-// Deliberately does *not* have constexpr construction.
-struct A {
-  A(int a) : a_(a) {}
-
-  int a_;
-};
-
-constexpr auto l3{[]() { return std::tuple{A{1}}; }};
-constexpr auto l3_prime{[]() { return std::tuple{A{1}}; }};
-constexpr auto l3_prime_prime{[]() { return std::tuple{A{9999}}; }};
-
-// Note: Value portion of A cannot be compared, so l3 == l3''.
-static_assert(LambdaCompatible_v<l3, l3>);
-static_assert(LambdaCompatible_v<l3, l3_prime>);
-static_assert(LambdaCompatible_v<l3, l3_prime_prime>);
-static_assert(!LambdaCompatible_v<l3, l1>);
-
-// Non-type template arguments compare fine.
-constexpr auto l4{[]() { return std::tuple{Vals<'a'>{}}; }};
-constexpr auto l4_prime{[]() { return std::tuple{Vals<'a'>{}}; }};
-constexpr auto l4_prime_prime{
-    []() { return std::tuple{Vals<'a', 'a', 'a'>{}}; }};
-constexpr auto l4b_prime_prime{
-    []() { return std::tuple{Vals<'b', 'b', 'b'>{}}; }};
-
-static_assert(LambdaCompatible_v<l4, l4>);
-static_assert(LambdaCompatible_v<l4, l4_prime>);
-static_assert(LambdaCompatible_v<l4_prime, l4_prime>);
-static_assert(LambdaCompatible_v<l4_prime, l4>);
-static_assert(LambdaCompatible_v<l4_prime_prime, l4_prime_prime>);
-static_assert(!LambdaCompatible_v<l4_prime_prime, l4b_prime_prime>);
-
-static_assert(!LambdaCompatible_v<l4, l1>);
-static_assert(!LambdaCompatible_v<l1, l4>);
-
-}  // namespace
diff --git a/metaprogramming/lambda_string.h b/metaprogramming/lambda_string.h
index 1df43c4d..37a59376 100644
--- a/metaprogramming/lambda_string.h
+++ b/metaprogramming/lambda_string.h
@@ -45,6 +45,8 @@ struct StringAsType : StringAsTypeBase {
 
 template <typename Identifier, std::size_t... I>
 constexpr auto LambdaToStr(Identifier id, std::index_sequence<I...>) {
+  // This stifles an incorrect compiler warning on gcc.
+  static_assert(!std::is_same_v<void, decltype(id)>);
   return StringAsType<id()[I]...>{};
 }
 
diff --git a/metaprogramming/n_bit_sequence.h b/metaprogramming/n_bit_sequence.h
index 99861a3c..2ca60827 100644
--- a/metaprogramming/n_bit_sequence.h
+++ b/metaprogramming/n_bit_sequence.h
@@ -36,6 +36,35 @@ struct NBitSequence<> {
   using Increment = NBitSequence<>;
 };
 
+template <size_t I, typename Sequence>
+using GetBit = TypeOfNthTupleElement_t<I, Sequence>;
+
+// If the next bit is overflowing (i.e. it just rolled over), this current
+// value increments. Bits only overflow for a single cycle, otherwise higher
+// order bits flip when no rollover is happening.
+template <size_t I, typename Sequence, std::size_t kSequenceSize>
+struct IncrementedBit {
+  using type = std::conditional_t<
+      IncrementedBit<I + 1, Sequence, kSequenceSize>::type::overflow_bit_,
+      typename GetBit<I, Sequence>::Increment,
+      typename GetBit<I, Sequence>::ResetOverflow>;
+};
+
+template <typename Sequence, std::size_t kSequenceSize>
+struct IncrementedBit<kSequenceSize - 1, Sequence, kSequenceSize> {
+  using type = typename GetBit<kSequenceSize - 1, Sequence>::Increment;
+};
+
+template <typename Sequence, std::size_t kSequenceSize, typename index_sequence>
+struct IncrementSequenceHelper {};
+
+template <typename Sequence, std::size_t kSequenceSize, size_t... Is>
+struct IncrementSequenceHelper<Sequence, kSequenceSize,
+                               std::index_sequence<Is...>> {
+  using type = NBitSequence<
+      typename IncrementedBit<Is, Sequence, kSequenceSize>::type...>;
+};
+
 // Represents a sequence of "NBits".  This can be useful for generating
 // selections of pools of objects of various sizes.
 //
@@ -52,9 +81,6 @@ struct NBitSequence<NBit<values, max_values, overflows>...> {
   using Sequence = std::tuple<NBit<values, max_values, overflows>...>;
   using TypeMask = TypeIndexMask<values...>;
 
-  template <size_t I>
-  using GetBit = TypeOfNthTupleElement_t<I, Sequence>;
-
   // Helper method to compare values of all NBits.
   template <size_t... Bits>
   static constexpr bool Same(std::index_sequence<Bits...> = {}) {
@@ -68,31 +94,8 @@ struct NBitSequence<NBit<values, max_values, overflows>...> {
   template <size_t... Bits>
   static constexpr bool same_ = Same(std::index_sequence<Bits...>{});
 
-  // If the next bit is overflowing (i.e. it just rolled over), this current
-  // value increments. Bits only overflow for a single cycle, otherwise higher
-  // order bits flip when no rollover is happening.
-  template <size_t I>
-  struct IncrementedBit {
-    using type = std::conditional_t<IncrementedBit<I + 1>::type::overflow_bit_,
-                                    typename GetBit<I>::Increment,
-                                    typename GetBit<I>::ResetOverflow>;
-  };
-
-  template <>
-  struct IncrementedBit<sequence_size_ - 1> {
-    using type = typename GetBit<sequence_size_ - 1>::Increment;
-  };
-
-  template <typename index_sequence>
-  struct IncrementSequenceHelper {};
-
-  template <size_t... Is>
-  struct IncrementSequenceHelper<std::index_sequence<Is...>> {
-    using type = NBitSequence<typename IncrementedBit<Is>::type...>;
-  };
-
   using Increment = typename IncrementSequenceHelper<
-      std::make_index_sequence<sequence_size_>>::type;
+      Sequence, sequence_size_, std::make_index_sequence<sequence_size_>>::type;
 };
 
 }  // namespace jni::metaprogramming
diff --git a/metaprogramming/next.h b/metaprogramming/next.h
index ec440ffa..217643e5 100644
--- a/metaprogramming/next.h
+++ b/metaprogramming/next.h
@@ -43,7 +43,7 @@ struct EndConstRefVal;
 // |T| must always be a container of a single kind of template expression.
 template <typename T>
 using Next_t =
-    typename PackDiscriminatedForward<NextType, NextVal,
+    typename PackDiscriminatedForward<NextType,
                                       NextConstRefVal>::template type<T>;
 
 }  // namespace jni::metaprogramming
diff --git a/metaprogramming/next_test.cc b/metaprogramming/next_test.cc
index 565b290f..59f01fea 100644
--- a/metaprogramming/next_test.cc
+++ b/metaprogramming/next_test.cc
@@ -28,6 +28,8 @@ using ::jni::metaprogramming::NextConstRefVal;  // NOLINT
 using ::jni::metaprogramming::NextType;         // NOLINT
 using ::jni::metaprogramming::NextVal;          // NOLINT
 
+namespace jni::metaprogramming {
+
 ////////////////////////////////////////////////////////////////////////////////
 // Type tests.
 ////////////////////////////////////////////////////////////////////////////////
@@ -58,6 +60,7 @@ struct NextType<TypeCounter> {
 };
 
 static_assert(std::is_same_v<Next_t<TypeCounter_t<0, 3>>, TypeCounter_t<1, 3>>);
+
 static_assert(
     std::is_same_v<Next_t<Next_t<TypeCounter_t<0, 3>>>, TypeCounter_t<2, 3>>);
 static_assert(std::is_same_v<Next_t<Next_t<Next_t<TypeCounter_t<0, 3>>>>,
@@ -91,12 +94,14 @@ struct NextVal<Counter> {
   using type = typename Helper<T>::type;
 };
 
+/*
 static_assert(std::is_same_v<Next_t<Counter<0, 3>>, Counter<1, 3>>);
 static_assert(std::is_same_v<Next_t<Next_t<Counter<0, 3>>>, Counter<2, 3>>);
 static_assert(
     std::is_same_v<Next_t<Next_t<Next_t<Counter<0, 3>>>>, Counter<3, 3>>);
 static_assert(std::is_same_v<Next_t<Next_t<Next_t<Next_t<Counter<0, 3>>>>>,
                              EndVal<Counter>>);
+                             */
 
 ////////////////////////////////////////////////////////////////////////////////
 // Const Auto& tests.
@@ -110,18 +115,18 @@ static constexpr std::size_t kTheValue0 = 0;
 static constexpr std::size_t kMaxValSizeGlobal = 3;
 
 template <>
-struct ::jni::metaprogramming::NextConstRefVal<::ConstRefCounter> {
+struct NextConstRefVal<ConstRefCounter> {
   template <typename T>
   struct Helper;
 
   template <const std::size_t& I, const std::size_t& kMaxVal>
-  struct Helper<::ConstRefCounter<I, kMaxVal>> {
+  struct Helper<ConstRefCounter<I, kMaxVal>> {
     static constexpr std::size_t kNextVal = I + 1;
     using type = ConstRefCounter<kNextVal, kMaxVal>;
   };
 
   template <const std::size_t& kMaxVal>
-  struct Helper<::ConstRefCounter<kMaxVal, kMaxVal>> {
+  struct Helper<ConstRefCounter<kMaxVal, kMaxVal>> {
     using type = EndConstRefVal<ConstRefCounter>;
   };
 
@@ -138,3 +143,5 @@ static_assert(
     Next_t<
         Next_t<Next_t<ConstRefCounter<kTheValue0, kMaxValSizeGlobal>>>>::val ==
     3);
+
+}  // namespace jni::metaprogramming
diff --git a/metaprogramming/pack_discriminator.h b/metaprogramming/pack_discriminator.h
index 84558777..33c05775 100644
--- a/metaprogramming/pack_discriminator.h
+++ b/metaprogramming/pack_discriminator.h
@@ -22,8 +22,6 @@ namespace jni::metaprogramming {
 enum class PackType {
   NOT_CONTAINER,
   TYPES,
-  AUTO,
-  AUTO_REF,
   CONST_AUTO_REF,
 };
 
@@ -41,16 +39,6 @@ struct PackDiscrimator {
     static constexpr PackType val = PackType::TYPES;
   };
 
-  template <template <auto...> class Container, auto... Vs>
-  struct Helper<Container<Vs...>> {
-    static constexpr PackType val = PackType::AUTO;
-  };
-
-  template <template <auto&...> class Container, auto&... Vs>
-  struct Helper<Container<Vs...>> {
-    static constexpr PackType val = PackType::AUTO_REF;
-  };
-
   template <template <const auto&...> class Container, const auto&... Vs>
   struct Helper<Container<Vs...>> {
     static constexpr PackType val = PackType::CONST_AUTO_REF;
@@ -65,10 +53,9 @@ static constexpr PackType PackDiscriminator_e =
     PackDiscrimator::template val<T>;
 
 // Metafunction to forward a containerized pack to a compatible container.
-template <template <template <typename...> class> class TypesContainer,
-          template <template <auto...> class> class AutoContainer,
-          template <template <const auto&...> class>
-          class ConstAutoRefContainer>
+template <
+    template <template <typename...> class> class TypesContainer,
+    template <template <const auto&...> class> class ConstAutoRefContainer>
 struct PackDiscriminatedForward {
   template <typename T>
   struct Helper;
@@ -79,12 +66,6 @@ struct PackDiscriminatedForward {
         typename TypesContainer<Container>::template type<Container<Ts...>>;
   };
 
-  template <template <auto...> class Container, auto... vs>
-  struct Helper<Container<vs...>> {
-    using type =
-        typename AutoContainer<Container>::template type<Container<vs...>>;
-  };
-
   template <template <const auto&...> class Container, const auto&... vs>
   struct Helper<Container<vs...>> {
     using type = typename ConstAutoRefContainer<Container>::template type<
diff --git a/metaprogramming/pack_discriminator_test.cc b/metaprogramming/pack_discriminator_test.cc
index a7767d70..41ef6029 100644
--- a/metaprogramming/pack_discriminator_test.cc
+++ b/metaprogramming/pack_discriminator_test.cc
@@ -21,9 +21,6 @@ namespace {
 using ::jni::metaprogramming::PackDiscriminator_e;
 using ::jni::metaprogramming::PackType;
 
-int a = 1;
-int b = 1;
-
 static constexpr bool kVal1 = false;
 static constexpr bool kVal2 = false;
 
@@ -32,20 +29,9 @@ struct NonContainer {};
 template <typename... Ts>
 struct A {};
 
-template <auto... Vs>
-struct B {};
-
-template <auto&... Vs>
-struct C {};
-
 template <const auto&... Vs>
 struct D {};
 
-// See class comment.
-// static_assert(PackDiscriminator_e<B<>> == PackType::AUTO);
-// static_assert(PackDiscriminator_e<C<>> == PackType::AUTO_REF);
-// static_assert(PackDiscriminator_e<D<>> == PackType::CONST_AUTO_REF);
-
 static_assert(PackDiscriminator_e<int> == PackType::NOT_CONTAINER);
 static_assert(PackDiscriminator_e<NonContainer> == PackType::NOT_CONTAINER);
 
@@ -53,12 +39,6 @@ static_assert(PackDiscriminator_e<A<>> == PackType::TYPES);
 static_assert(PackDiscriminator_e<A<float>> == PackType::TYPES);
 static_assert(PackDiscriminator_e<A<int, float>> == PackType::TYPES);
 
-static_assert(PackDiscriminator_e<B<0>> == PackType::AUTO);
-static_assert(PackDiscriminator_e<B<0, 1>> == PackType::AUTO);
-
-static_assert(PackDiscriminator_e<C<a>> == PackType::AUTO_REF);
-static_assert(PackDiscriminator_e<C<a, b>> == PackType::AUTO_REF);
-
 static_assert(PackDiscriminator_e<D<kVal1>> == PackType::CONST_AUTO_REF);
 static_assert(PackDiscriminator_e<D<kVal1, kVal2>> == PackType::CONST_AUTO_REF);
 
diff --git a/metaprogramming/passthrough_test.cc b/metaprogramming/passthrough_test.cc
index 14e12a10..44d1d8dd 100644
--- a/metaprogramming/passthrough_test.cc
+++ b/metaprogramming/passthrough_test.cc
@@ -39,7 +39,7 @@ struct A {
   void Foo() {}
 
   ~A() {
-    if (val_0 == 0xdeadbeef) {
+    if (val_0 == 0xdead) {
       // never happens because custom dtor.
       fail_happened = true;
     }
@@ -85,11 +85,15 @@ TEST(Passthrough, PeersThroughDereference) {
 }
 
 TEST(Passthrough, CustomDtorIsInvoked) {
-  { Passthrough<A, ReleaseObjectRef<A>> val{0xdeadbeef}; }
+  {
+    Passthrough<A, ReleaseObjectRef<A>> val{0xdead};
+  }
 
   EXPECT_FALSE(fail_happened);
 
-  { Passthrough<A> val{0xdeadbeef}; }
+  {
+    Passthrough<A> val{0xdead};
+  }
   EXPECT_TRUE(fail_happened);
 }
 
diff --git a/metaprogramming/queryable_map.h b/metaprogramming/queryable_map.h
index 9e38446c..fc55a3dc 100644
--- a/metaprogramming/queryable_map.h
+++ b/metaprogramming/queryable_map.h
@@ -26,7 +26,7 @@
 namespace jni::metaprogramming {
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::*nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
           typename IndexSequenceType>
 class QueryableMapBase {};
 
@@ -50,46 +50,50 @@ class QueryableMapBase {};
 // the the const char cannot be propagated without losing its constexpr-ness,
 // and so the clang extension can no longer restrict function candidates.
 template <typename CrtpBase, const auto& tup_container_v,
-          std::size_t container_size, typename TupContainerT,
-          const auto TupContainerT::*nameable_member>
+          std::size_t container_size, typename TupContainerT, typename MemberT,
+          MemberT nameable_member>
 class QueryableMap
-    : public QueryableMapBase<CrtpBase, tup_container_v, TupContainerT,
+    : public QueryableMapBase<CrtpBase, tup_container_v, TupContainerT, MemberT,
                               nameable_member,
                               std::make_index_sequence<container_size>> {};
 
-template <typename CrtpBase, const auto& tup_container_v,
-          const auto std::decay_t<decltype(tup_container_v)>::*nameable_member>
-using QueryableMap_t =
-    QueryableMap<CrtpBase, tup_container_v,
-                 std::tuple_size_v<std::decay_t<decltype((tup_container_v.*
-                                                          nameable_member))>>,
-                 std::decay_t<decltype(tup_container_v)>, nameable_member>;
+template <typename CrtpBase, const auto& tup_container_v, typename MemberT,
+          MemberT nameable_member>
+using QueryableMap_t = QueryableMap<
+    CrtpBase, tup_container_v,
+    std::tuple_size_v<
+        std::decay_t<decltype((tup_container_v.*nameable_member))>>,
+    std::decay_t<decltype(tup_container_v)>, MemberT, nameable_member>;
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::*nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
           std::size_t I>
 class QueryableMapEntry;
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::*nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
           std::size_t... idxs>
-class QueryableMapBase<CrtpBase, tup_container_v, TupContainerT,
+class QueryableMapBase<CrtpBase, tup_container_v, TupContainerT, MemberT,
                        nameable_member, std::index_sequence<idxs...>>
     : public QueryableMapEntry<CrtpBase, tup_container_v, TupContainerT,
-                               nameable_member, idxs>... {
+                               MemberT, nameable_member, idxs>... {
  public:
+#if __clang__
   using QueryableMapEntry<CrtpBase, tup_container_v, TupContainerT,
-                          nameable_member, idxs>::operator[]...;
+
+                          MemberT, nameable_member, idxs>::operator[]...;
 
   using QueryableMapEntry<CrtpBase, tup_container_v, TupContainerT,
-                          nameable_member, idxs>::Contains...;
+
+                          MemberT, nameable_member, idxs>::Contains...;
+#endif  // __clang__
 
   // Will select subclass specialisations if present.
   constexpr bool Contains(const char* key) { return false; }
 };
 
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::*nameable_member,
+          typename TupContainerT, typename MemberT, MemberT nameable_member,
           std::size_t I>
 class QueryableMapEntry {
  public:
@@ -119,10 +123,7 @@ class QueryableMapEntry {
                 ""))) {
     return true;
   }
-#else
-  static_assert(false,
-                "This container requires clang for compile time strings.");
-#endif
+#endif  // __clang__
 };
 
 }  // namespace jni::metaprogramming
diff --git a/metaprogramming/queryable_map_20.h b/metaprogramming/queryable_map_20.h
index ddf16743..db862668 100644
--- a/metaprogramming/queryable_map_20.h
+++ b/metaprogramming/queryable_map_20.h
@@ -43,12 +43,16 @@ namespace jni::metaprogramming {
 // |tup_container_v| is a static instance of an object whose |nameable_member|
 //   contains a public field called name_.  It might seem strange not to
 //   directly pass a const auto&, however, this prevents accessing subobjects.
+// |TupContainerT| is the type of the container for the member.
+// |MemberT| is the type of a *pointer to member* in the container, *not* the
+//   actual type of the member itself.
+// |nameable_member| is pointer to member of the nameable type.
 //
 // The motivation for using inheritance as opposed to a simple member is that
 // the the const char cannot be propagated without losing its constexpr-ness,
 // and so the clang extension can no longer restrict function candidates.
 template <typename CrtpBase, const auto& tup_container_v,
-          typename TupContainerT, const auto TupContainerT::* nameable_member>
+          typename TupContainerT, typename MemberT, MemberT nameable_member>
 class QueryableMap20 {
 #if __cplusplus >= 202002L
  private:
@@ -81,12 +85,6 @@ class QueryableMap20 {
 #endif  // __cplusplus >= 202002L
 };
 
-template <typename CrtpBase, const auto& tup_container_v,
-          const auto std::decay_t<decltype(tup_container_v)>::* nameable_member>
-using QueryableMap20_t =
-    QueryableMap20<CrtpBase, tup_container_v,
-                   std::decay_t<decltype(tup_container_v)>, nameable_member>;
-
 }  // namespace jni::metaprogramming
 
 #endif  // JNI_BIND_METAPROGRAMMING_QUERYABLE_MAP_20_H
diff --git a/metaprogramming/queryable_map_20_test.cc b/metaprogramming/queryable_map_20_test.cc
index 8a06e5b4..270b4c04 100644
--- a/metaprogramming/queryable_map_20_test.cc
+++ b/metaprogramming/queryable_map_20_test.cc
@@ -26,7 +26,7 @@
 
 #if __cplusplus >= 202002L
 
-using jni::metaprogramming::QueryableMap20_t;
+using jni::metaprogramming::QueryableMap20;
 using jni::metaprogramming::StringLiteral;
 
 struct Str {
@@ -46,11 +46,13 @@ constexpr NameContainer name_container{
 
 ////////////////////////////////////////////////////////////////////////////////
 class SampleClassNowExposingCallOperator1
-    : public QueryableMap20_t<SampleClassNowExposingCallOperator1,
-                              name_container, &NameContainer::container1_> {
+    : public QueryableMap20<
+          SampleClassNowExposingCallOperator1, name_container, NameContainer,
+          decltype(&NameContainer::container1_), &NameContainer::container1_> {
  protected:
-  friend QueryableMap20_t<SampleClassNowExposingCallOperator1, name_container,
-                          &NameContainer::container1_>;
+  friend QueryableMap20<SampleClassNowExposingCallOperator1, name_container,
+                        NameContainer, decltype(&NameContainer::container1_),
+                        &NameContainer::container1_>;
 
   template <size_t I, StringLiteral key_literal>
   auto QueryableMap20Call() {
diff --git a/metaprogramming/queryable_map_test.cc b/metaprogramming/queryable_map_test.cc
index d943092a..b8a0845c 100644
--- a/metaprogramming/queryable_map_test.cc
+++ b/metaprogramming/queryable_map_test.cc
@@ -50,10 +50,11 @@ using ValuesTup = std::tuple<int, SomeCustomKeyStruct, double>;
 
 class SampleClassNowExposingCallOperator1
     : public QueryableMap_t<SampleClassNowExposingCallOperator1, name_container,
+                            decltype(&NameContainer::container1_),
                             &NameContainer::container1_> {
  protected:
   template <typename CrtpBase, const auto& tup_container_v,
-            typename TupContainerT, const auto TupContainerT::*nameable_member,
+            typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
   friend class jni::metaprogramming::QueryableMapEntry;
 
@@ -79,8 +80,10 @@ constexpr SomeIndexerStruct kSomeKey{"Foo"};
 
 template <const auto& val>
 void FuncThatTrampolinesStaticValue(SampleClassNowExposingCallOperator1& map) {
+#if __clang__
   map["Foo"];
   map[val.key_];
+#endif  // __clang__
 }
 
 template <typename, typename = void>
@@ -88,6 +91,8 @@ struct InSet {
   using type = std::false_type;
 };
 
+#if __clang__
+
 TEST(QueryableMapTest1, HasCorrectTypesAndForwardsCalls) {
   SampleClassNowExposingCallOperator1 val;
   val["Foo"];
@@ -107,12 +112,15 @@ TEST(QueryableMapTest1, HasCorrectTypesAndForwardsCalls) {
   // val["BazNar"];
 }
 
+#endif  // __clang__
+
 class SampleClassNowExposingCallOperator2
     : public QueryableMap_t<SampleClassNowExposingCallOperator2, name_container,
+                            decltype(&NameContainer::container2_),
                             &NameContainer::container2_> {
  protected:
   template <typename CrtpBase, const auto& tup_container_v,
-            typename TupContainerT, const auto TupContainerT::*nameable_member,
+            typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
   friend class jni::metaprogramming::QueryableMapEntry;
 
@@ -130,6 +138,8 @@ class SampleClassNowExposingCallOperator2
   }
 };
 
+#if __clang__
+
 TEST(QueryableMapTest2, HasCorrectTypesAndForwardsCalls) {
   SampleClassNowExposingCallOperator2 val;
   val["Fizz"];
@@ -140,4 +150,6 @@ TEST(QueryableMapTest2, HasCorrectTypesAndForwardsCalls) {
   // val("BazNar", 7, 8, 9);
 }
 
+#endif  // __clang__
+
 }  // namespace
diff --git a/metaprogramming/string_concatenate.h b/metaprogramming/string_concatenate.h
index 26c473ab..adb6eaad 100644
--- a/metaprogramming/string_concatenate.h
+++ b/metaprogramming/string_concatenate.h
@@ -36,6 +36,9 @@ struct StringConcatenate {
       (append_single_string(Vs), ...);
       arr[len] = 0;
 
+      // This stifles an incorrect compiler warning on gcc.
+      static_assert(!std::is_same_v<void, decltype(append_single_string)>);
+
       return arr;
     }
 
diff --git a/metaprogramming/type_map.h b/metaprogramming/type_map.h
deleted file mode 100644
index 6d727de4..00000000
--- a/metaprogramming/type_map.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright 2021 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_METAPROGRAMMING_TYPE_MAP_H_
-#define JNI_BIND_METAPROGRAMMING_TYPE_MAP_H_
-
-#include <cstddef>
-#include <string_view>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "lambda_string.h"
-#include "tuple_from_size.h"
-#include "type_of_nth_element.h"
-
-namespace jni::metaprogramming {
-
-template <typename Key, typename Value, typename... Args>
-class TypeMapEntry {};
-
-template <typename Key, typename Value, typename... Args>
-class TypeMapEntry<Key, Value, std::tuple<Args...>> {
- public:
-  static_assert(std::is_base_of_v<metaprogramming::StringAsTypeBase, Key>);
-  static constexpr std::string_view name_ = Key::chars_as_sv;
-
-  template <typename Query,
-            typename = std::enable_if_t<std::is_same_v<Key, Query>, void>>
-  constexpr Value& Get() {
-    return value_;
-  }
-
-#if __clang__
-  // Android NDK seems to have a compiler issue that loses constexpr-ness on
-  // std::string_view but not const char*.
-  constexpr Value& Get(const char* key)
-      __attribute__((enable_if(key == Key::chars_as_sv, ""))) {
-    return value_;
-  }
-#endif
-
- private:
-  Value value_ = {};
-};
-
-template <typename KeysTuple, typename ValuesTuple, typename ArgsTuple,
-          typename IndexSequenceType>
-class TypeMapBase {};
-
-template <typename... Keys, typename... Values, typename... ArgTups,
-          size_t... Indices>
-class TypeMapBase<std::tuple<Keys...>, std::tuple<Values...>,
-                  std::tuple<ArgTups...>, std::index_sequence<Indices...>>
-    : public TypeMapEntry<TypeOfNthElement_t<Indices, Keys...>,
-                          TypeOfNthElement_t<Indices, Values...>,
-                          TypeOfNthElement_t<Indices, ArgTups...>>... {
- public:
-  using TypeMapEntry<TypeOfNthElement_t<Indices, Keys...>,
-                     TypeOfNthElement_t<Indices, Values...>,
-                     TypeOfNthElement_t<Indices, ArgTups...>>::Get...;
-
-  static_assert(sizeof...(Keys) == sizeof...(Values));
-};
-
-template <typename KeysTuple, typename ValuesTuple, typename... ArgTupsTuple>
-class TypeMap {};
-
-template <typename... Keys, typename... Values, typename... ArgTups>
-class TypeMap<std::tuple<Keys...>, std::tuple<Values...>,
-              std::tuple<ArgTups...>>
-    : public TypeMapBase<std::tuple<Keys...>, std::tuple<Values...>,
-                         std::tuple<ArgTups...>,
-                         std::index_sequence_for<Keys...>> {
-  static_assert(sizeof...(Keys) == sizeof...(Values));
-  static_assert(sizeof...(Keys) == sizeof...(ArgTups));
-};
-
-template <typename... Keys, typename... Values>
-class TypeMap<std::tuple<Keys...>, std::tuple<Values...>, void>
-    : public TypeMap<std::tuple<Keys...>, std::tuple<Values...>,
-                     decltype(TupleFromSize<std::tuple<>, sizeof...(Keys)>())> {
-};
-
-template <typename, typename>
-struct TypeMapBuilder {};
-
-template <typename KeysAsTuple, typename ValuesAsTuple,
-          typename ArgsAsTuple = void>
-using TypemapBuilder_t = TypeMap<KeysAsTuple, ValuesAsTuple, ArgsAsTuple>;
-
-}  // namespace jni::metaprogramming
-
-#endif  // JNI_BIND_METAPROGRAMMING_TYPE_MAP_H_
diff --git a/metaprogramming/type_map_test.cc b/metaprogramming/type_map_test.cc
deleted file mode 100644
index 1e7d329d..00000000
--- a/metaprogramming/type_map_test.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-#include "type_map.h"
-
-#include <optional>
-#include <string>
-#include <tuple>
-#include <type_traits>
-
-#include <gtest/gtest.h>
-
-namespace {
-
-using ::jni::metaprogramming::LambdaStringToType;
-using ::jni::metaprogramming::StringAsType;
-using ::jni::metaprogramming::TypemapBuilder_t;
-
-TEST(TypeMap, CompilesWhenEmptyWithOrWithoutCallableArgs) {
-  static_assert(
-      std::is_same_v<TypemapBuilder_t<std::tuple<>, std::tuple<>>,
-                     TypemapBuilder_t<std::tuple<>, std::tuple<>, void>>);
-  static_assert(std::is_same_v<
-                TypemapBuilder_t<std::tuple<>, std::tuple<>, std::tuple<>>,
-                TypemapBuilder_t<std::tuple<>, std::tuple<>, std::tuple<>>>);
-}
-
-TEST(TypeMap, SimpleTest) {
-  struct B {};
-  TypemapBuilder_t<
-      std::tuple<StringAsType<'F', 'O', 'O'>, StringAsType<'B', 'A', 'R'>>,
-      std::tuple<double, B>>
-      tp;
-  static_assert(std::is_same_v<decltype(tp.Get("FOO")), double&>);
-  static_assert(std::is_same_v<decltype(tp.Get("BAR")), B&>);
-}
-
-TEST(TypeMap, TypeMapWithStrings) {
-  constexpr auto string_lambda_1 = STR("FOO");
-  constexpr auto string_lambda_2 = STR("BAR");
-  constexpr auto string_lambda_3 = STR("BAZ");
-
-  using StringType1 = LambdaStringToType<decltype(string_lambda_1)>;
-  using StringType2 = LambdaStringToType<decltype(string_lambda_2)>;
-  using StringType3 = LambdaStringToType<decltype(string_lambda_3)>;
-
-  TypemapBuilder_t<std::tuple<StringType1, StringType2, StringType3>,
-                   std::tuple<int, float, std::optional<std::string>>>
-      type_map;
-
-  static_assert(std::is_same_v<decltype(type_map.Get<StringType1>()), int&>);
-  static_assert(std::is_same_v<decltype(type_map.Get("FOO")), int&>);
-  static_assert(std::is_same_v<decltype(type_map.Get("BAR")), float&>);
-  static_assert(std::is_same_v<decltype(type_map.Get<StringType2>()), float&>);
-  static_assert(std::is_same_v<decltype(type_map.Get("BAZ")),
-                               std::optional<std::string>&>);
-  static_assert(std::is_same_v<decltype(type_map.Get<StringType3>()),
-                               std::optional<std::string>&>);
-}
-
-}  // namespace
diff --git a/release_header_smoke_test.cc b/release_header_smoke_test.cc
index 6e7072e8..b0d38b18 100644
--- a/release_header_smoke_test.cc
+++ b/release_header_smoke_test.cc
@@ -23,13 +23,13 @@ TEST_F(JniTest, SmokeTest_SimplyRun) {
   };
 
   jni::GlobalObject<object> obj{};
-  obj("Foo", 1, 2.f);
-  obj("Baz", 1.f);
-  obj("Baz", 1.f);
-  obj("Baz", 2.f);
-  obj("Baz", 3.f);
-  obj("Bar");
-  obj["SomeField"].Get();
+  obj.Call<"Foo">(1, 2.f);
+  obj.Call<"Baz">(1.f);
+  obj.Call<"Baz">(1.f);
+  obj.Call<"Baz">(2.f);
+  obj.Call<"Baz">(3.f);
+  obj.Call<"Bar">();
+  obj.Access<"SomeField">().Get();
 }
 
 }  // namespace