diff --git a/implementation/BUILD b/implementation/BUILD
index 079548f3..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",
     ],
 )
 
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/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/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/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/metaprogramming/BUILD b/metaprogramming/BUILD
index 9d4bc956..7653892a 100644
--- a/metaprogramming/BUILD
+++ b/metaprogramming/BUILD
@@ -877,6 +877,7 @@ cc_test(
 cc_library(
     name = "queryable_map",
     hdrs = ["queryable_map.h"],
+    tags = ["manual"],
     deps = [
         ":interleave",
         ":tuple_from_size",
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/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/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/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/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;
     }