Support recursive types in parameterized records

jyemin · jyemin · commit 132041ee90cb · 2022-10-03T14:47:31.000-04:00
Provide codec support for records whose type declarations contain cycles. JAVA-4745
diff --git a/bson-record-codec/src/main/org/bson/codecs/record/RecordCodec.java b/bson-record-codec/src/main/org/bson/codecs/record/RecordCodec.java
@@ -89,12 +89,11 @@ Object getValue(final Record record) throws InvocationTargetException, IllegalAc
         @SuppressWarnings("deprecation")
         private static Codec<?> computeCodec(final List<Type> typeParameters, final RecordComponent component,
                 final CodecRegistry codecRegistry) {
-            var codec = codecRegistry.get(toWrapper(resolveComponentType(typeParameters, component)));
-            if (codec instanceof Parameterizable parameterizableCodec
-                    && component.getGenericType() instanceof ParameterizedType parameterizedType) {
-                codec = parameterizableCodec.parameterize(codecRegistry,
-                        resolveActualTypeArguments(typeParameters, component.getDeclaringRecord(), parameterizedType));
-            }
+            var rawType = toWrapper(resolveComponentType(typeParameters, component));
+            var codec = component.getGenericType() instanceof ParameterizedType parameterizedType
+                    ? codecRegistry.get(rawType,
+                    resolveActualTypeArguments(typeParameters, component.getDeclaringRecord(), parameterizedType))
+                    : codecRegistry.get(rawType);
             BsonType bsonRepresentationType = null;
 
             if (component.isAnnotationPresent(BsonRepresentation.class)) {
diff --git a/bson-record-codec/src/test/unit/org/bson/codecs/record/RecordCodecTest.java b/bson-record-codec/src/test/unit/org/bson/codecs/record/RecordCodecTest.java
@@ -50,6 +50,8 @@
 import org.bson.codecs.record.samples.TestRecordWithNestedParameterizedRecord;
 import org.bson.codecs.record.samples.TestRecordWithParameterizedRecord;
 import org.bson.codecs.record.samples.TestRecordWithPojoAnnotations;
+import org.bson.codecs.record.samples.TestSelfReferentialHolderRecord;
+import org.bson.codecs.record.samples.TestSelfReferentialRecord;
 import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import org.junit.jupiter.api.Test;
@@ -341,6 +343,38 @@ public void testRecordWithExtraData() {
         assertEquals(testRecord, decoded);
     }
 
+    @Test
+    public void testSelfReferentialRecords() {
+        var registry = fromProviders(new RecordCodecProvider(), Bson.DEFAULT_CODEC_REGISTRY);
+        var codec = registry.get(TestSelfReferentialHolderRecord.class);
+        var identifier = new ObjectId();
+        var testRecord = new TestSelfReferentialHolderRecord("0",
+                new TestSelfReferentialRecord<>("1",
+                new TestSelfReferentialRecord<>("2", null, null),
+                new TestSelfReferentialRecord<>("3", null, null)));
+
+        var document = new BsonDocument();
+        var writer = new BsonDocumentWriter(document);
+
+        // when
+        codec.encode(writer, testRecord, EncoderContext.builder().build());
+
+        // then
+        assertEquals(
+                new BsonDocument("_id", new BsonString("0"))
+                        .append("selfReferentialRecord",
+                        new BsonDocument("name", new BsonString("1"))
+                        .append("left", new BsonDocument("name", new BsonString("2")))
+                        .append("right", new BsonDocument("name", new BsonString("3")))),
+                document);
+
+        // when
+        var decoded = codec.decode(new BsonDocumentReader(document), DecoderContext.builder().build());
+
+        // then
+        assertEquals(testRecord, decoded);
+    }
+
     @Test
     public void testExceptionsForAnnotationsNotOnRecordComponent() {
         assertThrows(CodecConfigurationException.class, () ->
diff --git a/bson-record-codec/src/test/unit/org/bson/codecs/record/samples/TestSelfReferentialHolderRecord.java b/bson-record-codec/src/test/unit/org/bson/codecs/record/samples/TestSelfReferentialHolderRecord.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bson.codecs.record.samples;
+
+import org.bson.codecs.pojo.annotations.BsonId;
+
+public record TestSelfReferentialHolderRecord(@BsonId String id,
+                                              TestSelfReferentialRecord<String> selfReferentialRecord) {
+}
diff --git a/bson-record-codec/src/test/unit/org/bson/codecs/record/samples/TestSelfReferentialRecord.java b/bson-record-codec/src/test/unit/org/bson/codecs/record/samples/TestSelfReferentialRecord.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bson.codecs.record.samples;
+
+import com.mongodb.lang.Nullable;
+
+public record TestSelfReferentialRecord<T>(T name,
+                                        @Nullable TestSelfReferentialRecord<T> left,
+                                        @Nullable TestSelfReferentialRecord<T> right) {
+}
diff --git a/bson/src/main/org/bson/codecs/ContainerCodecHelper.java b/bson/src/main/org/bson/codecs/ContainerCodecHelper.java
@@ -71,12 +71,7 @@ static Codec<?> getCodec(final CodecRegistry codecRegistry, final Type type) {
             return codecRegistry.get((Class<?>) type);
         } else if (type instanceof ParameterizedType) {
             ParameterizedType parameterizedType = (ParameterizedType) type;
-            Codec<?> rawCodec = codecRegistry.get((Class<?>) parameterizedType.getRawType());
-            if (rawCodec instanceof Parameterizable) {
-                return ((Parameterizable) rawCodec).parameterize(codecRegistry, Arrays.asList(parameterizedType.getActualTypeArguments()));
-            } else {
-                return rawCodec;
-            }
+            return codecRegistry.get((Class<?>) parameterizedType.getRawType(), Arrays.asList(parameterizedType.getActualTypeArguments()));
         } else {
             throw new CodecConfigurationException("Unsupported generic type of container: " + type);
         }
diff --git a/bson/src/main/org/bson/codecs/configuration/CodecRegistry.java b/bson/src/main/org/bson/codecs/configuration/CodecRegistry.java
@@ -18,6 +18,9 @@
 
 import org.bson.codecs.Codec;
 
+import java.lang.reflect.Type;
+import java.util.List;
+
 /**
  * A registry of Codec instances searchable by the class that the Codec can encode and decode.
  *
@@ -28,7 +31,11 @@
  *
  * <p>As of the 4.0 release, this class extends the {@code CodecProvider} interface.  This capability was introduced to enable nesting
  * registries inside another registry.</p>
+ *
+ * <p>Applications are encouraged to NOT implement this interface, but rather use the factory methods in {@link CodecRegistries}.</p>
+ *
  * @since 3.0
+ * @see CodecRegistries
  */
 public interface CodecRegistry extends CodecProvider {
     /**
@@ -40,4 +47,24 @@ public interface CodecRegistry extends CodecProvider {
      * @throws CodecConfigurationException if the registry does not contain a codec for the given class.
      */
     <T> Codec<T> get(Class<T> clazz);
+
+    /**
+     * Gets a Codec for the given parameterized class, after resolving any type variables with the given type arguments.
+     *
+     * <p>
+     * The default behavior is to throw a {@link CodecConfigurationException}.  Applications are encouraged to either override this
+     * method in their own implementations of this interface, or else use the factory methods in {@link CodecRegistries}.
+     * </p>
+     *
+     * @param clazz the parameterized class
+     * @param typeArguments the type arguments to apply to the parameterized class
+     * @return a codec for the given class, with the given type parameters resolved
+     * @throws CodecConfigurationException by default, if the implementation does not override this method, or if no codec can be found
+     * for the given class and type arguments.
+     * @param <T> the class type
+     * @since 4.8
+     */
+    default <T> Codec<T> get(Class<T> clazz, List<Type> typeArguments) {
+        throw new CodecConfigurationException("Make this message really informative");  // TODO
+    }
 }
diff --git a/bson/src/main/org/bson/internal/ChildCodecRegistry.java b/bson/src/main/org/bson/internal/ChildCodecRegistry.java
@@ -20,36 +20,59 @@
 import org.bson.codecs.Codec;
 import org.bson.codecs.configuration.CodecRegistry;
 
+import javax.annotation.Nullable;
+import java.lang.reflect.Type;
+import java.util.List;
+
 // An implementation of CodecRegistry that is used to detect cyclic dependencies between Codecs
 class ChildCodecRegistry<T> implements CodecRegistry {
 
     private final ChildCodecRegistry<?> parent;
     private final CycleDetectingCodecRegistry registry;
     private final Class<T> codecClass;
+    private final List<Type> types;
 
     ChildCodecRegistry(final CycleDetectingCodecRegistry registry, final Class<T> codecClass) {
+        this(registry, codecClass, null);
+    }
+
+    ChildCodecRegistry(final CycleDetectingCodecRegistry registry, final Class<T> codecClass, final List<Type> types) {
         this.codecClass = codecClass;
         this.parent = null;
         this.registry = registry;
+        this.types = types;
     }
 
-
-    private ChildCodecRegistry(final ChildCodecRegistry<?> parent, final Class<T> codecClass) {
+    private ChildCodecRegistry(final ChildCodecRegistry<?> parent, final Class<T> codecClass, @Nullable final List<Type> types) {
         this.parent = parent;
         this.codecClass = codecClass;
         this.registry = parent.registry;
+        this.types = types;
     }
 
     public Class<T> getCodecClass() {
         return codecClass;
     }
 
+    public List<Type> getTypes() {
+        return types;
+    }
+
     // Gets a Codec, but if it detects a cyclic dependency, return a LazyCodec which breaks the chain.
     public <U> Codec<U> get(final Class<U> clazz) {
         if (hasCycles(clazz)) {
-            return new LazyCodec<U>(registry, clazz);
+            return new LazyCodec<U>(registry, clazz, null);
+        } else {
+            return registry.get(new ChildCodecRegistry<>(this, clazz, null));
+        }
+    }
+
+    @Override
+    public <U> Codec<U> get(final Class<U> clazz, final List<Type> typeArguments) {
+        if (hasCycles(clazz)) {
+            return new LazyCodec<U>(registry, clazz, typeArguments);
         } else {
-            return registry.get(new ChildCodecRegistry<U>(this, clazz));
+            return registry.get(new ChildCodecRegistry<>(this, clazz, typeArguments));
         }
     }
 
diff --git a/bson/src/main/org/bson/internal/CodecCache.java b/bson/src/main/org/bson/internal/CodecCache.java
@@ -19,36 +19,75 @@
 import org.bson.codecs.Codec;
 import org.bson.codecs.configuration.CodecConfigurationException;
 
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
 import static java.lang.String.format;
 
 final class CodecCache {
-    private final ConcurrentMap<Class<?>, Optional<Codec<?>>> codecCache = new ConcurrentHashMap<>();
 
-    public boolean containsKey(final Class<?> clazz) {
-        return codecCache.containsKey(clazz);
+    static final class CodecCacheKey {
+        private final Class<?> clazz;
+        private final List<Type> types;
+
+        CodecCacheKey(final Class<?> clazz, final List<Type> types) {
+            this.clazz = clazz;
+            this.types = types;
+        }
+
+        @Override
+        public boolean equals(final Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            CodecCacheKey that = (CodecCacheKey) o;
+            return clazz.equals(that.clazz) && Objects.equals(types, that.types);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(clazz, types);
+        }
+
+        @Override
+        public String toString() {
+            return "CodecCacheKey{"
+                    + "clazz=" + clazz
+                    + ", types=" + types
+                    + '}';
+        }
+    }
+
+    private final ConcurrentMap<CodecCacheKey, Optional<Codec<?>>> codecCache = new ConcurrentHashMap<>();
+
+    public boolean containsKey(final CodecCacheKey codecCacheKey) {
+        return codecCache.containsKey(codecCacheKey);
     }
 
-    public void put(final Class<?> clazz, final Codec<?> codec){
-        codecCache.put(clazz, Optional.ofNullable(codec));
+    public void put(final CodecCacheKey codecCacheKey, final Codec<?> codec){
+        codecCache.put(codecCacheKey, Optional.ofNullable(codec));
     }
 
     @SuppressWarnings("unchecked")
-    public synchronized <T> Codec<T> putIfMissing(final Class<T> clazz, final Codec<T> codec) {
-        Optional<Codec<?>> cachedCodec = codecCache.computeIfAbsent(clazz, clz -> Optional.of(codec));
+    public synchronized <T> Codec<T> putIfMissing(final CodecCacheKey codecCacheKey, final Codec<T> codec) {
+        Optional<Codec<?>> cachedCodec = codecCache.computeIfAbsent(codecCacheKey, clz -> Optional.of(codec));
         if (cachedCodec.isPresent()) {
             return (Codec<T>) cachedCodec.get();
         }
-        codecCache.put(clazz, Optional.of(codec));
+        codecCache.put(codecCacheKey, Optional.of(codec));
         return codec;
     }
 
     @SuppressWarnings("unchecked")
-    public <T> Codec<T> getOrThrow(final Class<T> clazz) {
-        return (Codec<T>) codecCache.getOrDefault(clazz, Optional.empty()).orElseThrow(
-                () -> new CodecConfigurationException(format("Can't find a codec for %s.", clazz)));
+    public <T> Codec<T> getOrThrow(final CodecCacheKey codecCacheKey) {
+        return (Codec<T>) codecCache.getOrDefault(codecCacheKey, Optional.empty()).orElseThrow(
+                () -> new CodecConfigurationException(format("Can't find a codec for %s.", codecCacheKey)));
     }
 }
diff --git a/bson/src/main/org/bson/internal/LazyCodec.java b/bson/src/main/org/bson/internal/LazyCodec.java
@@ -23,14 +23,19 @@
 import org.bson.codecs.EncoderContext;
 import org.bson.codecs.configuration.CodecRegistry;
 
+import java.lang.reflect.Type;
+import java.util.List;
+
 class LazyCodec<T> implements Codec<T> {
     private final CodecRegistry registry;
     private final Class<T> clazz;
+    private final List<Type> types;
     private volatile Codec<T> wrapped;
 
-    LazyCodec(final CodecRegistry registry, final Class<T> clazz) {
+    LazyCodec(final CodecRegistry registry, final Class<T> clazz, final List<Type> types) {
         this.registry = registry;
         this.clazz = clazz;
+        this.types = types;
     }
 
     @Override
@@ -50,7 +55,11 @@ public T decode(final BsonReader reader, final DecoderContext decoderContext) {
 
     private Codec<T> getWrapped() {
         if (wrapped == null) {
-            wrapped = registry.get(clazz);
+            if (types == null) {
+                wrapped = registry.get(clazz);
+            } else {
+                wrapped = registry.get(clazz, types);
+            }
         }
 
         return wrapped;
diff --git a/bson/src/main/org/bson/internal/OverridableUuidRepresentationCodecRegistry.java b/bson/src/main/org/bson/internal/OverridableUuidRepresentationCodecRegistry.java
diff --git a/bson/src/main/org/bson/internal/ProvidersCodecRegistry.java b/bson/src/main/org/bson/internal/ProvidersCodecRegistry.java
diff --git a/bson/src/test/unit/org/bson/internal/CodecCacheSpecification.groovy b/bson/src/test/unit/org/bson/internal/CodecCacheSpecification.groovy
