Constructor parser upgrades (#16)

* Constructor-based parsing follow-ups

- Honor @JsonIgnore consistently across analyzer, validator, and generator
  (collapses four drifting field-skip predicates into a single
  ConstructorAnalyzer.getParseableFields).
- Match generic constructor parameter types: List<String> now resolves to
  reflection's raw List, fixing immutable POJOs with generic-typed
  constructor parameters silently failing constructor matching.
- Use field names for constructor-bound locals so sibling fields don't
  collide on level-based names (threaded through Collection, Map,
  PrimitiveArray, CustomObject, Enum, Simple parsers; legacy setter-based
  output stays byte-identical).
- Allow user Map subclasses (class FooMap extends HashMap<K,V>) to dispatch
  to a custom parser by simple name, while keeping JDK Map types excluded
  so raw Map fields don't route to a non-existent MapParser.
- Bump version to 1.1.1-SNAPSHOT.

* Test new constructor-based parsing behaviors via t1-t3 pipeline

Adds two new immutable POJO fixtures wired into TestRootObjectType so the
t1 (expected roundtrip), t2 (generated-vs-expected), and t3 (generated
roundtrip) scripts all exercise the new behaviors:

- TestConstructorWithGenericsType — constructor params List<String>,
  Map<String,Integer>, Set<String>, int[], String[]. Covers stripGenerics
  matching plus the variableName overrides on CollectionFieldParser,
  MapFieldParser, and PrimitiveArrayFieldParser.
- TestConstructorWithIgnoredFieldType — final @JsonIgnore field that is
  NOT a constructor parameter (derived from another). Covers
  getParseableFields skipping @JsonIgnore on the constructor-based path
  so the single-arg constructor matches the single parseable field.

Plus a focused unit test CustomObjectFieldParserTest for the isJdkMap
guard (raw java.util Maps don't route to a non-existent parser; user
Map subclasses still pass through).

* Support Java records in constructor-based parsing

- Detect clazz.isRecord() and use getRecordComponents() instead of source-file parsing
- Skip validateGetterSetter shape check for records (bare x() accessors)
- Add TestRecordType fixture wired into TestRootObjectType for t1-t3 coverage

* Extract local-variable name resolution into ParserCommonUtils.localVarName

Replaces the variableName != null ? ... : getVariableNameForLevel(...) ternary
duplicated 17 times across the collection/map/primitive-array parsers.

Author: JornC

gwt-beans-codegen-core/src/main/java/nl/aerius/codegen/analyzer/ConstructorAnalyzer.java

@@ -3,6 +3,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.RecordComponent;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -12,11 +13,13 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.github.javaparser.StaticJavaParser;
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.ConstructorDeclaration;
 
+import nl.aerius.codegen.generator.parser.ParserCommonUtils;
 import nl.aerius.codegen.util.Logger;
 
 /**
@@ -91,6 +94,12 @@ private Optional<ConstructorInfo> findMatchingConstructorInfo(final Class<?> cla
       return Optional.empty();
     }
 
+    // Records: use the compiler-generated canonical constructor and component names
+    // directly via reflection. No source-file lookup needed.
+    if (clazz.isRecord()) {
+      return buildRecordConstructorInfo(clazz, parseableFields);
+    }
+
     final Set<String> fieldNames = parseableFields.stream()
         .map(Field::getName)
         .collect(Collectors.toSet());
@@ -159,6 +168,25 @@ private Optional<ConstructorInfo> findMatchingConstructorInfo(final Class<?> cla
     return Optional.empty();
   }
 
+  private Optional<ConstructorInfo> buildRecordConstructorInfo(final Class<?> clazz, final List<Field> parseableFields) {
+    final RecordComponent[] components = clazz.getRecordComponents();
+    final List<String> paramNames = Arrays.stream(components)
+        .map(RecordComponent::getName)
+        .collect(Collectors.toList());
+    final Class<?>[] paramTypes = Arrays.stream(components)
+        .map(RecordComponent::getType)
+        .toArray(Class<?>[]::new);
+    try {
+      final Constructor<?> canonical = clazz.getDeclaredConstructor(paramTypes);
+      logger.info("Found canonical record constructor for " + clazz.getName() + " with parameters: " + paramNames);
+      return Optional.of(new ConstructorInfo(canonical, paramNames, parseableFields));
+    } catch (final NoSuchMethodException e) {
+      // Should be impossible: every record has a compiler-generated canonical constructor.
+      logger.warn("Record " + clazz.getName() + " has no canonical constructor: " + e.getMessage());
+      return Optional.empty();
+    }
+  }
+
   /**
    * Validates that constructor parameter types match the corresponding field types.
    *
@@ -231,20 +259,27 @@ private Class<?> getPrimitiveWrapper(final Class<?> type) {
   }
 
   /**
-   * Gets all fields that should be parsed (non-static, non-transient, non-synthetic).
+   * Canonical predicate for fields that participate in JSON parsing: non-static,
+   * non-transient, non-synthetic, and not {@code @JsonIgnore}. Shared by analyzer,
+   * validator, and generator.
    */
   public static List<Field> getParseableFields(final Class<?> clazz) {
     final List<Field> fields = new ArrayList<>();
     for (final Field field : clazz.getDeclaredFields()) {
-      if (!Modifier.isStatic(field.getModifiers())
-          && !Modifier.isTransient(field.getModifiers())
-          && !field.isSynthetic()) {
+      if (isParseable(field)) {
         fields.add(field);
       }
     }
     return fields;
   }
 
+  public static boolean isParseable(final Field field) {
+    return !Modifier.isStatic(field.getModifiers())
+        && !Modifier.isTransient(field.getModifiers())
+        && !field.isSynthetic()
+        && !field.isAnnotationPresent(JsonIgnore.class);
+  }
+
   /**
    * Checks if a class has setter methods for all parseable fields.
    * If true, setter-based parsing is preferred over constructor-based.
@@ -301,11 +336,13 @@ private Constructor<?> findMatchingReflectionConstructor(final Class<?> clazz,
   }
 
   /**
-   * Checks if a source type name matches a reflection type.
+   * Matches a source type name (with generics stripped) against a reflection type, so
+   * {@code List<String>} resolves to raw {@code List} / {@code java.util.List}.
    */
   private boolean typeNamesMatch(final String sourceTypeName, final Class<?> reflectionType) {
-    return sourceTypeName.equals(reflectionType.getName())
-        || sourceTypeName.equals(reflectionType.getSimpleName());
+    final String rawSourceName = ParserCommonUtils.stripGenerics(sourceTypeName);
+    return rawSourceName.equals(reflectionType.getName())
+        || rawSourceName.equals(reflectionType.getSimpleName());
   }
 
   /**

gwt-beans-codegen-core/src/main/java/nl/aerius/codegen/analyzer/TypeAnalyzer.java

@@ -1,7 +1,6 @@
 package nl.aerius.codegen.analyzer;
 
 import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.math.BigDecimal;
@@ -160,13 +159,11 @@ private void analyzeTypeAndSubtypes(final Class<?> type) {
 
     // Always analyze fields, even for types with custom parsers
     // This ensures we discover all types that might need parsers
-    for (final Field field : type.getDeclaredFields()) {
-      if (!Modifier.isStatic(field.getModifiers()) && !Modifier.isTransient(field.getModifiers())) {
-        try {
-          analyzeField(field);
-        } catch (final TypeNotPresentException e) {
-          skippedTypes.add(e.typeName());
-        }
+    for (final Field field : ConstructorAnalyzer.getParseableFields(type)) {
+      try {
+        analyzeField(field);
+      } catch (final TypeNotPresentException e) {
+        skippedTypes.add(e.typeName());
       }
     }
   }

gwt-beans-codegen-core/src/main/java/nl/aerius/codegen/generator/ParserWriterUtils.java

@@ -133,24 +133,24 @@ public static void generateParserForFields(final TypeSpec.Builder typeSpec, fina
 
     if (constructorInfo.isPresent()) {
       // Constructor-based: single parse method that constructs the object
-      typeSpec.addMethod(createConstructorBasedParseMethod(targetClass, parserPackage, classFinder, constructorInfo.get()));
+      typeSpec.addMethod(createConstructorBasedParseMethod(targetClass, parserPackage, constructorInfo.get()));
     } else {
       // Setter-based: existing approach
-      addSetterBasedParseMethods(typeSpec, targetClass, parserPackage, classFinder);
+      addSetterBasedParseMethods(typeSpec, targetClass, parserPackage);
     }
   }
 
   /**
    * Adds setter-based parse methods to the type specification.
    */
   private static void addSetterBasedParseMethods(final TypeSpec.Builder typeSpec, final Class<?> targetClass,
-      final String parserPackage, final ClassFinder classFinder) {
+      final String parserPackage) {
     if (hasJsonTypeInfoWithNameDiscriminator(targetClass)) {
       typeSpec.addMethod(createPolymorphicObjectParseMethod(targetClass, parserPackage));
     } else {
       typeSpec.addMethod(createStandardObjectParseMethod(targetClass, parserPackage));
     }
-    typeSpec.addMethod(createConfigParseMethod(targetClass, parserPackage, classFinder));
+    typeSpec.addMethod(createConfigParseMethod(targetClass, parserPackage));
   }
 
   /**
@@ -248,16 +248,11 @@ public static ClassName determineParserClassName(final Type type, final String p
       }
     }
     // Fallback for complex types - might need refinement
-    String typeName = type.getTypeName();
-    // Basic attempt to get a simple name
-    if (typeName.contains("<")) {
-      typeName = typeName.substring(0, typeName.indexOf('<'));
-    }
+    String typeName = ParserCommonUtils.stripGenerics(type.getTypeName());
     if (typeName.contains(".")) {
       typeName = typeName.substring(typeName.lastIndexOf('.') + 1);
     }
     return determineParserClassName(typeName, parserPackage);
-    // throw new IllegalArgumentException("Cannot determine parser class name for type: " + type.getTypeName());
   }
 
   /**
@@ -376,7 +371,7 @@ private static MethodSpec createPolymorphicObjectParseMethod(final Class<?> targ
    * Parses all fields into local variables and then calls the constructor.
    */
   private static MethodSpec createConstructorBasedParseMethod(final Class<?> targetClass, final String parserPackage,
-      final ClassFinder classFinder, final ConstructorInfo constructorInfo) {
+      final ConstructorInfo constructorInfo) {
     final ClassName targetClassName = ClassName.get(targetClass);
     final MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("parse")
         .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
@@ -439,7 +434,7 @@ private static String generateFieldParsingCode(final MethodSpec.Builder methodBu
     return resultVar;
   }
 
-  private static MethodSpec createConfigParseMethod(final Class<?> targetClass, final String parserPackage, final ClassFinder classFinder) {
+  private static MethodSpec createConfigParseMethod(final Class<?> targetClass, final String parserPackage) {
     final ClassName targetClassName = ClassName.get(targetClass);
     final MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("parse")
         .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
@@ -458,56 +453,30 @@ private static MethodSpec createConfigParseMethod(final Class<?> targetClass, fi
           .addStatement("$T.parse($L, config)", determineParserClassName(superclass, parserPackage), ParserCommonUtils.BASE_OBJECT_PARAM_NAME);
     }
 
-    // Process all fields
-    for (final Field field : targetClass.getDeclaredFields()) {
-      if (!java.lang.reflect.Modifier.isStatic(field.getModifiers())
-          && !java.lang.reflect.Modifier.isTransient(field.getModifiers())
-          && !field.isSynthetic()) {
-
-        // ==> INSERT @JsonIgnore CHECK HERE <==
-        try {
-          final Class<? extends java.lang.annotation.Annotation> jsonIgnoreAnnotation = (Class<? extends java.lang.annotation.Annotation>) classFinder
-              .forName("com.fasterxml.jackson.annotation.JsonIgnore");
-          if (field.isAnnotationPresent(jsonIgnoreAnnotation)) {
-            methodBuilder.addCode("\n"); // Add newline for spacing
-            methodBuilder.addComment("Skipping ignored field: $L", field.getName());
-            continue; // Skip processing this ignored field
-          }
-        } catch (final ClassNotFoundException e) {
-          // Log or handle the case where JsonIgnore annotation class is not available on the classpath during generation
-          methodBuilder.addCode("\n");
-          methodBuilder.addComment("WARNING: Cannot check for @JsonIgnore, com.fasterxml.jackson.annotation.JsonIgnore not found.");
-          // Proceed without checking - might generate code for ignored fields if annotation is used but class not found
-        }
-        // ==> END @JsonIgnore CHECK <==
-
-        methodBuilder.addCode("\n");
-        methodBuilder.addComment("Parse $L", field.getName());
-        // Determine if null check is required (true for non-primitives)
-        final boolean requireNonNull = !ParserCommonUtils.isPrimitiveType(field.getGenericType());
-        methodBuilder.addCode(ParserCommonUtils.createFieldExistsCheck(
-            ParserCommonUtils.BASE_OBJECT_PARAM_NAME, // Use constant here
-            field.getName(),
-            requireNonNull, // Pass determined value
-            innerCode -> {
-              // Pass CodeBlock representing the field name string literal
-              final CodeBlock fieldAccess = ParserCommonUtils.createFieldAccessCode(
-                  field.getGenericType(),
-                  ParserCommonUtils.BASE_OBJECT_PARAM_NAME, // Use constant here
-                  CodeBlock.of("$S", field.getName()));
-
-              final String resultVar = dispatchGenerateParsingCodeInto(
-                  innerCode,
-                  field.getGenericType(),
-                  ParserCommonUtils.BASE_OBJECT_PARAM_NAME, // Use constant here
-                  parserPackage,
-                  fieldAccess, // Pass the code to access the field's data
-                  1, // Start top-level fields at level 1 - Remove last arg
-                  field.getGenericType() // Pass fieldType
-              );
-              innerCode.addStatement("config.set$L($L)", ParserCommonUtils.capitalize(field.getName()), resultVar);
-            }));
-      }
+    for (final Field field : ConstructorAnalyzer.getParseableFields(targetClass)) {
+      methodBuilder.addCode("\n");
+      methodBuilder.addComment("Parse $L", field.getName());
+      final boolean requireNonNull = !ParserCommonUtils.isPrimitiveType(field.getGenericType());
+      methodBuilder.addCode(ParserCommonUtils.createFieldExistsCheck(
+          ParserCommonUtils.BASE_OBJECT_PARAM_NAME,
+          field.getName(),
+          requireNonNull,
+          innerCode -> {
+            final CodeBlock fieldAccess = ParserCommonUtils.createFieldAccessCode(
+                field.getGenericType(),
+                ParserCommonUtils.BASE_OBJECT_PARAM_NAME,
+                CodeBlock.of("$S", field.getName()));
+
+            final String resultVar = dispatchGenerateParsingCodeInto(
+                innerCode,
+                field.getGenericType(),
+                ParserCommonUtils.BASE_OBJECT_PARAM_NAME,
+                parserPackage,
+                fieldAccess,
+                1,
+                field.getGenericType());
+            innerCode.addStatement("config.set$L($L)", ParserCommonUtils.capitalize(field.getName()), resultVar);
+          }));
     }
 
     return methodBuilder.build();