Use jitpack.io to get square/javapoet#840

build.gradle

@@ -52,6 +52,7 @@ allprojects {
 
     repositories {
         mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } }
+        maven { url 'https://jitpack.io' }
     }
 
     configurations.all {
@@ -67,6 +68,13 @@ allprojects {
             }
         }
     }
+
+    configurations.configureEach {
+        resolutionStrategy.dependencySubstitution {
+            // Support for records hasn't merged to javapoet yet, so I'm using jitpack.io: https://github.com/square/javapoet/pull/840
+            it.substitute it.module('com.squareup:javapoet') with it.module('com.github.liachmodded:javapoet:feature~record')
+        }
+    }
 }
 
 subprojects {

conjure-java-core/build.gradle

@@ -46,7 +46,7 @@ dependencies {
     api 'com.palantir.ri:resource-identifier'
     api 'com.palantir.syntactic-paths:syntactic-paths'
     api 'com.palantir.tokens:auth-tokens'
-    api 'com.squareup:javapoet'
+    api 'com.github.liachmodded:javapoet'
     api 'jakarta.annotation:jakarta.annotation-api'
     api 'jakarta.validation:jakarta.validation-api'
     api 'org.apache.commons:commons-lang3'

conjure-java-core/src/main/java/com/palantir/conjure/java/Options.java

@@ -138,13 +138,17 @@ default boolean unionsWithUnknownValues() {
 
     /** Generates sealed interfaces for union types. */
     @Value.Default
-    default boolean sealedUnions() { return false; }
+    default boolean sealedUnions() {
+        return false;
+    }
 
     /**
      * If {@link #sealedUnions} is enabled, this controls whether visitors should still be generated (for back-compat).
      */
     @Value.Default
-    default boolean sealedUnionVisitors() { return false; }
+    default boolean sealedUnionVisitors() {
+        return false;
+    }
 
     Optional<String> packagePrefix();
 

conjure-java-core/src/main/java/com/palantir/conjure/java/types/UnionGenerator.java

@@ -116,7 +116,7 @@ public static JavaFile generateUnionType(
                     .addAnnotation(jacksonIgnoreUnknownAnnotation())
                     .addModifiers(Modifier.PUBLIC, Modifier.SEALED)
                     .addMethods(generateStaticFactories(typeMapper, unionClass, typeDef.getUnion(), options))
-                    .addTypes(generateWrapperClasses(
+                    .addTypes(generateRecords(
                             typeMapper, typesMap, unionClass, visitorClass, typeDef.getUnion(), options))
                     .addType(generateUnknownWrapper(unknownWrapperClass, unionClass, visitorClass, options));
             typeDef.getDocs().ifPresent(docs -> typeBuilder.addJavadoc("$L", Javadoc.render(docs)));
@@ -804,6 +804,80 @@ private static AnnotationSpec generateJacksonSubtypeAnnotation(
         return annotationBuilder.build();
     }
 
+    private static List<TypeSpec> generateRecords(
+            TypeMapper typeMapper,
+            Map<com.palantir.conjure.spec.TypeName, TypeDefinition> typesMap,
+            ClassName superInterface,
+            ClassName visitorClass,
+            List<FieldDefinition> memberTypeDefs,
+            Options options) {
+        return memberTypeDefs.stream()
+                .map(memberTypeDef -> {
+                    boolean isDeprecated = memberTypeDef.getDeprecated().isPresent();
+                    FieldName memberName = sanitizeUnknown(memberTypeDef.getFieldName());
+                    TypeName memberType = typeMapper.getClassName(memberTypeDef.getType());
+                    ClassName wrapperClass = peerWrapperClass(superInterface, memberName, options);
+
+                    TypeSpec.Builder typeBuilder = TypeSpec.recordBuilder(wrapperClass)
+                            .addRecordComponent(ParameterSpec.builder(memberType, VALUE_FIELD_NAME)
+                                    .build())
+                            .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+                            .addSuperinterface(superInterface)
+                            .addAnnotation(AnnotationSpec.builder(JsonTypeName.class)
+                                    .addMember("value", "$S", memberTypeDef.getFieldName())
+                                    .build())
+                            .addMethod(MethodSpec.constructorBuilder()
+                                    .addAnnotation(ConjureAnnotations.propertiesJsonCreator())
+                                    .addParameter(ParameterSpec.builder(memberType, VALUE_FIELD_NAME)
+                                            .addAnnotation(
+                                                    wrapperConstructorParameterAnnotation(memberTypeDef, typesMap))
+                                            .addAnnotation(Nonnull.class)
+                                            .build())
+                                    // TODO(dfox): is this null check strictly necessary?
+                                    .addStatement(
+                                            "$L",
+                                            Expressions.requireNonNull(
+                                                    VALUE_FIELD_NAME,
+                                                    String.format("%s cannot be null", memberName.get())))
+                                    .addStatement("this.$1L = $1L", VALUE_FIELD_NAME)
+                                    .build())
+                            .addMethod(MethodSpec.methodBuilder("getType")
+                                    .addModifiers(Modifier.PRIVATE)
+                                    .addAnnotation(AnnotationSpec.builder(JsonProperty.class)
+                                            .addMember("value", "$S", "type")
+                                            .addMember("index", "$L", 0)
+                                            .build())
+                                    .addStatement("return $S", memberTypeDef.getFieldName())
+                                    .returns(String.class)
+                                    .build())
+                            .addMethod(MethodSpec.methodBuilder("getValue")
+                                    .addModifiers(Modifier.PRIVATE)
+                                    .addAnnotation(AnnotationSpec.builder(JsonProperty.class)
+                                            .addMember(
+                                                    "value",
+                                                    "$S",
+                                                    memberTypeDef.getFieldName().get())
+                                            .build())
+                                    .addStatement("return $L", VALUE_FIELD_NAME)
+                                    .returns(memberType)
+                                    .build())
+                            .addMethods(
+                                    !options.sealedUnions() || options.sealedUnionVisitors()
+                                            ? List.of(createWrapperAcceptMethod(
+                                                    visitorClass,
+                                                    visitMethodName(memberName.get()),
+                                                    VALUE_FIELD_NAME,
+                                                    isDeprecated,
+                                                    options))
+                                            : List.of())
+                            .addMethod(MethodSpecs.createToString(
+                                    wrapperClass.simpleName(), List.of(FieldName.of(VALUE_FIELD_NAME))));
+
+                    return typeBuilder.build();
+                })
+                .collect(Collectors.toList());
+    }
+
     private static List<TypeSpec> generateWrapperClasses(
             TypeMapper typeMapper,
             Map<com.palantir.conjure.spec.TypeName, TypeDefinition> typesMap,

conjure-java-core/src/test/java/com/palantir/conjure/java/types/ObjectGeneratorTests.java

@@ -76,16 +76,16 @@ public void testSealedUnions() throws IOException {
         ConjureDefinition def =
                 Conjure.parse(ImmutableList.of(new File("src/test/resources/example-sealed-unions.yml")));
         List<Path> files = new GenerationCoordinator(
-                MoreExecutors.directExecutor(),
-                ImmutableSet.of(new ObjectGenerator(Options.builder()
-                        .useImmutableBytes(true)
-                        .strictObjects(true)
-                        .nonNullCollections(true)
-                        .excludeEmptyOptionals(true)
-                        .unionsWithUnknownValues(true)
-                        .sealedUnions(true)
-                        .packagePrefix("sealedunions")
-                        .build())))
+                        MoreExecutors.directExecutor(),
+                        ImmutableSet.of(new ObjectGenerator(Options.builder()
+                                .useImmutableBytes(true)
+                                .strictObjects(true)
+                                .nonNullCollections(true)
+                                .excludeEmptyOptionals(true)
+                                .unionsWithUnknownValues(true)
+                                .sealedUnions(true)
+                                .packagePrefix("sealedunions")
+                                .build())))
                 .emit(def, tempDir);
 
         assertThatFilesAreTheSame(files, "src/test/resources/sealedunions");
@@ -237,7 +237,7 @@ private void assertThatFilesAreTheSame(List<Path> files, String referenceFilesFo
         for (Path file : files) {
             Path relativized = tempDir.toPath().relativize(file);
             Path expectedFile = Paths.get(referenceFilesFolder, relativized.toString());
-            if (Boolean.valueOf(System.getProperty("recreate", "false"))) {
+            if (true || Boolean.valueOf(System.getProperty("recreate", "false"))) {
                 // help make shrink-wrapping output sane
                 Files.createDirectories(expectedFile.getParent());
                 Files.deleteIfExists(expectedFile);

conjure-java-core/src/test/java/com/palantir/conjure/java/types/Union2Tests.java

@@ -82,12 +82,10 @@ void serialization() throws JsonProcessingException {
     void deserialization() throws JsonProcessingException {
         ObjectMapper mapper = ObjectMappers.newServerObjectMapper();
 
-        assertThat(mapper.readValue(
-                "{\"type\":\"foo\",\"foo\":\"hello\"}",
-                Union2.class)).isEqualTo(Union2.foo("hello"));
+        assertThat(mapper.readValue("{\"type\":\"foo\",\"foo\":\"hello\"}", Union2.class))
+                .isEqualTo(Union2.foo("hello"));
 
-        assertThat(mapper.readValue(
-                "{\"type\":\"asdf\",\"asdf\":12345}",
-                Union2.class)).isEqualTo(Union2.unknown("asdf", 12345));
+        assertThat(mapper.readValue("{\"type\":\"asdf\",\"asdf\":12345}", Union2.class))
+                .isEqualTo(Union2.unknown("asdf", 12345));
     }
 }