Merge branch '2.18' into 2.19

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/AnnotationIntrospector.java

@@ -1399,14 +1399,14 @@ public JsonCreator.Mode findCreatorAnnotation(MapperConfig<?> config, Annotated
 
     /**
      * Method called to check if introspector can find a Creator it considers
-     * the "Default Creator": Creator to use as the primary, when no Creator has
+     * the "Primary Creator": Creator to use as the primary one, when no Creator has
      * explicit annotation ({@link #findCreatorAnnotation} returns {@code null}).
      * Examples of default creators include the canonical constructor defined by
      * Java Records; "Data" classes by frameworks
      * like Lombok and JVM languages like Kotlin and Scala (case classes) also have
      * similar concepts.
      * If introspector can determine that one of given {@link PotentialCreator}s should
-     * be considered the default, it should return it; if not, should return {@code null}.
+     * be considered the primary, it should return it; if not, should return {@code null}.
      * Note that core databind functionality may call this method even in the presence of
      * explicitly annotated creators; and may or may not use Creator returned depending
      * on other criteria.
@@ -1416,6 +1416,11 @@ public JsonCreator.Mode findCreatorAnnotation(MapperConfig<?> config, Annotated
      *<p>
      * NOTE: method is NOT called for Java Record types; selection of the canonical constructor
      * as the Primary creator is handled directly by {@link POJOPropertiesCollector}
+     *<p>
+     * NOTE: naming of this method is unfortunately inconsistent in that "default Creator"
+     * has other meanings than "primary Creator" -- in other places Jackson code
+     * refers to no-arguments Constructors as "default Creators". So this method
+     * ought to have been named {@code findPrimaryCreator()}.
      *
      * @param config Configuration settings in effect (for deserialization)
      * @param valueClass Class being instantiated; defines Creators passed

src/main/java/com/fasterxml/jackson/databind/deser/impl/CreatorCollector.java

@@ -122,9 +122,7 @@ public ValueInstantiator constructValueInstantiator(DeserializationContext ctxt)
      * it with data. Default creator is only used if no other creators are
      * indicated.
      *
-     * @param creator
-     *            Creator method; no-arguments constructor or static factory
-     *            method.
+     * @param creator Creator method; no-arguments constructor or factory method.
      */
     public void setDefaultCreator(AnnotatedWithParams creator) {
         _creators[C_DEFAULT] = _fixAccess(creator);

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

@@ -739,13 +739,13 @@ public PotentialCreator findDefaultCreator(MapperConfig<?> config,
             AnnotatedClass valueClass,
             List<PotentialCreator> declaredConstructors,
             List<PotentialCreator> declaredFactories) {
-        PotentialCreator defCtor = _primary.findDefaultCreator(config,
+        PotentialCreator primaryCtor = _primary.findDefaultCreator(config,
                 valueClass, declaredConstructors, declaredFactories);
-        if (defCtor == null) {
-            defCtor = _secondary.findDefaultCreator(config,
+        if (primaryCtor == null) {
+            primaryCtor = _secondary.findDefaultCreator(config,
                     valueClass, declaredConstructors, declaredFactories);
         }
-        return defCtor;
+        return primaryCtor;
     }
 
     /*

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

@@ -656,22 +656,25 @@ protected void _addCreators(Map<String, POJOPropertyBuilder> props)
         List<PotentialCreator> constructors = _collectCreators(_classDef.getConstructors());
         List<PotentialCreator> factories = _collectCreators(_classDef.getFactoryMethods());
 
-        // Then find what is the Default Constructor (if one exists for type):
+        // Then find what is the Primary Constructor (if one exists for type):
         // for Java Records and potentially other types too ("data classes"):
         // Needs to be done early to get implicit names populated
-        final PotentialCreator defaultCreator;
+        final PotentialCreator primaryCreator;
         if (_isRecordType) {
-            defaultCreator = JDK14Util.findCanonicalRecordConstructor(_config, _classDef, constructors);
+            primaryCreator = JDK14Util.findCanonicalRecordConstructor(_config, _classDef, constructors);
         } else {
-            defaultCreator = _annotationIntrospector.findDefaultCreator(_config, _classDef,
+            // 02-Nov-2024, tatu: Alas, naming here is confusing: method properly
+            //    should have been "findPrimaryCreator()" so as not to confused with
+            //    0-args default Creators...
+            primaryCreator = _annotationIntrospector.findDefaultCreator(_config, _classDef,
                     constructors, factories);
         }
         // Next: remove creators marked as explicitly disabled
         _removeDisabledCreators(constructors);
         _removeDisabledCreators(factories);
 
         // And then remove non-annotated static methods that do not look like factories
-        _removeNonFactoryStaticMethods(factories, defaultCreator);
+        _removeNonFactoryStaticMethods(factories, primaryCreator);
 
         // and use annotations to find explicitly chosen Creators
         if (_useAnnotations) { // can't have explicit ones without Annotation introspection
@@ -682,30 +685,30 @@ protected void _addCreators(Map<String, POJOPropertyBuilder> props)
                     creators.hasPropertiesBased());
         }
 
-        // If no Explicitly annotated creators (or Default one) found, look
+        // If no Explicitly annotated creators (or Primary one) found, look
         // for ones with explicitly-named ({@code @JsonProperty}) parameters
         if (!creators.hasPropertiesBased()) {
             // only discover constructor Creators?
-            _addCreatorsWithAnnotatedNames(creators, constructors, defaultCreator);
+            _addCreatorsWithAnnotatedNames(creators, constructors, primaryCreator);
         }
 
-        // But if no annotation-based Creators found, find/use Default Creator
+        // But if no annotation-based Creators found, find/use Primary Creator
         // detected earlier, if any
-        if (defaultCreator != null) {
+        if (primaryCreator != null) {
             // ... but only process if still included as a candidate
-            if (constructors.remove(defaultCreator)
-                    || factories.remove(defaultCreator)) {
+            if (constructors.remove(primaryCreator)
+                    || factories.remove(primaryCreator)) {
                 // and then consider delegating- vs properties-based
-                if (_isDelegatingConstructor(defaultCreator)) {
+                if (_isDelegatingConstructor(primaryCreator)) {
                     // 08-Oct-2024, tatu: [databind#4724] Only add if no explicit
                     //    candidates added
                     if (!creators.hasDelegating()) {
                         // ... not technically explicit but simpler this way
-                        creators.addExplicitDelegating(defaultCreator);
+                        creators.addExplicitDelegating(primaryCreator);
                     }
-                } else { // default creator is properties-based
+                } else { // primary creator is properties-based
                     if (!creators.hasPropertiesBased()) {
-                        creators.setPropertiesBased(_config, defaultCreator, "Primary");
+                        creators.setPropertiesBased(_config, primaryCreator, "Primary");
                     }
                 }
             }
@@ -717,7 +720,7 @@ protected void _addCreators(Map<String, POJOPropertyBuilder> props)
         final ConstructorDetector ctorDetector = _config.getConstructorDetector();
         if (!creators.hasPropertiesBasedOrDelegating()
                 && !ctorDetector.requireCtorAnnotation()) {
-            // But only if no default constructor available OR if we are configured
+            // But only if no Default (0-args) constructor available OR if we are configured
             // to prefer properties-based Creators
             if ((_classDef.getDefaultConstructor() == null)
                     || ctorDetector.singleArgCreatorDefaultsToProperties()) {
@@ -753,7 +756,7 @@ private boolean _isDelegatingConstructor(PotentialCreator ctor)
         case DISABLED:
         case PROPERTIES:
             return false;
-        default: // case DEFAULT:
+        default:
         }
 
         // Only consider single-arg case, for now
@@ -804,7 +807,7 @@ private void _removeNonVisibleCreators(List<PotentialCreator> ctors)
     }
 
     private void _removeNonFactoryStaticMethods(List<PotentialCreator> ctors,
-            PotentialCreator defaultCreator)
+            PotentialCreator primaryCreator)
     {
         final Class<?> rawType = _type.getRawClass();
         Iterator<PotentialCreator> it = ctors.iterator();
@@ -814,8 +817,8 @@ private void _removeNonFactoryStaticMethods(List<PotentialCreator> ctors,
             if (ctor.isAnnotated()) {
                 continue;
             }
-            // Do not trim canonical either
-            if (defaultCreator == ctor) {
+            // Do not trim Primary creator either
+            if (primaryCreator == ctor) {
                 continue;
             }
             // Copied from `BasicBeanDescription.isFactoryMethod()`
@@ -932,14 +935,14 @@ private boolean _isExplicitlyAnnotatedCreatorPropsBased(PotentialCreator ctor,
     }
 
     private void _addCreatorsWithAnnotatedNames(PotentialCreators collector,
-            List<PotentialCreator> ctors, PotentialCreator defaultCtor)
+            List<PotentialCreator> ctors, PotentialCreator primaryCtor)
     {
         final List<PotentialCreator> found = _findCreatorsWithAnnotatedNames(ctors);
-        // 16-Jul-2024, tatu: [databind#4620] If Default Creator found, it
+        // 16-Jul-2024, tatu: [databind#4620] If Primary Creator found, it
         //    will be used to resolve candidate to use, if any
-        if (defaultCtor != null) {
-            if (found.contains(defaultCtor)) {
-                collector.setPropertiesBased(_config, defaultCtor, "implicit");
+        if (primaryCtor != null) {
+            if (found.contains(primaryCtor)) {
+                collector.setPropertiesBased(_config, primaryCtor, "implicit");
                 return;
             }
         }

src/test/java/com/fasterxml/jackson/databind/tofix/AaaCreator4777Test.java

@@ -0,0 +1,74 @@
+package com.fasterxml.jackson.databind.tofix;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.deser.*;
+import com.fasterxml.jackson.databind.deser.std.StdValueInstantiator;
+import com.fasterxml.jackson.databind.json.JsonMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
+
+public class AaaCreator4777Test extends DatabindTestUtil
+{
+    static class Foo {
+        String whoMadeWho;
+
+        protected Foo() { whoMadeWho = "creator"; } 
+        
+        @JsonCreator
+        static Foo create() {
+            Foo foo = new Foo();
+            foo.whoMadeWho = "factory";
+            return foo;
+        }
+    }
+
+    @SuppressWarnings("serial")
+    static class Instantiator extends StdValueInstantiator {
+        public Instantiator(StdValueInstantiator src) {
+            super(src);
+        }
+    }
+
+    static class Instantiators implements ValueInstantiators {
+        Instantiator last = null;
+
+        @Override
+        public ValueInstantiator findValueInstantiator(
+                DeserializationConfig config,
+                BeanDescription beanDesc,
+                ValueInstantiator defaultInstantiator
+        ) {
+            if (defaultInstantiator instanceof StdValueInstantiator) {
+                Instantiator instantiator = new Instantiator((StdValueInstantiator) defaultInstantiator);
+                last = instantiator;
+                return instantiator;
+            } else {
+                return defaultInstantiator;
+            }
+        }
+    }
+
+    @Test
+    public void test() throws Exception {
+        Instantiators i = new Instantiators();
+
+        SimpleModule sm = new SimpleModule() {
+            @Override
+            public void setupModule(SetupContext context) {
+                super.setupModule(context);
+                context.addValueInstantiators(i);
+            }
+        };
+        ObjectMapper mapper = JsonMapper.builder().addModule(sm).build();
+
+        Foo result = mapper.readValue("{}", Foo.class);
+
+        Assertions.assertEquals("factory", result.whoMadeWho);
+        
+        Assertions.assertNull(i.last.getWithArgsCreator());
+    }
+}