Fix GCC.

c++/Makefile.am

@@ -149,10 +149,11 @@ BUILT_SOURCES = $(test_capnpc_outputs) $(capnpc_outputs)
 check_PROGRAMS = capnproto-test
 capnproto_test_LDADD = -lgtest -lgtest_main libcapnproto.a
 capnproto_test_SOURCES =                                       \
-  src/kj/array-test.c++                                        \
   src/kj/common-test.c++                                       \
-  src/kj/debug-test.c++                                        \
+  src/kj/memory-test.c++                                       \
+  src/kj/array-test.c++                                        \
   src/kj/string-test.c++                                       \
+  src/kj/debug-test.c++                                        \
   src/kj/units-test.c++                                        \
   src/capnproto/blob-test.c++                                  \
   src/capnproto/layout-test.c++                                \

c++/src/kj/array-test.c++

@@ -101,13 +101,15 @@ TEST(Array, TrivialConstructor) {
   {
     Array<char> chars = heapArray<char>(32);
 
-    // Somewhat hacky:  We can't guarantee that the new array is allocated in the same place, but
-    // any reasonable allocator is highly likely to do so.  If it does, then we expect that the
-    // memory has not been initialized.
-    if (chars.begin() == ptr) {
-      EXPECT_NE(chars[0], 0);
-      EXPECT_NE(chars[1], 0);
-    }
+    // TODO(test):  The following doesn't work in opt mode -- I guess some allocators zero the
+    //   memory?  Is there some other way we can test this?  Maybe override malloc()?
+//    // Somewhat hacky:  We can't guarantee that the new array is allocated in the same place, but
+//    // any reasonable allocator is highly likely to do so.  If it does, then we expect that the
+//    // memory has not been initialized.
+//    if (chars.begin() == ptr) {
+//      EXPECT_NE(chars[0], 0);
+//      EXPECT_NE(chars[1], 0);
+//    }
   }
 }
 

c++/src/kj/array.h

@@ -77,8 +77,7 @@ public:
     other.ptr = nullptr;
     other.size_ = 0;
   }
-  template <typename = EnableIfConst<T>>
-  inline Array(Array<RemoveConst<T>>&& other) noexcept
+  inline Array(Array<RemoveConstOrBogus<T>>&& other) noexcept
       : ptr(other.ptr), size_(other.size_), disposer(other.disposer) {
     other.ptr = nullptr;
     other.size_ = 0;

c++/src/kj/common-test.c++

@@ -158,6 +158,13 @@ TEST(Common, MaybeConstness) {
   Maybe<int&> mi = i;
   const Maybe<int&> cmi = mi;
 //  const Maybe<int&> cmi2 = cmi;    // shouldn't compile!  Transitive const violation.
+
+  KJ_IF_MAYBE(i2, cmi) {
+    EXPECT_EQ(&i, i2);
+  } else {
+    ADD_FAILURE();
+  }
+
   Maybe<const int&> mci = mi;
   const Maybe<const int&> cmci = mci;
   const Maybe<const int&> cmci2 = cmci;

c++/src/kj/common.h

@@ -243,6 +243,10 @@ template <typename T> struct EnableIfConst_;
 template <typename T> struct EnableIfConst_<const T> { typedef T Type; };
 template <typename T> using EnableIfConst = typename EnableIfConst_<T>::Type;
 
+template <typename T> struct RemoveConstOrBogus_ { struct Type; };
+template <typename T> struct RemoveConstOrBogus_<const T> { typedef T Type; };
+template <typename T> using RemoveConstOrBogus = typename RemoveConstOrBogus_<T>::Type;
+
 // =======================================================================================
 // Equivalents to std::move() and std::forward(), since these are very commonly needed and the
 // std header <utility> pulls in lots of other stuff.

c++/src/kj/memory.h

@@ -88,8 +88,7 @@ public:
   Own(const Own& other) = delete;
   inline Own(Own&& other) noexcept
       : disposer(other.disposer), ptr(other.ptr) { other.ptr = nullptr; }
-  template <typename = EnableIfConst<T>>
-  inline Own(Own<RemoveConst<T>>&& other) noexcept
+  inline Own(Own<RemoveConstOrBogus<T>>&& other) noexcept
       : disposer(other.disposer), ptr(other.ptr) { other.ptr = nullptr; }
   template <typename U>
   inline Own(Own<U>&& other) noexcept