Further Support Null Analysis

.mvn/jvm.config

@@ -0,0 +1,10 @@
+--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED
+--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED

README.md

@@ -8,8 +8,7 @@ Uses Annotation processing to generate builders for records.
 ## Distinguishing features
 - By default, Collection/Optional Types will not be null (an empty collection/optional will be provided)
 - We can choose the default value of a record component in the generated builder
-- Copies nullability annotations to the generated setters to aid in static analysis
-
+- Support for generating Checker/NullAway compliant builders for static null analysis.
 ## Usage
 ### 1. Add dependency:
 ```xml
@@ -22,7 +21,7 @@ Uses Annotation processing to generate builders for records.
 </dependency>
 ```
 
-When working with Java modules you need to add the annotation module as a static dependency.
+Add the annotation module as a static dependency when working with Java modules.
 ```java
 module my.module {
   requires static io.avaje.recordbuilder;
@@ -39,7 +38,9 @@ public record ArmoredCore(
 ```
 
 The following builder class will be generated for the above:
-```java
+<details>
+    <summary>Generated Class, (click to expand)</summary>
+<pre content="java">
 /**  Builder class for {@link ArmoredCore} */
 public class ArmoredCoreBuilder {
   private String coreName = "Steel Haze";
@@ -105,5 +106,29 @@ public class ArmoredCoreBuilder {
       this.ap = ap;
       return this;
   }
+}
+  </pre>
+</details>
+
+## Default Values
+Using `@DefaultValue` we can directly write the code to set the default value in the generated builder. This allows us to directly write a value or use static methods to set the default builder state.
+```java
+@RecordBuilder
+public record Defaults(
+    @DefaultValue("List.of(1,2,3)") List<Integer> list,
+    @DefaultValue("24") int num,
+    @DefaultValue("\"string val\"") String str,
+    @DefaultValue("CustomClass.createDefault()") CustomClass custom) {}
+```
+
+This will generate:
+```java
+public class DefaultsBuilder {
+  private List<Integer> list = List.of(1,2,3);
+  private int num = 24;
+  private String str = "string val";
+  private CustomClass custom = CustomClass.createDefault();
+
+...the rest of the builder
 }
 ```

avaje-record-builder-core/src/main/java/io/avaje/recordbuilder/internal/BuilderPrism.java

@@ -0,0 +1,45 @@
+package io.avaje.recordbuilder.internal;
+
+import java.util.List;
+
+import javax.lang.model.type.TypeMirror;
+
+public interface BuilderPrism {
+
+  default boolean imported() {
+    return this instanceof ImportPrism;
+  }
+
+  /**
+   * Returns a Boolean representing the value of the {@code boolean public abstract boolean
+   * getters() } member of the Annotation.
+   *
+   * @see io.avaje.recordbuilder.RecordBuilder.Import#getters()
+   */
+  Boolean getters();
+
+  /**
+   * Returns a Boolean representing the value of the {@code boolean public abstract boolean
+   * enforceNullSafety() } member of the Annotation.
+   *
+   * @see io.avaje.recordbuilder.RecordBuilder.Import#enforceNullSafety()
+   */
+  Boolean enforceNullSafety();
+
+  /**
+   * Returns a TypeMirror representing the value of the {@code java.lang.Class<? extends
+   * java.lang.annotation.Annotation> public abstract Class<? extends
+   * java.lang.annotation.Annotation> nullableAnnotation() } member of the Annotation.
+   *
+   * @see io.avaje.recordbuilder.RecordBuilder.Import#nullableAnnotation()
+   */
+  TypeMirror nullableAnnotation();
+
+  /**
+   * Returns a List&lt;TypeMirror&gt; representing the value of the {@code public abstract
+   * Class<?>[] builderInterfaces() } member of the Annotation.
+   *
+   * @see io.avaje.recordbuilder.RecordBuilder.Import#builderInterfaces()
+   */
+  List<TypeMirror> builderInterfaces();
+}

avaje-record-builder-core/src/main/java/io/avaje/recordbuilder/internal/ClassBodyBuilder.java

@@ -1,27 +1,28 @@
 package io.avaje.recordbuilder.internal;
 
-import static io.avaje.recordbuilder.internal.APContext.elements;
 import static io.avaje.recordbuilder.internal.Templates.classTemplate;
 import static java.util.stream.Collectors.joining;
 
 import java.text.MessageFormat;
 import java.util.List;
 import java.util.Optional;
-import java.util.stream.Stream;
 
 import javax.lang.model.element.RecordComponentElement;
 import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
 
-// TODO better name?
 public class ClassBodyBuilder {
 
-  static String createClassStart(TypeElement type, String typeParams, boolean isImported) {
+  private ClassBodyBuilder() {}
+
+  static String createClassStart(
+      BuilderPrism prism,
+      TypeElement type,
+      String typeParams,
+      boolean isImported,
+      String packageName) {
 
     final var components = type.getRecordComponents();
-    final var packageName =
-        elements().getPackageOf(type).getQualifiedName().toString()
-            + (isImported ? ".builder" : "");
     final var shortName = type.getSimpleName().toString();
     if (type.getEnclosingElement() instanceof TypeElement) {
       isImported = true;
@@ -42,6 +43,14 @@ static String createClassStart(TypeElement type, String typeParams, boolean isIm
 
     final RecordModel rm = new RecordModel(type, isImported, components, utype);
     rm.initialImports();
+    rm.nullableAnnotation(GlobalSettings.nullableAnnotation().orElse(prism.nullableAnnotation().toString()));
+    var implementsStr =
+        prism.builderInterfaces().stream()
+            .map(TypeMirror::toString)
+            .peek(rm::addImport)
+            .map(ProcessorUtils::shortType)
+            .collect(joining(", "))
+            .transform(s -> s.isEmpty() ? s : "implements " + s);
     final String fieldString = rm.fields();
     final var imports = rm.importsFormat();
     final var numberOfComponents = components.size();
@@ -51,11 +60,12 @@ static String createClassStart(TypeElement type, String typeParams, boolean isIm
     final String builderFrom =
         builderFrom(components).transform(s -> numberOfComponents > 5 ? "\n        " + s : s);
     final String build =
-        build(components).transform(s -> numberOfComponents > 6 ? "\n        " + s : s);
+        build(components, prism).transform(s -> numberOfComponents > 6 ? "\n        " + s : s);
     return classTemplate(
         packageName,
         imports,
         shortName,
+        implementsStr,
         fieldString,
         constructorParams,
         constructorBody,
@@ -88,7 +98,16 @@ private static String builderFrom(List<? extends RecordComponentElement> compone
         .collect(joining(", "));
   }
 
-  private static String build(List<? extends RecordComponentElement> components) {
-    return components.stream().map(RecordComponentElement::getSimpleName).collect(joining(", "));
+  private static String build(
+      List<? extends RecordComponentElement> components, BuilderPrism prism) {
+
+    return components.stream()
+        .map(
+            element ->
+                !Utils.isNullableType(UType.parse(element.asType()).mainType())
+                        && Utils.isNonNullable(element, prism)
+                    ? "requireNonNull(%s)".formatted(element.getSimpleName())
+                    : element.getSimpleName())
+        .collect(joining(", "));
   }
 }