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/analyzer/TypeAnalyzer.java

@@ -106,7 +106,7 @@ public Set<ClassName> analyzeClass(final String className) {
       printedTypes.clear();
       polymorphicallyReachedTypes.clear();
 
-      analyzeTypeAndSubtypes(rootClass);
+      analyzeTypeAndSubtypes(rootClass, true);
 
       if (!skippedTypes.isEmpty()) {
         logger.info("Warning: The following types were not found and skipped:");
@@ -120,21 +120,15 @@ public Set<ClassName> analyzeClass(final String className) {
   }
 
   /**
-   * Returns the polymorphic base types that were reached directly (as a field
-   * type or type argument) during the most recent analysis. Such types need a
-   * polymorphic dispatch parser; polymorphic bases reached only via a concrete
-   * subtype's superclass walk are absent from this set and should be emitted as
-   * standard parsers (so the concrete subtype can still parse its inherited
-   * fields without forcing sibling subtypes to be generated).
+   * 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) {
-    analyzeTypeAndSubtypes(type, true);
-  }
-
   private void analyzeTypeAndSubtypes(final Class<?> type, final boolean reachedDirectly) {
     if (!shouldAnalyzeType(type)) {
       return;
@@ -145,34 +139,28 @@ private void analyzeTypeAndSubtypes(final Class<?> type, final boolean reachedDi
     final boolean newPolymorphicReach = polymorphic && reachedDirectly && polymorphicallyReachedTypes.add(type);
 
     if (!firstVisit && !newPolymorphicReach) {
-      return; // Already processed and no new direct reach to expand on
+      return;
     }
 
     if (firstVisit) {
-      // Print the class hierarchy if we haven't seen this type before
       if (!printedTypes.contains(type.getName())) {
         printClassHierarchy(type);
         printedTypes.add(type.getName());
       }
 
-      // 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)");
       }
 
-      // Walk superclasses, but mark them as not-directly-reached so a polymorphic
-      // base discovered only via a concrete subtype's superclass chain does not
-      // expand into its sibling subtypes.
+      // 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);
       }
 
-      // 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);
@@ -244,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

@@ -1,7 +1,6 @@
 package nl.aerius.codegen.generator;
 
 import java.io.IOException;
-import java.util.Collections;
 import java.util.Set;
 
 import com.palantir.javapoet.ClassName;
@@ -23,11 +22,6 @@ public class ParserWriter {
   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) {
-    this(outputDir, parserPackage, generatorName, generatorDetails, classFinder, logger, Collections.emptySet());
-  }
-
   public ParserWriter(final String outputDir, final String parserPackage, final String generatorName,
       final String generatorDetails, final ClassFinder classFinder, final Logger logger,
       final Set<Class<?>> polymorphicallyReachedTypes) {

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

@@ -119,24 +119,12 @@ 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
-   */
-  public static void generateParserForFields(final TypeSpec.Builder typeSpec, final Class<?> targetClass, final String parserPackage,
-      final ClassFinder classFinder) {
-    generateParserForFields(typeSpec, targetClass, parserPackage, classFinder,
-        hasJsonTypeInfoWithNameDiscriminator(targetClass));
-  }
-
-  /**
-   * Main entry point for generating a parser class with explicit polymorphic
-   * dispatch control. When {@code usePolymorphicDispatch} is false on a class
-   * that has @JsonTypeInfo/@JsonSubTypes, a standard parse method is emitted
-   * instead of the discriminator switch - used when the analyzer determined
-   * the type is reachable only via a concrete subtype, so sibling subtype
-   * parsers are not generated and a polymorphic switch would not compile.
+   * 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 boolean usePolymorphicDispatch) {

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

@@ -58,26 +58,19 @@ void testCustomParserTypeHandling() {
   void abstractBaseReachedViaConcreteSubtypeOnlyDoesNotExpandSiblings() {
     final Set<ClassName> types = analyzer.analyzeClass(ConcreteOnlyRootClass.class.getName());
 
-    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_ConcreteOnlyRootClass")));
     assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubAlpha")));
-    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolyAbstractBase")),
-        "Abstract base should still be discovered (its parse(handle, config) is invoked by the subtype parser)");
-    assertFalse(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubBeta")),
-        "Sibling subtype must be skipped when the base is only reached via a concrete subtype");
-    assertFalse(analyzer.getPolymorphicallyReachedTypes().contains(PolyAbstractBase.class),
-        "Base reached only via concrete subtype's superclass walk should NOT be flagged for polymorphic dispatch");
+    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_PolyAbstractBase")));
     assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubAlpha")));
-    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubBeta")),
-        "Abstract field type must walk all subtypes for the discriminator switch");
-    assertTrue(analyzer.getPolymorphicallyReachedTypes().contains(PolyAbstractBase.class),
-        "Direct abstract reach must flag the base for polymorphic dispatch generation");
+    assertTrue(types.contains(ClassName.get("nl.aerius.codegen.analyzer", "TypeAnalyzerTest_PolySubBeta")));
+    assertTrue(analyzer.getPolymorphicallyReachedTypes().contains(PolyAbstractBase.class));
   }
 
   @Test
@@ -130,71 +123,28 @@ private static class ComplexNestedTestClass {
     private Map<TestEnum, Map<Integer, Map<Integer, String>>> complexNestedMap;
   }
 
-  // Polymorphic hierarchy used by reach-tracking tests.
   @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;
-
-    public String getBaseLabel() {
-      return baseLabel;
-    }
-
-    public void setBaseLabel(final String baseLabel) {
-      this.baseLabel = baseLabel;
-    }
   }
 
   private static class PolySubAlpha extends PolyAbstractBase {
     private int alphaValue;
-
-    public int getAlphaValue() {
-      return alphaValue;
-    }
-
-    public void setAlphaValue(final int alphaValue) {
-      this.alphaValue = alphaValue;
-    }
   }
 
   private static class PolySubBeta extends PolyAbstractBase {
     private boolean betaFlag;
-
-    public boolean isBetaFlag() {
-      return betaFlag;
-    }
-
-    public void setBetaFlag(final boolean betaFlag) {
-      this.betaFlag = betaFlag;
-    }
   }
 
-  // Field declares the concrete subtype - base is reached only via its superclass chain.
   private static class ConcreteOnlyRootClass {
     private PolySubAlpha onlyConcrete;
-
-    public PolySubAlpha getOnlyConcrete() {
-      return onlyConcrete;
-    }
-
-    public void setOnlyConcrete(final PolySubAlpha onlyConcrete) {
-      this.onlyConcrete = onlyConcrete;
-    }
   }
 
-  // Field declares the abstract base - every subtype must be reachable.
   private static class AbstractFieldRootClass {
     private PolyAbstractBase polymorphic;
-
-    public PolyAbstractBase getPolymorphic() {
-      return polymorphic;
-    }
-
-    public void setPolymorphic(final PolyAbstractBase polymorphic) {
-      this.polymorphic = polymorphic;
-    }
   }
 }

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

@@ -70,10 +70,6 @@ Stream<DynamicTest> shouldGenerateMatchingParsers() throws IOException {
   void shouldSkipSiblingSubtypeWhenOnlyConcreteSubtypeIsReached() {
     final Path siblingParser = outputDir.resolve("nl/aerius/codegen/test/generated/TestSinglePolySubYParser.java");
     Assertions.assertFalse(Files.exists(siblingParser),
-        "TestSinglePolySubYParser should NOT be generated: nothing in the reachable type graph "
-            + "references TestSinglePolyBase abstractly, only TestSinglePolySubX is referenced. "
-            + "Generating a parser for TestSinglePolySubY would force callers to ship hand-written "
-            + "custom parsers for hierarchies that contain unsupported codegen patterns. "
-            + "Found unexpected file at: " + 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

@@ -3,11 +3,8 @@
 import nl.aerius.codegen.test.types.polymorphic.TestSinglePolySubX;
 
 /**
- * Wires only a concrete subtype of a polymorphic hierarchy. The hierarchy's
- * abstract base (TestSinglePolyBase) is reachable via the subtype's superclass
- * chain, but no field is declared as the base itself - so the generator should
- * skip sibling subtype parsers (TestSinglePolySubY) and emit a plain parser
- * for the abstract base rather than a polymorphic discriminator switch.
+ * 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;