Fix GCC warnings.

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

@@ -90,10 +90,10 @@ int TestNoexceptObject::count = 0;
 int TestNoexceptObject::copiedCount = 0;
 
 TEST(Array, TrivialConstructor) {
-  char* ptr;
+//  char* ptr;
   {
     Array<char> chars = heapArray<char>(32);
-    ptr = chars.begin();
+//    ptr = chars.begin();
     chars[0] = 12;
     chars[1] = 34;
   }

c++/src/kj/array.h

@@ -250,7 +250,7 @@ public:
   inline size_t size() const { return pos - ptr; }
   inline size_t capacity() const { return endPtr - ptr; }
   inline T& operator[](size_t index) const {
-    KJ_IREQUIRE(index < pos - ptr, "Out-of-bounds Array access.");
+    KJ_IREQUIRE(index < implicitCast<size_t>(pos - ptr), "Out-of-bounds Array access.");
     return ptr[index];
   }
 

c++/src/kj/parse/char-test.c++

@@ -219,7 +219,7 @@ TEST(CharParsers, Integer) {
     Input input(text.begin(), text.end());
     Maybe<uint64_t> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(12349, *value);
+      EXPECT_EQ(12349u, *value);
     } else {
       ADD_FAILURE() << "Expected integer, got null.";
     }
@@ -231,7 +231,7 @@ TEST(CharParsers, Integer) {
     Input input(text.begin(), text.end());
     Maybe<uint64_t> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(0x1aF0, *value);
+      EXPECT_EQ(0x1aF0u, *value);
     } else {
       ADD_FAILURE() << "Expected integer, got null.";
     }
@@ -243,7 +243,7 @@ TEST(CharParsers, Integer) {
     Input input(text.begin(), text.end());
     Maybe<uint64_t> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(064270, *value);
+      EXPECT_EQ(064270u, *value);
     } else {
       ADD_FAILURE() << "Expected integer, got null.";
     }

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

@@ -255,13 +255,13 @@ TEST(CommonParsers, OptionalParser) {
     Input input(text.begin(), text.end());
     Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(123, get<0>(*value));
+      EXPECT_EQ(123u, get<0>(*value));
       KJ_IF_MAYBE(value2, get<1>(*value)) {
-        EXPECT_EQ(456, *value2);
+        EXPECT_EQ(456u, *value2);
       } else {
         ADD_FAILURE() << "Expected 456, got null.";
       }
-      EXPECT_EQ(789, get<2>(*value));
+      EXPECT_EQ(789u, get<2>(*value));
     } else {
       ADD_FAILURE() << "Expected result tuple, got null.";
     }
@@ -273,9 +273,9 @@ TEST(CommonParsers, OptionalParser) {
     Input input(text.begin(), text.end());
     Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(123, get<0>(*value));
+      EXPECT_EQ(123u, get<0>(*value));
       EXPECT_TRUE(get<1>(*value) == nullptr);
-      EXPECT_EQ(789, get<2>(*value));
+      EXPECT_EQ(789u, get<2>(*value));
     } else {
       ADD_FAILURE() << "Expected result tuple, got null.";
     }
@@ -403,7 +403,7 @@ TEST(CommonParsers, AcceptIfParser) {
     Input input(text.begin(), text.end());
     Maybe<uint> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(456, *value);
+      EXPECT_EQ(456u, *value);
     } else {
       ADD_FAILURE() << "Expected parse result, got null.";
     }
@@ -415,7 +415,7 @@ TEST(CommonParsers, AcceptIfParser) {
     Input input(text.begin(), text.end());
     Maybe<uint> result = parser(input);
     KJ_IF_MAYBE(value, result) {
-      EXPECT_EQ(789, *value);
+      EXPECT_EQ(789u, *value);
     } else {
       ADD_FAILURE() << "Expected parse result, got null.";
     }

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

@@ -36,27 +36,27 @@ struct Quux { uint quux; Quux(uint i): quux(i) {} };
 
 TEST(Tuple, Tuple) {
   Tuple<Foo, Bar> t = tuple(Foo(123), Bar(456));
-  EXPECT_EQ(123, get<0>(t).foo);
-  EXPECT_EQ(456, get<1>(t).bar);
+  EXPECT_EQ(123u, get<0>(t).foo);
+  EXPECT_EQ(456u, get<1>(t).bar);
 
   Tuple<Foo, Bar, Baz, Qux, Quux> t2 = tuple(t, Baz(789), tuple(Qux(321), Quux(654)));
-  EXPECT_EQ(123, get<0>(t2).foo);
-  EXPECT_EQ(456, get<1>(t2).bar);
-  EXPECT_EQ(789, get<2>(t2).baz);
-  EXPECT_EQ(321, get<3>(t2).qux);
-  EXPECT_EQ(654, get<4>(t2).quux);
+  EXPECT_EQ(123u, get<0>(t2).foo);
+  EXPECT_EQ(456u, get<1>(t2).bar);
+  EXPECT_EQ(789u, get<2>(t2).baz);
+  EXPECT_EQ(321u, get<3>(t2).qux);
+  EXPECT_EQ(654u, get<4>(t2).quux);
 
   Tuple<Own<Foo>, Own<Bar>> t3 = tuple(heap<Foo>(123), heap<Bar>(456));
-  EXPECT_EQ(123, get<0>(t3)->foo);
-  EXPECT_EQ(456, get<1>(t3)->bar);
+  EXPECT_EQ(123u, get<0>(t3)->foo);
+  EXPECT_EQ(456u, get<1>(t3)->bar);
 
   Tuple<Own<Foo>, Own<Bar>, Own<Baz>, Own<Qux>, Own<Quux>> t4 =
       tuple(mv(t3), heap<Baz>(789), tuple(heap<Qux>(321), heap<Quux>(654)));
-  EXPECT_EQ(123, get<0>(t4)->foo);
-  EXPECT_EQ(456, get<1>(t4)->bar);
-  EXPECT_EQ(789, get<2>(t4)->baz);
-  EXPECT_EQ(321, get<3>(t4)->qux);
-  EXPECT_EQ(654, get<4>(t4)->quux);
+  EXPECT_EQ(123u, get<0>(t4)->foo);
+  EXPECT_EQ(456u, get<1>(t4)->bar);
+  EXPECT_EQ(789u, get<2>(t4)->baz);
+  EXPECT_EQ(321u, get<3>(t4)->qux);
+  EXPECT_EQ(654u, get<4>(t4)->quux);
 
   Tuple<String, StringPtr> t5 = tuple(heapString("foo"), "bar");
   EXPECT_EQ("foo", get<0>(t5));
@@ -71,20 +71,20 @@ TEST(Tuple, Tuple) {
   EXPECT_EQ("quux", get<4>(t6));
 
   kj::apply([](Foo a, Bar b, Own<Foo> c, Own<Bar> d, uint e, StringPtr f, StringPtr g) {
-    EXPECT_EQ(123, a.foo);
-    EXPECT_EQ(456, b.bar);
-    EXPECT_EQ(123, c->foo);
-    EXPECT_EQ(456, d->bar);
-    EXPECT_EQ(789, e);
+    EXPECT_EQ(123u, a.foo);
+    EXPECT_EQ(456u, b.bar);
+    EXPECT_EQ(123u, c->foo);
+    EXPECT_EQ(456u, d->bar);
+    EXPECT_EQ(789u, e);
     EXPECT_EQ("foo", f);
     EXPECT_EQ("bar", g);
   }, t, tuple(heap<Foo>(123), heap<Bar>(456)), 789, mv(t5));
 
   uint i = tuple(123);
-  EXPECT_EQ(123, i);
+  EXPECT_EQ(123u, i);
 
   i = tuple(tuple(), 456, tuple(tuple(), tuple()));
-  EXPECT_EQ(456, i);
+  EXPECT_EQ(456u, i);
 }
 
 }  // namespace kj