Smart subtype walk (#18)

* Skip sibling subtypes when only a concrete subtype is referenced

A polymorphic base reached only via a concrete subtype's superclass walk
now generates a plain parser instead of a discriminator switch, and its
sibling subtypes are no longer walked. This lets consumers reference
e.g. Point fields without forcing parsers for LineString and Polygon
when those siblings only exist in the base's @JsonSubTypes list.

Bases reached directly as a field or type-argument keep the existing
behavior: every subtype is walked and a polymorphic dispatch parser is
emitted.

* Drop dead overloads and trim verbose comments

The single-arg analyzeTypeAndSubtypes, the no-polymorphic-set ParserWriter
constructor, and the 4-arg generateParserForFields each had exactly one
caller in the previous commit; inline them so there is one entry point per
operation. Also strip narration-style comments and accessor noise from
fixtures that the analyzer never touches.

Author: JornC

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

@@ -106,6 +106,7 @@ public static void generateParsersForClass(final Class<?> targetClass, final Str
       final TypeAnalyzer analyzer = new TypeAnalyzer(classFinder, logger);
       analyzer.setCustomParserTypes(customParserTypes);
       final Set<ClassName> classNames = analyzer.analyzeClass(targetClass.getName());
+      final Set<Class<?>> polymorphicallyReachedTypes = analyzer.getPolymorphicallyReachedTypes();
 
       // Filter out types that have custom parsers (this is now redundant since
       // TypeAnalyzer handles it)
@@ -116,7 +117,8 @@ public static void generateParsersForClass(final Class<?> targetClass, final Str
 
       // Create a parser writer and generate all parsers
       // Pass the generator name and details (version + hash) to the writer
-      final ParserWriter parserWriter = new ParserWriter(outputDir, parserPackage, generatorName, generatorDetails, classFinder, logger);
+      final ParserWriter parserWriter = new ParserWriter(outputDir, parserPackage, generatorName, generatorDetails, classFinder, logger,
+          polymorphicallyReachedTypes);
 
       parserWriter.generateParsers(classFinder, filteredClassNames);
 

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

@@ -39,6 +39,7 @@ public class TypeAnalyzer {
   private final Set<Class<?>> processedTypes;
   private final Set<String> skippedTypes;
   private final Set<ClassName> discoveredTypes;
+  private final Set<Class<?>> polymorphicallyReachedTypes;
   private final Set<String> printedTypes = new HashSet<>();
   private final Set<String> customParserTypes = new HashSet<>();
   private final ClassFinder classFinder;
@@ -80,6 +81,7 @@ public TypeAnalyzer(final ClassFinder classFinder, final Logger logger) {
     processedTypes = new HashSet<>();
     skippedTypes = new HashSet<>();
     discoveredTypes = new TreeSet<>(Comparator.comparing(ClassName::toString));
+    polymorphicallyReachedTypes = new HashSet<>();
   }
 
   /**
@@ -102,8 +104,9 @@ public Set<ClassName> analyzeClass(final String className) {
       skippedTypes.clear();
       discoveredTypes.clear();
       printedTypes.clear();
+      polymorphicallyReachedTypes.clear();
 
-      analyzeTypeAndSubtypes(rootClass);
+      analyzeTypeAndSubtypes(rootClass, true);
 
       if (!skippedTypes.isEmpty()) {
         logger.info("Warning: The following types were not found and skipped:");
@@ -116,56 +119,71 @@ public Set<ClassName> analyzeClass(final String className) {
     }
   }
 
-  private void analyzeTypeAndSubtypes(final Class<?> type) {
+  /**
+   * Polymorphic bases reached directly (as a field type or type argument) in
+   * the most recent analysis. The generator emits a discriminator switch for
+   * these; bases reached only via a concrete subtype's superclass chain are
+   * absent and get a standard parse method instead.
+   */
+  public Set<Class<?>> getPolymorphicallyReachedTypes() {
+    return polymorphicallyReachedTypes;
+  }
+
+  private void analyzeTypeAndSubtypes(final Class<?> type, final boolean reachedDirectly) {
     if (!shouldAnalyzeType(type)) {
       return;
     }
 
-    if (!processedTypes.add(type)) {
-      return; // Already processed
-    }
+    final boolean polymorphic = isPolymorphicBase(type);
+    final boolean firstVisit = processedTypes.add(type);
+    final boolean newPolymorphicReach = polymorphic && reachedDirectly && polymorphicallyReachedTypes.add(type);
 
-    // Print the class hierarchy if we haven't seen this type before
-    if (!printedTypes.contains(type.getName())) {
-      printClassHierarchy(type);
-      printedTypes.add(type.getName());
+    if (!firstVisit && !newPolymorphicReach) {
+      return;
     }
 
-    // If this type has a custom parser, skip adding it for generation
-    // but continue analyzing its fields and subtypes
-    if (!hasCustomParser(type)) {
-      addTypeForGeneration(type);
-    } else {
-      logger.info("Skipping parser generation for " + type.getName() + " (has custom parser)");
-    }
+    if (firstVisit) {
+      if (!printedTypes.contains(type.getName())) {
+        printClassHierarchy(type);
+        printedTypes.add(type.getName());
+      }
 
-    // Find and process superclasses
-    final Class<?> superclass = type.getSuperclass();
-    if (superclass != null && superclass != Object.class) {
-      analyzeTypeAndSubtypes(superclass);
-    }
+      if (!hasCustomParser(type)) {
+        addTypeForGeneration(type);
+      } else {
+        logger.info("Skipping parser generation for " + type.getName() + " (has custom parser)");
+      }
 
-    final JsonSubTypes subTypesAnnotation = type.getAnnotation(JsonSubTypes.class);
-    final JsonTypeInfo typeInfoAnnotation = type.getAnnotation(JsonTypeInfo.class); // Check presence of base annotation too
+      // Superclasses are not "directly reached" - if the superclass is a
+      // polymorphic base, sibling subtypes stay unwalked.
+      final Class<?> superclass = type.getSuperclass();
+      if (superclass != null && superclass != Object.class) {
+        analyzeTypeAndSubtypes(superclass, false);
+      }
 
-    if (subTypesAnnotation != null && typeInfoAnnotation != null) { // Only process if both are present
+      for (final Field field : ConstructorAnalyzer.getParseableFields(type)) {
+        try {
+          analyzeField(field);
+        } catch (final TypeNotPresentException e) {
+          skippedTypes.add(e.typeName());
+        }
+      }
+    }
+
+    // Only expand @JsonSubTypes when the polymorphic base was reached directly.
+    if (newPolymorphicReach) {
+      final JsonSubTypes subTypesAnnotation = type.getAnnotation(JsonSubTypes.class);
       logger.info("Found @JsonSubTypes on: " + type.getName() + ", analyzing listed subtypes...");
       for (final JsonSubTypes.Type subType : subTypesAnnotation.value()) {
         final Class<?> subTypeValue = subType.value();
         logger.info("  - Analyzing subtype: " + subTypeValue.getName());
-        analyzeTypeAndSubtypes(subTypeValue); // Recursive call for the subtype
+        analyzeTypeAndSubtypes(subTypeValue, true);
       }
     }
+  }
 
-    // Always analyze fields, even for types with custom parsers
-    // This ensures we discover all types that might need parsers
-    for (final Field field : ConstructorAnalyzer.getParseableFields(type)) {
-      try {
-        analyzeField(field);
-      } catch (final TypeNotPresentException e) {
-        skippedTypes.add(e.typeName());
-      }
-    }
+  private boolean isPolymorphicBase(final Class<?> type) {
+    return type.isAnnotationPresent(JsonSubTypes.class) && type.isAnnotationPresent(JsonTypeInfo.class);
   }
 
   private void analyzeField(final Field field) {
@@ -214,12 +232,12 @@ private void analyzeType(final Type type) {
       if (isUnsupportedType(classType)) {
         throw new UnsupportedTypeException(classType.getName(), "type parameter/element", Object.class);
       }
-      analyzeTypeAndSubtypes(classType);
+      analyzeTypeAndSubtypes(classType, true);
     } else if (type instanceof ParameterizedType) {
       final ParameterizedType paramType = (ParameterizedType) type;
       // Analyze the raw type
       if (paramType.getRawType() instanceof Class<?>) {
-        analyzeTypeAndSubtypes((Class<?>) paramType.getRawType());
+        analyzeTypeAndSubtypes((Class<?>) paramType.getRawType(), true);
       }
       // Analyze all type arguments recursively
       for (final Type typeArg : paramType.getActualTypeArguments()) {

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

@@ -20,15 +20,18 @@ public class ParserWriter {
   private final String generatorDetails;
   private final ClassFinder classFinder;
   private final Logger logger;
+  private final Set<Class<?>> polymorphicallyReachedTypes;
 
   public ParserWriter(final String outputDir, final String parserPackage, final String generatorName,
-      final String generatorDetails, final ClassFinder classFinder, final Logger logger) {
+      final String generatorDetails, final ClassFinder classFinder, final Logger logger,
+      final Set<Class<?>> polymorphicallyReachedTypes) {
     this.outputDir = outputDir;
     this.parserPackage = parserPackage;
     this.generatorName = generatorName;
     this.generatorDetails = generatorDetails;
     this.classFinder = classFinder;
     this.logger = logger;
+    this.polymorphicallyReachedTypes = polymorphicallyReachedTypes;
   }
 
   /**
@@ -43,8 +46,10 @@ public void generateParser(final Class<?> targetClass) throws IOException {
     // Create the parser type specification, passing both name and details
     final TypeSpec.Builder typeSpec = ParserWriterUtils.createParserTypeSpec(parserClassName, generatorName, generatorDetails);
 
+    final boolean usePolymorphicDispatch = polymorphicallyReachedTypes.contains(targetClass);
+
     // Add parser methods
-    ParserWriterUtils.generateParserForFields(typeSpec, targetClass, parserPackage, classFinder);
+    ParserWriterUtils.generateParserForFields(typeSpec, targetClass, parserPackage, classFinder, usePolymorphicDispatch);
 
     // Write to file
     ParserWriterUtils.writeParserToFile(outputDir, parserPackage, typeSpec.build(), parserClassName, logger);

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

@@ -119,13 +119,15 @@ public static void registerCustomParser(final String typeName, final String pack
   }
 
   /**
-   * Main entry point for generating a parser class.
-   * Creates both parse(String) and parse(JSONObjectHandle) methods.
-   * For constructor-based types (no setters), generates constructor-based parse method.
-   * @param classFinder
+   * Main entry point for generating a parser class. When
+   * {@code usePolymorphicDispatch} is false on a class that has
+   * {@code @JsonTypeInfo}/{@code @JsonSubTypes}, a standard parse method is
+   * emitted instead of the discriminator switch - the caller has determined
+   * the type is reached only via a concrete subtype and the sibling subtype
+   * parsers are not generated.
    */
   public static void generateParserForFields(final TypeSpec.Builder typeSpec, final Class<?> targetClass, final String parserPackage,
-      final ClassFinder classFinder) {
+      final ClassFinder classFinder, final boolean usePolymorphicDispatch) {
     typeSpec.addMethod(createStringParseMethod(targetClass));
 
     // Check if this class should use constructor-based parsing
@@ -136,16 +138,16 @@ public static void generateParserForFields(final TypeSpec.Builder typeSpec, fina
       typeSpec.addMethod(createConstructorBasedParseMethod(targetClass, parserPackage, constructorInfo.get()));
     } else {
       // Setter-based: existing approach
-      addSetterBasedParseMethods(typeSpec, targetClass, parserPackage);
+      addSetterBasedParseMethods(typeSpec, targetClass, parserPackage, usePolymorphicDispatch);
     }
   }
 
   /**
    * Adds setter-based parse methods to the type specification.
    */
   private static void addSetterBasedParseMethods(final TypeSpec.Builder typeSpec, final Class<?> targetClass,
-      final String parserPackage) {
-    if (hasJsonTypeInfoWithNameDiscriminator(targetClass)) {
+      final String parserPackage, final boolean usePolymorphicDispatch) {
+    if (usePolymorphicDispatch) {
       typeSpec.addMethod(createPolymorphicObjectParseMethod(targetClass, parserPackage));
     } else {
       typeSpec.addMethod(createStandardObjectParseMethod(targetClass, parserPackage));

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/analyzer/TypeAnalyzerTest.java

@@ -12,6 +12,10 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.JsonTypeInfo.Id;
 import com.palantir.javapoet.ClassName;
 
 import nl.aerius.codegen.util.ClassFinder;
@@ -50,6 +54,25 @@ void testCustomParserTypeHandling() {
     assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_CustomParserTestClass")));
   }
 
+  @Test
+  void abstractBaseReachedViaConcreteSubtypeOnlyDoesNotExpandSiblings() {
+    final Set<ClassName> types = analyzer.analyzeClass(ConcreteOnlyRootClass.class.getName());
+
+    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubAlpha")));
+    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolyAbstractBase")));
+    assertFalse(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubBeta")));
+    assertFalse(analyzer.getPolymorphicallyReachedTypes().contains(PolyAbstractBase.class));
+  }
+
+  @Test
+  void abstractBaseReachedDirectlyExpandsAllSubtypes() {
+    final Set<ClassName> types = analyzer.analyzeClass(AbstractFieldRootClass.class.getName());
+
+    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubAlpha")));
+    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubBeta")));
+    assertTrue(analyzer.getPolymorphicallyReachedTypes().contains(PolyAbstractBase.class));
+  }
+
   @Test
   void testNestedCollectionTypes() {
     final Set<ClassName> types = analyzer.analyzeClass(NestedCollectionTestClass.class.getName());
@@ -99,4 +122,29 @@ private enum TestEnum {
   private static class ComplexNestedTestClass {
     private Map<TestEnum, Map<Integer, Map<Integer, String>>> complexNestedMap;
   }
+
+  @JsonTypeInfo(use = Id.NAME, property = "_type")
+  @JsonSubTypes({
+      @Type(value = PolySubAlpha.class, name = "alpha"),
+      @Type(value = PolySubBeta.class, name = "beta")
+  })
+  private static abstract class PolyAbstractBase {
+    private String baseLabel;
+  }
+
+  private static class PolySubAlpha extends PolyAbstractBase {
+    private int alphaValue;
+  }
+
+  private static class PolySubBeta extends PolyAbstractBase {
+    private boolean betaFlag;
+  }
+
+  private static class ConcreteOnlyRootClass {
+    private PolySubAlpha onlyConcrete;
+  }
+
+  private static class AbstractFieldRootClass {
+    private PolyAbstractBase polymorphic;
+  }
 }

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/test/GeneratedParserValidationTest.java

@@ -9,6 +9,7 @@
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestFactory;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestInstance.Lifecycle;
@@ -65,5 +66,10 @@ Stream<DynamicTest> shouldGenerateMatchingParsers() throws IOException {
     });
   }
 
-  // Removed compareAllParsers method as logic moved to @TestFactory
+  @Test
+  void shouldSkipSiblingSubtypeWhenOnlyConcreteSubtypeIsReached() {
+    final Path siblingParser = outputDir.resolve("nl/aerius/codegen/test/generated/TestSinglePolySubYParser.java");
+    Assertions.assertFalse(Files.exists(siblingParser),
+        "Sibling subtype parser must not be generated when only the other concrete subtype is referenced: " + siblingParser);
+  }
 }

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/test/types/TestConcreteSubtypeOnlyType.java

@@ -0,0 +1,25 @@
+package nl.aerius.codegen.test.types;
+
+import nl.aerius.codegen.test.types.polymorphic.TestSinglePolySubX;
+
+/**
+ * References only one concrete subtype of a polymorphic hierarchy. The
+ * sibling subtype (TestSinglePolySubY) must not get a generated parser.
+ */
+public class TestConcreteSubtypeOnlyType {
+  private TestSinglePolySubX onlySubtype;
+
+  public TestSinglePolySubX getOnlySubtype() {
+    return onlySubtype;
+  }
+
+  public void setOnlySubtype(TestSinglePolySubX onlySubtype) {
+    this.onlySubtype = onlySubtype;
+  }
+
+  public static TestConcreteSubtypeOnlyType createFullObject() {
+    TestConcreteSubtypeOnlyType obj = new TestConcreteSubtypeOnlyType();
+    obj.setOnlySubtype(new TestSinglePolySubX("labelX", 99));
+    return obj;
+  }
+}

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/test/types/TestRootObjectType.java

@@ -21,6 +21,7 @@ public class TestRootObjectType {
   private TestNestedMapType nestedMapType;
 
   private TestPolyBase testPolyBase;
+  private TestConcreteSubtypeOnlyType concreteSubtypeOnly;
   private TestPrimitiveArrayType primitiveArrays;
   private TestConstructorBasedType constructorBased;
   private TestConstructorWithGenericsType constructorWithGenerics;
@@ -131,6 +132,14 @@ public void setTestPolyBase(TestPolyBase testPolyBase) {
     this.testPolyBase = testPolyBase;
   }
 
+  public TestConcreteSubtypeOnlyType getConcreteSubtypeOnly() {
+    return concreteSubtypeOnly;
+  }
+
+  public void setConcreteSubtypeOnly(TestConcreteSubtypeOnlyType concreteSubtypeOnly) {
+    this.concreteSubtypeOnly = concreteSubtypeOnly;
+  }
+
   public TestPrimitiveArrayType getPrimitiveArrays() {
     return primitiveArrays;
   }
@@ -186,6 +195,7 @@ public static TestRootObjectType createFullObject() {
     obj.setConcreteType(ConcreteType.createFullObject());
     obj.setNestedMapType(TestNestedMapType.createFullObject());
     obj.setTestPolyBase(new TestPolySubA("BaseValueA", 123));
+    obj.setConcreteSubtypeOnly(TestConcreteSubtypeOnlyType.createFullObject());
     obj.setPrimitiveArrays(TestPrimitiveArrayType.createFullObject());
     obj.setConstructorBased(TestConstructorBasedType.createFullObject());
     obj.setConstructorWithGenerics(TestConstructorWithGenericsType.createFullObject());
@@ -234,6 +244,7 @@ public static TestRootObjectType createNullObject() {
     obj.setConcreteType(null);
     obj.setNestedMapType(null);
     obj.setTestPolyBase(null);
+    obj.setConcreteSubtypeOnly(null);
     obj.setPrimitiveArrays(null);
     return obj;
   }