Refactor Bean property introspection

src/main/java/com/fasterxml/jackson/databind/introspect/POJOPropertiesCollector.java

@@ -8,6 +8,7 @@
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.cfg.ConstructorDetector;
 import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
 import com.fasterxml.jackson.databind.cfg.MapperConfig;
 import com.fasterxml.jackson.databind.jdk14.JDK14Util;
@@ -88,7 +89,7 @@ public class POJOPropertiesCollector
      */
     protected LinkedHashMap<String, POJOPropertyBuilder> _properties;
 
-    protected LinkedList<POJOPropertyBuilder> _creatorProperties;
+    protected List<POJOPropertyBuilder> _creatorProperties;
 
     /**
      * A set of "field renamings" that have been discovered, indicating
@@ -430,7 +431,7 @@ protected void collectAll()
         //    inner classes, see [databind#1502]
         // 13-May-2023, PJ: Need to avoid adding creators for Records when serializing [databind#3925]
         if (!_classDef.isNonStaticInnerClass() && !(_forSerialization && isRecord)) {
-            _addCreators(props);
+            _addPotentialCreators(props);
         }
 
         // Remove ignored properties, first; this MUST precede annotation merging
@@ -614,9 +615,162 @@ protected void _addFields(Map<String, POJOPropertyBuilder> props)
         }
     }
 
+    // @since 2.18
+    protected void _addPotentialCreators(Map<String, POJOPropertyBuilder> props)
+    {
+        _creatorProperties = new ArrayList<>();
+
+        // First, resolve explicit annotations:
+        List<PotentialCreator> ctors = _collectCreators(_classDef.getConstructors());
+        List<PotentialCreator> factories = _collectCreators(_classDef.getFactoryMethods());
+
+        final PotentialCreators collector = new PotentialCreators(ctors, factories);
+
+        // and use them to find highest precedence Creators
+        if (_useAnnotations) { // can't have explicit ones without Annotation introspection
+            // Start with Constructors as they have higher precedence:
+            _addExplicitCreators(collector, collector.constructors, props, false);
+            // followed by Factory methods (lower precedence)
+            _addExplicitCreators(collector, collector.factories, props,
+                    collector.propertiesBased != null);
+        }
+
+        final boolean hasExplicit = collector.hasParametersBasedOrDelegating();
+
+        // Find canonical (record) Constructor if no explicitly marked creators:
+        if (!hasExplicit) {
+            // !!! TODO
+        }
+
+        PotentialCreator primary = collector.propertiesBased;
+        if (primary != null) {
+            _addExplicitCreatorParams(props, primary);
+        }
+    }
+
+    private List<PotentialCreator> _collectCreators(List<? extends AnnotatedWithParams> ctors)
+    {
+        List<PotentialCreator> result = null;
+        for (AnnotatedWithParams ctor : ctors) {
+            JsonCreator.Mode creatorMode = _useAnnotations
+                    ? _annotationIntrospector.findCreatorAnnotation(_config, ctor) : null;
+            // explicitly prevented? Remove
+            if (creatorMode == JsonCreator.Mode.DISABLED) {
+                continue;
+            }
+            if (result == null) {
+                result = new ArrayList<>();
+            }
+            result.add(new PotentialCreator(ctor, creatorMode));
+        }
+        return (result == null) ? Collections.emptyList() : result;
+    }
+
+    private void _addExplicitCreators(PotentialCreators collector, List<PotentialCreator> ctors,
+            Map<String, POJOPropertyBuilder> props,
+            boolean skipPropsBased)
+    {
+        final ConstructorDetector ctorDetector = _config.getConstructorDetector();
+        Iterator<PotentialCreator> it = ctors.iterator();
+        while (it.hasNext()) {
+            PotentialCreator ctor = it.next();
+
+            final int paramCount = ctor.paramCount();
+            if (paramCount == 0) {
+                it.remove();
+                collector.addDefault(ctor.creator);
+                continue;
+            }
+
+            if (ctor.creatorMode == null) {
+                continue;
+            }
+            it.remove();
+
+            Boolean propsBased = null;
+
+            switch (ctor.creatorMode) {
+            case DELEGATING:
+                propsBased = false;
+                break;
+            case PROPERTIES:
+                propsBased = true;
+                break;
+            case DEFAULT:
+            default:
+                // First things first: if not single-arg Creator, must be Properties-based
+                // !!! Or does it? What if there's @JacksonInject etc?
+                if (paramCount != 1) {
+                    propsBased = true;
+                }
+            }
+
+            // Must be 1-arg case:
+            if (propsBased == null) {
+                // Is ambiguity/heuristics allowed?
+                if (ctorDetector.requireCtorAnnotation()) {
+                    throw new IllegalArgumentException(String.format(
+                            "Ambiguous 1-argument Creator; `ConstructorDetector` requires specifying `mode`: %s",
+                            ctor));
+                }
+
+                // First things first: if explicit names found, is Properties-based
+                ctor.introspectParamNames(_config);
+                propsBased = ctor.hasExplicitNames()
+                        || ctorDetector.singleArgCreatorDefaultsToProperties();
+                // One more possibility: implicit name that maps to implied
+                // property based on Field/Getter/Setter
+                if (!propsBased) {
+                    String implName = ctor.implicitNameSimple(0);
+                    propsBased = (implName != null) && props.containsKey(implName);
+                }
+            }
+
+            if (propsBased) {
+                // Skipping done if we already got higher-precedence Creator
+                if (!skipPropsBased) {
+                    collector.addPropertiesBased(_config, ctor, "explicit");
+                }
+            } else {
+                collector.addDelegating(ctor);
+            }
+        }
+    }
+
+    private void _addExplicitCreatorParams(Map<String, POJOPropertyBuilder> props,
+            PotentialCreator ctor)
+    {
+        for (int i = 0, len = ctor.paramCount(); i < len; ++i) {
+            final AnnotatedParameter param = ctor.param(i);
+            final PropertyName explName = ctor.explicitName(i);
+            PropertyName implName = ctor.implicitName(i);
+            final boolean hasExplicit = (explName != null);
+
+            if (!hasExplicit) {
+                if (implName == null) {
+                    // Important: if neither implicit nor explicit name, cannot make use of
+                    // this creator parameter -- may or may not be a problem, verified at a later point.
+                    continue;
+                }
+            }
+
+            // 27-Dec-2019, tatu: [databind#2527] may need to rename according to field
+            if (implName != null) {
+                String n = _checkRenameByField(implName.getSimpleName());
+                implName = PropertyName.construct(n);
+            }
+
+            POJOPropertyBuilder prop = (implName == null)
+                    ? _property(props, explName) : _property(props, implName);
+            prop.addCtor(param, hasExplicit ? explName : implName, hasExplicit, true, false);
+            _creatorProperties.add(prop);
+        }
+    }
+
     /**
      * Method for collecting basic information on constructor(s) found
      */
