use wildcards

compiler/src/main/cpp/capnpc-java.c++

@@ -305,7 +305,6 @@ private:
     case schema::Type::STRUCT: {
       auto structSchema = type.asStruct();
       if (structSchema.getProto().getIsGeneric()) {
-        KJ_LOG(ERROR, suffix);
         auto typeArgs = getTypeArguments(structSchema, structSchema, kj::str(suffix));
         return kj::strTree(
           javaFullName(structSchema), ".", suffix, "<",
@@ -1103,10 +1102,15 @@ private:
           spaces(indent), "    return ",
           "_getPointerField(", factoryArg, ", ", offset, ", ", defaultParams, ");\n",
           spaces(indent), "  }\n",
-          spaces(indent), "  public final void set", titleCase, "(", readerType, " value) {\n",
+
-          unionDiscrim.set,
+          // TODO deal with generics here.
-          spaces(indent), "    _setPointerField(", factoryArg, ",", offset, ", value);\n",
+          (field.getType().asStruct().getProto().getIsGeneric() ? kj::strTree() :
-          spaces(indent), "  }\n",
+           kj::strTree(
+             spaces(indent), "  public final void set", titleCase, "(", readerType, " value) {\n",
+             unionDiscrim.set,
+             spaces(indent), "    _setPointerField(", factoryArg, ",", offset, ", value);\n",
+             spaces(indent), "  }\n")),
+
           spaces(indent), "  public final ", builderType, " init", titleCase, "() {\n",
           unionDiscrim.set,
           spaces(indent), "    return ",
@@ -1352,11 +1356,11 @@ private:
         kj::strTree(
           spaces(indent+1), "public static final class Builder", builderTypeParams, " extends org.capnproto.StructBuilder {\n",
           kj::strTree(KJ_MAP(p, typeParamVec) {
-              return kj::strTree(spaces(indent), "    final org.capnproto.FromPointerBuilder<", p, "_Builder> ", p, "_Factory;\n");
+              return kj::strTree(spaces(indent), "    final org.capnproto.PointerFactory<", p, "_Builder, ?> ", p, "_Factory;\n");
             }),
           spaces(indent+1), "  Builder(",
           KJ_MAP(p, typeParamVec) {
-            return kj::strTree("org.capnproto.FromPointerBuilder<", p, "_Builder> ", p, "_Factory,");
+            return kj::strTree("org.capnproto.PointerFactory<", p, "_Builder, ?> ", p, "_Factory,");
           },
           "org.capnproto.SegmentBuilder segment, int data, int pointers,",
           "int dataSize, short pointerCount){\n",
@@ -1384,11 +1388,11 @@ private:
         kj::strTree(
           spaces(indent+1), "public static final class Reader", readerTypeParams, " extends org.capnproto.StructReader {\n",
           KJ_MAP(p, typeParamVec) {
-              return kj::strTree(spaces(indent), "    final org.capnproto.FromPointerReader<", p, "_Reader> ", p, "_Factory;\n");
+              return kj::strTree(spaces(indent), "    final org.capnproto.PointerFactory<?,", p, "_Reader> ", p, "_Factory;\n");
             },
           spaces(indent+1), "  Reader(",
           KJ_MAP(p, typeParamVec) {
-            return kj::strTree("org.capnproto.FromPointerReader<", p, "_Reader> ", p, "_Factory,");
+            return kj::strTree("org.capnproto.PointerFactory<?,", p, "_Reader> ", p, "_Factory,");
           },
           "org.capnproto.SegmentReader segment, int data, int pointers,",
           "int dataSize, short pointerCount, int nestingLimit){\n",

compiler/src/test/scala/org/capnproto/EncodingTest.scala

@@ -58,6 +58,23 @@ class EncodingSuite extends FunSuite {
     TestUtil.checkTestMessage(reader);
   }
 
+  test("Generics") {
+    val message = new MessageBuilder();
+    val factory = TestGenerics.newFactory(TestAllTypes.factory, Text.factory);
+    val root = message.initRoot(factory);
+    TestUtil.initTestMessage(root.getFoo());
+    //root.getRev().setFoo(Text.factory, new Text.Reader("Hello"));
+    val bar = root.getRev().initBar(1);
+    bar.set(0, 11);
+    var boolList = root.getDub().getFoo().initBoolList(2);
+    boolList.set(0, false);
+    boolList.set(1, true);
+
+
+    TestUtil.checkTestMessage(root.getFoo());
+    TestUtil.checkTestMessage(root.asReader(factory).getFoo());
+  }
+
   test("Defaults") {
     val message = new MessageBuilder();
     val defaults = message.initRoot(TestDefaults.factory);

compiler/src/test/schema/test.capnp

@@ -324,27 +324,28 @@ struct TestNewVersion {
 
 struct TestGenerics(Foo, Bar) {
   foo @0 :Foo;
-  rev @1 :TestGenerics(Text, List(UInt8));
+  bar @1 :Bar;
-#  dub @2 :TestGenerics(Foo, Bar);
+  rev @2 :TestGenerics(Text, List(UInt8));
+  dub @3 :TestGenerics(Foo, Bar);
 
-#  struct Inner {
+  struct Inner {
-#    foo @0 :Foo;
+    foo @0 :Foo;
-#    bar @1 :Bar;
+    bar @1 :Bar;
-#  }
+  }
 
-#  struct Inner2(Baz) {
+  struct Inner2(Baz) {
-#    bar @0 :Bar;
+    bar @0 :Bar;
-#    baz @1 :Baz;
+    baz @1 :Baz;
-#    innerBound @2 :Inner;
+    innerBound @2 :Inner;
-#    innerUnbound @3 :TestGenerics.Inner;
+    innerUnbound @3 :TestGenerics.Inner;
 
-#    struct DeepNest(Qux) {
+    struct DeepNest(Qux) {
-#      foo @0 :Foo;
+      foo @0 :Foo;
-#      bar @1 :Bar;
+      bar @1 :Bar;
-#      baz @2 :Baz;
+      baz @2 :Baz;
-#      qux @3 :Qux;
+      qux @3 :Qux;
-#    }
+    }
-#  }
+  }
 }
 
 

runtime/src/main/java/org/capnproto/StructFactory.java

@@ -22,11 +22,10 @@
 package org.capnproto;
 
 public abstract class StructFactory<Builder, Reader extends StructReader>
-    implements FromPointerBuilder<Builder>,
+    implements PointerFactory<Builder, Reader>,
     FromPointerBuilderRefDefault<Builder>,
     StructBuilder.Factory<Builder>,
     SetPointerBuilder<Reader>,
-    FromPointerReader<Reader>,
     FromPointerReaderRefDefault<Reader>,
     StructReader.Factory<Reader> {
     public final Reader fromPointerReaderRefDefault(SegmentReader segment, int pointer,