RecordBuilder Enhancer

New module to Inject verification, defensive copying, null checks or
custom code into your Java Record constructors during compilation.

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: Randgalt

.github/workflows/maven_java16.yml

@@ -0,0 +1,24 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: Maven Build - Java 16
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK
+      uses: actions/setup-java@v1
+      with:
+        java-version: 16
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml

.github/workflows/maven_java17.yml

@@ -0,0 +1,24 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: Maven Build - Java 17
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK
+      uses: actions/setup-java@v1
+      with:
+        java-version: 17
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml

.mvn/jvm.config

@@ -1 +0,0 @@
---enable-preview

.travis.yml

@@ -1,3 +0,0 @@
-language: java
-jdk:
-  - openjdk14

README.md

@@ -1,17 +1,28 @@
-[![Build Status](https://travis-ci.org/Randgalt/record-builder.svg?branch=master)](https://travis-ci.org/Randgalt/record-builder)
-[![Maven Central](https://img.shields.io/maven-central/v/io.soabase.record-builder/record-builder.svg)](https://search.maven.org/search?q=g:io.soabase.record-builder%20a:record-builder)
+[![Build Status](https://github.com/Randgalt/record-builder/workflows/Java%20CI%20with%20Maven/badge.svg)](https://github.com/Randgalt/record-builder/actions)
+[![Maven Central](https://img.shields.io/maven-central/v/io.soabase.record-builder/record-builder.svg?sort=date)](https://search.maven.org/search?q=g:io.soabase.record-builder%20a:record-builder)
 
-# RecordBuilder - Early Access
+# RecordBuilder
 
 ## What is RecordBuilder
 
-Java 14 is introducing [Records](https://cr.openjdk.java.net/~briangoetz/amber/datum.html) as a preview feature. Since Java 9, features in Java are being released in stages. While the Java 14 version of records is fantastic, it's currently missing an important feature for data classes: a builder. This project is an annotation processor that creates companion builder classes for Java records.
+Java 16 introduces [Records](https://openjdk.java.net/jeps/395). While this version of records is fantastic, 
+it's currently missing some important features normally found in data classes: a builder 
+and "with"ers. This project is an annotation processor that creates:
+ 
+- a companion builder class for Java records
+- an interface that adds "with" copy methods
+- an annotation that generates a Java record from an Interface template
 
-In addition to a record builder an annotation is provided that can generate a Java record from an Interface template. This will be useful for DAO-style interfaces, etc.
-where a Record (with toString(), hashCode(), equals(), etc.) and a companion RecordBuilder are needed.
+_Details:_
 
 - [RecordBuilder Details](#RecordBuilder-Example)
-- [Record From Interface Details](#Record-Interface-Example)
+- [Wither Details](#Wither-Example)
+- [RecordBuilder Full Definition](#Builder-Class-Definition)
+- [Record From Interface Details](#RecordInterface-Example)
+- [Generation Via Includes](#generation-via-includes)
+- [Usage](#usage)
+- [Customizing](customizing.md) (e.g. add immutable collections, etc.)
+- **_NEW!!_** [RecordBuilder Enhancer](record-builder-enhancer/README.md) - Inject verification, defensive copying, null checks or custom code into your Java Record constructors during compilation!
 
 ## RecordBuilder Example
 
@@ -24,18 +35,63 @@ This will generate a builder class that can be used ala:
 
 ```java
 // build from components
-var n1 = NameAndAgeBuilder.builder().name(aName).age(anAge).build();
+NameAndAge n1 = NameAndAgeBuilder.builder().name(aName).age(anAge).build();
 
 // generate a copy with a changed value
-var n2 = NameAndAgeBuilder.builder(n1).age(newAge).build(); // name is the same as the name in n1
+NameAndAge n2 = NameAndAgeBuilder.builder(n1).age(newAge).build(); // name is the same as the name in n1
 
 // pass to other methods to set components
 var builder = new NameAndAgeBuilder();
 setName(builder);
 setAge(builder);
-var n3 = builder.build();
+NameAndAge n3 = builder.build();
+
+// use the generated static constructor/builder
+import static NameAndAgeBuilder.NameAndAge;
+...
+var n4 = NameAndAge("hey", 42);
 ```
 
+## Wither Example
+
+```java
+@RecordBuilder
+public record NameAndAge(String name, int age) implements NameAndAgeBuilder.With {}
+```
+
+In addition to creating a builder, your record is enhanced by "wither" methods ala:
+
+```java
+NameAndAge r1 = new NameAndAge("foo", 123);
+NameAndAge r2 = r1.withName("bar");
+NameAndAge r3 = r2.withAge(456);
+
+// access the builder as well
+NameAndAge r4 = r3.with().age(101).name("baz").build();
+
+// alternate method of accessing the builder (note: no need to call "build()")
+NameAndAge r5 = r4.with(b -> b.age(200).name("whatever"));
+
+// perform some logic in addition to changing values
+NameAndAge r5 = r4.with(b -> {
+   if (b.age() > 13) {
+       b.name("Teen " + b.name());
+   } else {
+       b.name("whatever"));
+   }
+});
+
+// or, if you cannot add the "With" interface to your record...
+NameAndAge r6 = NameAndAgeBuilder.from(r5).with(b -> b.age(200).name("whatever"));
+NameAndAge r7 = NameAndAgeBuilder.from(r5).withName("boop");
+```
+
+_Hat tip to [Benji Weber](https://benjiweber.co.uk/blog/2020/09/19/fun-with-java-records/) for the Withers idea._
+
+## Builder Class Definition
+
+(Note: you can see a builder class built using `@RecordBuilderFull` here: [FullRecordBuilder.java](https://gist.github.com/Randgalt/8aa487a847ea2acdd76d702f7cf17d6a))
+
 The full builder class is defined as:
 
 ```java
@@ -52,6 +108,13 @@ public class NameAndAgeBuilder {
         this.age = age;
     }
 
+    /**
+     * Static constructor/builder. Can be used instead of new NameAndAge(...)
+     */
+    public static NameAndAge NameAndAge(String name, int age) {
+        return new NameAndAge(name, age);
+    }
+
     /**
      * Return a new builder with all fields set to default Java values
      */
@@ -66,6 +129,21 @@ public class NameAndAgeBuilder {
         return new NameAndAgeBuilder(from.name(), from.age());
     }
 
+    /**
+     * Return a "with"er for an existing record instance
+     */
+    public static NameAndAgeBuilder.With from(NameAndAge from) {
+        return new _FromWith(from);
+    }
+
+    /**
+     * Return a stream of the record components as map entries keyed with the component name and the value as the component value
+     */
+    public static Stream<Map.Entry<String, Object>> stream(NameAndAge record) {
+        return Stream.of(new AbstractMap.SimpleImmutableEntry<>("name", record.name()),
+                 new AbstractMap.SimpleImmutableEntry<>("age", record.age()));
+    }
+
     /**
      * Return a new record instance with all fields set to the current values in this builder
      */
@@ -73,6 +151,23 @@ public class NameAndAgeBuilder {
         return new NameAndAge(name, age);
     }
 
+    @Override
+    public String toString() {
+        return "NameAndAgeBuilder[name=" + name + ", age=" + age + "]";
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, age);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return (this == o) || ((o instanceof NameAndAgeBuilder r)
+                && Objects.equals(name, r.name)
+                && (age == r.age));
+    }
+
     /**
      * Set a new value for the {@code name} record component in the builder
      */
@@ -104,28 +199,66 @@ public class NameAndAgeBuilder {
     }
 
     /**
-     * Return a stream of the record components as map entries keyed with the component name and the value as the component value
+     * Add withers to {@code NameAndAge}
      */
-    public static Stream<Map.Entry<String, Object>> stream(NameAndAge record) {
-        return Stream.of(new AbstractMap.SimpleEntry<>("name", record.name()),
-                 new AbstractMap.SimpleEntry<>("age", record.age()));
+    public interface With {
+        /**
+         * Return the current value for the {@code name} record component in the builder
+         */
+        String name();
+
+        /**
+         * Return the current value for the {@code age} record component in the builder
+         */
+        int age();
+
+        /**
+         * Return a new record builder using the current values
+         */
+        default NameAndAgeBuilder with() {
+            return new NameAndAgeBuilder(name(), age());
+        }
+
+        /**
+         * Return a new record built from the builder passed to the given consumer
+         */
+        default NameAndAge with(Consumer<NameAndAgeBuilder> consumer) {
+            NameAndAgeBuilder builder = with();
+            consumer.accept(builder);
+            return builder.build();
+        }
+
+        /**
+         * Return a new instance of {@code NameAndAge} with a new value for {@code name}
+         */
+        default NameAndAge withName(String name) {
+            return new NameAndAge(name, age());
+        }
+
+        /**
+         * Return a new instance of {@code NameAndAge} with a new value for {@code age}
+         */
+        default NameAndAge withAge(int age) {
+            return new NameAndAge(name(), age);
+        }
     }
 
-    @Override
-    public String toString() {
-        return "NameAndAgeBuilder[name=" + name + ", age=" + age + "]";
-    }
+    private static final class _FromWith implements NameAndAgeBuilder.With {
+        private final NameAndAge from;
 
-    @Override
-    public int hashCode() {
-        return Objects.hash(name, age);
-    }
+        private _FromWith(NameAndAge from) {
+            this.from = from;
+        }
 
-    @Override
-    public boolean equals(Object o) {
-        return (this == o) || ((o instanceof NameAndAgeBuilder b)
-                && Objects.equals(name, b.name)
-                && (age == b.age));
+        @Override
+        public String name() {
+            return from.name();
+        }
+
+        @Override
+        public int age() {
+            return from.age();
+        }
     }
 }
 ```
@@ -144,7 +277,8 @@ This will generate a record ala:
 
 ```java
 @RecordBuilder
-public record NameAndAgeRecord(String name, int age){}
+public record NameAndAgeRecord(String name, int age) implements 
+    NameAndAge, NameAndAgeRecordBuilder.With {}
 ```
 
 Note that the generated record is annotated with `@RecordBuilder` so a record
@@ -158,74 +292,65 @@ Notes:
   - ...cannot have type parameters
 - Methods with default implementations are used in the generation unless they are annotated with `@IgnoreDefaultMethod`
 - If you do not want a record builder generated, annotate your interface as `@RecordInterface(addRecordBuilder = false)`
+- If your interface is a JavaBean (e.g. `getThing()`, `isThing()`) the "get" and "is" prefixes are
+stripped and forwarding methods are added.
+
+## Generation Via Includes
+
+An alternate method of generation is to use the Include variants of the annotations. These variants
+act on lists of specified classes. This allows the source classes to be pristine or even come from
+libraries where you are not able to annotate the source. 
+
+E.g.
+
+```java
+import some.library.code.ImportedRecord
+import some.library.code.ImportedInterface
+
+@RecordBuilder.Include({
+    ImportedRecord.class    // generates a record builder for ImportedRecord  
+})
+@RecordInterface.Include({
+    ImportedInterface.class // generates a record interface for ImportedInterface 
+})
+public void Placeholder {
+}
+```
+
+`@RecordBuilder.Include` also supports a `packages` attribute that includes all records
+in the listed packages.
+
+The target package for generation is the same as the package that contains the "Include"
+annotation. Use `packagePattern` to change this (see Javadoc for details).  
+
+## Enhancer
+
+[RecordBuilder Enhancer](record-builder-enhancer/README.md) - Inject verification, defensive copying, null 
+checks or custom code into your Java Record constructors during compilation. 
 
 ## Usage
 
 ### Maven
 
-1\. Add the dependency that contains the `@RecordBuilder` annotation.
+Add a dependency that contains the discoverable annotation processor:
 
-```
+```xml
 <dependency>
     <groupId>io.soabase.record-builder</groupId>
-    <artifactId>record-builder-core</artifactId>
-    <version>set-version-here</version>
+    <artifactId>record-builder-processor</artifactId>
+    <version>${record.builder.version}</version>
+    <scope>provided</scope>
 </dependency>
-
 ```
 
-2\. Enable the annotation processing for the Maven Compiler Plugin:
-
-```
-<plugin>
-    <groupId>org.apache.maven.plugins</groupId>
-    <artifactId>maven-compiler-plugin</artifactId>
-    <version>set-version-here</version>
-    <configuration>
-        <annotationProcessorPaths>
-            <annotationProcessorPath>
-                <groupId>io.soabase.record-builder</groupId>
-                <artifactId>record-builder-processor</artifactId>
-                <version>set-version-here</version>
-            </annotationProcessorPath>
-        </annotationProcessorPaths>
-        <annotationProcessors>
-            <annotationProcessor>io.soabase.recordbuilder.processor.RecordBuilderProcessor</annotationProcessor>
-        </annotationProcessors>
-
-        
-        <!-- "release" and "enable-preview" are required while records are preview features -->
-        <release>14</release>
-        <compilerArgs>
-            <arg>--enable-preview</arg>
-        </compilerArgs>
-
-        ... any other options here ...
-    </configuration>
-</plugin>
-```
-
-3\. Enable Preview for Maven
-
-Create a file in your project's root named `.mvn/jvm.config`. The file should have 1 line with the value: `--enable-preview`. (see: https://stackoverflow.com/questions/58023240)
-
 ### Gradle
 
 Add the following to your build.gradle file:
 
-```
+```groovy
 dependencies {
     annotationProcessor 'io.soabase.record-builder:record-builder-processor:$version-goes-here'
-    implementation 'io.soabase.record-builder:record-builder-core:$version-goes-here'
-}
-
-tasks.withType(JavaCompile) {
-    options.fork = true
-    options.forkOptions.jvmArgs += '--enable-preview'
-    options.compilerArgs += '--enable-preview'
-}
-tasks.withType(Test) {
-    jvmArgs += "--enable-preview"
+    compileOnly 'io.soabase.record-builder:record-builder-core:$version-goes-here'
 }
 ```
 
@@ -233,32 +358,8 @@ tasks.withType(Test) {
 
 Depending on your IDE you are likely to need to enable Annotation Processing in your IDE settings.
 
-## Enable Preview
-
-Note: records are a preview feature only. You'll need take a number of steps in order to try RecordBuilder:
-
-- Install and make active Java 14 or later
-- Make sure your development tool is using Java 14 or later and is configured to enable preview features (for Maven I've documented how to do this here: [https://stackoverflow.com/a/59363152/2048051](https://stackoverflow.com/a/59363152/2048051))
-- Bear in mind that this is not yet meant for production and there are numerous bugs in the tools and JDKs.
-
-Note: I've seen some very odd compilation bugs with the current Java 14 and Maven. If you get internal Javac errors I suggest rebuilding with `mvn clean package` and/or `mvn clean install`.
-
 ## Customizing
 
-The names of the generated methods, etc. are determined by [RecordBuilderMetaData](https://github.com/Randgalt/record-builder/blob/master/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderMetaData.java). If you want to use your own meta data instance:
-
-- Create a class that implements RecordBuilderMetaData
-- When compiling, make sure that the compiled class is in the processor path
-- Add a "metaDataClass" compiler option with the class name. E.g. `javac ... -AmetaDataClass=foo.bar.MyMetaData`
-
-Alternatively, you can provide values for each individual meta data (or combinations):
-
-- `javac ... -Asuffix=foo`
-- `javac ... -AinterfaceSuffix=foo`
-- `javac ... -AcopyMethodName=foo`
-- `javac ... -AbuilderMethodName=foo`
-- `javac ... -AbuildMethodName=foo`
-- `javac ... -AcomponentsMethodName=foo`
-- `javac ... -AfileComment=foo`
-- `javac ... -AfileIndent=foo`
-- `javac ... -AprefixEnclosingClassNames=foo`
+RecordBuilder can be customized to your needs and you can even create your
+own custom RecordBuilder annotations. See [Customizing RecordBuilder](customizing.md)
+for details.

customizing.md

@@ -0,0 +1,95 @@
+[◀︎ RecordBuilder](README.md) • Customizing RecordBuilder
+
+# RecordBuilderFull
+
+Note: `@RecordBuilderFull` has most optional features enabled. It's an alternate
+form of `@RecordBuilder` that uses the [templating mechanism](#create-a-custom-annotation) to
+enable optional features.
+
+# Customizing RecordBuilder
+
+RecordBuilder can be customized in a number of ways. The types of customizations will change over time. See
+[@RecordBuilder.Options](record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java)
+for the current set of customizations and their default values. For example, the `useImmutableCollections` option
+adds special handling for record components of type `java.util.List`, `java.util.Set`, `java.util.Map` and `java.util.Collection`. When the record is built, any components of these types are passed through an added shim method that uses the corresponding immutable collection (e.g. `List.copyOf(o)`) or an empty immutable collection if the component is `null`.
+
+You can:
+
+- [Customize an entire build](#customize-an-entire-build) - all uses of `@RecordBuilder` in your project
+- [Customize a single record](#customize-a-single-record) annotated with `@RecordBuilder`
+- [Create a custom annotation](#create-a-custom-annotation) that specifies your options and use that instead of `@RecordBuilder`
+
+## Customize an entire build
+
+To customize an entire build, use javac's annotation processor options via `-A` on the command line.
+The options available are the same as the attributes in [@RecordBuilder.Options](record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java).
+i.e. to disable "prefixing enclosing class names", compile with:
+
+```shell
+javac -AprefixEnclosingClassNames=false ...
+```
+
+_Note: use a separate `-A` for each option._
+
+#### Maven
+
+If you are using Maven, specify the options in the compiler plugin:
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-compiler-plugin</artifactId>
+    <version>${maven-compiler-plugin-version}</version>
+    <configuration>
+        <compilerArgs>
+            <arg>-AprefixEnclosingClassNames=false</arg>
+            <arg>-AfileComment="something different"</arg>
+        </compilerArgs>
+    </configuration>
+</plugin>
+```
+
+#### Gradle
+
+For Gradle, specify the options:
+
+```groovy
+compilerArgs.addAll(['-AprefixEnclosingClassNames=false', '-AfileComment="something different"'])
+```
+
+## Customize a single record
+
+To customize a single record, add `@RecordBuilder.Options` in addition to
+`@RecordBuilder`.
+
+E.g.
+
+```java
+@RecordBuilder.Options(withClassName = "Wither")
+@RecordBuilder
+public record MyRecord(String s){}
+```
+
+## Create a custom annotation
+
+Using `@RecordBuilder.Template` you can create your own RecordBuilder annotation
+that uses the set of options you want. E.g. to create a custom annotation that
+uses an alternate file comment and an alternate With classname:
+
+```java
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        fileComment = "MyCo license",
+        withClassName = "Wither"
+))
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface MyCoRecordBuilder {
+}
+```
+
+Now, you can use `@MyCoRecordBuilder` instead of `@RecordBuilder` and the record
+will be built with options as specified.
+
+Note: the template mechanism also supports `@RecordInterface` templates via the `asRecordInterface` attribute.
+When it is set a `@RecordInterface` template is created instead.

pom.xml

@@ -5,12 +5,16 @@
     <groupId>io.soabase.record-builder</groupId>
     <artifactId>record-builder</artifactId>
     <packaging>pom</packaging>
-    <version>1.7.ea</version>
+    <version>34-SNAPSHOT</version>
 
     <modules>
         <module>record-builder-core</module>
         <module>record-builder-processor</module>
         <module>record-builder-test</module>
+        <module>record-builder-validator</module>
+        <module>record-builder-enhancer</module>
+        <module>record-builder-test-custom-enhancer</module> <!-- must be set to ignore in IntelliJ -->
+        <module>record-builder-enhancer-core</module> <!-- must be set to ignore in IntelliJ -->
     </modules>
 
     <properties>
@@ -18,7 +22,7 @@
         <project.build.resourceEncoding>UTF-8</project.build.resourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 
-        <jdk-version>14</jdk-version>
+        <jdk-version>16</jdk-version>
 
         <maven-compiler-plugin-version>3.8.1</maven-compiler-plugin-version>
         <maven-source-plugin-version>3.2.0</maven-source-plugin-version>
@@ -28,12 +32,24 @@
         <maven-gpg-plugin-version>1.6</maven-gpg-plugin-version>
         <maven-javadoc-plugin-version>3.1.1</maven-javadoc-plugin-version>
         <maven-clean-plugin-version>3.1.0</maven-clean-plugin-version>
-        <maven-shade-plugin-version>3.2.1</maven-shade-plugin-version>
+        <maven-shade-plugin-version>3.3.0</maven-shade-plugin-version>
         <maven-release-plugin-version>2.5.3</maven-release-plugin-version>
+        <maven-jar-plugin-version>3.2.0</maven-jar-plugin-version>
+        <maven-surefire-plugin-version>3.0.0-M5</maven-surefire-plugin-version>
+
+        <jacoco-maven-plugin-version>0.8.7</jacoco-maven-plugin-version>
+
+        <license-file-path>src/etc/header.txt</license-file-path>
 
         <javapoet-version>1.12.1</javapoet-version>
         <junit-jupiter-version>5.5.2</junit-jupiter-version>
-        <asm-version>7.2</asm-version>
+        <asm-version>9.3</asm-version>
+        <validation-api-version>2.0.1.Final</validation-api-version>
+        <hibernate-validator-version>6.0.20.Final</hibernate-validator-version>
+        <javax-el-version>3.0.1-b09</javax-el-version>
+        <byte-buddy.version>1.12.10</byte-buddy.version>
+        <guava.version>31.1-jre</guava.version>
+        <picocli.version>4.6.3</picocli.version>
     </properties>
 
     <name>Record Builder</name>
@@ -70,7 +86,7 @@
         <url>https://github.com/randgalt/record-builder</url>
         <connection>scm:git:https://github.com/randgalt/record-builder.git</connection>
         <developerConnection>scm:git:git@github.com:randgalt/record-builder.git</developerConnection>
-        <tag>record-builder-1.7.ea</tag>
+        <tag>record-builder-1.16</tag>
     </scm>
 
     <issueManagement>
@@ -93,6 +109,18 @@
 
     <dependencyManagement>
         <dependencies>
+            <dependency>
+                <groupId>net.bytebuddy</groupId>
+                <artifactId>byte-buddy</artifactId>
+                <version>${byte-buddy.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>net.bytebuddy</groupId>
+                <artifactId>byte-buddy-agent</artifactId>
+                <version>${byte-buddy.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>com.squareup</groupId>
                 <artifactId>javapoet</artifactId>
@@ -105,26 +133,101 @@
                 <version>${project.version}</version>
             </dependency>
 
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-enhancer</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-enhancer-core</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-processor</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-test-custom-enhancer</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-validator</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>org.junit.jupiter</groupId>
                 <artifactId>junit-jupiter</artifactId>
                 <version>${junit-jupiter-version}</version>
             </dependency>
+
+            <dependency>
+                <groupId>javax.validation</groupId>
+                <artifactId>validation-api</artifactId>
+                <version>${validation-api-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.hibernate.validator</groupId>
+                <artifactId>hibernate-validator</artifactId>
+                <version>${hibernate-validator-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.glassfish</groupId>
+                <artifactId>javax.el</artifactId>
+                <version>${javax-el-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>com.google.guava</groupId>
+                <artifactId>guava</artifactId>
+                <version>${guava.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.ow2.asm</groupId>
+                <artifactId>asm</artifactId>
+                <version>${asm-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.ow2.asm</groupId>
+                <artifactId>asm-tree</artifactId>
+                <version>${asm-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>info.picocli</groupId>
+                <artifactId>picocli</artifactId>
+                <version>${picocli.version}</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
     <build>
         <pluginManagement>
             <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>${maven-surefire-plugin-version}</version>
+                </plugin>
+
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
                     <version>${maven-compiler-plugin-version}</version>
                     <configuration>
                         <release>${jdk-version}</release>
-                        <compilerArgs>
-                            <arg>--enable-preview</arg>
-                        </compilerArgs>
                     </configuration>
                 </plugin>
 
@@ -156,7 +259,7 @@
                     <artifactId>maven-license-plugin</artifactId>
                     <version>${maven-license-plugin-version}</version>
                     <configuration>
-                        <header>src/etc/header.txt</header>
+                        <header>${license-file-path}</header>
                         <excludes>
                             <exclude>**/*.apt</exclude>
                             <exclude>**/*.md</exclude>
@@ -179,9 +282,12 @@
                             <exclude>**/io/soabase/com/google/**</exclude>
                             <exclude>**/com/company/**</exclude>
                             <exclude>**/META-INF/services/**</exclude>
+                            <exclude>**/safe/**</exclude>
                             <exclude>**/jvm.config</exclude>
                             <exclude>**/.java-version</exclude>
                             <exclude>**/.travis.yml</exclude>
+                            <exclude>**/gradlew</exclude>
+                            <exclude>**/.github/**</exclude>
                         </excludes>
                         <strictCheck>true</strictCheck>
                     </configuration>
@@ -222,44 +328,6 @@
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-shade-plugin</artifactId>
                     <version>${maven-shade-plugin-version}</version>
-                    <configuration>
-                        <createDependencyReducedPom>true</createDependencyReducedPom>
-                        <dependencyReducedPomLocation>${project.build.outputDirectory}/META-INF/reduced-pom.xml</dependencyReducedPomLocation>
-                        <filters>
-                            <filter>
-                                <excludes>
-                                    <exclude>META-INF/*.SF</exclude>
-                                    <exclude>META-INF/*.DSA</exclude>
-                                    <exclude>META-INF/*.RSA</exclude>
-                                </excludes>
-                            </filter>
-                        </filters>
-                    </configuration>
-                    <executions>
-                        <execution>
-                            <phase>package</phase>
-                            <goals>
-                                <goal>shade</goal>
-                            </goals>
-                            <configuration>
-                                <transformers>
-                                    <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
-                                </transformers>
-                            </configuration>
-                        </execution>
-                    </executions>
-                    <dependencies>
-                        <dependency>
-                            <groupId>org.ow2.asm</groupId>
-                            <artifactId>asm</artifactId>
-                            <version>${asm-version}</version>
-                        </dependency>
-                        <dependency>
-                            <groupId>org.ow2.asm</groupId>
-                            <artifactId>asm-commons</artifactId>
-                            <version>${asm-version}</version>
-                        </dependency>
-                    </dependencies>
                 </plugin>
 
                 <plugin>
@@ -271,6 +339,24 @@
                         <tagNameFormat>record-builder-@{project.version}</tagNameFormat>
                     </configuration>
                 </plugin>
+
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <version>${maven-jar-plugin-version}</version>
+                </plugin>
+
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-gpg-plugin</artifactId>
+                    <version>${maven-gpg-plugin-version}</version>
+                </plugin>
+
+                <plugin>
+                    <groupId>org.jacoco</groupId>
+                    <artifactId>jacoco-maven-plugin</artifactId>
+                    <version>${jacoco-maven-plugin-version}</version>
+                </plugin>
             </plugins>
         </pluginManagement>
 
@@ -278,11 +364,6 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <source>14</source>
-                    <target>14</target>
-                    <compilerArgs>--enable-preview</compilerArgs>
-                </configuration>
             </plugin>
 
             <plugin>
@@ -309,6 +390,11 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-release-plugin</artifactId>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+            </plugin>
         </plugins>
     </build>
 
@@ -319,7 +405,6 @@
                 <plugins>
                     <plugin>
                         <artifactId>maven-gpg-plugin</artifactId>
-                        <version>${maven-gpg-plugin-version}</version>
                         <configuration>
                             <passphrase>${gpg.passphrase}</passphrase>
                             <useAgent>true</useAgent>

record-builder-core/pom.xml

@@ -3,20 +3,27 @@
     <parent>
         <groupId>io.soabase.record-builder</groupId>
         <artifactId>record-builder</artifactId>
-        <version>1.7.ea</version>
+        <version>34-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>record-builder-core</artifactId>
+
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
+                <artifactId>maven-jar-plugin</artifactId>
                 <configuration>
-                    <source>14</source>
-                    <target>14</target>
-                    <compilerArgs>--enable-preview</compilerArgs>
+                    <archive>
+                        <manifestEntries>
+                            <Automatic-Module-Name>io.soabase.recordbuilder.core</Automatic-Module-Name>
+                        </manifestEntries>
+                    </archive>
                 </configuration>
             </plugin>
         </plugins>

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java

@@ -15,12 +15,251 @@
  */
 package io.soabase.recordbuilder.core;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
+@Inherited
 public @interface RecordBuilder {
+    @Target({ElementType.TYPE, ElementType.PACKAGE})
+    @Retention(RetentionPolicy.SOURCE)
+    @Inherited
+    @interface Include {
+        /**
+         * @return list of classes to include
+         */
+        Class<?>[] value() default {};
+
+        /**
+         * Synonym for {@code value()}. When using the other attributes it maybe more clear to
+         * use {@code classes()} instead of {@code value()}. Note: both attributes are applied
+         * (i.e. a union of classes from both attributes).
+         *
+         * @return list of classes
+         */
+        Class<?>[] classes() default {};
+
+        /**
+         * Optional list of package names. All records in the packages will get processed as
+         * if they were listed as classes to include.
+         *
+         * @return list of package names
+         */
+        String[] packages() default {};
+
+        /**
+         * Pattern used to generate the package for the generated class. The value
+         * is the literal package name however two replacement values can be used. '@'
+         * is replaced with the package of the {@code Include} annotation. '*' is replaced with
+         * the package of the included class.
+         *
+         * @return package pattern
+         */
+        String packagePattern() default "@";
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @Target(ElementType.TYPE)
+    @Inherited
+    @interface Options {
+        /**
+         * The builder class name will be the name of the record (prefixed with any enclosing class) plus this suffix. E.g.
+         * if the record name is "Foo", the builder will be named "FooBuilder".
+         */
+        String suffix() default "Builder";
+
+        /**
+         * Used by {@code RecordInterface}. The generated record will have the same name as the annotated interface
+         * plus this suffix. E.g. if the interface name is "Foo", the record will be named "FooRecord".
+         */
+        String interfaceSuffix() default "Record";
+
+        /**
+         * The name to use for the copy builder
+         */
+        String copyMethodName() default "builder";
+
+        /**
+         * The name to use for the builder
+         */
+        String builderMethodName() default "builder";
+
+        /**
+         * The name to use for the build method
+         */
+        String buildMethodName() default "build";
+
+        /**
+         * The name to use for the from-to-wither method
+         */
+        String fromMethodName() default "from";
+
+        /**
+         * The name to use for the method that returns the record components as a stream
+         */
+        String componentsMethodName() default "stream";
+
+        /**
+         * If true, a "With" interface is generated and an associated static factory
+         */
+        boolean enableWither() default true;
+
+        /**
+         * The name to use for the nested With class
+         */
+        String withClassName() default "With";
+
+        /**
+         * The prefix to use for the methods in the With class
+         */
+        String withClassMethodPrefix() default "with";
+
+        /**
+         * Return the comment to place at the top of generated files. Return null or an empty string for no comment.
+         */
+        String fileComment() default "Auto generated by io.soabase.recordbuilder.core.RecordBuilder: https://github.com/Randgalt/record-builder";
+
+        /**
+         * Return the file indent to use
+         */
+        String fileIndent() default "    ";
+
+        /**
+         * If the record is declared inside of another class, the outer class's name will
+         * be prefixed to the builder name if this returns true.
+         */
+        boolean prefixEnclosingClassNames() default true;
+
+        /**
+         * If true, any annotations (if applicable) on record components are copied
+         * to the builder methods
+         *
+         * @return true/false
+         */
+        boolean inheritComponentAnnotations() default true;
+
+        /**
+         * Set the default value of {@code Optional} record components to
+         * {@code Optional.empty()}
+         */
+        boolean emptyDefaultForOptional() default true;
+
+        /**
+         * Add non-optional setter methods for optional record components.
+         */
+        boolean addConcreteSettersForOptional() default false;
+
+        /**
+         * Add not-null checks for record components annotated with any annotation named either "NotNull",
+         * "NoNull", or "NonNull" (see {@link #interpretNotNullsPattern()} for the actual regex matching pattern).
+         */
+        boolean interpretNotNulls() default false;
+
+        /**
+         * If {@link #interpretNotNulls()} is true, this is the regex pattern used to determine if an annotation name
+         * means "not null"
+         */
+        String interpretNotNullsPattern() default "(?i)((notnull)|(nonnull)|(nonull))";
+
+        /**
+         * <p>Pass built records through the Java Validation API if it's available in the classpath.</p>
+         *
+         * <p>IMPORTANT:
+         * if this option is enabled you must include the {@code record-builder-validator} dependency in addition
+         * to {@code record-builder-core}. {@code record-builder-validator} is implemented completely via reflection and
+         * does not require other dependencies. Alternatively, you can define your own class with the package {@code package io.soabase.recordbuilder.validator;}
+         * named {@code RecordBuilderValidator} which has a public static method: {@code public static <T> T validate(T o)}.</p>
+         */
+        boolean useValidationApi() default false;
+
+        /**
+         * Adds special handling for record components of type {@link java.util.List}, {@link java.util.Set},
+         * {@link java.util.Map} and {@link java.util.Collection}. When the record is built, any components
+         * of these types are passed through an added shim method that uses the corresponding immutable collection
+         * (e.g. {@code List.copyOf(o)}) or an empty immutable collection if the component is {@code null}.
+         */
+        boolean useImmutableCollections() default false;
+
+        /**
+         * When enabled, collection types ({@code List}, {@code Set} and {@code Map}) are handled specially.
+         * The setters for these types now create an internal collection and items are added to that
+         * collection. Additionally, "adder" methods prefixed with {@link #singleItemBuilderPrefix()} are created
+         * to add single items to these collections.
+         */
+        boolean addSingleItemCollectionBuilders() default false;
+
+        /**
+         * The prefix for adder methods when {@link #addSingleItemCollectionBuilders()} is enabled
+         */
+        String singleItemBuilderPrefix() default "add";
+
+        /**
+         * When enabled, adds functional methods to the nested "With" class (such as {@code map()} and {@code accept()}).
+         */
+        boolean addFunctionalMethodsToWith() default false;
+
+        /**
+         * If set, all builder setter methods will be prefixed with this string. Camel-casing will
+         * still be enforced, so if this option is set to "set" a field named "myField" will get
+         * a corresponding setter named "setMyField".
+         */
+        String setterPrefix() default "";
+
+        /**
+         * If true, getters will be generated for the Builder class.
+         */
+        boolean enableGetters() default true;
+
+        /**
+         * If set, all builder getter methods will be prefixed with this string. Camel-casing will
+         * still be enforced, so if this option is set to "get", a field named "myField" will get
+         * a corresponding getter named "getMyField".
+         */
+        String getterPrefix() default "";
+
+        /**
+         * If set, all boolean builder getter methods will be prefixed with this string.
+         * Camel-casing will still be enforced, so if this option is set to "is", a field named
+         * "myField" will get a corresponding getter named "isMyField".
+         */
+        String booleanPrefix() default "";
+
+        /**
+         * If set, the Builder will contain an internal interface with this name. This interface
+         * contains getters for all the fields in the Record prefixed with the value supplied in
+         * {@link this.getterPrefix} and {@link this.booleanPrefix}. This interface can be
+         * implemented by the original Record to have proper bean-style prefixed getters.
+         *
+         * Please note that unless either of the aforementioned prefixes are set,
+         * this option does nothing.
+         */
+        String beanClassName() default "";
+
+        /**
+         * If true, generated classes are annotated with {@code RecordBuilderGenerated} which has a retention
+         * policy of {@code CLASS}. This ensures that analyzers such as Jacoco will ignore the generated class.
+         */
+        boolean addClassRetainedGenerated() default false;
+
+        /**
+         * The {@link #fromMethodName} method instantiates an internal private class. This is the
+         * name of that class.
+         */
+        String fromWithClassName() default "_FromWith";
+
+        /**
+         * If true, a functional-style builder is added so that record instances can be instantiated
+         * without {@code new}.
+         */
+        boolean addStaticBuilder() default true;
+    }
+
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Inherited
+    @interface Template {
+        RecordBuilder.Options options();
+
+        boolean asRecordInterface() default false;
+    }
 }

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderFull.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.core;
+
+import java.lang.annotation.*;
+
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        interpretNotNulls = true,
+        useImmutableCollections = true,
+        addSingleItemCollectionBuilders = true,
+        addFunctionalMethodsToWith = true,
+        addClassRetainedGenerated = true
+))
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+/**
+ * An alternate form of {@code @RecordBuilder} that has most
+ * optional features turned on
+ */
+public @interface RecordBuilderFull {
+}

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderGenerated.java

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.core;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * Jacoco ignores classes and methods annotated with `*Generated`
+ */
+@Target({PACKAGE, TYPE, METHOD, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, PARAMETER})
+@Retention(RetentionPolicy.CLASS)
+public @interface RecordBuilderGenerated {
+}

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderMetaData.java

@@ -1,117 +0,0 @@
-/**
- * Copyright 2019 Jordan Zimmerman
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.soabase.recordbuilder.core;
-
-public interface RecordBuilderMetaData {
-    /**
-     * If you want to use your own meta data instance:
-     * <ul>
-     *     <li>create a class that implements {@code RecordBuilderMetaData}</li>
-     *     <li>When compiling, make sure that compiled class is in the processor path</li>
-     *     <li>Add a "metaDataClass" compiler option with the class name. E.g. {@code javac ... -AmetaDataClass=foo.bar.MyMetaData}</li>
-     * </ul>
-     */
-    String JAVAC_OPTION_NAME = "metaDataClass";
-
-    /**
-     * The default meta data instance
-     */
-    RecordBuilderMetaData DEFAULT = new RecordBuilderMetaData() {};
-
-    /**
-     * The builder class name will be the name of the record (prefixed with any enclosing class) plus this suffix. E.g.
-     * if the record name is "Foo", the builder will be named "FooBuilder".
-     *
-     * @return suffix
-     */
-    default String suffix() {
-        return "Builder";
-    }
-
-    /**
-     * Used by {@code RecordInterface}. The generated record will have the same name as the annotated interface
-     * plus this suffix. E.g. if the interface name is "Foo", the record will be named "FooRecord".
-     *
-     * @return suffix
-     */
-    default String interfaceSuffix() {
-        return "Record";
-    }
-
-    /**
-     * The name to use for the copy builder
-     *
-     * @return copy builder name
-     */
-    default String copyMethodName() {
-        return builderMethodName();
-    }
-
-    /**
-     * The name to use for the builder
-     *
-     * @return builder name
-     */
-    default String builderMethodName() {
-        return "builder";
-    }
-
-    /**
-     * The name to use for the build method
-     *
-     * @return build method
-     */
-    default String buildMethodName() {
-        return "build";
-    }
-
-    /**
-     * The name to use for the method that returns the record components as a stream
-     *
-     * @return build method
-     */
-    default String componentsMethodName() {
-        return "stream";
-    }
-
-    /**
-     * Return the comment to place at the top of generated files. Return null or an empty string for no comment.
-     *
-     * @return comment or empty
-     */
-    default String fileComment() {
-        return "Auto generated by io.soabase.recordbuilder.core.RecordBuilder: https://github.com/Randgalt/record-builder";
-    }
-
-    /**
-     * Return the file indent to use
-     *
-     * @return file index
-     */
-    default String fileIndent() {
-        return "    ";
-    }
-
-    /**
-     * If the record is declared inside of another class, the outer class's name will
-     * be prefixed to the builder name if this returns true.
-     *
-     * @return true/false
-     */
-    default boolean prefixEnclosingClassNames() {
-        return true;
-    }
-}

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordInterface.java

@@ -15,13 +15,47 @@
  */
 package io.soabase.recordbuilder.core;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
+@Inherited
 public @interface RecordInterface {
     boolean addRecordBuilder() default true;
+
+    @Target({ElementType.TYPE, ElementType.PACKAGE})
+    @Retention(RetentionPolicy.SOURCE)
+    @Inherited
+    @interface Include {
+        /**
+         * @return list of classes to include
+         */
+        Class<?>[] value() default {};
+
+        /**
+         * Synonym for {@code value()}. When using the other attributes it maybe more clear to
+         * use {@code classes()} instead of {@code value()}. Note: both attributes are applied
+         * (i.e. a union of classes from both attributes).
+         *
+         * @return list of classes
+         */
+        Class<?>[] classes() default {};
+
+        /**
+         * If true the generated record is annotated with {@code @RecordBuilder}
+         *
+         * @return true/false
+         */
+        boolean addRecordBuilder() default true;
+
+        /**
+         * Pattern used to generate the package for the generated class. The value
+         * is the literal package name however two replacement values can be used. '@'
+         * is replaced with the package of the {@code Include} annotation. '*' is replaced with
+         * the package of the included class.
+         *
+         * @return package pattern
+         */
+        String packagePattern() default "@";
+    }
 }

record-builder-enhancer-core/pom.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>34-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>record-builder-enhancer-core</artifactId>
+
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm-tree</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <createDependencyReducedPom>true</createDependencyReducedPom>
+                    <dependencyReducedPomLocation>${project.build.directory}/dependency-reduced-pom.xml</dependencyReducedPomLocation>
+                    <useDependencyReducedPomInJar>true</useDependencyReducedPomInJar>
+                    <relocations>
+                        <relocation>
+                            <pattern>org.objectweb</pattern>
+                            <shadedPattern>recordbuilder.org.objectweb</shadedPattern>
+                        </relocation>
+                    </relocations>
+                    <transformers>
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
+                    </transformers>
+                    <filters>
+                        <filter>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/RecordBuilderEnhance.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface RecordBuilderEnhance {
+    Class<? extends RecordBuilderEnhancer>[] enhancers();
+
+    RecordBuilderEnhanceArguments[] arguments() default {};
+
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Inherited
+    @interface Template {
+        Class<? extends RecordBuilderEnhancer>[] enhancers();
+
+        RecordBuilderEnhanceArguments[] arguments() default {};
+    }
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/RecordBuilderEnhanceArguments.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface RecordBuilderEnhanceArguments {
+    Class<? extends RecordBuilderEnhancer> enhancer();
+
+    String[] arguments();
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/spi/Entry.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.spi;
+
+import javax.lang.model.element.RecordComponentElement;
+import javax.lang.model.type.TypeMirror;
+
+public record Entry(int parameterIndex, RecordComponentElement element, TypeMirror erasedType) {
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/spi/Processor.java

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.spi;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import java.util.List;
+
+public interface Processor {
+    Elements elements();
+
+    Types types();
+
+    boolean hasEnhancer(Class<? extends RecordBuilderEnhancer> enhancer);
+
+    boolean verboseRequested();
+
+    void logInfo(CharSequence msg);
+
+    void logWarning(CharSequence msg);
+
+    void logError(CharSequence msg);
+
+    List<Entry> asEntries(TypeElement element);
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/spi/RecordBuilderEnhancer.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.spi;
+
+import org.objectweb.asm.tree.InsnList;
+
+import javax.lang.model.element.TypeElement;
+import java.util.List;
+
+@FunctionalInterface
+public interface RecordBuilderEnhancer {
+    InsnList enhance(Processor processor, TypeElement element, List<String> arguments);
+}

record-builder-enhancer/README.md

@@ -0,0 +1,454 @@
+# RecordBuilder Enhancer
+
+## What is RecordBuilder Enhancer
+
+Inject verification, defensive copying, null checks or custom code into your Java Record constructors during compilation.
+
+#### Features:
+
+- [Builtin enhancers](#builtin-enhancers) to help with null checks and defensive copying
+- [SPI](#write-your-own-custom-enhancer) for writing your own [custom enhancers](#write-your-own-custom-enhancer)
+- [Create a custom annotation](#create-a-custom-annotation) that specifies a custom set of enhancers
+ 
+#### Is it safe? Does it use undocumented features of Java?
+
+- The Enhancer modifies your Java class files. There are some inherent safety concerns with this. However:
+  - The industry standard [ASM](https://asm.ow2.io) library is used to do the modifications. ASM is even used in the JDK itself.
+  - The Enhancer only inserts code in the default constructor of Java records. The code is inserted just after the
+    call to `super()` and before any existing code in the constructor.
+  - It's implemented as a standard [javac plugin](https://docs.oracle.com/en/java/javase/16/docs/api/jdk.compiler/com/sun/source/util/Plugin.html) and uses no undocumented features
+- If you don't like the builtin enhancers you can [write your own](#write-your-own-custom-enhancer)
+
+#### How does it relate to [RecordBuilder](../README.md)?
+
+They aren't directly related but they share some code and both work on java records.
+
+#### Why RecordBuilder Enhancer?
+
+Java Records are fantastic data carriers and solve much of the pain of the lack of these types of classes
+in older versions of Java. [RecordBuilder](../README.md) adds builders and withers to records. However,
+records are still missing simple `null` checks and a few other niceties. This means boilerplate
+for every record. RecordBuilder Enhancer is targeted at being able to write Java records without having to add
+any additional code.
+
+## How to Use RecordBuilder Enhancer
+
+First, configure your build environment: see [details below](#javac-plugin). Then, use the Enhancer's
+annotations to specify Java records that you want to be enhanced.
+
+```java
+@RecordBuilderEnhance(enhancers = RequireNonNull.class)
+public record MyRecord(String s, List<String> l) {
+}
+```
+
+Enhancer inserts code into the default constructor as if you wrote this:
+
+```java
+public record MyRecord(String s, List<String> l) {
+    public MyRecord {
+        Objects.requireNonNull(s, "s is null");
+        Objects.requireNonNull(l, "l is null");
+    }
+}
+```
+
+The class file will be updated like this:
+
+![](disassembly1.png)
+
+Enhancers are applied in the order listed in the annotation. E.g.
+
+```java
+// will apply RequireNonNull and then CopyCollection
+@RecordBuilderEnhance(enhancers = {RequireNonNull.class, CopyCollection.class})
+public record MyRecord(List<String> l) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(List<String> l) {
+    Objects.requireNonNull(l);
+    l = List.copyOf(l);
+}
+```
+
+#### Arguments
+
+Enhancers can optional receive arguments (the builtin [NotNullAnnotations](#notnullannotations) does). Use `@RecordBuilderEnhanceArguments`
+to pass arguments. E.g.
+
+```java
+@RecordBuilderEnhance(enhancers = NotNullAnnotations.class, 
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = "altnonnull"))
+public record MyRecord(@AltNonNull List<String> l) {}
+```
+
+
+## Builtin Enhancers
+
+| ID                                                                    | Arguments             | Description                                                                                                                                                                                                                                                   |
+|-----------------------------------------------------------------------|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [EmptyNullOptional](#emptynulloptional)                               | -                     | Use `empty()` for null Optional/OptionalInt/OptionalLong/OptionalDouble record components                                                                                                                                                                     |
+| [EmptyNullString](#emptynullstring)                                   | -                     | Use `""` for null String record components                                                                                                                                                                                                                    |
+| [CopyCollection](#copycollection)                                     | -                     | Make defensive copies of Collection, List and Map record components                                                                                                                                                                                           |
+| [CopyCollectionNullableEmpty](#copycollectionnullableempty)           | -                     | Make defensive copies of Collection, List and Map record components or empty collections when `null`                                                                                                                                                          |
+| [GuavaCopyCollection](#guavacopycollection)                           | -                     | Same as CopyCollection but uses Google Guava collections                                                                                                                                                                                                      |
+| [GuavaCopyCollectionNullableEmpty](#guavacopycollectionnullableempty) | -                     | Same as CopyCollectionNullableEmpty but uses Google Guava collections                                                                                                                                                                                         |
+| [RequireNonNull](#requirenonnull)                                     | -                     | Call `requireNonNull()` on all non-primitive record components - note: checks other enhancers and doesn't apply to Strings if EmptyNullString is being used, etc.                                                                                             |
+| [NotNullAnnotations](#notnullannotations)                             | expression (optional) | Any parameter with an annotation whose name matches this enhancer's regular expression argument will be passed to `requireNonNull()`. The argument is optional. If not supplied then _(notnull)&#124;(nonnull)_ is used. Matching is always case insensitive. |
+
+### Examples
+
+#### EmptyNullOptional
+
+```java
+@RecordBuilderEnhance(enhancers = EmptyNullOptional.class)
+public record MyRecord(Optional<String> s, OptionalInt i) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(Optional<String> s, OptionalInt i) {
+    public MyRecord {
+        s = (s != null) ? s : Optional.empty();
+        i = (i != null) ? i : OptionalInt.empty();
+    }
+}
+```
+
+-------
+
+#### EmptyNullString
+
+```java
+@RecordBuilderEnhance(enhancers = EmptyNullString.class)
+public record MyRecord(String s) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        s = (s != null) ? s : "";
+    }
+}
+```
+
+-------
+
+#### CopyCollection
+
+```java
+@RecordBuilderEnhance(enhancers = CopyCollection.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = Set.copyOf(c);
+        s = Set.copyOf(s);
+        l = List.copyOf(l);
+        m = Map.copyOf(m);
+    }
+}
+```
+
+-------
+
+#### CopyCollectionNullableEmpty
+
+```java
+@RecordBuilderEnhance(enhancers = CopyCollectionNullableEmpty.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = (c != null) ? Set.copyOf(c) : Set.of();
+        s = (s != null) ? Set.copyOf(s) : Set.of();
+        l = (l != null) ? List.copyOf(l) : List.of();
+        m = (m != null) ? Map.copyOf(m) : Map.of();
+    }
+}
+```
+
+-------
+
+#### GuavaCopyCollection
+
+```java
+@RecordBuilderEnhance(enhancers = GuavaCopyCollection.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = ImmutableSet.copyOf(c);
+        s = ImmutableSet.copyOf(s);
+        l = ImmutableList.copyOf(l);
+        m = Map.copyOf(m);
+    }
+}
+```
+
+-------
+
+#### GuavaCopyCollectionNullableEmpty
+
+```java
+@RecordBuilderEnhance(enhancers = GuavaCopyCollectionNullableEmpty.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = (c != null) ? ImmutableSet.copyOf(c) : ImmutableSet.of();
+        s = (s != null) ? ImmutableSet.copyOf(s) : ImmutableSet.of();
+        l = (l != null) ? ImmutableList.copyOf(l) : ImmutableList.of();
+        m = (m != null) ? ImmutableMap.copyOf(m) : ImmutableMap.of();
+    }
+}
+```
+
+-------
+
+#### RequireNonNull
+
+```java
+@RecordBuilderEnhance(enhancers = RequireNonNull.class)
+public record MyRecord(String s, Instant t) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s, Instant t) {
+    public MyRecord {
+        Objects.requireNonNull(s, "s is null");
+        Objects.requireNonNull(t, "t is null");
+    }
+}
+```
+
+-------
+
+#### NotNullAnnotations
+
+```java
+@RecordBuilderEnhance(enhancers = NotNullAnnotations.class,
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = "(notnull)|(mynil)"))
+public record MyRecord(String s, @NotNull Instant t, @MyNil Thing thing) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s, @NotNull Instant t, @MyNil Thing thing) {
+    public MyRecord {
+        Objects.requireNonNull(t, "t is null");
+        Objects.requireNonNull(thing, "thing is null");
+    }
+}
+```
+
+## Create A Custom Annotation
+
+Using `@RecordBuilderEnhance.Template` you can create your own RecordBuilderEnhance annotation that always uses the set of enhancers that you want. 
+
+```java
+@RecordBuilderEnhance.Template(enhancers = {RequireNonNull.class, NotNullAnnotations.class},
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = "altnonnull.*"))
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface MyCoEnhance {
+}
+```
+
+Now, you can use `@MyCoEnhance` instead of `@RecordBuilderEnhance` and the record will be enhanced with the enhancers specified.
+
+## Javac Plugin
+
+Add a dependency that contains the discoverable javac plugin to your build tool (see below for [Maven](#maven) or [Gradle](#gradle)). javac will
+auto discover the Enhancer plugin. By default the enhancer assumes the standard directory layout used by
+most Java build systems. i.e. if a Java source file is at `/foo/bar/myproject/src/main/java/my/package/MyClass.java`
+the Enhancer will assume that the compiled class file for that source file will be found at
+`/foo/bar/myproject/target/classes/my/package/MyClass.class`. If your build system does not use this method then
+the Enhancer will need additional configuration ([see below](#options)). You can also 
+configure some of the behavior of the Enhancer ([see below](#options)).
+
+### Maven
+
+```xml
+<!-- only needed during compilation -->
+<dependency>
+    <groupId>io.soabase.record-builder</groupId>
+    <artifactId>record-builder-enhancer</artifactId>
+    <version>${record.builder.version}</version>
+    <scope>provided</scope>
+</dependency>
+
+<!-- contains the annotations -->
+<dependency>
+    <groupId>io.soabase.record-builder</groupId>
+    <artifactId>record-builder-enhancer-core</artifactId>
+    <version>${record.builder.version}</version>
+</dependency>
+```
+
+### Gradle
+
+```groovy
+dependencies {
+  compileOnly 'io.soabase.record-builder:record-builder-enhancer:$version-goes-here'
+  api 'io.soabase.record-builder:record-enhancer-core:$version-goes-here'
+}
+```
+
+### Options
+
+For normal usage you won't need to set any options for the Enhancer. The following options are available if you need them:
+
+```text
+[-hv] [--disable] [--dryRun] [--outputDirectory=<outputTo>] [DIRECTORY]
+
+      [DIRECTORY]   The build's output directory - i.e. where javac writes generated classes. 
+                    The value can be a full path or a relative path. If not provided the Enhancer 
+                    plugin will attempt to use standard directories.
+      --disable     Deactivate/disable the plugin
+      --dryRun      Dry run only - doesn't modify any classes. You should enable verbose as well via: -v
+  -h, --help        Outputs this help
+      --outputDirectory=<outputTo>
+                    Optional alternate output directory for enhanced class files
+  -v, --verbose     Verbose output during compilation
+```
+
+javac plugin options are specifed on the javac command line or as part of your build tool. On the command line:
+
+```shell
+javac -Xplugin:"recordbuilderenhancer ...arguments..."
+```
+
+In Maven:
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-compiler-plugin</artifactId>
+    <configuration>
+        <compilerArgument>-Xplugin:recordbuilderenhancer ...arguments...</compilerArgument>
+    </configuration>
+</plugin>
+```
+
+## Write Your Own Custom Enhancer
+
+Notes on writing your own enhancer:
+
+- Custom Enhancers must be built as separate modules from the code base you want to enhance. This is because
+the enhancers must be available during compilation.
+- You should somewhat be familiar with Java's AST classes though they are not hard to understand for newcomers
+- Enhancers use the [ASM library](https://asm.ow2.io) to produce a list of statements to be inserted into Java record constructors
+- You will need some knowledge of Java bytecode specifics and the Java Language specification. However, it's pretty simple
+to use javac and javap to show you what bytecodes you need to specify ([see below](#how-to-get-the-bytecodes-for-your-enhancer))
+- **IMPORTANT** - the ASM library has been shaded into the RecordBuilder Enhancer JAR. Make sure your custom enhancer uses the ASM classes
+that are in the package `recordbuilder.org.objectweb.asm.*`. Many libraries use ASM and you may see the same classes in multiple packages.
+
+For reference look at the implementation of the builtin enhancers to see exactly how to write one. [EmptyNullString](src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullString.java)
+is a simple one to use as an example.
+
+#### Add the SPI to your build
+
+The RecordBuilder Enhancer SPI must be added to the module for your custom enhancer. It's artifact ID is `record-builder-enhancer-core`.
+Your enhancer module can contain as many enhancers as you want. Each enhancer must implement the following interface:
+
+```java
+public interface RecordBuilderEnhancer {
+    InsnList enhance(Processor processor, TypeElement element, List<String> arguments);
+}
+```
+
+Your custom enhancer is called for Java records that are annotated to list your enhancer class.
+Your enhancer is created once during the start of the build process and will be called multiple times for each Java record
+that is annotated with your enhancer. Your enhancer must return a list of instructions to insert or an empty list.
+The `element` parameter refers to the Java record being currently compiled. `arguments` are any arguments specified in the annotation
+for the Java record. `Processor` holds utilities useful during enhancing. Look at the builtin enhancers to see details on how to write
+them - [EmptyNullString](src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullString.java) is a good one to start with.
+
+Build and install your enhancer JAR and you can then use your new custom enhancer as a dependency in other projects and it will be available as an enhancer.
+Alternatively, if you have a multi-module build your enhancer can be a module and used to enhance the other modules in the
+project. The [record-builder-test-custom-enhancer](../record-builder-test-custom-enhancer) does this.
+
+#### How to get the bytecodes for your enhancer
+
+The trick for getting the bytecodes for your enhancer is to write a simple Java source file that does what you want and then 
+use the java tools to get the bytecodes. For example, let's say you want a custom enhancer that outputs the current date and time to standard 
+out.
+
+Create a text file called "Temp.java" ala:
+
+```java
+import java.time.Instant;
+
+public class Temp {
+  public Temp() {
+    System.out.println(Instant.now());
+  }
+}
+```
+
+From a terminal compile the class:
+
+```shell
+javac Temp.java
+```
+
+Then dump the java bytecodes from the compiled class:
+
+```shell
+javap -c Temp.class
+```
+
+You will see:
+
+```text
+Compiled from "Temp.java"
+public class Temp {
+  public Temp();
+    Code:
+       0: aload_0
+       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
+       4: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
+       7: invokestatic  #13                 // Method java/time/Instant.now:()Ljava/time/Instant;
+      10: invokevirtual #19                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
+      13: return
+}
+```
+
+The first two lines are the call to `super()`. The lines labeld `4`, `7`, and `10` are the bytecodes that you want for your enhancer.
+
+Your enhance() implementation would look like this:
+
+```java
+InsnList insnList = new InsnList();
+insnList.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"));
+insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/time/Instant", "now", "()Ljava/time/Instant;"));
+insnList.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V"));
+return insnList;
+```

record-builder-enhancer/pom.xml

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>34-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>record-builder-enhancer</artifactId>
+
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>info.picocli</groupId>
+            <artifactId>picocli</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <createDependencyReducedPom>true</createDependencyReducedPom>
+                    <dependencyReducedPomLocation>${project.build.directory}/dependency-reduced-pom.xml</dependencyReducedPomLocation>
+                    <useDependencyReducedPomInJar>true</useDependencyReducedPomInJar>
+                    <relocations>
+                        <relocation>
+                            <pattern>picocli</pattern>
+                            <shadedPattern>recordbuilder.picocli</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>safe</pattern>
+                            <shadedPattern>META-INF.services</shadedPattern>
+                        </relocation>
+                    </relocations>
+                    <transformers>
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                            <manifestEntries>
+                                <Main-Class>io.soabase.recordbuilder.enhancer.Main</Main-Class>
+                            </manifestEntries>
+                        </transformer>
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
+                    </transformers>
+                    <filters>
+                        <filter>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/EnhancersController.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static io.soabase.recordbuilder.enhancer.RecordBuilderEnhancerPlugin.adjustedClassName;
+
+class EnhancersController {
+    private final Map<String, Optional<RecordBuilderEnhancer>> enhancers = new ConcurrentHashMap<>();
+
+    record EnhancerAndArgs(RecordBuilderEnhancer enhancer, List<String> arguments) {}
+
+    List<EnhancerAndArgs> getEnhancers(ProcessorImpl processor, TypeElement typeElement) {
+        return internalGetEnhancers(processor, typeElement).flatMap(spec -> toEnhancer(processor, spec)).toList();
+    }
+
+    private Stream<EnhancerSpec> internalGetEnhancers(ProcessorImpl processor, TypeElement typeElement) {
+        Optional<? extends AnnotationMirror> recordBuilderEnhance = getAnnotationMirror(processor, typeElement);
+        Optional<? extends AnnotationMirror> recordBuilderEnhanceTemplate = getTemplateAnnotationMirror(processor, typeElement);
+        if (recordBuilderEnhance.isPresent() && recordBuilderEnhanceTemplate.isPresent()) {
+            processor.logError("RecordBuilderEnhance and RecordBuilderEnhance.Template cannot be combined.");
+            return Stream.of();
+        }
+        return Stream.concat(recordBuilderEnhance.stream().flatMap(this::getEnhancersAnnotationValue), recordBuilderEnhanceTemplate.stream().flatMap(this::getEnhancersAnnotationValue));
+    }
+
+    private Map<String, Object> getAnnotationValueMap(AnnotationMirror annotationMirror)
+    {
+        return annotationMirror.getElementValues().entrySet().stream()
+                .collect(Collectors.toMap(entry -> entry.getKey().getSimpleName().toString(), entry -> entry.getValue().getValue()));
+    }
+
+    private record EnhancerSpec(String enhancerClass, List<String> arguments) {}
+
+    @SuppressWarnings("unchecked")
+    private Stream<EnhancerSpec> getEnhancersAnnotationValue(AnnotationMirror annotationMirror)
+    {
+        Map<String, Object> annotationValueMap = getAnnotationValueMap(annotationMirror);
+
+        List<? extends AnnotationValue> argumentsValue = (List<? extends AnnotationValue>) annotationValueMap.getOrDefault("arguments", List.of()); // list of RecordBuilderEnhanceArguments mirrors
+        Map<String, List<String>> argumentsMap = argumentsValue.stream()
+                .flatMap(argumentMirror -> {
+                    Map<String, Object> argumentMap = getAnnotationValueMap((AnnotationMirror) argumentMirror.getValue());
+                    Object enhancer = argumentMap.get("enhancer");
+                    Object arguments = argumentMap.get("arguments");
+                    if ((enhancer != null) && (arguments != null)) {
+                        List<String> argumentList = ((List<? extends AnnotationValue>) arguments).stream().map(value -> value.getValue().toString()).toList();
+                        return Stream.of(Map.entry(enhancer.toString(), argumentList));
+                    }
+                    return Stream.of();
+                })
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        List<? extends AnnotationValue> enhancers = (List<? extends AnnotationValue>) annotationValueMap.get("enhancers");
+        if (enhancers != null) {
+            return enhancers.stream().map(annotationValue -> {
+                TypeMirror typeMirror = (TypeMirror) annotationValue.getValue();
+                return new EnhancerSpec(typeMirror.toString(), argumentsMap.getOrDefault(typeMirror.toString(), List.of()));
+            });
+        }
+        return Stream.of();
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, ? extends AnnotationValue> getArgumentsAnnotations(AnnotationMirror annotationMirror)
+    {
+        return annotationMirror.getElementValues().entrySet().stream()
+                .filter(entry -> entry.getKey().getSimpleName().contentEquals("arguments"))
+                .flatMap(entry -> ((List<? extends AnnotationValue>) entry.getValue().getValue()).stream())
+                .flatMap(annotationValue -> ((AnnotationMirror) annotationValue.getValue()).getElementValues().entrySet().stream()) // now as RecordBuilderEnhanceArguments
+
+                .collect(Collectors.toMap(entry -> entry.getKey().getSimpleName().toString(), Map.Entry::getValue));
+    }
+
+    private Optional<? extends AnnotationMirror> getAnnotationMirror(ProcessorImpl processor, TypeElement typeElement) {
+        return processor.elements().getAllAnnotationMirrors(typeElement).stream()
+                .filter(annotationMirror -> annotationMirror.getAnnotationType().toString().equals(adjustedClassName(RecordBuilderEnhance.class)))
+                .findFirst();
+    }
+
+    private Optional<? extends AnnotationMirror> getTemplateAnnotationMirror(ProcessorImpl processor, TypeElement typeElement) {
+        return processor.elements().getAllAnnotationMirrors(typeElement).stream()
+                .flatMap(annotationMirror -> processor.elements().getAllAnnotationMirrors(annotationMirror.getAnnotationType().asElement()).stream())
+                .filter(annotationMirror -> annotationMirror.getAnnotationType().toString().equals(adjustedClassName(RecordBuilderEnhance.Template.class)))
+                .findFirst();
+    }
+
+    private Stream<EnhancerAndArgs> toEnhancer(ProcessorImpl processor, EnhancerSpec spec)
+    {
+        return enhancers.computeIfAbsent(spec.enhancerClass(), __ -> newEnhancer(processor, spec.enhancerClass()))
+                .stream()
+                .map(enhancer -> new EnhancerAndArgs(enhancer, spec.arguments()));
+    }
+
+    private Optional<RecordBuilderEnhancer> newEnhancer(ProcessorImpl processor, String enhancerClass)
+    {
+        try {
+            Class<?> clazz = Class.forName(enhancerClass, true, RecordBuilderEnhancerPlugin.class.getClassLoader());
+            Object enhancer = clazz.getConstructor().newInstance();
+            return Optional.of((RecordBuilderEnhancer) enhancer);
+        } catch (Exception e) {
+            processor.logError("Could not create enhancer instance. type=%s exception=%s message=%s".formatted(enhancerClass, e.getClass().getSimpleName(), e.getMessage()));
+            return Optional.empty();
+        }
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/Main.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import picocli.CommandLine;
+
+public class Main {
+    public static void main(String[] args) {
+        CommandLine commandLine = new CommandLine(new PluginOptions());
+        commandLine.usage(System.out);
+    }
+
+    private Main() {
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/PluginOptions.java

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+import picocli.CommandLine.Parameters;
+
+import java.io.File;
+
+@Command(name = "RecordBuilder Enhancer",
+        description = "Enhances Java record class files with validations, preconditions, etc. See https://github.com/Randgalt/record-builder for details",
+        usageHelpAutoWidth = true)
+class PluginOptions {
+    @Parameters(paramLabel = "DIRECTORY", arity = "0..1", description = "The build's output directory - i.e. where javac writes generated classes. The value can be a full path or a relative path. If not provided the Enhancer plugin will attempt to use standard directories.")
+    String directory = "";
+
+    @Option(names = {"-h", "--help"}, description = "Outputs this help")
+    boolean helpRequested = false;
+
+    @Option(names = {"-v", "--verbose"}, description = "Verbose output during compilation")
+    boolean verbose = false;
+
+    @Option(names = {"--disable"}, description = "Deactivate/disable the plugin")
+    boolean disable = false;
+
+    @Option(names = {"--dryRun"}, description = "Dry run only - doesn't modify any classes. You should enable verbose as well via: -v")
+    boolean dryRun = false;
+
+    @Option(names = {"--outputDirectory"}, description = "Optional alternate output directory for enhanced class files")
+    File outputTo = null;
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/ProcessorImpl.java

@@ -0,0 +1,110 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.util.Trees;
+import io.soabase.recordbuilder.enhancer.EnhancersController.EnhancerAndArgs;
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import javax.lang.model.element.RecordComponentElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import javax.tools.Diagnostic;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+class ProcessorImpl
+    implements Processor {
+    private final Collection<? extends Class<? extends RecordBuilderEnhancer>> enhancers;
+    private final Elements elements;
+    private final Types types;
+    private final Trees trees;
+    private final CompilationUnitTree compilationUnit;
+    private final boolean verboseRequested;
+
+    ProcessorImpl(Elements elements, Types types, Trees trees, CompilationUnitTree compilationUnit, boolean verboseRequested) {
+        this(Set.of(), elements, types, trees, compilationUnit, verboseRequested);
+    }
+
+    private ProcessorImpl(Collection<? extends Class<? extends RecordBuilderEnhancer>> enhancers, Elements elements, Types types, Trees trees, CompilationUnitTree compilationUnit, boolean verboseRequested) {
+        this.enhancers = enhancers;
+        this.elements = elements;
+        this.types = types;
+        this.trees = trees;
+        this.compilationUnit = compilationUnit;
+        this.verboseRequested = verboseRequested;
+    }
+
+    ProcessorImpl withEnhancers(List<EnhancerAndArgs> enhancers)
+    {
+        Collection<? extends Class<? extends RecordBuilderEnhancer>> enhancersList = enhancers.stream().map(enhancerAndArgs -> enhancerAndArgs.enhancer().getClass()).toList();
+        return new ProcessorImpl(enhancersList, elements, types, trees, compilationUnit, verboseRequested);
+    }
+
+    @Override
+    public boolean verboseRequested() {
+        return verboseRequested;
+    }
+
+    @Override
+    public List<Entry> asEntries(TypeElement element) {
+        List<? extends RecordComponentElement> recordComponents = element.getRecordComponents();
+        return IntStream.range(0, recordComponents.size())
+                .mapToObj(index -> new Entry(index + 1, recordComponents.get(index), types().erasure(recordComponents.get(index).asType())))
+                .toList();
+    }
+
+    @Override
+    public boolean hasEnhancer(Class<? extends RecordBuilderEnhancer> enhancer) {
+        return enhancers.contains(enhancer);
+    }
+
+    @Override
+    public void logInfo(CharSequence msg) {
+        printMessage(Diagnostic.Kind.NOTE, msg);
+    }
+
+    @Override
+    public void logWarning(CharSequence msg) {
+        printMessage(Diagnostic.Kind.MANDATORY_WARNING, msg);
+    }
+
+    @Override
+    public void logError(CharSequence msg) {
+        msg += " - Use -h for help in your -Xplugin arguments";
+        printMessage(Diagnostic.Kind.ERROR, msg);
+    }
+
+    @Override
+    public Elements elements() {
+        return elements;
+    }
+
+    @Override
+    public Types types() {
+        return types;
+    }
+
+    private void printMessage(Diagnostic.Kind kind, CharSequence msg) {
+        trees.printMessage(kind, "[RecordBuilder Enhancer] " + msg, compilationUnit, compilationUnit);
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/RecordBuilderEnhancerPlugin.java

@@ -0,0 +1,139 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import io.soabase.recordbuilder.enhancer.EnhancersController.EnhancerAndArgs;
+import io.soabase.recordbuilder.enhancer.Session.FileStreams;
+import picocli.CommandLine;
+import recordbuilder.org.objectweb.asm.ClassReader;
+import recordbuilder.org.objectweb.asm.ClassWriter;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class RecordBuilderEnhancerPlugin
+        implements Plugin, TaskListener {
+    private volatile Session session;
+
+    @Override
+    public String getName() {
+        return "recordbuilderenhancer";
+    }
+
+    @Override
+    public boolean autoStart() {
+        return true;
+    }
+
+    @Override
+    public void init(JavacTask task, String... args) {
+        PluginOptions pluginOptions = new PluginOptions();
+        CommandLine commandLine = new CommandLine(pluginOptions);
+        commandLine.parseArgs(args);
+        if (!pluginOptions.disable) {
+            session = new Session(task, this, pluginOptions, commandLine);
+        }
+    }
+
+    @Override
+    public void finished(TaskEvent taskEvent) {
+        if (taskEvent.getKind() == TaskEvent.Kind.GENERATE) {
+            TypeElement typeElement = taskEvent.getTypeElement();
+            ProcessorImpl processor = session.newProcessor(taskEvent);
+            session.checkPrintHelp(processor);
+            List<EnhancerAndArgs> enhancers = session.enhancersController().getEnhancers(processor, typeElement);
+            if (!enhancers.isEmpty()) {
+                if (typeElement.getRecordComponents().isEmpty()) {
+                    processor.logError(typeElement.getQualifiedName() + " is not a record");
+                } else {
+                    if (processor.verboseRequested()) {
+                        processor.logWarning("Enhancing %s with %s".formatted(typeElement.getSimpleName(), enhancers.stream().map(enhancer -> enhancer.getClass().getName()).collect(Collectors.joining(","))));
+                    }
+                    session.getFileStreams(processor, typeElement, taskEvent.getCompilationUnit().getSourceFile().toUri()).ifPresent(fileStreams -> enhance(typeElement, processor.withEnhancers(enhancers), enhancers, fileStreams));
+                }
+            }
+        }
+    }
+
+    private boolean removeAndSaveSuperCall(MethodNode constructor, InsnList insnList) {
+        ListIterator<AbstractInsnNode> iterator = constructor.instructions.iterator();
+        while (iterator.hasNext()) {
+            AbstractInsnNode node = iterator.next();
+            iterator.remove();
+            insnList.add(node);
+            if ((node.getOpcode() == Opcodes.INVOKESPECIAL) && ((MethodInsnNode) node).owner.equals("java/lang/Record") && ((MethodInsnNode) node).name.equals("<init>")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void enhance(TypeElement typeElement, ProcessorImpl processor, List<EnhancerAndArgs> specs, FileStreams fileStreams) {
+        try {
+            ClassNode classNode = new ClassNode();
+            try (InputStream in = fileStreams.openInputStream()) {
+                ClassReader classReader = new ClassReader(in);
+                classReader.accept(classNode, 0);
+            }
+            InsnList insnList = new InsnList();
+            MethodNode constructor = findConstructor(classNode).orElseThrow(() -> new IllegalStateException("Could not find default constructor"));
+            if (!removeAndSaveSuperCall(constructor, insnList)) {
+                processor.logError("Unrecognized constructor - missing super() call.");
+                return;
+            }
+            specs.stream()
+                    .map(spec -> spec.enhancer().enhance(processor, typeElement, spec.arguments()))
+                    .forEach(insnList::add);
+            constructor.instructions.insert(insnList);
+
+            ClassWriter classWriter = new ClassWriter(Opcodes.ASM9 | ClassWriter.COMPUTE_FRAMES);
+            classNode.accept(classWriter);
+
+            if (!session.isDryRun()) {
+                try (OutputStream out = fileStreams.openOutputStream()) {
+                    out.write(classWriter.toByteArray());
+                }
+            }
+        } catch (IOException e) {
+            processor.logError("Could not process " + typeElement.getQualifiedName() + " - " + e.getMessage());
+        }
+    }
+
+    static String adjustedClassName(Class<?> clazz) {
+        return clazz.getName().replace('$', '.');
+    }
+
+    private static Optional<MethodNode> findConstructor(ClassNode classNode) {
+        String defaultConstructorDescription = classNode.recordComponents.stream()
+                .map(recordComponentNode -> recordComponentNode.descriptor)
+                .collect(Collectors.joining("", "(", ")V"));
+        return classNode.methods.stream()
+                .filter(methodNode -> methodNode.name.equals("<init>") && methodNode.desc.equals(defaultConstructorDescription))
+                .findFirst();
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/Session.java

@@ -0,0 +1,186 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.source.util.Trees;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import picocli.CommandLine;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.*;
+import java.io.*;
+import java.net.URI;
+import java.util.List;
+import java.util.Optional;
+
+public class Session implements SessionFlag {
+    private final JavacTask task;
+    private final StandardJavaFileManager fileManager;
+    private final Trees trees;
+    private final EnhancersController enhancersController;
+    private final PluginOptions pluginOptions;
+    private final CommandLine commandLine;
+
+    public Session(JavacTask task, TaskListener taskListener, PluginOptions pluginOptions, CommandLine commandLine) {
+        this.task = task;
+        this.pluginOptions = pluginOptions;
+        this.commandLine = commandLine;
+        task.addTaskListener(taskListener);
+        enhancersController = new EnhancersController();
+        //PluginOptions.setupCommandLine(this.commandLine, enhancersController.enhancers(), true);
+        fileManager = ToolProvider.getSystemJavaCompiler().getStandardFileManager(null, null, null);
+        try {
+            fileManager.setLocation(StandardLocation.CLASS_OUTPUT, List.of(new File(this.pluginOptions.directory).getAbsoluteFile()));
+        } catch (IOException e) {
+            throw new RuntimeException("Could not set the class output path", e);
+        }
+
+        trees = Trees.instance(task);
+
+        if (pluginOptions.outputTo != null) {
+            if (!pluginOptions.outputTo.isDirectory() && !pluginOptions.outputTo.exists() && !pluginOptions.outputTo.mkdirs()) {
+                throw new RuntimeException("Could not create directory: " + pluginOptions.outputTo);
+            }
+        }
+    }
+
+    public boolean enabled()
+    {
+        return !pluginOptions.disable;
+    }
+
+    public boolean isDryRun()
+    {
+        return pluginOptions.dryRun;
+    }
+
+    public JavacTask task() {
+        return task;
+    }
+
+    public interface FileStreams
+    {
+        InputStream openInputStream() throws IOException;
+
+        OutputStream openOutputStream() throws IOException;
+    }
+
+    public Optional<FileStreams> getFileStreams(Processor processor, TypeElement element, URI fileUri) {
+        String directory = pluginOptions.directory;
+        if (directory.isEmpty()) {
+            String pathToFile = fileUri.getPath();
+            int srcMainJavaIndex = pathToFile.indexOf("src/main/java");
+            if (srcMainJavaIndex >= 0) {
+                directory = pathToFile.substring(0, srcMainJavaIndex) + "target/classes";
+            }
+            else {
+                directory = ".";
+            }
+        }
+        String className = getClassName(element);
+        File absoluteDirectory = new File(directory).getAbsoluteFile();
+        if (pluginOptions.verbose) {
+            processor.logWarning("Using classPath %s for class %s".formatted(absoluteDirectory, className));
+        }
+        try {
+            fileManager.setLocation(StandardLocation.CLASS_OUTPUT, List.of(absoluteDirectory));
+            JavaFileObject inputJavaFile = fileManager.getJavaFileForOutput(StandardLocation.CLASS_OUTPUT, className, JavaFileObject.Kind.CLASS, null);
+            JavaFileObject outputJavaFile;
+            if (pluginOptions.outputTo != null) {
+                fileManager.setLocation(StandardLocation.CLASS_OUTPUT, List.of(pluginOptions.outputTo));
+                outputJavaFile = fileManager.getJavaFileForOutput(StandardLocation.CLASS_OUTPUT, className, JavaFileObject.Kind.CLASS, null);
+            }
+            else {
+                outputJavaFile = inputJavaFile;
+            }
+            FileStreams fileStreams = new FileStreams() {
+                @Override
+                public InputStream openInputStream() throws IOException {
+                    return inputJavaFile.openInputStream();
+                }
+
+                @Override
+                public OutputStream openOutputStream() throws IOException {
+                    return outputJavaFile.openOutputStream();
+                }
+            };
+            return Optional.of(fileStreams);
+        } catch (IOException e) {
+            processor.logError("Could not set classpath to %s for class %s: %s".formatted(absoluteDirectory, className, e.getMessage()));
+            return Optional.empty();
+        }
+    }
+
+    public EnhancersController enhancersController() {
+        return enhancersController;
+    }
+
+    public ProcessorImpl newProcessor(TaskEvent taskEvent)
+    {
+        return new ProcessorImpl(task.getElements(), task.getTypes(), trees, taskEvent.getCompilationUnit(), pluginOptions.verbose);
+    }
+
+    public void checkPrintHelp(Processor processor)
+    {
+        if (pluginOptions.helpRequested && getAndSetFlag("show-help")) {
+            StringWriter help = new StringWriter();
+            help.write('\n');
+            commandLine.usage(new PrintWriter(help));
+            processor.logError(help.toString());
+        }
+    }
+
+    @Override
+    public boolean getAndSetFlag(String name)
+    {
+        boolean wasSet = isSet(name);
+        if (!wasSet) {
+            set(name);
+            return true;
+        }
+        return false;
+    }
+
+    private String getClassName(TypeElement typeElement) {
+        return task.getElements().getPackageOf(typeElement).getQualifiedName() + "." + getClassName(typeElement, "");
+    }
+
+    private static String getClassName(Element element, String separator) {
+        // prefix enclosing class names if nested in a class
+        if (element instanceof TypeElement) {
+            return getClassName(element.getEnclosingElement(), "$") + element.getSimpleName().toString() + separator;
+        }
+        return "";
+    }
+
+    private boolean isSet(String name)
+    {
+        return Boolean.parseBoolean(System.getProperty(toKey(name)));
+    }
+
+    private void set(String name)
+    {
+        System.setProperty(toKey(name), "true");
+    }
+
+    private String toKey(String name) {
+        return Session.class.getName() + ":" + name;
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/SessionFlag.java

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+@FunctionalInterface
+public interface SessionFlag {
+    boolean getAndSetFlag(String name);
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollection.java

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class CopyCollection extends CopyCollectionBase {
+    @Override
+    protected boolean isInterface() {
+        return true;
+    }
+
+    @Override
+    protected String mapMethod() {
+        return "(Ljava/util/Map;)Ljava/util/Map;";
+    }
+
+    @Override
+    protected String setMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/Set;";
+    }
+
+    @Override
+    protected String listMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/List;";
+    }
+
+    @Override
+    protected String map() {
+        return "java/util/Map";
+    }
+
+    @Override
+    protected String set() {
+        return "java/util/Set";
+    }
+
+    @Override
+    protected String list() {
+        return "java/util/List";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollectionBase.java

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.InsnList;
+import recordbuilder.org.objectweb.asm.tree.MethodInsnNode;
+import recordbuilder.org.objectweb.asm.tree.VarInsnNode;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public abstract class CopyCollectionBase
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror collectionType = processor.elements().getTypeElement("java.util.Collection").asType();
+        TypeMirror listType = processor.elements().getTypeElement("java.util.List").asType();
+        TypeMirror mapType = processor.elements().getTypeElement("java.util.Map").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element).stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), collectionType) || processor.types().isAssignable(entry.erasedType(), mapType))
+                .forEach(entry -> {
+                    // aload_1
+                    // invokestatic  #7                  // InterfaceMethod java/util/List.copyOf:(Ljava/util/Collection;)Ljava/util/Set;
+                    // astore_1
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    if (processor.types().isAssignable(entry.erasedType(), listType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, list(), "copyOf", listMethod(), isInterface()));
+                    } else if (processor.types().isAssignable(entry.erasedType(), collectionType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, set(), "copyOf", setMethod(), isInterface()));
+                    } else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, map(), "copyOf", mapMethod(), isInterface()));
+                    }
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+
+    abstract protected boolean isInterface();
+
+    abstract protected String mapMethod();
+
+    abstract protected String setMethod();
+
+    abstract protected String listMethod();
+
+    abstract protected String map();
+
+    abstract protected String set();
+
+    abstract protected String list();
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollectionNullableEmpty.java

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class CopyCollectionNullableEmpty extends CopyCollectionNullableEmptyBase {
+    @Override
+    protected boolean isInterface() {
+        return true;
+    }
+
+    @Override
+    protected String mapEmptyMethod() {
+        return "()Ljava/util/Map;";
+    }
+
+    @Override
+    protected String setEmptyMethod() {
+        return "()Ljava/util/Set;";
+    }
+
+    @Override
+    protected String listEmptyMethod() {
+        return "()Ljava/util/List;";
+    }
+
+    @Override
+    protected String mapCopyMethod() {
+        return "(Ljava/util/Map;)Ljava/util/Map;";
+    }
+
+    @Override
+    protected String setCopyMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/Set;";
+    }
+
+    @Override
+    protected String listCopyMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/List;";
+    }
+
+    @Override
+    protected String map() {
+        return "java/util/Map";
+    }
+
+    @Override
+    protected String set() {
+        return "java/util/Set";
+    }
+
+    @Override
+    protected String list() {
+        return "java/util/List";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollectionNullableEmptyBase.java

@@ -0,0 +1,96 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Label;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public abstract class CopyCollectionNullableEmptyBase
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror collectionType = processor.elements().getTypeElement("java.util.Collection").asType();
+        TypeMirror listType = processor.elements().getTypeElement("java.util.List").asType();
+        TypeMirror mapType = processor.elements().getTypeElement("java.util.Map").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element).stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), collectionType) || processor.types().isAssignable(entry.erasedType(), mapType))
+                .forEach(entry -> {
+                    /*
+                       4: aload_1
+                       5: ifnull        15
+                       8: aload_1
+                       9: invokestatic  #7                  // InterfaceMethod java/util/Set.copyOf:(Ljava/util/Collection;)Ljava/util/Set;
+                      12: goto          18
+                      15: invokestatic  #13                 // InterfaceMethod java/util/Set.of:()Ljava/util/Set;
+                      18: astore_1
+                     */
+                    LabelNode doEmptylabel = new LabelNode(new Label());
+                    LabelNode doCopylabel = new LabelNode(new Label());
+                    LabelNode doAssignlabel = new LabelNode(new Label());
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.IFNULL, doEmptylabel));
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    if (processor.types().isAssignable(entry.erasedType(), listType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, list(), "copyOf", listCopyMethod(), isInterface()));
+                    } else if (processor.types().isAssignable(entry.erasedType(), collectionType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, set(), "copyOf", setCopyMethod(), isInterface()));
+                    } else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, map(), "copyOf", mapCopyMethod(), isInterface()));
+                    }
+                    insnList.add(new JumpInsnNode(Opcodes.GOTO, doAssignlabel));
+                    insnList.add(doEmptylabel);
+                    if (processor.types().isAssignable(entry.erasedType(), listType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, list(), "of", listEmptyMethod(), isInterface()));
+                    } else if (processor.types().isAssignable(entry.erasedType(), collectionType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, set(), "of", setEmptyMethod(), isInterface()));
+                    } else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, map(), "of", mapEmptyMethod(), isInterface()));
+                    }
+                    insnList.add(doAssignlabel);
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+
+    abstract protected boolean isInterface();
+
+    abstract protected String mapEmptyMethod();
+
+    abstract protected String setEmptyMethod();
+
+    abstract protected String listEmptyMethod();
+
+    abstract protected String mapCopyMethod();
+
+    abstract protected String setCopyMethod();
+
+    abstract protected String listCopyMethod();
+
+    abstract protected String map();
+
+    abstract protected String set();
+
+    abstract protected String list();
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullOptional.java

@@ -0,0 +1,74 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Label;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public class EmptyNullOptional
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror optionalType = processor.elements().getTypeElement("java.util.Optional").asType();
+        TypeMirror optionalIntType = processor.elements().getTypeElement("java.util.OptionalInt").asType();
+        TypeMirror optionalLongType = processor.elements().getTypeElement("java.util.OptionalLong").asType();
+        TypeMirror optionalDouble = processor.elements().getTypeElement("java.util.OptionalDouble").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element)
+                .stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), optionalType) || processor.types().isAssignable(entry.erasedType(), optionalIntType) || processor.types().isAssignable(entry.erasedType(), optionalLongType) || processor.types().isAssignable(entry.erasedType(), optionalDouble))
+                .forEach(entry -> {
+                    /*
+                       4: aload         5
+                       6: ifnull        14
+                       9: aload         5
+                      11: goto          17
+                      14: invokestatic  #7                  // Method java/util/Optional.empty:()Ljava/util/Optional;
+                      17: astore        5
+                    */
+                    LabelNode doEmptylabel = new LabelNode(new Label());
+                    LabelNode doAssignlabel = new LabelNode(new Label());
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.IFNULL, doEmptylabel));
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.GOTO, doAssignlabel));
+                    insnList.add(doEmptylabel);
+                    if (processor.types().isAssignable(entry.erasedType(), optionalIntType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/OptionalInt", "empty", "()Ljava/util/OptionalInt;"));
+                    }
+                    else if (processor.types().isAssignable(entry.erasedType(), optionalLongType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/OptionalLong", "empty", "()Ljava/util/OptionalLong;"));
+                    }
+                    else if (processor.types().isAssignable(entry.erasedType(), optionalDouble)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/OptionalDouble", "empty", "()Ljava/util/OptionalDouble;"));
+                    }
+                    else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/Optional", "empty", "()Ljava/util/Optional;"));
+                    }
+                    insnList.add(doAssignlabel);
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullString.java

@@ -0,0 +1,59 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Label;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public class EmptyNullString
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror stringType = processor.elements().getTypeElement("java.lang.String").asType();
+        InsnList insnList = new InsnList();
+        processor.asEntries(element)
+                .stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), stringType))
+                .forEach(entry -> {
+                    /*
+                       4: aload_1
+                       5: ifnull        12
+                       8: aload_1
+                       9: goto          14
+                      12: ldc           #7                  // String
+                      14: astore_1
+                    */
+                    LabelNode doEmptylabel = new LabelNode(new Label());
+                    LabelNode doAssignlabel = new LabelNode(new Label());
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.IFNULL, doEmptylabel));
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.GOTO, doAssignlabel));
+                    insnList.add(doEmptylabel);
+                    insnList.add(new LdcInsnNode(""));
+                    insnList.add(doAssignlabel);
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/GuavaCopyCollection.java

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class GuavaCopyCollection extends CopyCollectionBase {
+    @Override
+    protected boolean isInterface() {
+        return false;
+    }
+
+    @Override
+    protected String mapMethod() {
+        return "(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;";
+    }
+
+    @Override
+    protected String setMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableSet;";
+    }
+
+    @Override
+    protected String listMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableList;";
+    }
+
+    @Override
+    protected String map() {
+        return "com/google/common/collect/ImmutableMap";
+    }
+
+    @Override
+    protected String set() {
+        return "com/google/common/collect/ImmutableSet";
+    }
+
+    @Override
+    protected String list() {
+        return "com/google/common/collect/ImmutableList";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/GuavaCopyCollectionNullableEmpty.java

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class GuavaCopyCollectionNullableEmpty extends CopyCollectionNullableEmptyBase {
+    @Override
+    protected boolean isInterface() {
+        return false;
+    }
+
+    @Override
+    protected String mapEmptyMethod() {
+        return "()Lcom/google/common/collect/ImmutableMap;";
+    }
+
+    @Override
+    protected String setEmptyMethod() {
+        return "()Lcom/google/common/collect/ImmutableSet;";
+    }
+
+    @Override
+    protected String listEmptyMethod() {
+        return "()Lcom/google/common/collect/ImmutableList;";
+    }
+
+    @Override
+    protected String mapCopyMethod() {
+        return "(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;";
+    }
+
+    @Override
+    protected String setCopyMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableSet;";
+    }
+
+    @Override
+    protected String listCopyMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableList;";
+    }
+
+    @Override
+    protected String map() {
+        return "com/google/common/collect/ImmutableMap";
+    }
+
+    @Override
+    protected String set() {
+        return "com/google/common/collect/ImmutableSet";
+    }
+
+    @Override
+    protected String list() {
+        return "com/google/common/collect/ImmutableList";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/NotNullAnnotations.java

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.tree.InsnList;
+
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.TypeElement;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import java.util.stream.Stream;
+
+public class NotNullAnnotations
+        implements RecordBuilderEnhancer
+{
+    public static final String DEFAULT_EXPRESSION = "(notnull)|(nonnull)";
+
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        InsnList insnList = new InsnList();
+        if (arguments.size() > 1) {
+            processor.logError("Too many arguments to NotNullAnnotations.");
+        } else {
+            String expression = arguments.isEmpty() ? DEFAULT_EXPRESSION : arguments.get(0);
+            try {
+                Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
+                processor.asEntries(element)
+                        .stream()
+                        .filter(entry -> !entry.erasedType().getKind().isPrimitive())
+                        .filter(entry -> hasMatchingAnnotation(entry, pattern))
+                        .forEach(entry -> RequireNonNull.enhance(insnList, entry));
+            } catch (PatternSyntaxException e) {
+                processor.logError("Bad argument to NotNullAnnotations: " + e.getMessage());
+            }
+        }
+        return insnList;
+    }
+
+    private boolean hasMatchingAnnotation(Entry entry, Pattern pattern)
+    {
+        Stream<? extends AnnotationMirror> typeMirrors = entry.element().asType().getAnnotationMirrors().stream();
+        Stream<? extends AnnotationMirror> elementMirrors = entry.element().getAnnotationMirrors().stream();
+        return Stream.concat(typeMirrors, elementMirrors)
+                .anyMatch(mirror -> pattern.matcher(mirror.getAnnotationType().asElement().getSimpleName().toString()).matches());
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/ProcessorUtil.java

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import javax.lang.model.type.TypeMirror;
+import java.util.stream.Stream;
+
+class ProcessorUtil {
+    private ProcessorUtil() {
+    }
+
+    static boolean isNotHandledByOthers(Class<? extends RecordBuilderEnhancer> enhancer, Processor processor, Entry entry, TypeMirror... types)
+    {
+        if (!processor.hasEnhancer(enhancer)) {
+            return true;
+        }
+        if (types == null) {
+            return true;
+        }
+        return Stream.of(types).noneMatch(type -> processor.types().isAssignable(entry.erasedType(), type));
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/RequireNonNull.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+import static io.soabase.recordbuilder.enhancer.enhancers.ProcessorUtil.isNotHandledByOthers;
+
+public class RequireNonNull
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror optionalType = processor.elements().getTypeElement("java.util.Optional").asType();
+        TypeMirror stringType = processor.elements().getTypeElement("java.lang.String").asType();
+        TypeMirror collectionType = processor.elements().getTypeElement("java.util.Collection").asType();
+        TypeMirror listType = processor.elements().getTypeElement("java.util.List").asType();
+        TypeMirror mapType = processor.elements().getTypeElement("java.util.Map").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element)
+                .stream()
+                .filter(entry -> !entry.erasedType().getKind().isPrimitive())
+                .filter(entry -> isNotHandledByOthers(EmptyNullOptional.class, processor, entry, optionalType))
+                .filter(entry -> isNotHandledByOthers(EmptyNullString.class, processor, entry, stringType))
+                .filter(entry -> isNotHandledByOthers(CopyCollectionNullableEmpty.class, processor, entry, collectionType, listType, mapType))
+                .filter(entry -> isNotHandledByOthers(CopyCollection.class, processor, entry, collectionType, listType, mapType))
+                .filter(entry -> isNotHandledByOthers(GuavaCopyCollectionNullableEmpty.class, processor, entry, collectionType, listType, mapType))
+                .filter(entry -> isNotHandledByOthers(GuavaCopyCollection.class, processor, entry, collectionType, listType, mapType))
+                .forEach(entry -> enhance(insnList, entry));
+        return insnList;
+    }
+
+    static void enhance(InsnList insnList, Entry entry) {
+        // java.util.Objects.requireNonNull(var1, "<name> is null");
+                    /*
+                        ALOAD 1
+                        LDC "X is null"
+                        INVOKESTATIC java/util/Objects.requireNonNull (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+                        POP
+                    */
+        insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+        insnList.add(new LdcInsnNode("%s is null".formatted(entry.element().getSimpleName())));
+        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/Objects", "requireNonNull", "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;"));
+        insnList.add(new InsnNode(Opcodes.POP));
+    }
+}

record-builder-enhancer/src/main/resources/safe/com.sun.source.util.Plugin

@@ -0,0 +1 @@
+io.soabase.recordbuilder.enhancer.RecordBuilderEnhancerPlugin

record-builder-processor/pom.xml

@@ -3,12 +3,16 @@
     <parent>
         <groupId>io.soabase.record-builder</groupId>
         <artifactId>record-builder</artifactId>
-        <version>1.7.ea</version>
+        <version>34-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>record-builder-processor</artifactId>
 
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>com.squareup</groupId>
@@ -28,9 +32,6 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
                     <proc>none</proc>
-                    <source>14</source>
-                    <target>14</target>
-                    <compilerArgs>--enable-preview</compilerArgs>
                 </configuration>
             </plugin>
         </plugins>

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/CollectionBuilderUtils.java

@@ -0,0 +1,228 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import com.squareup.javapoet.*;
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.lang.model.element.Modifier;
+import java.util.*;
+
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordBuilderAnnotation;
+
+class CollectionBuilderUtils {
+    private final boolean useImmutableCollections;
+    private final boolean addSingleItemCollectionBuilders;
+    private final String listShimName;
+    private final String mapShimName;
+    private final String setShimName;
+    private final String collectionShimName;
+
+    private boolean needsListShim;
+    private boolean needsMapShim;
+    private boolean needsSetShim;
+    private boolean needsCollectionShim;
+
+    private static final TypeName listType = TypeName.get(List.class);
+    private static final TypeName mapType = TypeName.get(Map.class);
+    private static final TypeName setType = TypeName.get(Set.class);
+    private static final TypeName collectionType = TypeName.get(Collection.class);
+
+    private static final TypeVariableName tType = TypeVariableName.get("T");
+    private static final TypeVariableName kType = TypeVariableName.get("K");
+    private static final TypeVariableName vType = TypeVariableName.get("V");
+    private static final ParameterizedTypeName parameterizedListType = ParameterizedTypeName.get(ClassName.get(List.class), tType);
+    private static final ParameterizedTypeName parameterizedMapType = ParameterizedTypeName.get(ClassName.get(Map.class), kType, vType);
+    private static final ParameterizedTypeName parameterizedSetType = ParameterizedTypeName.get(ClassName.get(Set.class), tType);
+    private static final ParameterizedTypeName parameterizedCollectionType = ParameterizedTypeName.get(ClassName.get(Collection.class), tType);
+
+    CollectionBuilderUtils(List<RecordClassType> recordComponents, RecordBuilder.Options metaData) {
+        useImmutableCollections = metaData.useImmutableCollections();
+        addSingleItemCollectionBuilders = metaData.addSingleItemCollectionBuilders();
+
+        listShimName = adjustShimName(recordComponents, "__list", 0);
+        mapShimName = adjustShimName(recordComponents, "__map", 0);
+        setShimName = adjustShimName(recordComponents, "__set", 0);
+        collectionShimName = adjustShimName(recordComponents, "__collection", 0);
+    }
+
+    enum SingleItemsMetaDataMode {
+        STANDARD,
+        STANDARD_FOR_SETTER,
+        EXCLUDE_WILDCARD_TYPES
+    }
+
+    record SingleItemsMetaData(Class<?> singleItemCollectionClass, List<TypeName> typeArguments, TypeName wildType) {}
+
+    Optional<SingleItemsMetaData> singleItemsMetaData(RecordClassType component, SingleItemsMetaDataMode mode) {
+        if (addSingleItemCollectionBuilders && (component.typeName() instanceof ParameterizedTypeName parameterizedTypeName)) {
+            Class<?> collectionClass = null;
+            ClassName wildcardClass = null;
+            int typeArgumentQty = 0;
+            if (isList(component)) {
+                collectionClass = ArrayList.class;
+                wildcardClass = ClassName.get(Collection.class);
+                typeArgumentQty = 1;
+            } else if (isSet(component)) {
+                collectionClass = HashSet.class;
+                wildcardClass = ClassName.get(Collection.class);
+                typeArgumentQty = 1;
+            } else if (isMap(component)) {
+                collectionClass = HashMap.class;
+                wildcardClass = (ClassName) component.rawTypeName();
+                typeArgumentQty = 2;
+            }
+            var hasWildcardTypeArguments = hasWildcardTypeArguments(parameterizedTypeName, typeArgumentQty);
+            if (collectionClass != null) {
+                return switch (mode) {
+                    case STANDARD -> singleItemsMetaDataWithWildType(parameterizedTypeName, collectionClass, wildcardClass, typeArgumentQty);
+
+                    case STANDARD_FOR_SETTER -> {
+                        if (hasWildcardTypeArguments) {
+                            yield Optional.of(new SingleItemsMetaData(collectionClass, parameterizedTypeName.typeArguments, component.typeName()));
+                        }
+                        yield singleItemsMetaDataWithWildType(parameterizedTypeName, collectionClass, wildcardClass, typeArgumentQty);
+                    }
+
+                    case EXCLUDE_WILDCARD_TYPES -> {
+                        if (hasWildcardTypeArguments) {
+                            yield Optional.empty();
+                        }
+                        yield singleItemsMetaDataWithWildType(parameterizedTypeName, collectionClass, wildcardClass, typeArgumentQty);
+                    }
+                };
+            }
+        }
+        return Optional.empty();
+    }
+
+    boolean isImmutableCollection(RecordClassType component) {
+        return useImmutableCollections && (isList(component) || isMap(component) || isSet(component) || component.rawTypeName().equals(collectionType));
+    }
+
+    boolean isList(RecordClassType component) {
+        return component.rawTypeName().equals(listType);
+    }
+
+    boolean isMap(RecordClassType component) {
+        return component.rawTypeName().equals(mapType);
+    }
+
+    boolean isSet(RecordClassType component) {
+        return component.rawTypeName().equals(setType);
+    }
+
+    void add(CodeBlock.Builder builder, RecordClassType component) {
+        if (useImmutableCollections) {
+            if (isList(component)) {
+                needsListShim = true;
+                builder.add("$L($L)", listShimName, component.name());
+            } else if (isMap(component)) {
+                needsMapShim = true;
+                builder.add("$L($L)", mapShimName, component.name());
+            } else if (isSet(component)) {
+                needsSetShim = true;
+                builder.add("$L($L)", setShimName, component.name());
+            } else if (component.rawTypeName().equals(collectionType)) {
+                needsCollectionShim = true;
+                builder.add("$L($L)", collectionShimName, component.name());
+            } else {
+                builder.add("$L", component.name());
+            }
+        } else {
+            builder.add("$L", component.name());
+        }
+    }
+
+    void addShims(TypeSpec.Builder builder) {
+        if (!useImmutableCollections) {
+            return;
+        }
+
+        if (needsListShim) {
+            builder.addMethod(buildMethod(listShimName, listType, parameterizedListType, tType));
+        }
+        if (needsSetShim) {
+            builder.addMethod(buildMethod(setShimName, setType, parameterizedSetType, tType));
+        }
+        if (needsMapShim) {
+            builder.addMethod(buildMethod(mapShimName, mapType, parameterizedMapType, kType, vType));
+        }
+        if (needsCollectionShim) {
+            builder.addMethod(buildCollectionsMethod());
+        }
+    }
+
+    private Optional<SingleItemsMetaData> singleItemsMetaDataWithWildType(ParameterizedTypeName parameterizedTypeName, Class<?> collectionClass, ClassName wildcardClass, int typeArgumentQty) {
+        TypeName wildType;
+        if (typeArgumentQty == 1) {
+            wildType = ParameterizedTypeName.get(wildcardClass, WildcardTypeName.subtypeOf(parameterizedTypeName.typeArguments.get(0)));
+        } else { // if (typeArgumentQty == 2)
+            wildType = ParameterizedTypeName.get(wildcardClass, WildcardTypeName.subtypeOf(parameterizedTypeName.typeArguments.get(0)), WildcardTypeName.subtypeOf(parameterizedTypeName.typeArguments.get(1)));
+        }
+        return Optional.of(new SingleItemsMetaData(collectionClass, parameterizedTypeName.typeArguments, wildType));
+    }
+
+    private boolean hasWildcardTypeArguments(ParameterizedTypeName parameterizedTypeName, int argumentCount) {
+        for (int i = 0; i < argumentCount; ++i) {
+            if (parameterizedTypeName.typeArguments.size() > i) {
+                if (parameterizedTypeName.typeArguments.get(i) instanceof WildcardTypeName) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private String adjustShimName(List<RecordClassType> recordComponents, String baseName, int index) {
+        var name = (index == 0) ? baseName : (baseName + index);
+        if (recordComponents.stream().anyMatch(component -> component.name().equals(name))) {
+            return adjustShimName(recordComponents, baseName, index + 1);
+        }
+        return name;
+    }
+
+    private MethodSpec buildMethod(String name, TypeName mainType, ParameterizedTypeName parameterizedType, TypeVariableName... typeVariables) {
+        var code = CodeBlock.of("return (o != null) ? $T.copyOf(o) : $T.of()", mainType, mainType);
+        return MethodSpec.methodBuilder(name)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+                .addTypeVariables(Arrays.asList(typeVariables))
+                .returns(parameterizedType)
+                .addParameter(parameterizedType, "o")
+                .addStatement(code)
+                .build();
+    }
+
+    private MethodSpec buildCollectionsMethod() {
+        var code = CodeBlock.builder()
+                .add("if (o instanceof Set) {\n")
+                .indent()
+                .addStatement("return $T.copyOf(o)", setType)
+                .unindent()
+                .addStatement("}")
+                .addStatement("return (o != null) ? $T.copyOf(o) : $T.of()", listType, listType)
+                .build();
+        return MethodSpec.methodBuilder(collectionShimName)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+                .addTypeVariable(tType)
+                .returns(parameterizedCollectionType)
+                .addParameter(parameterizedCollectionType, "o")
+                .addCode(code)
+                .build();
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/ElementUtils.java

@@ -19,15 +19,72 @@ import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.ParameterizedTypeName;
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeVariableName;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-
+import io.soabase.recordbuilder.core.RecordBuilder;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.RecordComponentElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 public class ElementUtils {
+    public static Optional<? extends AnnotationMirror> findAnnotationMirror(ProcessingEnvironment processingEnv, Element element, String annotationClass) {
+        return processingEnv.getElementUtils().getAllAnnotationMirrors(element).stream()
+            .filter(e -> e.getAnnotationType().toString().equals(annotationClass))
+            .findFirst();
+    }
+
+    public static Optional<? extends AnnotationValue> getAnnotationValue(Map<? extends ExecutableElement, ? extends AnnotationValue> values, String name) {
+        return values.entrySet()
+            .stream()
+            .filter(e -> e.getKey().getSimpleName().toString().equals(name))
+            .map(Map.Entry::getValue)
+            .findFirst();
+    }
+
+    @SuppressWarnings("unchecked")
+    public static List<TypeMirror> getAttributeTypeMirrorList(AnnotationValue attribute)
+    {
+        List<? extends AnnotationValue> values = (attribute != null) ? (List<? extends AnnotationValue>)attribute.getValue() : Collections.emptyList();
+        return values.stream().map(v -> (TypeMirror)v.getValue()).collect(Collectors.toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static List<String> getAttributeStringList(AnnotationValue attribute)
+    {
+        List<? extends AnnotationValue> values = (attribute != null) ? (List<? extends AnnotationValue>)attribute.getValue() : Collections.emptyList();
+        return values.stream().map(v -> (String)v.getValue()).collect(Collectors.toList());
+    }
+
+    public static boolean getBooleanAttribute(AnnotationValue attribute)
+    {
+        Object value = (attribute != null) ? attribute.getValue() : null;
+        if ( value != null )
+        {
+            return Boolean.parseBoolean(String.valueOf(value));
+        }
+        return false;
+    }
+
+    public static String getStringAttribute(AnnotationValue attribute, String defaultValue)
+    {
+        Object value = (attribute != null) ? attribute.getValue() : null;
+        if ( value != null )
+        {
+            return String.valueOf(value);
+        }
+        return defaultValue;
+    }
+
     public static String getPackageName(TypeElement typeElement) {
         while (typeElement.getNestingKind().isNested()) {
             Element enclosingElement = typeElement.getEnclosingElement();
@@ -37,8 +94,9 @@ public class ElementUtils {
                 break;
             }
         }
-        String name = typeElement.getEnclosingElement().toString();
-        return !name.equals("unnamed package") ? name : "";
+        String name = typeElement.getQualifiedName().toString();
+        int index = name.lastIndexOf(".");
+        return (index > -1) ? name.substring(0, index) : "";
     }
 
     public static ClassType getClassType(String packageName, String simpleName, List<? extends TypeParameterElement> typeParameters) {
@@ -57,16 +115,43 @@ public class ElementUtils {
         return new ClassType(ParameterizedTypeName.get(builderClassName, typeNames), builderClassName.simpleName());
     }
 
-    public static ClassType getClassType(RecordComponentElement recordComponent) {
-        return new ClassType(TypeName.get(recordComponent.asType()), recordComponent.getSimpleName().toString());
+    public static RecordClassType getRecordClassType(ProcessingEnvironment processingEnv, RecordComponentElement recordComponent, List<? extends AnnotationMirror> accessorAnnotations, List<? extends AnnotationMirror> canonicalConstructorAnnotations) {
+        var typeName = TypeName.get(recordComponent.asType());
+        var rawTypeName = TypeName.get(processingEnv.getTypeUtils().erasure(recordComponent.asType()));
+        return new RecordClassType(typeName, rawTypeName, recordComponent.getSimpleName().toString(), accessorAnnotations, canonicalConstructorAnnotations);
     }
 
-    public static String getBuilderName(TypeElement element, RecordBuilderMetaData metaData, ClassType classType, String suffix) {
+    public static String getWithMethodName(ClassType component, String prefix) {
+        var name = component.name();
+        if (name.length() == 1) {
+            return prefix + name.toUpperCase();
+        }
+        return prefix + Character.toUpperCase(name.charAt(0)) + name.substring(1);
+    }
+
+    public static String getBuilderName(TypeElement element, RecordBuilder.Options metaData, ClassType classType, String suffix) {
         // generate the class name
         var baseName = classType.name() + suffix;
         return metaData.prefixEnclosingClassNames() ? (getBuilderNamePrefix(element.getEnclosingElement()) + baseName) : baseName;
     }
 
+    public static Optional<? extends Element> findCanonicalConstructor(TypeElement record) {
+        if ( record.getKind() != ElementKind.RECORD ) {
+            return Optional.empty();
+        }
+
+        // based on https://github.com/openjdk/jdk/pull/3556/files#diff-a6270f4b50989abe733607c69038b2036306d13f77276af005d023b7fc57f1a2R2368
+        var componentList = record.getRecordComponents().stream().map(e -> e.asType().toString()).collect(Collectors.toList());
+        return record.getEnclosedElements().stream()
+            .filter(element -> element.getKind() == ElementKind.CONSTRUCTOR)
+            .filter(element -> {
+                var parameters = ((ExecutableElement)element).getParameters();
+                var parametersList = parameters.stream().map(e -> e.asType().toString()).collect(Collectors.toList());
+                return componentList.equals(parametersList);
+            })
+            .findFirst();
+    }
+
     private static String getBuilderNamePrefix(Element element) {
         // prefix enclosing class names if nested in a class
         if (element instanceof TypeElement) {

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/IncludeHelper.java

@@ -0,0 +1,96 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.*;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.Diagnostic;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+class IncludeHelper {
+    private final boolean isValid;
+    private final List<TypeElement> classTypeElements;
+    private final Map<? extends ExecutableElement, ? extends AnnotationValue> annotationValues;
+
+    IncludeHelper(ProcessingEnvironment processingEnv, Element element, AnnotationMirror annotationMirror, boolean packagesSupported) {
+        annotationValues = processingEnv.getElementUtils().getElementValuesWithDefaults(annotationMirror);
+        var value = ElementUtils.getAnnotationValue(annotationValues, "value");
+        var classes = ElementUtils.getAnnotationValue(annotationValues, "classes");
+        var packages = ElementUtils.getAnnotationValue(annotationValues, "packages");
+        var isValid = true;
+        var classTypeElements = new ArrayList<TypeElement>();
+        if (value.isPresent() || classes.isPresent() || packages.isPresent()) {
+            var valueList = value.map(ElementUtils::getAttributeTypeMirrorList).orElseGet(List::of);
+            var classesList = classes.map(ElementUtils::getAttributeTypeMirrorList).orElseGet(List::of);
+            var packagesList = packages.map(ElementUtils::getAttributeStringList).orElseGet(List::of);
+            if (valueList.isEmpty() && classesList.isEmpty() && packagesList.isEmpty()) {
+                if (packagesSupported) {
+                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "At least one of \"value\", \"classes\" or \"packages\" required", element);
+                } else {
+                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "At least one of \"value\" or \"classes\" required", element);
+                }
+                isValid = false;
+            }
+            isValid = processList(processingEnv, isValid, element, valueList, classTypeElements);
+            isValid = processList(processingEnv, isValid, element, classesList, classTypeElements);
+            packages.ifPresent(annotationValue -> processPackages(processingEnv, classTypeElements, packagesList));
+        } else {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not read attribute for annotation", element);
+            isValid = false;
+        }
+        this.isValid = isValid;
+        this.classTypeElements = List.copyOf(classTypeElements);
+    }
+
+    Map<? extends ExecutableElement, ? extends AnnotationValue> getAnnotationValues() {
+        return annotationValues;
+    }
+
+    boolean isValid() {
+        return isValid;
+    }
+
+    List<TypeElement> getClassTypeElements() {
+        return classTypeElements;
+    }
+
+    private boolean processList(ProcessingEnvironment processingEnv, boolean isValid, Element element, List<TypeMirror> list, ArrayList<TypeElement> classTypeElements) {
+        for (var typeMirror : list) {
+            TypeElement typeElement = (TypeElement) processingEnv.getTypeUtils().asElement(typeMirror);
+            if (typeElement == null) {
+                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not get element for: " + typeMirror, element);
+                isValid = false;
+            } else {
+                classTypeElements.add(typeElement);
+            }
+        }
+        return isValid;
+    }
+
+    private void processPackages(ProcessingEnvironment processingEnv, List<TypeElement> classTypeElements, List<String> packagesList) {
+        for (var packageName : packagesList) {
+            var packageElement = processingEnv.getElementUtils().getPackageElement(packageName);
+            for (var child : packageElement.getEnclosedElements()) {
+                if (child.getKind() == ElementKind.RECORD) {
+                    classTypeElements.add((TypeElement) child);
+                }
+            }
+        }
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordBuilderProcessor.java

@@ -15,49 +15,85 @@
  */
 package io.soabase.recordbuilder.processor;
 
-import com.squareup.javapoet.*;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
+import static io.soabase.recordbuilder.processor.CollectionBuilderUtils.SingleItemsMetaDataMode.EXCLUDE_WILDCARD_TYPES;
+import static io.soabase.recordbuilder.processor.CollectionBuilderUtils.SingleItemsMetaDataMode.STANDARD;
+import static io.soabase.recordbuilder.processor.CollectionBuilderUtils.SingleItemsMetaDataMode.STANDARD_FOR_SETTER;
+import static io.soabase.recordbuilder.processor.ElementUtils.getBuilderName;
+import static io.soabase.recordbuilder.processor.ElementUtils.getWithMethodName;
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordBuilderAnnotation;
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.recordBuilderGeneratedAnnotation;
 
-import javax.lang.model.element.Element;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import java.util.AbstractMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.*;
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import static io.soabase.recordbuilder.processor.ElementUtils.getBuilderName;
-import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordBuilderAnnotation;
+import com.squareup.javapoet.*;
+import io.soabase.recordbuilder.core.RecordBuilder;
 
 class InternalRecordBuilderProcessor {
-    private final RecordBuilderMetaData metaData;
+    private final RecordBuilder.Options metaData;
     private final ClassType recordClassType;
     private final String packageName;
     private final ClassType builderClassType;
     private final List<TypeVariableName> typeVariables;
-    private final List<ClassType> recordComponents;
+    private final List<RecordClassType> recordComponents;
     private final TypeSpec builderType;
     private final TypeSpec.Builder builder;
+    private final String uniqueVarName;
+    private final Pattern notNullPattern;
+    private final CollectionBuilderUtils collectionBuilderUtils;
 
-    InternalRecordBuilderProcessor(TypeElement record, RecordBuilderMetaData metaData) {
+    private static final TypeName overrideType = TypeName.get(Override.class);
+    private static final TypeName validType = ClassName.get("javax.validation", "Valid");
+    private static final TypeName validatorTypeName = ClassName.get("io.soabase.recordbuilder.validator", "RecordBuilderValidator");
+    private static final TypeVariableName rType = TypeVariableName.get("R");
+    private final ProcessingEnvironment processingEnv;
+
+    InternalRecordBuilderProcessor(ProcessingEnvironment processingEnv, TypeElement record, RecordBuilder.Options metaData, Optional<String> packageNameOpt) {
+        this.processingEnv = processingEnv;
+        var recordActualPackage = ElementUtils.getPackageName(record);
         this.metaData = metaData;
         recordClassType = ElementUtils.getClassType(record, record.getTypeParameters());
-        packageName = ElementUtils.getPackageName(record);
+        packageName = packageNameOpt.orElse(recordActualPackage);
         builderClassType = ElementUtils.getClassType(packageName, getBuilderName(record, metaData, recordClassType, metaData.suffix()), record.getTypeParameters());
         typeVariables = record.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList());
-        recordComponents = record.getRecordComponents().stream().map(ElementUtils::getClassType).collect(Collectors.toList());
+        recordComponents = buildRecordComponents(record);
+        uniqueVarName = getUniqueVarName();
+        notNullPattern = Pattern.compile(metaData.interpretNotNullsPattern());
+        collectionBuilderUtils = new CollectionBuilderUtils(recordComponents, this.metaData);
 
         builder = TypeSpec.classBuilder(builderClassType.name())
-                .addModifiers(Modifier.PUBLIC)
                 .addAnnotation(generatedRecordBuilderAnnotation)
                 .addTypeVariables(typeVariables);
+        if (metaData.addClassRetainedGenerated()) {
+            builder.addAnnotation(recordBuilderGeneratedAnnotation);
+        }
+        addVisibility(recordActualPackage.equals(packageName), record.getModifiers());
+        if (metaData.enableWither()) {
+            addWithNestedClass();
+        }
+        if (!metaData.beanClassName().isEmpty()) {
+            addBeanNestedClass();
+        }
         addDefaultConstructor();
-        addAllArgsConstructor();
+        if (metaData.addStaticBuilder()) {
+            addStaticBuilder();
+        }
+        if (recordComponents.size() > 0) {
+            addAllArgsConstructor();
+        }
         addStaticDefaultBuilderMethod();
         addStaticCopyBuilderMethod();
+        if (metaData.enableWither()) {
+            addStaticFromWithMethod();
+        }
         addStaticComponentsMethod();
         addBuildMethod();
         addToStringMethod();
@@ -66,8 +102,16 @@ class InternalRecordBuilderProcessor {
         recordComponents.forEach(component -> {
             add1Field(component);
             add1SetterMethod(component);
-            add1GetterMethod(component);
+            if (metaData.enableGetters()) {
+                add1GetterMethod(component);
+            }
+            if (metaData.addConcreteSettersForOptional()) {
+                add1ConcreteOptionalSetterMethod(component);
+            }
+            var collectionMetaData = collectionBuilderUtils.singleItemsMetaData(component, EXCLUDE_WILDCARD_TYPES);
+            collectionMetaData.ifPresent(meta -> add1CollectionBuilders(meta, component));
         });
+        collectionBuilderUtils.addShims(builder);
         builderType = builder.build();
     }
 
@@ -83,6 +127,219 @@ class InternalRecordBuilderProcessor {
         return builderType;
     }
 
+    private void addVisibility(boolean builderIsInRecordPackage, Set<Modifier> modifiers) {
+        if (builderIsInRecordPackage) {
+            if (modifiers.contains(Modifier.PUBLIC) || modifiers.contains(Modifier.PRIVATE) || modifiers.contains(Modifier.PROTECTED)) {
+                builder.addModifiers(Modifier.PUBLIC);  // builders are top level classes - can only be public or package-private
+            }
+            // is package-private
+        } else {
+            builder.addModifiers(Modifier.PUBLIC);
+        }
+    }
+
+    private List<RecordClassType> buildRecordComponents(TypeElement record) {
+        var accessorAnnotations = record.getRecordComponents().stream().map(e -> e.getAccessor().getAnnotationMirrors()).collect(Collectors.toList());
+        var canonicalConstructorAnnotations = ElementUtils.findCanonicalConstructor(record).map(constructor -> ((ExecutableElement) constructor).getParameters().stream().map(Element::getAnnotationMirrors).collect(Collectors.toList())).orElse(List.of());
+        var recordComponents = record.getRecordComponents();
+        return IntStream.range(0, recordComponents.size())
+                .mapToObj(index -> {
+                    var thisAccessorAnnotations = (accessorAnnotations.size() > index) ? accessorAnnotations.get(index) : List.<AnnotationMirror>of();
+                    var thisCanonicalConstructorAnnotations = (canonicalConstructorAnnotations.size() > index) ? canonicalConstructorAnnotations.get(index) : List.<AnnotationMirror>of();
+                    return ElementUtils.getRecordClassType(processingEnv, recordComponents.get(index), thisAccessorAnnotations, thisCanonicalConstructorAnnotations);
+                })
+                .collect(Collectors.toList());
+    }
+
+    private void addWithNestedClass() {
+        /*
+            Adds a nested interface that adds withers similar to:
+
+            public class MyRecordBuilder {
+                public interface With {
+                    // with methods
+                }
+            }
+         */
+        var classBuilder = TypeSpec.interfaceBuilder(metaData.withClassName())
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addJavadoc("Add withers to {@code $L}\n", recordClassType.name())
+                .addModifiers(Modifier.PUBLIC)
+                .addTypeVariables(typeVariables);
+        if (metaData.addClassRetainedGenerated()) {
+            classBuilder.addAnnotation(recordBuilderGeneratedAnnotation);
+        }
+        recordComponents.forEach(component -> addNestedGetterMethod(classBuilder, component, prefixedName(component, true)));
+        addWithBuilderMethod(classBuilder);
+        addWithSuppliedBuilderMethod(classBuilder);
+        IntStream.range(0, recordComponents.size()).forEach(index -> add1WithMethod(classBuilder, recordComponents.get(index), index));
+        if (metaData.addFunctionalMethodsToWith()) {
+            classBuilder.addType(buildFunctionalInterface("Function", true))
+                    .addType(buildFunctionalInterface("Consumer", false))
+                    .addMethod(buildFunctionalHandler("Function", "map", true))
+                    .addMethod(buildFunctionalHandler("Consumer", "accept", false));
+        }
+        builder.addType(classBuilder.build());
+    }
+
+    private void addBeanNestedClass() {
+        /*
+            Adds a nested interface that adds getters similar to:
+
+            public class MyRecordBuilder {
+                public interface Bean {
+                    // getter methods
+                }
+            }
+         */
+        var classBuilder = TypeSpec.interfaceBuilder(metaData.beanClassName())
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addJavadoc("Add getters to {@code $L}\n", recordClassType.name())
+                .addModifiers(Modifier.PUBLIC)
+                .addTypeVariables(typeVariables);
+        recordComponents.forEach(component -> {
+            if (prefixedName(component, true).equals(component.name())) {
+                return;
+            }
+            addNestedGetterMethod(classBuilder, component, component.name());
+            add1PrefixedGetterMethod(classBuilder, component);
+        });
+        builder.addType(classBuilder.build());
+    }
+
+    private void addWithSuppliedBuilderMethod(TypeSpec.Builder classBuilder) {
+        /*
+            Adds a method that returns a pre-filled copy builder similar to:
+
+            default MyRecord with(Consumer<MyRecordBuilder> consumer) {
+                MyRecordBuilder builder = with();
+                consumer.accept(builder);
+                return builder.build();
+            }
+         */
+        var codeBlockBuilder = CodeBlock.builder()
+                .add("$T builder = with();\n", builderClassType.typeName())
+                .add("consumer.accept(builder);\n")
+                .add("return builder.build();\n");
+        var consumerType = ParameterizedTypeName.get(ClassName.get(Consumer.class), builderClassType.typeName());
+        var parameter = ParameterSpec.builder(consumerType, "consumer").build();
+        var methodSpec = MethodSpec.methodBuilder(metaData.withClassMethodPrefix())
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addJavadoc("Return a new record built from the builder passed to the given consumer")
+                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+                .addParameter(parameter)
+                .returns(recordClassType.typeName())
+                .addCode(codeBlockBuilder.build())
+                .build();
+        classBuilder.addMethod(methodSpec);
+    }
+
+    private void addWithBuilderMethod(TypeSpec.Builder classBuilder) {
+        /*
+            Adds a method that returns a pre-filled copy builder similar to:
+
+            default MyRecordBuilder with() {
+                return MyRecordBuilder.builder(r);
+            }
+         */
+        var codeBlockBuilder = CodeBlock.builder()
+                .add("return new $L$L(", builderClassType.name(), typeVariables.isEmpty() ? "" : "<>");
+        addComponentCallsAsArguments(-1, codeBlockBuilder);
+        codeBlockBuilder.add(");");
+        var methodSpec = MethodSpec.methodBuilder(metaData.withClassMethodPrefix())
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addJavadoc("Return a new record builder using the current values")
+                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+                .returns(builderClassType.typeName())
+                .addCode(codeBlockBuilder.build())
+                .build();
+        classBuilder.addMethod(methodSpec);
+    }
+
+    private String getUniqueVarName() {
+        return getUniqueVarName("");
+    }
+
+    private String getUniqueVarName(String prefix) {
+        var name = prefix + "r";
+        var alreadyExists = recordComponents.stream()
+                .map(ClassType::name)
+                .anyMatch(n -> n.equals(name));
+        return alreadyExists ? getUniqueVarName(prefix + "_") : name;
+    }
+
+    private void add1WithMethod(TypeSpec.Builder classBuilder, RecordClassType component, int index) {
+        /*
+            Adds a with method for the component similar to:
+
+            default MyRecord withName(String name) {
+                return new MyRecord(name, r.age());
+            }
+         */
+        var codeBlockBuilder = CodeBlock.builder();
+        addNullCheckCodeBlock(codeBlockBuilder, index);
+        codeBlockBuilder.add("$[return ");
+        if (metaData.useValidationApi()) {
+            codeBlockBuilder.add("$T.validate(", validatorTypeName);
+        }
+        codeBlockBuilder.add("new $T(", recordClassType.typeName());
+        addComponentCallsAsArguments(index, codeBlockBuilder);
+        codeBlockBuilder.add(")");
+        if (metaData.useValidationApi()) {
+            codeBlockBuilder.add(")");
+        }
+        codeBlockBuilder.add(";$]");
+
+        var methodName = getWithMethodName(component, metaData.withClassMethodPrefix());
+        var parameterSpecBuilder = ParameterSpec.builder(component.typeName(), component.name());
+        addConstructorAnnotations(component, parameterSpecBuilder);
+        var methodSpec = MethodSpec.methodBuilder(methodName)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addJavadoc("Return a new instance of {@code $L} with a new value for {@code $L}\n", recordClassType.name(), component.name())
+                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+                .addParameter(parameterSpecBuilder.build())
+                .addCode(codeBlockBuilder.build())
+                .returns(recordClassType.typeName())
+                .build();
+        classBuilder.addMethod(methodSpec);
+    }
+
+    private void add1PrefixedGetterMethod(TypeSpec.Builder classBuilder, RecordClassType component) {
+        /*
+            Adds a get method for the component similar to:
+
+            default MyRecord getName() {
+                return name();
+            }
+         */
+        var codeBlockBuilder = CodeBlock.builder();
+        codeBlockBuilder.add("$[return $L()$];", component.name());
+
+        var methodName = prefixedName(component, true);
+        var methodSpec = MethodSpec.methodBuilder(methodName)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addJavadoc("Returns the value of {@code $L}\n", component.name())
+                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+                .addCode(codeBlockBuilder.build())
+                .returns(component.typeName())
+                .build();
+        classBuilder.addMethod(methodSpec);
+    }
+
+    private void addComponentCallsAsArguments(int index, CodeBlock.Builder codeBlockBuilder) {
+        IntStream.range(0, recordComponents.size()).forEach(parameterIndex -> {
+            if (parameterIndex > 0) {
+                codeBlockBuilder.add(", ");
+            }
+            RecordClassType parameterComponent = recordComponents.get(parameterIndex);
+            if (parameterIndex == index) {
+                collectionBuilderUtils.add(codeBlockBuilder, parameterComponent);
+            } else {
+                codeBlockBuilder.add("$L()", prefixedName(parameterComponent, true));
+            }
+        });
+    }
+
     private void addDefaultConstructor() {
         /*
             Adds a default constructor similar to:
@@ -97,6 +354,54 @@ class InternalRecordBuilderProcessor {
         builder.addMethod(constructor);
     }
 
+    private void addStaticBuilder() {
+        /*
+            Adds an static builder similar to:
+
+            public static MyRecord(int p1, T p2, ...) {
+                return new MyRecord(p1, p2, ...);
+            }
+         */
+        CodeBlock codeBlock = buildCodeBlock();
+        var builder = MethodSpec.methodBuilder(recordClassType.name())
+                .addJavadoc("Static constructor/builder. Can be used instead of new $L(...)\n", recordClassType.name())
+                .addTypeVariables(typeVariables)
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .returns(recordClassType.typeName())
+                .addCode(codeBlock);
+        recordComponents.forEach(component -> {
+            var parameterSpecBuilder = ParameterSpec.builder(component.typeName(), component.name());
+            addConstructorAnnotations(component, parameterSpecBuilder);
+            builder.addParameter(parameterSpecBuilder.build());
+        });
+        this.builder.addMethod(builder.build());
+    }
+
+    private void addNullCheckCodeBlock(CodeBlock.Builder builder) {
+        if (metaData.interpretNotNulls()) {
+            for (int i = 0; i < recordComponents.size(); ++i) {
+                addNullCheckCodeBlock(builder, i);
+            }
+        }
+    }
+
+    private void addNullCheckCodeBlock(CodeBlock.Builder builder, int index) {
+        if (metaData.interpretNotNulls()) {
+            var component = recordComponents.get(index);
+            if (!collectionBuilderUtils.isImmutableCollection(component)) {
+                if (!component.typeName().isPrimitive() && isNullAnnotated(component)) {
+                    builder.addStatement("$T.requireNonNull($L, $S)", Objects.class, component.name(), component.name() + " is required");
+                }
+            }
+        }
+    }
+
+    private boolean isNullAnnotated(RecordClassType component) {
+        return component.getCanonicalConstructorAnnotations().stream()
+                .anyMatch(annotation -> notNullPattern.matcher(annotation.getAnnotationType().asElement().getSimpleName().toString()).matches());
+    }
+
     private void addAllArgsConstructor() {
         /*
             Adds an all-args constructor similar to:
@@ -112,8 +417,9 @@ class InternalRecordBuilderProcessor {
                 .addAnnotation(generatedRecordBuilderAnnotation);
         recordComponents.forEach(component -> {
             constructorBuilder.addParameter(component.typeName(), component.name());
-            var codeBuilder = CodeBlock.builder().add("this.$L = $L", component.name(), component.name());
-            constructorBuilder.addStatement(codeBuilder.build());
+            var collectionMetaData = collectionBuilderUtils.singleItemsMetaData(component, STANDARD);
+            collectionMetaData.ifPresentOrElse(meta -> constructorBuilder.addStatement("this.$L = new $T<>($L)", component.name(), meta.singleItemCollectionClass(), component.name()),
+                    () -> constructorBuilder.addStatement("this.$L = $L", component.name(), component.name()));
         });
         builder.addMethod(constructorBuilder.build());
     }
@@ -188,13 +494,18 @@ class InternalRecordBuilderProcessor {
          */
         var codeBuilder = CodeBlock.builder();
         codeBuilder.add("return (this == o) || (");
-        codeBuilder.add("(o instanceof $L b)", builderClassType.name());
+        if (typeVariables.isEmpty()) {
+            codeBuilder.add("(o instanceof $L $L)", builderClassType.name(), uniqueVarName);
+        } else {
+            String wildcardList = typeVariables.stream().map(__ -> "?").collect(Collectors.joining(","));
+            codeBuilder.add("(o instanceof $L<$L> $L)", builderClassType.name(), wildcardList, uniqueVarName);
+        }
         recordComponents.forEach(recordComponent -> {
             String name = recordComponent.name();
             if (recordComponent.typeName().isPrimitive()) {
-                codeBuilder.add("\n&& ($L == b.$L)", name, name);
+                codeBuilder.add("\n&& ($L == $L.$L)", name, uniqueVarName, name);
             } else {
-                codeBuilder.add("\n&& $T.equals($L, b.$L)", Objects.class, name, name);
+                codeBuilder.add("\n&& $T.equals($L, $L.$L)", Objects.class, name, uniqueVarName, name);
             }
         });
         codeBuilder.add(")");
@@ -218,7 +529,39 @@ class InternalRecordBuilderProcessor {
                 return new MyRecord(p1, p2, ...);
             }
          */
-        var codeBuilder = CodeBlock.builder().add("return new $T(", recordClassType.typeName());
+        CodeBlock codeBlock = buildCodeBlock();
+        var methodSpec = MethodSpec.methodBuilder(metaData.buildMethodName())
+                .addJavadoc("Return a new record instance with all fields set to the current values in this builder\n")
+                .addModifiers(Modifier.PUBLIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .returns(recordClassType.typeName())
+                .addCode(codeBlock)
+                .build();
+        builder.addMethod(methodSpec);
+    }
+
+    private CodeBlock buildCodeBlock() {
+        /*
+            Builds the code block for allocating the record from its parts
+        */
+
+        var codeBuilder = CodeBlock.builder();
+
+        IntStream.range(0, recordComponents.size()).forEach(index -> {
+            var recordComponent = recordComponents.get(index);
+            if (collectionBuilderUtils.isImmutableCollection(recordComponent)) {
+                codeBuilder.add("$[$L = ", recordComponent.name());
+                collectionBuilderUtils.add(codeBuilder, recordComponents.get(index));
+                codeBuilder.add(";\n$]");
+            }
+        });
+
+        addNullCheckCodeBlock(codeBuilder);
+        codeBuilder.add("$[return ");
+        if (metaData.useValidationApi()) {
+            codeBuilder.add("$T.validate(", validatorTypeName);
+        }
+        codeBuilder.add("new $T(", recordClassType.typeName());
         IntStream.range(0, recordComponents.size()).forEach(index -> {
             if (index > 0) {
                 codeBuilder.add(", ");
@@ -226,13 +569,92 @@ class InternalRecordBuilderProcessor {
             codeBuilder.add("$L", recordComponents.get(index).name());
         });
         codeBuilder.add(")");
+        if (metaData.useValidationApi()) {
+            codeBuilder.add(")");
+        }
+        codeBuilder.add(";$]");
+        return codeBuilder.build();
+    }
 
-        var methodSpec = MethodSpec.methodBuilder(metaData.buildMethodName())
-                .addJavadoc("Return a new record instance with all fields set to the current values in this builder\n")
-                .addModifiers(Modifier.PUBLIC)
+    private TypeName buildWithTypeName()
+    {
+        ClassName rawTypeName = ClassName.get(packageName, builderClassType.name() + "." + metaData.withClassName());
+        if (typeVariables.isEmpty()) {
+            return rawTypeName;
+        }
+        return ParameterizedTypeName.get(rawTypeName, typeVariables.toArray(new TypeName[]{}));
+    }
+
+    private void addFromWithClass() {
+        /*
+            Adds static private class that implements/proxies the Wither
+
+            private static final class _FromWith implements MyRecordBuilder.With {
+                private final MyRecord from;
+
+                @Override
+                public String p1() {
+                    return from.p1();
+                }
+
+                @Override
+                public String p2() {
+                    return from.p2();
+                }
+            }
+         */
+
+        var fromWithClassBuilder = TypeSpec.classBuilder(metaData.fromWithClassName())
+                .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
                 .addAnnotation(generatedRecordBuilderAnnotation)
-                .returns(recordClassType.typeName())
-                .addStatement(codeBuilder.build())
+                .addTypeVariables(typeVariables)
+                .addSuperinterface(buildWithTypeName());
+        if (metaData.addClassRetainedGenerated()) {
+            fromWithClassBuilder.addAnnotation(recordBuilderGeneratedAnnotation);
+        }
+
+        fromWithClassBuilder.addField(recordClassType.typeName(), "from", Modifier.PRIVATE, Modifier.FINAL);
+        MethodSpec constructorSpec = MethodSpec.constructorBuilder()
+                .addParameter(recordClassType.typeName(), "from")
+                .addStatement("this.from = from")
+                .addModifiers(Modifier.PRIVATE)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .build();
+        fromWithClassBuilder.addMethod(constructorSpec);
+
+        IntStream.range(0, recordComponents.size()).forEach(index -> {
+            var component = recordComponents.get(index);
+            MethodSpec methodSpec = MethodSpec.methodBuilder(prefixedName(component, true))
+                    .returns(component.typeName())
+                    .addAnnotation(Override.class)
+                    .addModifiers(Modifier.PUBLIC)
+                    .addStatement("return from.$L()", component.name())
+                    .addAnnotation(generatedRecordBuilderAnnotation)
+                    .build();
+            fromWithClassBuilder.addMethod(methodSpec);
+        });
+        this.builder.addType(fromWithClassBuilder.build());
+    }
+
+    private void addStaticFromWithMethod() {
+        /*
+            Adds static method that returns a "with"er view of an existing record.
+
+            public static With from(MyRecord from) {
+                return new _FromWith(from);
+            }
+         */
+
+        addFromWithClass();
+
+        var methodSpec = MethodSpec.methodBuilder(metaData.fromMethodName())
+                .addJavadoc("Return a \"with\"er for an existing record instance\n")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addTypeVariables(typeVariables)
+                .addParameter(recordClassType.typeName(), metaData.fromMethodName())
+                .returns(buildWithTypeName())
+                .addStatement("return new $L$L(from)", metaData.fromWithClassName(), typeVariables.isEmpty() ? "" : "<>")
                 .build();
         builder.addMethod(methodSpec);
     }
@@ -290,10 +712,8 @@ class InternalRecordBuilderProcessor {
             Adds a static method that converts a record instance into a stream of its component parts
 
             public static Stream<Map.Entry<String, Object>> stream(MyRecord record) {
-                return Stream.of(
-                    new AbstractMap.SimpleEntry<>("p1", record.p1()),
-                    new AbstractMap.SimpleEntry<>("p2", record.p2())
-                );
+                return Stream.of(new AbstractMap.SimpleImmutableEntry<>("p1", record.p1()),
+                         new AbstractMap.SimpleImmutableEntry<>("p2", record.p2()));
             }
          */
         var codeBuilder = CodeBlock.builder().add("return $T.of(", Stream.class);
@@ -302,7 +722,7 @@ class InternalRecordBuilderProcessor {
                 codeBuilder.add(",\n ");
             }
             var name = recordComponents.get(index).name();
-            codeBuilder.add("new $T<>($S, record.$L())", AbstractMap.SimpleEntry.class, name, name);
+            codeBuilder.add("new $T<>($S, record.$L())", AbstractMap.SimpleImmutableEntry.class, name, name);
         });
         codeBuilder.add(")");
         var mapEntryTypeVariables = ParameterizedTypeName.get(Map.Entry.class, String.class, Object.class);
@@ -325,11 +745,187 @@ class InternalRecordBuilderProcessor {
 
             private T p;
          */
-        var fieldSpec = FieldSpec.builder(component.typeName(), component.name(), Modifier.PRIVATE).build();
-        builder.addField(fieldSpec);
+        var fieldSpecBuilder = FieldSpec.builder(component.typeName(), component.name(), Modifier.PRIVATE);
+        if (metaData.emptyDefaultForOptional()) {
+            Optional<OptionalType> thisOptionalType = OptionalType.fromClassType(component);
+            if (thisOptionalType.isPresent()) {
+                var codeBlock = CodeBlock.builder()
+                        .add("$T.empty()", thisOptionalType.get().typeName())
+                        .build();
+                fieldSpecBuilder.initializer(codeBlock);
+            }
+        }
+        builder.addField(fieldSpecBuilder.build());
     }
 
-    private void add1GetterMethod(ClassType component) {
+    private void addNestedGetterMethod(TypeSpec.Builder classBuilder, RecordClassType component, String methodName) {
+        /*
+            For a single record component, add a getter similar to:
+
+            T p();
+         */
+        var methodSpecBuilder = MethodSpec.methodBuilder(methodName)
+                .addJavadoc("Return the current value for the {@code $L} record component in the builder\n", component.name())
+                .addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .returns(component.typeName());
+        addAccessorAnnotations(component, methodSpecBuilder, this::filterOutValid);
+        classBuilder.addMethod(methodSpecBuilder.build());
+    }
+
+    private boolean filterOutOverride(AnnotationSpec annotationSpec) {
+        return !annotationSpec.type.equals(overrideType);
+    }
+
+    private boolean filterOutValid(AnnotationSpec annotationSpec) {
+        return !annotationSpec.type.equals(validType);
+    }
+
+    private void addConstructorAnnotations(RecordClassType component, ParameterSpec.Builder parameterSpecBuilder) {
+        if (metaData.inheritComponentAnnotations()) {
+            component.getCanonicalConstructorAnnotations()
+                    .stream()
+                    .map(AnnotationSpec::get)
+                    .filter(this::filterOutOverride)
+                    .forEach(parameterSpecBuilder::addAnnotation);
+        }
+    }
+
+    private void addAccessorAnnotations(RecordClassType component, MethodSpec.Builder methodSpecBuilder, Predicate<AnnotationSpec> additionalFilter) {
+        if (metaData.inheritComponentAnnotations()) {
+            component.getAccessorAnnotations()
+                    .stream()
+                    .map(AnnotationSpec::get)
+                    .filter(this::filterOutOverride)
+                    .filter(additionalFilter)
+                    .forEach(methodSpecBuilder::addAnnotation);
+        }
+    }
+
+    private String capitalize(String s) {
+        return (s.length() < 2) ? s.toUpperCase(Locale.ROOT) : (Character.toUpperCase(s.charAt(0)) + s.substring(1));
+    }
+
+    private void add1CollectionBuilders(CollectionBuilderUtils.SingleItemsMetaData meta, RecordClassType component) {
+        if (collectionBuilderUtils.isList(component) || collectionBuilderUtils.isSet(component)) {
+            add1ListBuilder(meta, component);
+        } else if (collectionBuilderUtils.isMap(component)) {
+            add1MapBuilder(meta, component);
+        }
+    }
+
+    private void add1MapBuilder(CollectionBuilderUtils.SingleItemsMetaData meta, RecordClassType component) {
+        /*
+            For a single map record component, add a methods similar to:
+
+            public T addP(K key, V value) {
+                if (this.p == null) {
+                    this.p = new HashMap<>();
+                }
+                this.p.put(key, value);
+                return this;
+            }
+
+            public T addP(Stream<? extends Map.Entry<K, V> i) {
+                if (p == null) {
+                    p = new HashMap<>();
+                }
+                i.forEach(this.p::put);
+                return this;
+            }
+
+            public T addP(Iterable<? extends Map.Entry<K, V> i) {
+                if (p == null) {
+                    p = new HashMap<>();
+                }
+                i.forEach(this.p::put);
+                return this;
+            }
+         */
+        for (var i = 0; i < 3; ++i) {
+            var codeBlockBuilder = CodeBlock.builder()
+                    .beginControlFlow("if (this.$L == null)", component.name())
+                    .addStatement("this.$L = new $T<>()", component.name(), HashMap.class)
+                    .endControlFlow();
+            var methodSpecBuilder = MethodSpec.methodBuilder(metaData.singleItemBuilderPrefix() + capitalize(component.name()))
+                    .addJavadoc("Add to the internally allocated {@code HashMap} for {@code $L}\n", component.name())
+                    .addModifiers(Modifier.PUBLIC)
+                    .addAnnotation(generatedRecordBuilderAnnotation)
+                    .returns(builderClassType.typeName());
+            if (i == 0) {
+                methodSpecBuilder.addParameter(meta.typeArguments().get(0), "key");
+                methodSpecBuilder.addParameter(meta.typeArguments().get(1), "value");
+                codeBlockBuilder.addStatement("this.$L.put(key, value)", component.name());
+            } else {
+                var parameterClass = ClassName.get((i == 1) ? Stream.class : Iterable.class);
+                var entryType = ParameterizedTypeName.get(ClassName.get(Map.Entry.class), WildcardTypeName.subtypeOf(meta.typeArguments().get(0)), WildcardTypeName.subtypeOf(meta.typeArguments().get(1)));
+                ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(parameterClass, WildcardTypeName.subtypeOf(entryType));
+                methodSpecBuilder.addParameter(parameterizedTypeName, "i");
+                codeBlockBuilder.addStatement("i.forEach(entry -> this.$L.put(entry.getKey(), entry.getValue()))", component.name());
+            }
+            codeBlockBuilder.addStatement("return this");
+            methodSpecBuilder.addCode(codeBlockBuilder.build());
+            builder.addMethod(methodSpecBuilder.build());
+        }
+    }
+
+    private void add1ListBuilder(CollectionBuilderUtils.SingleItemsMetaData meta, RecordClassType component) {
+        /*
+            For a single list or set record component, add methods similar to:
+
+            public T addP(I i) {
+                if (this.p == null) {
+                    this.p = new ArrayList<>();
+                }
+                this.p.add(i);
+                return this;
+            }
+
+            public T addP(Stream<? extends I> i) {
+                if (this.p == null) {
+                    this.p = new ArrayList<>();
+                }
+                this.p.addAll(i);
+                return this;
+            }
+
+            public T addP(Iterable<? extends I> i) {
+                if (this.p == null) {
+                    this.p = new ArrayList<>();
+                }
+                this.p.addAll(i);
+                return this;
+            }
+         */
+        for (var i = 0; i < 3; ++i) {
+            var addClockBlock = CodeBlock.builder();
+            TypeName parameter;
+            if (i == 0) {
+                addClockBlock.addStatement("this.$L.add(i)", component.name());
+                parameter = meta.typeArguments().get(0);
+            } else {
+                addClockBlock.addStatement("i.forEach(this.$L::add)", component.name());
+                var parameterClass = ClassName.get((i == 1) ? Stream.class : Iterable.class);
+                parameter = ParameterizedTypeName.get(parameterClass, WildcardTypeName.subtypeOf(meta.typeArguments().get(0)));
+            }
+            var codeBlockBuilder = CodeBlock.builder()
+                    .beginControlFlow("if (this.$L == null)", component.name())
+                    .addStatement("this.$L = new $T<>()", component.name(), meta.singleItemCollectionClass())
+                    .endControlFlow()
+                    .add(addClockBlock.build())
+                    .addStatement("return this");
+            var methodSpecBuilder = MethodSpec.methodBuilder(metaData.singleItemBuilderPrefix() + capitalize(component.name()))
+                    .addJavadoc("Add to the internally allocated {@code $L} for {@code $L}\n", meta.singleItemCollectionClass().getSimpleName(), component.name())
+                    .addModifiers(Modifier.PUBLIC)
+                    .addAnnotation(generatedRecordBuilderAnnotation)
+                    .returns(builderClassType.typeName())
+                    .addParameter(parameter, "i")
+                    .addCode(codeBlockBuilder.build());
+            builder.addMethod(methodSpecBuilder.build());
+        }
+    }
+
+    private void add1GetterMethod(RecordClassType component) {
         /*
             For a single record component, add a getter similar to:
 
@@ -337,17 +933,17 @@ class InternalRecordBuilderProcessor {
                 return p;
             }
          */
-        var methodSpec = MethodSpec.methodBuilder(component.name())
+        var methodSpecBuilder = MethodSpec.methodBuilder(prefixedName(component, true))
                 .addJavadoc("Return the current value for the {@code $L} record component in the builder\n", component.name())
                 .addModifiers(Modifier.PUBLIC)
                 .addAnnotation(generatedRecordBuilderAnnotation)
                 .returns(component.typeName())
-                .addStatement("return $L", component.name())
-                .build();
-        builder.addMethod(methodSpec);
+                .addStatement("return $L", component.name());
+        addAccessorAnnotations(component, methodSpecBuilder, __ -> true);
+        builder.addMethod(methodSpecBuilder.build());
     }
 
-    private void add1SetterMethod(ClassType component) {
+    private void add1SetterMethod(RecordClassType component) {
         /*
             For a single record component, add a setter similar to:
 
@@ -356,16 +952,140 @@ class InternalRecordBuilderProcessor {
                 return this;
             }
          */
-        var parameterSpec = ParameterSpec.builder(component.typeName(), component.name()).build();
-        var methodSpec = MethodSpec.methodBuilder(component.name())
-                .addJavadoc("Set a new value for the {@code $L} record component in the builder\n", component.name())
+        var methodSpec = MethodSpec.methodBuilder(prefixedName(component, false))
                 .addModifiers(Modifier.PUBLIC)
                 .addAnnotation(generatedRecordBuilderAnnotation)
-                .addParameter(parameterSpec)
-                .returns(builderClassType.typeName())
-                .addStatement("this.$L = $L", component.name(), component.name())
-                .addStatement("return this")
+                .returns(builderClassType.typeName());
+
+        var collectionMetaData = collectionBuilderUtils.singleItemsMetaData(component, STANDARD_FOR_SETTER);
+        var parameterSpecBuilder = collectionMetaData.map(meta -> {
+            CodeBlock.Builder codeSpec = CodeBlock.builder();
+            codeSpec.addStatement("this.$L = ($L != null) ? new $T<>($L) : null", component.name(), component.name(), meta.singleItemCollectionClass(), component.name());
+            methodSpec.addJavadoc("Re-create the internally allocated {@code $L} for {@code $L} by copying the argument\n", meta.singleItemCollectionClass().getSimpleName(), component.name())
+                    .addCode(codeSpec.build());
+            return ParameterSpec.builder(meta.wildType(), component.name());
+        }).orElseGet(() -> {
+            methodSpec.addJavadoc("Set a new value for the {@code $L} record component in the builder\n", component.name())
+                    .addStatement("this.$L = $L", component.name(), component.name());
+            return ParameterSpec.builder(component.typeName(), component.name());
+        });
+        addConstructorAnnotations(component, parameterSpecBuilder);
+        methodSpec.addStatement("return this").addParameter(parameterSpecBuilder.build());
+        builder.addMethod(methodSpec.build());
+    }
+
+    private void add1ConcreteOptionalSetterMethod(RecordClassType component) {
+         /*
+            For a single optional record component, add a concrete setter similar to:
+
+            public MyRecordBuilder p(T p) {
+                this.p = p;
+                return this;
+            }
+         */
+        var optionalType = OptionalType.fromClassType(component);
+        if (optionalType.isEmpty()) {
+            return;
+        }
+        var type = optionalType.get();
+        var methodSpec = MethodSpec.methodBuilder(prefixedName(component, false))
+                .addModifiers(Modifier.PUBLIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .returns(builderClassType.typeName());
+
+        var parameterSpecBuilder = ParameterSpec.builder(type.valueType(), component.name());
+        methodSpec.addJavadoc("Set a new value for the {@code $L} record component in the builder\n", component.name())
+                .addStatement(getOptionalStatement(type), component.name(), type.typeName(), component.name());
+        addConstructorAnnotations(component, parameterSpecBuilder);
+        methodSpec.addStatement("return this").addParameter(parameterSpecBuilder.build());
+        builder.addMethod(methodSpec.build());
+    }
+
+    private String getOptionalStatement(OptionalType type) {
+
+        if(type.isOptional()) {
+            return "this.$L = $T.ofNullable($L)";
+        }
+
+        return "this.$L = $T.of($L)";
+    }
+
+    private List<TypeVariableName> typeVariablesWithReturn() {
+        var variables = new ArrayList<TypeVariableName>();
+        variables.add(rType);
+        variables.addAll(typeVariables);
+        return variables;
+    }
+
+    private MethodSpec buildFunctionalHandler(String className, String methodName, boolean isMap) {
+        /*
+            Build a Functional handler ala:
+
+            default <R> R map(Function<R, T> proc) {
+                return proc.apply(p());
+            }
+        */
+        var localTypeVariables = isMap ? typeVariablesWithReturn() : typeVariables;
+        var typeName = localTypeVariables.isEmpty() ? ClassName.get("", className) : ParameterizedTypeName.get(ClassName.get("", className), localTypeVariables.toArray(TypeName[]::new));
+        var methodBuilder = MethodSpec.methodBuilder(methodName)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+                .addParameter(typeName, "proc");
+        var codeBlockBuilder = CodeBlock.builder();
+        if (isMap) {
+            methodBuilder.addJavadoc("Map record components into a new object");
+            methodBuilder.addTypeVariable(rType);
+            methodBuilder.returns(rType);
+            codeBlockBuilder.add("return ");
+        } else {
+            methodBuilder.addJavadoc("Perform an operation on record components");
+        }
+        codeBlockBuilder.add("proc.apply(");
+        addComponentCallsAsArguments(-1, codeBlockBuilder);
+        codeBlockBuilder.add(");");
+        methodBuilder.addCode(codeBlockBuilder.build());
+        return methodBuilder.build();
+    }
+
+    private TypeSpec buildFunctionalInterface(String className, boolean isMap) {
+        /*
+            Build a Functional interface ala:
+
+            @FunctionalInterface
+            interface Function<R, T> {
+                R apply(T a);
+            }
+        */
+        var localTypeVariables = isMap ? typeVariablesWithReturn() : typeVariables;
+        var methodBuilder = MethodSpec.methodBuilder("apply").addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT);
+        recordComponents.forEach(component -> {
+            var parameterSpecBuilder = ParameterSpec.builder(component.typeName(), component.name());
+            addConstructorAnnotations(component, parameterSpecBuilder);
+            methodBuilder.addParameter(parameterSpecBuilder.build());
+        });
+        if (isMap) {
+            methodBuilder.returns(rType);
+        }
+        return TypeSpec.interfaceBuilder(className)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addAnnotation(FunctionalInterface.class)
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+                .addTypeVariables(localTypeVariables)
+                .addMethod(methodBuilder.build())
                 .build();
-        builder.addMethod(methodSpec);
+    }
+
+    private String prefixedName(RecordClassType component, boolean isGetter) {
+        BiFunction<String, String, String> prefixer = (p, s) -> p.isEmpty()
+                ? s : p + Character.toUpperCase(s.charAt(0)) + s.substring(1);
+        boolean isBool = component.typeName().toString().toLowerCase(Locale.ROOT).equals("boolean");
+        if (isGetter) {
+            if (isBool) {
+                return prefixer.apply(metaData.booleanPrefix(), component.name());
+            }
+            return prefixer.apply(metaData.getterPrefix(), component.name());
+        }
+        return prefixer.apply(metaData.setterPrefix(), component.name());
     }
 }
+

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordInterfaceProcessor.java

@@ -16,10 +16,8 @@
 package io.soabase.recordbuilder.processor;
 
 import com.squareup.javapoet.*;
-import io.soabase.recordbuilder.core.RecordBuilder;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-import io.soabase.recordbuilder.core.RecordInterface;
 import io.soabase.recordbuilder.core.IgnoreDefaultMethod;
+import io.soabase.recordbuilder.core.RecordBuilder;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.ElementKind;
@@ -35,20 +33,27 @@ import java.util.stream.Collectors;
 
 import static io.soabase.recordbuilder.processor.ElementUtils.getBuilderName;
 import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordInterfaceAnnotation;
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.recordBuilderGeneratedAnnotation;
 
 class InternalRecordInterfaceProcessor {
     private final ProcessingEnvironment processingEnv;
     private final String packageName;
     private final TypeSpec recordType;
-    private final List<ExecutableElement> recordComponents;
+    private final List<Component> recordComponents;
     private final TypeElement iface;
     private final ClassType recordClassType;
+    private final List<String> alternateMethods;
 
     private static final String FAKE_METHOD_NAME = "__FAKE__";
 
-    InternalRecordInterfaceProcessor(ProcessingEnvironment processingEnv, TypeElement iface, RecordInterface recordInterface, RecordBuilderMetaData metaData) {
+    private static final Set<String> javaBeanPrefixes = Set.of("get", "is");
+
+    private record Component(ExecutableElement element, Optional<String> alternateName) {
+    }
+
+    InternalRecordInterfaceProcessor(ProcessingEnvironment processingEnv, TypeElement iface, boolean addRecordBuilder, RecordBuilder.Options metaData, Optional<String> packageNameOpt, boolean fromTemplate) {
         this.processingEnv = processingEnv;
-        packageName = ElementUtils.getPackageName(iface);
+        packageName = packageNameOpt.orElseGet(() -> ElementUtils.getPackageName(iface));
         recordComponents = getRecordComponents(iface);
         this.iface = iface;
 
@@ -64,16 +69,30 @@ class InternalRecordInterfaceProcessor {
                 .addModifiers(Modifier.PUBLIC)
                 .addAnnotation(generatedRecordInterfaceAnnotation)
                 .addTypeVariables(typeVariables);
-
-        if (recordInterface.addRecordBuilder()) {
-            builder.addAnnotation(RecordBuilder.class);
+        if (metaData.addClassRetainedGenerated()) {
+            builder.addAnnotation(recordBuilderGeneratedAnnotation);
         }
 
+        if (addRecordBuilder) {
+            ClassType builderClassType = ElementUtils.getClassType(packageName, getBuilderName(iface, metaData, recordClassType, metaData.suffix()) + "." + metaData.withClassName(), iface.getTypeParameters());
+            builder.addAnnotation(RecordBuilder.class);
+            builder.addSuperinterface(builderClassType.typeName());
+            if (fromTemplate) {
+                builder.addAnnotation(AnnotationSpec.get(metaData));
+            } else {
+                var options = iface.getAnnotation(RecordBuilder.Options.class);
+                if (options != null) {
+                    builder.addAnnotation(AnnotationSpec.get(options));
+                }
+            }
+        }
+
+        alternateMethods = buildAlternateMethods(recordComponents);
+
         recordType = builder.build();
     }
 
-    boolean isValid()
-    {
+    boolean isValid() {
         return !recordComponents.isEmpty();
     }
 
@@ -89,8 +108,7 @@ class InternalRecordInterfaceProcessor {
         return recordClassType;
     }
 
-    String toRecord(String classSource)
-    {
+    String toRecord(String classSource) {
         // javapoet does yet support records - so a class was created and we can reshape it
         // The class will look something like this:
         /*
@@ -116,22 +134,42 @@ class InternalRecordInterfaceProcessor {
         String declaration = matcher.group(1).trim().replace("class", "record");
         String implementsSection = matcher.group(2).trim();
         String argumentList = matcher.group(5).trim();
-        return declaration + argumentList + " " + implementsSection + " {}";
+
+        StringBuilder fixedRecord = new StringBuilder(declaration).append(argumentList).append(' ').append(implementsSection).append(" {");
+        alternateMethods.forEach(method -> fixedRecord.append('\n').append(method));
+        fixedRecord.append('}');
+        return fixedRecord.toString();
     }
 
-    private MethodSpec generateArgumentList()
-    {
+    private MethodSpec generateArgumentList() {
         MethodSpec.Builder builder = MethodSpec.methodBuilder(FAKE_METHOD_NAME);
-        recordComponents.forEach(element -> {
-            ParameterSpec parameterSpec = ParameterSpec.builder(ClassName.get(element.getReturnType()), element.getSimpleName().toString()).build();
-            builder.addTypeVariables(element.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()));
+        recordComponents.forEach(component -> {
+            String name = component.alternateName.orElseGet(() -> component.element.getSimpleName().toString());
+            ParameterSpec parameterSpec = ParameterSpec.builder(ClassName.get(component.element.getReturnType()), name).build();
+            builder.addTypeVariables(component.element.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()));
             builder.addParameter(parameterSpec);
         });
         return builder.build();
     }
 
-    private List<ExecutableElement> getRecordComponents(TypeElement iface) {
-        List<ExecutableElement> components = new ArrayList<>();
+    private List<String> buildAlternateMethods(List<Component> recordComponents) {
+        return recordComponents.stream()
+                .filter(component -> component.alternateName.isPresent())
+                .map(component -> {
+                    var method = MethodSpec.methodBuilder(component.element.getSimpleName().toString())
+                            .addAnnotation(Override.class)
+                            .addAnnotation(generatedRecordInterfaceAnnotation)
+                            .returns(ClassName.get(component.element.getReturnType()))
+                            .addModifiers(Modifier.PUBLIC)
+                            .addCode("return $L();", component.alternateName.get())
+                            .build();
+                    return method.toString();
+                })
+                .collect(Collectors.toList());
+    }
+
+    private List<Component> getRecordComponents(TypeElement iface) {
+        List<Component> components = new ArrayList<>();
         try {
             getRecordComponents(iface, components, new HashSet<>(), new HashSet<>());
             if (components.isEmpty()) {
@@ -144,14 +182,14 @@ class InternalRecordInterfaceProcessor {
         return components;
     }
 
-    private static class IllegalInterface extends RuntimeException
-    {
+    private static class IllegalInterface extends RuntimeException {
         public IllegalInterface(String message) {
             super(message);
         }
+
     }
 
-    private void getRecordComponents(TypeElement iface, Collection<? super ExecutableElement> components, Set<String> visitedSet, Set<String> usedNames) {
+    private void getRecordComponents(TypeElement iface, Collection<Component> components, Set<String> visitedSet, Set<String> usedNames) {
         if (!visitedSet.add(iface.getQualifiedName().toString())) {
             return;
         }
@@ -174,10 +212,21 @@ class InternalRecordInterfaceProcessor {
                     }
                 })
                 .filter(element -> usedNames.add(element.getSimpleName().toString()))
+                .map(element -> new Component(element, stripBeanPrefix(element.getSimpleName().toString())))
                 .collect(Collectors.toCollection(() -> components));
         iface.getInterfaces().forEach(parentIface -> {
             TypeElement parentIfaceElement = (TypeElement) processingEnv.getTypeUtils().asElement(parentIface);
             getRecordComponents(parentIfaceElement, components, visitedSet, usedNames);
         });
     }
+
+    private Optional<String> stripBeanPrefix(String name) {
+        return javaBeanPrefixes.stream()
+                .filter(prefix -> name.startsWith(prefix) && (name.length() > prefix.length()))
+                .findFirst()
+                .map(prefix -> {
+                    var stripped = name.substring(prefix.length());
+                    return Character.toLowerCase(stripped.charAt(0)) + stripped.substring(1);
+                });
+    }
 }

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/OptionBasedRecordBuilderMetaData.java

@@ -1,140 +0,0 @@
-/**
- * Copyright 2019 Jordan Zimmerman
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.soabase.recordbuilder.processor;
-
-import java.util.Map;
-
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-
-public class OptionBasedRecordBuilderMetaData implements RecordBuilderMetaData {
-    /**
-     * @see #suffix()
-     */
-    public static final String OPTION_SUFFIX = "suffix";
-
-    /**
-     * @see #interfaceSuffix()
-     */
-    public static final String OPTION_INTERFACE_SUFFIX = "interfaceSuffix";
-
-    /**
-     * @see #copyMethodName()
-     */
-    public static final String OPTION_COPY_METHOD_NAME = "copyMethodName";
-
-    /**
-     * @see #builderMethodName()
-     */
-    public static final String OPTION_BUILDER_METHOD_NAME = "builderMethodName";
-
-    /**
-     * @see #buildMethodName()
-     */
-    public static final String OPTION_BUILD_METHOD_NAME = "buildMethodName";
-
-    /**
-     * @see #componentsMethodName()
-     */
-    public static final String OPTION_COMPONENTS_METHOD_NAME = "componentsMethodName";
-
-    /**
-     * @see #fileComment()
-     */
-    public static final String OPTION_FILE_COMMENT = "fileComment";
-
-    /**
-     * @see #fileIndent()
-     */
-    public static final String OPTION_FILE_INDENT = "fileIndent";
-
-    /**
-     * @see #prefixEnclosingClassNames()
-     */
-    public static final String OPTION_PREFIX_ENCLOSING_CLASS_NAMES = "prefixEnclosingClassNames";
-
-    private final String suffix;
-    private final String interfaceSuffix;
-    private final String copyMethodName;
-    private final String builderMethodName;
-    private final String buildMethodName;
-    private final String componentsMethodName;
-    private final String fileComment;
-    private final String fileIndent;
-    private final boolean prefixEnclosingClassNames;
-
-    public OptionBasedRecordBuilderMetaData(Map<String, String> options) {
-        suffix = options.getOrDefault(OPTION_SUFFIX, "Builder");
-        interfaceSuffix = options.getOrDefault(OPTION_INTERFACE_SUFFIX, "Record");
-        builderMethodName = options.getOrDefault(OPTION_BUILDER_METHOD_NAME, "builder");
-        copyMethodName = options.getOrDefault(OPTION_COPY_METHOD_NAME, builderMethodName);
-        buildMethodName = options.getOrDefault(OPTION_BUILD_METHOD_NAME, "build");
-        componentsMethodName = options.getOrDefault(OPTION_COMPONENTS_METHOD_NAME, "stream");
-        fileComment = options.getOrDefault(OPTION_FILE_COMMENT,
-                "Auto generated by io.soabase.recordbuilder.core.RecordBuilder: https://github.com/Randgalt/record-builder");
-        fileIndent = options.getOrDefault(OPTION_FILE_INDENT, "    ");
-        String prefixenclosingclassnamesopt = options.get(OPTION_PREFIX_ENCLOSING_CLASS_NAMES);
-        if (prefixenclosingclassnamesopt == null) {
-            prefixEnclosingClassNames = true;
-        } else {
-            prefixEnclosingClassNames = Boolean.parseBoolean(prefixenclosingclassnamesopt);
-        }
-    }
-
-    @Override
-    public String suffix() {
-        return suffix;
-    }
-
-    @Override
-    public String copyMethodName() {
-        return copyMethodName;
-    }
-
-    @Override
-    public String builderMethodName() {
-        return builderMethodName;
-    }
-
-    @Override
-    public String buildMethodName() {
-        return buildMethodName;
-    }
-
-    @Override
-    public String componentsMethodName() {
-        return componentsMethodName;
-    }
-
-    @Override
-    public String fileComment() {
-        return fileComment;
-    }
-
-    @Override
-    public String fileIndent() {
-        return fileIndent;
-    }
-
-    @Override
-    public boolean prefixEnclosingClassNames() {
-        return prefixEnclosingClassNames;
-    }
-
-    @Override
-    public String interfaceSuffix() {
-        return interfaceSuffix;
-    }
-}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/OptionalType.java

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+
+public record OptionalType(TypeName typeName, TypeName valueType) {
+
+    private static final TypeName optionalType = TypeName.get(Optional.class);
+    private static final TypeName optionalIntType = TypeName.get(OptionalInt.class);
+    private static final TypeName optionalLongType = TypeName.get(OptionalLong.class);
+    private static final TypeName optionalDoubleType = TypeName.get(OptionalDouble.class);
+
+    private static boolean isOptional(ClassType component) {
+        if (component.typeName().equals(optionalType)) {
+            return true;
+        }
+        return (component.typeName() instanceof ParameterizedTypeName parameterizedTypeName)
+                && parameterizedTypeName.rawType.equals(optionalType);
+    }
+
+    static Optional<OptionalType> fromClassType(final ClassType component) {
+        if (isOptional(component)) {
+            if (!(component.typeName() instanceof ParameterizedTypeName parameterizedType)) {
+                return Optional.of(new OptionalType(optionalType, TypeName.get(Object.class)));
+            }
+            final TypeName containingType = parameterizedType.typeArguments.isEmpty()
+                    ? TypeName.get(Object.class)
+                    : parameterizedType.typeArguments.get(0);
+            return Optional.of(new OptionalType(optionalType, containingType));
+        }
+        if (component.typeName().equals(optionalIntType)) {
+            return Optional.of(new OptionalType(optionalIntType, TypeName.get(int.class)));
+        }
+        if (component.typeName().equals(optionalLongType)) {
+            return Optional.of(new OptionalType(optionalLongType, TypeName.get(long.class)));
+        }
+        if (component.typeName().equals(optionalDoubleType)) {
+            return Optional.of(new OptionalType(optionalDoubleType, TypeName.get(double.class)));
+        }
+        return Optional.empty();
+    }
+
+    public boolean isOptional() {
+        return typeName.equals(optionalType);
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderMetaDataLoader.java

@@ -1,53 +0,0 @@
-/**
- * Copyright 2019 Jordan Zimmerman
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.soabase.recordbuilder.processor;
-
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.Map;
-import java.util.function.Consumer;
-
-import javax.annotation.processing.ProcessingEnvironment;
-
-class RecordBuilderMetaDataLoader {
-    private final RecordBuilderMetaData metaData;
-
-    RecordBuilderMetaDataLoader(ProcessingEnvironment processingEnv, Consumer<String> logger) {
-        Map<String, String> options = processingEnv.getOptions();
-        String metaDataClassName = options.get(RecordBuilderMetaData.JAVAC_OPTION_NAME);
-        if ((metaDataClassName != null) && !metaDataClassName.isEmpty()) {
-            RecordBuilderMetaData loadedMetaData = null;
-            try {
-                Class<?> clazz = Class.forName(metaDataClassName);
-                loadedMetaData = (RecordBuilderMetaData) clazz.getDeclaredConstructor().newInstance();
-                logger.accept("Found meta data: " + clazz);
-            } catch (InvocationTargetException e) {
-                // log the thrown exception instead of the invocation target exception
-                logger.accept("Could not load meta data: " + metaDataClassName + " - " + e.getCause());
-            } catch (Exception e) {
-                logger.accept("Could not load meta data: " + metaDataClassName + " - " + e);
-            }
-            metaData = (loadedMetaData != null) ? loadedMetaData : RecordBuilderMetaData.DEFAULT;
-        } else {
-            metaData = new OptionBasedRecordBuilderMetaData(options);
-        }
-    }
-
-    RecordBuilderMetaData getMetaData() {
-        return metaData;
-    }
-}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderOptions.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.HashMap;
+import java.util.Map;
+
+class RecordBuilderOptions {
+    private static final Map<String, Object> defaultValues = buildDefaultValues();
+
+    static RecordBuilder.Options build(Map<String, String> options) {
+        return (RecordBuilder.Options)Proxy.newProxyInstance(RecordBuilderOptions.class.getClassLoader(), new Class[]{RecordBuilder.Options.class}, (proxy, method, args) -> {
+            var name = method.getName();
+            var defaultValue = defaultValues.get(name);
+            var option = options.get(name);
+            if (option != null) {
+                if (defaultValue instanceof String) {
+                    return option;
+                }
+                if (defaultValue instanceof Boolean) {
+                    return Boolean.parseBoolean(option);
+                }
+                if (defaultValue instanceof Integer) {
+                    return Integer.parseInt(option);
+                }
+                if (defaultValue instanceof Long) {
+                    return Long.parseLong(option);
+                }
+                if (defaultValue instanceof Double) {
+                    return Double.parseDouble(option);
+                }
+                throw new IllegalArgumentException("Unhandled option type: " + defaultValue.getClass());
+            }
+            return defaultValue;
+        });
+    }
+
+    private static Map<String, Object> buildDefaultValues() {
+        var workMap = new HashMap<String, Object>();
+        for ( Method method : RecordBuilder.Options.class.getDeclaredMethods()) {
+            workMap.put(method.getName(), method.getDefaultValue());
+        }
+        workMap.put("toString", "Generated RecordBuilder.Options");
+        return Map.copyOf(workMap);
+    }
+
+    private RecordBuilderOptions() {
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderProcessor.java

@@ -18,39 +18,48 @@ package io.soabase.recordbuilder.processor;
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.JavaFile;
 import com.squareup.javapoet.TypeSpec;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordBuilderGenerated;
 import io.soabase.recordbuilder.core.RecordInterface;
 
-import javax.annotation.processing.*;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.Generated;
+import javax.annotation.processing.RoundEnvironment;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.PackageElement;
 import javax.lang.model.element.TypeElement;
 import javax.tools.Diagnostic;
 import javax.tools.JavaFileObject;
 import java.io.IOException;
 import java.io.Writer;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 
-import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.RECORD_BUILDER;
-import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.RECORD_INTERFACE;
+public class RecordBuilderProcessor
+        extends AbstractProcessor {
+    private static final String RECORD_BUILDER = RecordBuilder.class.getName();
+    private static final String RECORD_BUILDER_INCLUDE = RecordBuilder.Include.class.getName().replace('$', '.');
+    private static final String RECORD_INTERFACE = RecordInterface.class.getName();
+    private static final String RECORD_INTERFACE_INCLUDE = RecordInterface.Include.class.getName().replace('$', '.');
 
-@SupportedAnnotationTypes({RECORD_BUILDER, RECORD_INTERFACE})
-public class RecordBuilderProcessor extends AbstractProcessor {
-    public static final String RECORD_BUILDER = "io.soabase.recordbuilder.core.RecordBuilder";
-    public static final String RECORD_INTERFACE = "io.soabase.recordbuilder.core.RecordInterface";
-
-    static final AnnotationSpec generatedRecordBuilderAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RECORD_BUILDER).build();
-    static final AnnotationSpec generatedRecordInterfaceAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RECORD_INTERFACE).build();
+    static final AnnotationSpec generatedRecordBuilderAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RecordBuilder.class.getName()).build();
+    static final AnnotationSpec generatedRecordInterfaceAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RecordInterface.class.getName()).build();
+    static final AnnotationSpec recordBuilderGeneratedAnnotation = AnnotationSpec.builder(RecordBuilderGenerated.class).build();
 
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-        annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation)
-                .forEach(element -> process(annotation, element))
-        );
-        return true;
+        annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation).forEach(element -> process(annotation, element)));
+        return false;
     }
-    
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+        return Set.of("*");
+    }
+
     @Override
     public SourceVersion getSupportedSourceVersion() {
         // we don't directly return RELEASE_14 as that may 
@@ -61,30 +70,93 @@ public class RecordBuilderProcessor extends AbstractProcessor {
     }
 
     private void process(TypeElement annotation, Element element) {
-        var metaData = new RecordBuilderMetaDataLoader(processingEnv, s -> processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, s)).getMetaData();
-
-        if (annotation.getQualifiedName().toString().equals(RECORD_BUILDER)) {
-            processRecordBuilder((TypeElement) element, metaData);
-        } else if (annotation.getQualifiedName().toString().equals(RECORD_INTERFACE)) {
-            processRecordInterface((TypeElement) element, element.getAnnotation(RecordInterface.class), metaData);
+        String annotationClass = annotation.getQualifiedName().toString();
+        if (annotationClass.equals(RECORD_BUILDER)) {
+            var typeElement = (TypeElement) element;
+            processRecordBuilder(typeElement, getMetaData(typeElement), Optional.empty());
+        } else if (annotationClass.equals(RECORD_INTERFACE)) {
+            var typeElement = (TypeElement) element;
+            processRecordInterface(typeElement, element.getAnnotation(RecordInterface.class).addRecordBuilder(), getMetaData(typeElement), Optional.empty(), false);
+        } else if (annotationClass.equals(RECORD_BUILDER_INCLUDE) || annotationClass.equals(RECORD_INTERFACE_INCLUDE)) {
+            processIncludes(element, getMetaData(element), annotationClass);
         } else {
-            throw new RuntimeException("Unknown annotation: " + annotation);
+            var recordBuilderTemplate = annotation.getAnnotation(RecordBuilder.Template.class);
+            if (recordBuilderTemplate != null) {
+                if (recordBuilderTemplate.asRecordInterface()) {
+                    processRecordInterface((TypeElement) element, true, recordBuilderTemplate.options(), Optional.empty(), true);
+                } else {
+                    processRecordBuilder((TypeElement) element, recordBuilderTemplate.options(), Optional.empty());
+                }
+            }
         }
     }
 
-    private void processRecordInterface(TypeElement element, RecordInterface recordInterface, RecordBuilderMetaData metaData) {
+    private RecordBuilder.Options getMetaData(Element element) {
+        var recordSpecificMetaData = element.getAnnotation(RecordBuilder.Options.class);
+        return (recordSpecificMetaData != null) ? recordSpecificMetaData : RecordBuilderOptions.build(processingEnv.getOptions());
+    }
+
+    private void processIncludes(Element element, RecordBuilder.Options metaData, String annotationClass) {
+        var isRecordBuilderInclude = annotationClass.equals(RECORD_BUILDER_INCLUDE);
+        var annotationMirrorOpt = ElementUtils.findAnnotationMirror(processingEnv, element, annotationClass);
+        if (annotationMirrorOpt.isEmpty()) {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not get annotation mirror for: " + annotationClass, element);
+        } else {
+            var includeHelper = new IncludeHelper(processingEnv, element, annotationMirrorOpt.get(), isRecordBuilderInclude);
+            if (includeHelper.isValid()) {
+                var packagePattern = ElementUtils.getStringAttribute(ElementUtils.getAnnotationValue(includeHelper.getAnnotationValues(), "packagePattern").orElse(null), "*");
+                for (var typeElement : includeHelper.getClassTypeElements()) {
+                    var packageName = buildPackageName(packagePattern, element, typeElement);
+                    if (packageName != null) {
+                        if (isRecordBuilderInclude) {
+                            processRecordBuilder(typeElement, metaData, Optional.of(packageName));
+                        } else {
+                            var addRecordBuilderOpt = ElementUtils.getAnnotationValue(includeHelper.getAnnotationValues(), "addRecordBuilder");
+                            var addRecordBuilder = addRecordBuilderOpt.map(ElementUtils::getBooleanAttribute).orElse(true);
+                            processRecordInterface(typeElement, addRecordBuilder, metaData, Optional.of(packageName), false);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private String buildPackageName(String packagePattern, Element builderElement, TypeElement includedClass) {
+        PackageElement includedClassPackage = findPackageElement(includedClass, includedClass);
+        if (includedClassPackage == null) {
+            return null;
+        }
+        String replaced = packagePattern.replace("*", includedClassPackage.getQualifiedName().toString());
+        if (builderElement instanceof PackageElement) {
+            return replaced.replace("@", ((PackageElement) builderElement).getQualifiedName().toString());
+        }
+        return replaced.replace("@", ((PackageElement) builderElement.getEnclosingElement()).getQualifiedName().toString());
+    }
+
+    private PackageElement findPackageElement(Element actualElement, Element includedClass) {
+        if (includedClass == null) {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Element has not package", actualElement);
+            return null;
+        }
+        if (includedClass.getEnclosingElement() instanceof PackageElement) {
+            return (PackageElement) includedClass.getEnclosingElement();
+        }
+        return findPackageElement(actualElement, includedClass.getEnclosingElement());
+    }
+
+    private void processRecordInterface(TypeElement element, boolean addRecordBuilder, RecordBuilder.Options metaData, Optional<String> packageName, boolean fromTemplate) {
         if (!element.getKind().isInterface()) {
             processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "RecordInterface only valid for interfaces.", element);
             return;
         }
-        var internalProcessor = new InternalRecordInterfaceProcessor(processingEnv, element, recordInterface, metaData);
+        var internalProcessor = new InternalRecordInterfaceProcessor(processingEnv, element, addRecordBuilder, metaData, packageName, fromTemplate);
         if (!internalProcessor.isValid()) {
             return;
         }
         writeRecordInterfaceJavaFile(element, internalProcessor.packageName(), internalProcessor.recordClassType(), internalProcessor.recordType(), metaData, internalProcessor::toRecord);
     }
 
-    private void processRecordBuilder(TypeElement record, RecordBuilderMetaData metaData) {
+    private void processRecordBuilder(TypeElement record, RecordBuilder.Options metaData, Optional<String> packageName) {
         // we use string based name comparison for the element kind,
         // as the ElementKind.RECORD enum doesn't exist on JRE releases
         // older than Java 14, and we don't want to throw unexpected
@@ -93,30 +165,26 @@ public class RecordBuilderProcessor extends AbstractProcessor {
             processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "RecordBuilder only valid for records.", record);
             return;
         }
-        var internalProcessor = new InternalRecordBuilderProcessor(record, metaData);
+        var internalProcessor = new InternalRecordBuilderProcessor(processingEnv, record, metaData, packageName);
         writeRecordBuilderJavaFile(record, internalProcessor.packageName(), internalProcessor.builderClassType(), internalProcessor.builderType(), metaData);
     }
 
-    private void writeRecordBuilderJavaFile(TypeElement record, String packageName, ClassType builderClassType, TypeSpec builderType, RecordBuilderMetaData metaData) {
+    private void writeRecordBuilderJavaFile(TypeElement record, String packageName, ClassType builderClassType, TypeSpec builderType, RecordBuilder.Options metaData) {
         // produces the Java file
         JavaFile javaFile = javaFileBuilder(packageName, builderType, metaData);
         Filer filer = processingEnv.getFiler();
-        try
-        {
+        try {
             String fullyQualifiedName = packageName.isEmpty() ? builderClassType.name() : (packageName + "." + builderClassType.name());
             JavaFileObject sourceFile = filer.createSourceFile(fullyQualifiedName);
-            try ( Writer writer = sourceFile.openWriter() )
-            {
+            try (Writer writer = sourceFile.openWriter()) {
                 javaFile.writeTo(writer);
             }
-        }
-        catch ( IOException e )
-        {
+        } catch (IOException e) {
             handleWriteError(record, e);
         }
     }
 
-    private void writeRecordInterfaceJavaFile(TypeElement element, String packageName, ClassType classType, TypeSpec type, RecordBuilderMetaData metaData, Function<String, String> toRecordProc) {
+    private void writeRecordInterfaceJavaFile(TypeElement element, String packageName, ClassType classType, TypeSpec type, RecordBuilder.Options metaData, Function<String, String> toRecordProc) {
         JavaFile javaFile = javaFileBuilder(packageName, type, metaData);
 
         String classSourceCode = javaFile.toString();
@@ -124,25 +192,19 @@ public class RecordBuilderProcessor extends AbstractProcessor {
         String recordSourceCode = toRecordProc.apply(classSourceCode);
 
         Filer filer = processingEnv.getFiler();
-        try
-        {
+        try {
             String fullyQualifiedName = packageName.isEmpty() ? classType.name() : (packageName + "." + classType.name());
             JavaFileObject sourceFile = filer.createSourceFile(fullyQualifiedName);
-            try ( Writer writer = sourceFile.openWriter() )
-            {
+            try (Writer writer = sourceFile.openWriter()) {
                 writer.write(recordSourceCode);
             }
-        }
-        catch ( IOException e )
-        {
+        } catch (IOException e) {
             handleWriteError(element, e);
         }
     }
 
-    private JavaFile javaFileBuilder(String packageName, TypeSpec type, RecordBuilderMetaData metaData) {
-        var javaFileBuilder = JavaFile.builder(packageName, type)
-                .skipJavaLangImports(true)
-                .indent(metaData.fileIndent());
+    private JavaFile javaFileBuilder(String packageName, TypeSpec type, RecordBuilder.Options metaData) {
+        var javaFileBuilder = JavaFile.builder(packageName, type).skipJavaLangImports(true).indent(metaData.fileIndent());
         var comment = metaData.fileComment();
         if ((comment != null) && !comment.isEmpty()) {
             javaFileBuilder.addFileComment(comment);

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordClassType.java

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import com.squareup.javapoet.TypeName;
+
+import javax.lang.model.element.AnnotationMirror;
+import java.util.List;
+
+public class RecordClassType extends ClassType {
+    private final TypeName rawTypeName;
+    private final List<? extends AnnotationMirror> accessorAnnotations;
+    private final List<? extends AnnotationMirror> canonicalConstructorAnnotations;
+
+    public RecordClassType(TypeName typeName, TypeName rawTypeName, String name, List<? extends AnnotationMirror> accessorAnnotations, List<? extends AnnotationMirror> canonicalConstructorAnnotations) {
+        super(typeName, name);
+        this.rawTypeName = rawTypeName;
+        this.accessorAnnotations = accessorAnnotations;
+        this.canonicalConstructorAnnotations = canonicalConstructorAnnotations;
+    }
+
+    public TypeName rawTypeName() {
+        return rawTypeName;
+    }
+
+    public List<? extends AnnotationMirror> getAccessorAnnotations() {
+        return accessorAnnotations;
+    }
+
+    public List<? extends AnnotationMirror> getCanonicalConstructorAnnotations() {
+        return canonicalConstructorAnnotations;
+    }
+}

record-builder-test-custom-enhancer/pom.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>34-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>record-builder-test-custom-enhancer</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-deploy-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

record-builder-test-custom-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/test/TestEnhancer.java

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.FieldInsnNode;
+import recordbuilder.org.objectweb.asm.tree.InsnList;
+import recordbuilder.org.objectweb.asm.tree.InsnNode;
+import recordbuilder.org.objectweb.asm.tree.MethodInsnNode;
+
+import javax.lang.model.element.TypeElement;
+import java.util.List;
+
+public class TestEnhancer
+    implements RecordBuilderEnhancer
+{
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments)
+    {
+        /*
+           4: getstatic     #7                  // Field io/soabase/recordbuilder/enhancer/test/Counter.COUNTER:Ljava/util/concurrent/atomic/AtomicInteger;
+           7: invokevirtual #13                 // Method java/util/concurrent/atomic/AtomicInteger.incrementAndGet:()I
+          10: pop
+         */
+        InsnList insnList = new InsnList();
+        insnList.add(new FieldInsnNode(Opcodes.GETSTATIC, "io/soabase/recordbuilder/enhancer/test/Counter", "COUNTER", "Ljava/util/concurrent/atomic/AtomicInteger;"));
+        insnList.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/concurrent/atomic/AtomicInteger", "incrementAndGet", "()I"));
+        insnList.add(new InsnNode(Opcodes.POP));
+        return insnList;
+    }
+
+    public String description() {
+        return "This is a test";
+    }
+}

record-builder-test/pom.xml

@@ -3,18 +3,71 @@
     <parent>
         <groupId>io.soabase.record-builder</groupId>
         <artifactId>record-builder</artifactId>
-        <version>1.7.ea</version>
+        <version>34-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>record-builder-test</artifactId>
 
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
     <dependencies>
+        <dependency>
+            <groupId>javax.validation</groupId>
+            <artifactId>validation-api</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>io.soabase.record-builder</groupId>
             <artifactId>record-builder-core</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-processor</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-validator</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-test-custom-enhancer</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hibernate.validator</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>javax.el</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
@@ -24,25 +77,6 @@
 
     <build>
         <plugins>
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <annotationProcessorPaths>
-                        <annotationProcessorPath>
-                            <groupId>io.soabase.record-builder</groupId>
-                            <artifactId>record-builder-processor</artifactId>
-                            <version>${project.version}</version>
-                        </annotationProcessorPath>
-                    </annotationProcessorPaths>
-                    <annotationProcessors>
-                        <annotationProcessor>io.soabase.recordbuilder.processor.RecordBuilderProcessor</annotationProcessor>
-                    </annotationProcessors>
-                    <source>14</source>
-                    <target>14</target>
-                    <compilerArgs>--enable-preview</compilerArgs>
-                </configuration>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-deploy-plugin</artifactId>
@@ -58,6 +92,48 @@
                     <skip>true</skip>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>default-prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-report</id>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-check</id>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <includes>
+                                <include>io/soabase/recordbuilder/test/jacoco/*</include>
+                            </includes>
+                            <rules>
+                                <rule>
+                                    <element>BUNDLE</element>
+                                    <limits>
+                                        <limit>
+                                            <counter>COMPLEXITY</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <minimum>0.60</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </project>

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/CopyCollectionNullableEmptyTest.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.CopyCollectionNullableEmpty;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = CopyCollectionNullableEmpty.class)
+public record CopyCollectionNullableEmptyTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/Counter.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Counter {
+    public static final AtomicInteger COUNTER = new AtomicInteger();
+
+    private Counter() {
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/CustomEnhance.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.CopyCollectionNullableEmpty;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullOptional;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullString;
+import io.soabase.recordbuilder.enhancer.enhancers.RequireNonNull;
+
+import java.lang.annotation.*;
+
+@RecordBuilderEnhance.Template(enhancers = {CopyCollectionNullableEmpty.class, EmptyNullString.class, EmptyNullOptional.class, RequireNonNull.class})
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface CustomEnhance {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/CustomEnhanced.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+
+@CustomEnhance
+public record CustomEnhanced(String s, Optional<String> o, Instant i, List<BigDecimal> l) {
+    public CustomEnhanced {
+        Counter.COUNTER.decrementAndGet();
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/GuavaCopyCollectionNullableEmptyTest.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.GuavaCopyCollectionNullableEmpty;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = GuavaCopyCollectionNullableEmpty.class)
+public record GuavaCopyCollectionNullableEmptyTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/GuavaCopyCollectionTest.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.GuavaCopyCollection;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = GuavaCopyCollection.class)
+public record GuavaCopyCollectionTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/MadeUpNotNullable.java

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.RECORD_COMPONENT;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+@Target(RECORD_COMPONENT)
+@Retention(SOURCE)
+public @interface MadeUpNotNullable {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/NotNullAnnotation.java

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhanceArguments;
+import io.soabase.recordbuilder.enhancer.enhancers.NotNullAnnotations;
+
+import javax.validation.constraints.NotNull;
+
+@RecordBuilderEnhance(enhancers = NotNullAnnotations.class,
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = ".*notnull.*"))
+public record NotNullAnnotation(String s, @NotNull Integer i, @MadeUpNotNullable Double d) {
+    public NotNullAnnotation() {
+        this(null, null, null);
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/NotNullableCopyCollectionTest.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.CopyCollection;
+import io.soabase.recordbuilder.enhancer.enhancers.RequireNonNull;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = {RequireNonNull.class, CopyCollection.class})
+public record NotNullableCopyCollectionTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/OptionalTest.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullOptional;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+@RecordBuilderEnhance(enhancers = EmptyNullOptional.class)
+public record OptionalTest(OptionalInt i, OptionalLong l, OptionalDouble d, Optional<String> o) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/PluginTest.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+
+@RecordBuilderEnhance(enhancers = TestEnhancer.class)
+public record PluginTest(int i) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/StringTest.java

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullString;
+
+@RecordBuilderEnhance(enhancers = EmptyNullString.class)
+public record StringTest(String s) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Annotated.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Null;
+
+@RecordBuilder
+public record Annotated(@NotNull @Null String hey, @Min(10) @Max(100) int i, double d) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/BeanStyle.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordInterface;
+import java.time.Instant;
+
+@RecordInterface
+public interface BeanStyle {
+    String getName();
+
+    Instant getDate();
+
+    boolean isSomething();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Builder.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordInterface;
+
+@RecordInterface.Include({
+    Thingy.class
+})
+@RecordBuilder.Include({
+    Nested.NestedRecord.class
+})
+public class Builder {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionInterface.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordInterface;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordInterface
+@RecordBuilder.Options(useImmutableCollections = true)
+public interface CollectionInterface<T, X extends Point> {
+    List<T> l();
+
+    Set<T> s();
+
+    Map<T, X> m();
+
+    Collection<X> c();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecord.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordBuilder
+@RecordBuilder.Options(useImmutableCollections = true, addFunctionalMethodsToWith = true)
+public record CollectionRecord<T, X extends Point>(List<T> l, Set<T> s, Map<T, X> m,
+                                                   Collection<X> c) implements CollectionRecordBuilder.With<T, X> {
+    public static void main(String[] args) {
+        var r = new CollectionRecord<>(List.of("hey"), Set.of("there"), Map.of("one", new Point(10, 20)), Set.of(new Point(30, 40)));
+        Instant now = r.map((l1, s1, m1, c1) -> Instant.now());
+        r.accept((l1, s1, m1, c1) -> {
+        });
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecordConflicts.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordBuilder
+@RecordBuilder.Options(useImmutableCollections = true)
+public record CollectionRecordConflicts(List<String> __list, Set<String> __set, Map<String, String> __map, Collection<String> __collection) implements CollectionRecordConflictsBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CustomMethodNames.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.util.List;
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.test.CustomMethodNamesBuilder.Bean;
+
+@RecordBuilder
+@RecordBuilder.Options(
+    setterPrefix = "set", getterPrefix = "get", booleanPrefix = "is", beanClassName = "Bean")
+public record CustomMethodNames(
+    int theValue,
+    List<Integer> theList,
+    boolean theBoolean) implements Bean {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Customer.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.time.Instant;
+
+public interface Customer {
+    String name();
+
+    String address();
+
+    Instant activeDate();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Empty.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+public record Empty() implements EmptyBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/ExceptionDetails.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.lang.model.type.ErrorType;
+import java.util.List;
+
+@RecordBuilder
+public record ExceptionDetails(
+        String internalMessage, String endUserMessage, String httpStatus,
+        ErrorType errorType, List<String> jsonProblems, Throwable cause
+) {
+    @Override
+    public List<String> jsonProblems() {
+        if (jsonProblems == null) {
+            return List.of();
+        }
+        return jsonProblems;
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/FullRecord.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilderFull;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+import java.util.Map;
+
+@RecordBuilderFull
+public record FullRecord(@NotNull List<Number> numbers, @NotNull Map<Number, FullRecord> fullRecords, @NotNull String justAString) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/IgnoreAnnotated.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.constraints.NotNull;
+
+@RecordBuilder()
+@RecordBuilder.Options(inheritComponentAnnotations = false)
+public record IgnoreAnnotated(@NotNull String s) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/IncludeWithOption.java

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Options(prefixEnclosingClassNames = false)
+@RecordBuilder.Include(IncludeWithOption.Hey.class)
+public class IncludeWithOption {
+    public static record Hey(String s){}
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/InterfaceTemplateTest.java

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+@MyInterfaceTemplate
+public interface InterfaceTemplateTest {
+    String name();
+
+    int age();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/MutableCollectionRecord.java

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.List;
+
+@RecordBuilder
+public record MutableCollectionRecord(List<String> l) implements MutableCollectionRecordBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/MyInterfaceTemplate.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        fileComment = "This is a test",
+        withClassName = "Com"),
+        asRecordInterface = true
+)
+public @interface MyInterfaceTemplate {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/MyTemplate.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        fileComment = "This is a test",
+        withClassName = "Com"
+))
+public @interface MyTemplate
+{
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Nested.java

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+public class Nested {
+    record NestedRecord(int x, int y){}
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/NoStaticBuilder.java

@@ -0,0 +1,23 @@
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@RecordBuilder.Options(addStaticBuilder = false)
+@RecordBuilder
+public record NoStaticBuilder(String foo) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Pair.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+public record Pair<T, U>(T t, U u) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Point.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+public record Point(int x, int y) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithAnR.java

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+public record RecordWithAnR(int r, String b) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithOptional.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import javax.validation.constraints.NotNull;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+@RecordBuilder.Options(emptyDefaultForOptional = true, addConcreteSettersForOptional = true)
+@RecordBuilder
+public record RecordWithOptional(@NotNull Optional<String> value, Optional raw, OptionalInt i, OptionalLong l, OptionalDouble d) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithOptional2.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Options(emptyDefaultForOptional = true)
+@RecordBuilder
+public record RecordWithOptional2(Optional<String> value, Optional raw, OptionalInt i, OptionalLong l, OptionalDouble d) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequestWithValid.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+@RecordBuilder
+@RecordBuilder.Options(useValidationApi = true)
+public record RequestWithValid(@NotNull @Valid Part part) implements RequestWithValidBuilder.With {
+  public record Part(@NotBlank String name) {}
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+@RecordBuilder.Options(interpretNotNulls = true)
+@RecordBuilder
+public record RequiredRecord(@NotNull String hey, @NotNull int i, @NotNull List<String> l) implements RequiredRecordBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord2.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.constraints.NotNull;
+
+@RecordBuilder.Options(useValidationApi = true)
+@RecordBuilder
+public record RequiredRecord2(@NotNull String hey, @NotNull int i) implements RequiredRecord2Builder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/SimpleGenericRecord.java

@@ -18,5 +18,5 @@ package io.soabase.recordbuilder.test;
 import io.soabase.recordbuilder.core.RecordBuilder;
 
 @RecordBuilder
-public record SimpleGenericRecord<T>(int i, T s) {
+public record SimpleGenericRecord<T>(int i, T s) implements SimpleGenericRecordBuilder.With<T> {
 }

record-builder-test/src/main/java/io/soabase/recordbuilder/test/SimpleRecord.java

@@ -18,5 +18,6 @@ package io.soabase.recordbuilder.test;
 import io.soabase.recordbuilder.core.RecordBuilder;
 
 @RecordBuilder
+@RecordBuilder.Options(prefixEnclosingClassNames = false)
 public record SimpleRecord(int i, String s) {
 }

record-builder-test/src/main/java/io/soabase/recordbuilder/test/SingleItems.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordBuilder
+@RecordBuilder.Options(
+        addSingleItemCollectionBuilders = true,
+        singleItemBuilderPrefix = "add1",
+        useImmutableCollections = true,
+        addFunctionalMethodsToWith = true
+)
+public record SingleItems<T>(List<String> strings, Set<List<T>> sets, Map<Instant, T> map, Collection<T> collection) implements SingleItemsBuilder.With<T> {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/StrippedFeaturesRecord.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+@RecordBuilder.Options(
+    enableGetters = false,
+    enableWither = false
+)
+public record StrippedFeaturesRecord(int aField) {}