+    @Deprecated
     protected void _addCreators(Map<String, POJOPropertyBuilder> props)
     {
         // can be null if annotation processing is disabled...

src/main/java/com/fasterxml/jackson/databind/introspect/PotentialCreator.java

@@ -0,0 +1,119 @@
+package com.fasterxml.jackson.databind.introspect;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.databind.AnnotationIntrospector;
+import com.fasterxml.jackson.databind.PropertyName;
+import com.fasterxml.jackson.databind.cfg.MapperConfig;
+
+/**
+ * Information about a single Creator (constructor or factory method),
+ * kept during property introspection.
+ *
+ * @since 2.18
+ */
+public class PotentialCreator
+{
+    private static final PropertyName[] NO_NAMES = new PropertyName[0];
+
+    public final AnnotatedWithParams creator;
+
+    public final JsonCreator.Mode creatorMode;
+
+    private PropertyName[] implicitParamNames;
+
+    private PropertyName[] explicitParamNames;
+
+    public PotentialCreator(AnnotatedWithParams cr,
+            JsonCreator.Mode cm)
+    {
+        creator = cr;
+        creatorMode = cm;
+    }
+
+    /*
+    /**********************************************************************
+    /* Mutators
+    /**********************************************************************
+     */
+
+    public PotentialCreator introspectParamNames(MapperConfig<?> config)
+    {
+        if (implicitParamNames != null) {
+            return this;
+        }
+
+        final AnnotationIntrospector intr = config.getAnnotationIntrospector();
+        final int paramCount = creator.getParameterCount();
+
+        if (paramCount == 0) {
+            implicitParamNames = explicitParamNames = NO_NAMES;
+            return this;
+        }
+
+        explicitParamNames = new PropertyName[paramCount];
+        implicitParamNames = new PropertyName[paramCount];
+
+        for (int i = 0; i < paramCount; ++i) {
+            AnnotatedParameter param = creator.getParameter(i);
+
+            String rawImplName = intr.findImplicitPropertyName(param);
+            if (rawImplName != null && !rawImplName.isEmpty()) {
+                implicitParamNames[i] = PropertyName.construct(rawImplName);
+            }
+            PropertyName explName = intr.findNameForDeserialization(param);
+            if (explName != null && !explName.isEmpty()) {
+                explicitParamNames[i] = explName;
+            }
+        }
+        return this;
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors
+    /**********************************************************************
+     */
+
+    public int paramCount() {
+        return creator.getParameterCount();
+    }
+
+    public AnnotatedParameter param(int ix) {
+        return creator.getParameter(ix);
+    }
+
+    public boolean hasExplicitNames() {
+        for (int i = 0, end = explicitParamNames.length; i < end; ++i) {
+            if (explicitParamNames[i] != null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public PropertyName explicitName(int ix) {
+        return explicitParamNames[ix];
+    }
+
+    public PropertyName implicitName(int ix) {
+        return implicitParamNames[ix];
+    }
+
+    public String implicitNameSimple(int ix) {
+        PropertyName pn = implicitParamNames[ix];
+        return (pn == null) ? null : pn.getSimpleName();
+    }
+
+    /*
+    /**********************************************************************
+    /* Misc other
+    /**********************************************************************
+     */
+
+    // For troubleshooting
+    @Override
+    public String toString() {
+        return "(mode="+creatorMode+")"+creator;
+    }
+}
+

src/main/java/com/fasterxml/jackson/databind/introspect/PotentialCreators.java

@@ -0,0 +1,65 @@
+package com.fasterxml.jackson.databind.introspect;
+
+import java.util.*;
+
+import com.fasterxml.jackson.databind.cfg.MapperConfig;
+
+public class PotentialCreators
+{
+    public final List<PotentialCreator> constructors;
+
+    public final List<PotentialCreator> factories;
+
+    /**
+     * Property-based Creator found, if any
+     */
+    public PotentialCreator propertiesBased;
+
+    public AnnotatedWithParams defaultCreator;
+
+    public final List<PotentialCreator> delegating = new ArrayList<>();
+
+    public PotentialCreators(List<PotentialCreator> constructors,
+            List<PotentialCreator> factories)
+    {
+        this.constructors = constructors;
+        this.factories = factories;
+    }
+
+    /*
+    /**********************************************************************
+    /* Accumulating candidates
+    /**********************************************************************
+     */
+
+    // desc -> "explicit", "implicit" etc
+    public void addPropertiesBased(MapperConfig<?> config, PotentialCreator ctor, String mode)
+    {
+        if (propertiesBased != null) {
+            throw new IllegalArgumentException(String.format(
+                    "Conflicting property-based creators: already had %s creator %s, encountered another: %s",
+                    mode, propertiesBased.creator, ctor.creator));
+        }
+        propertiesBased = ctor.introspectParamNames(config);
+    }
+
+    public void addDelegating(PotentialCreator ctor)
+    {
+        delegating.add(ctor);
+    }
+
+    public void addDefault(AnnotatedWithParams ctor)
+    {
+        defaultCreator = ctor;
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors
+    /**********************************************************************
+     */
+
+    public boolean hasParametersBasedOrDelegating() {
+        return (propertiesBased != null) || !delegating.isEmpty();
+    }
+}