chore: cleans up interface definitions

Signed-off-by: Vincent Biret <[email protected]>

Author: baywet

src/Microsoft.OpenApi/Interfaces/IOpenApiReferenceHolder.cs

@@ -7,38 +7,44 @@ namespace Microsoft.OpenApi
     /// A generic interface for OpenApiReferenceable objects that have a target.
     /// </summary>
     /// <typeparam name="T">The type of the target being referenced</typeparam>
-    /// <typeparam name="V">The type of the interface implemented by both the target and the reference type</typeparam>
-    /// <typeparam name="U">The type for the reference holding the additional fields and annotations</typeparam>
-    public interface IOpenApiReferenceHolder<out T, V, U> : IOpenApiReferenceHolder<U> where T : IOpenApiReferenceable, V where U : OpenApiReference
+    /// <typeparam name="U">The type of the interface implemented by both the target and the reference type</typeparam>
+    /// <typeparam name="V">The type for the reference holding the additional fields and annotations</typeparam>
+    public interface IOpenApiReferenceHolder<out T, U, V> : IOpenApiReferenceHolder<V> where T : IOpenApiReferenceable, U where V : OpenApiReference, new()
     {
         /// <summary>
         /// Gets the resolved target object.
         /// </summary>
-        V? Target { get; }
-        
+        U? Target { get; }
+
         /// <summary>
         /// Gets the recursively resolved target object.
         /// </summary>
         T? RecursiveTarget { get; }
-        
+
         /// <summary>
         /// Copy the reference as a target element with overrides.
         /// </summary>
-        V CopyReferenceAsTargetElementWithOverrides(V source);
+        U CopyReferenceAsTargetElementWithOverrides(U source);
     }
     /// <summary>
     /// A generic interface for OpenApiReferenceable objects that have a target.
     /// </summary>
-    public interface IOpenApiReferenceHolder<U> : IOpenApiSerializable where U : OpenApiReference
+    /// <typeparam name="V">The type for the reference holding the additional fields and annotations</typeparam>
+    public interface IOpenApiReferenceHolder<V> : IOpenApiReferenceHolder where V : OpenApiReference, new()
     {
         /// <summary>
-        /// Indicates if object is populated with data or is just a reference to the data
+        /// Reference object.
         /// </summary>
-        bool UnresolvedReference { get; }
-
+        V Reference { get; init; }
+    }
+    /// <summary>
+    /// A generic interface for OpenApiReferenceable objects that have a target.
+    /// </summary>
+    public interface IOpenApiReferenceHolder : IOpenApiSerializable
+    {
         /// <summary>
-        /// Reference object.
+        /// Indicates if object is populated with data or is just a reference to the data
         /// </summary>
-        U Reference { get; init; }
+        bool UnresolvedReference { get; }
     }
 }

src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs

@@ -5,17 +5,17 @@ namespace Microsoft.OpenApi;
 /// Base class for OpenApiReferenceHolder.
 /// </summary>
 /// <typeparam name="T">The concrete class implementation type for the model.</typeparam>
-/// <typeparam name="V">The interface type for the model.</typeparam>
-/// <typeparam name="U">The type for the reference holding the additional fields and annotations</typeparam>
-public abstract class BaseOpenApiReferenceHolder<T, V, U> : IOpenApiReferenceHolder<T, V, U> where T : class, IOpenApiReferenceable, V where V : IOpenApiReferenceable, IOpenApiSerializable where U : OpenApiReference, new()
+/// <typeparam name="U">The interface type for the model.</typeparam>
+/// <typeparam name="V">The type for the reference holding the additional fields and annotations</typeparam>
+public abstract class BaseOpenApiReferenceHolder<T, U, V> : IOpenApiReferenceHolder<T, U, V> where T : class, IOpenApiReferenceable, U where U : IOpenApiReferenceable, IOpenApiSerializable where V : OpenApiReference, new()
 {
     /// <inheritdoc/>
-    public virtual V? Target
+    public virtual U? Target
     {
         get
         {
             if (Reference.HostDocument is null) return default;
-            return Reference.HostDocument.ResolveReferenceTo<V>(Reference);
+            return Reference.HostDocument.ResolveReferenceTo<U>(Reference);
         }
     }
     /// <inheritdoc/>
@@ -24,7 +24,7 @@ public T? RecursiveTarget
         get
         {
             return Target switch {
-                BaseOpenApiReferenceHolder<T, V, U> recursiveTarget => recursiveTarget.RecursiveTarget,
+                BaseOpenApiReferenceHolder<T, U, V> recursiveTarget => recursiveTarget.RecursiveTarget,
                 T concrete => concrete,
                 _ => null
             };
@@ -35,7 +35,7 @@ public T? RecursiveTarget
     /// Copy constructor
     /// </summary>
     /// <param name="source">The parameter reference to copy</param>
-    protected BaseOpenApiReferenceHolder(BaseOpenApiReferenceHolder<T, V, U> source)
+    protected BaseOpenApiReferenceHolder(BaseOpenApiReferenceHolder<T, U, V> source)
     {
         Utils.CheckArgumentNull(source);
         Reference = new(source.Reference);
@@ -59,7 +59,7 @@ protected BaseOpenApiReferenceHolder(string referenceId, OpenApiDocument? hostDo
         // we're not checking for null hostDocument as it's optional and can be set via additional methods by a walker
         // this way object initialization of a whole document is supported
 
-        Reference = new U()
+        Reference = new V()
         {
             Id = referenceId,
             HostDocument = hostDocument,
@@ -75,10 +75,10 @@ protected BaseOpenApiReferenceHolder(string referenceId, OpenApiDocument? hostDo
     public required U Reference { get; init; }
 #else
     /// <inheritdoc/>
-    public U Reference { get; init; }
+    public V Reference { get; init; }
 #endif
     /// <inheritdoc/>
-    public abstract V CopyReferenceAsTargetElementWithOverrides(V source);
+    public abstract U CopyReferenceAsTargetElementWithOverrides(U source);
     /// <inheritdoc/>
     public virtual void SerializeAsV3(IOpenApiWriter writer)
     {
@@ -126,7 +126,7 @@ public virtual void SerializeAsV2(IOpenApiWriter writer)
     /// <param name="writer">The OpenApiWriter.</param>
     /// <param name="action">The action to serialize the target object.</param>
     private protected void SerializeInternal(IOpenApiWriter writer,
-        Action<IOpenApiWriter, V> action)
+        Action<IOpenApiWriter, U> action)
     {
         Utils.CheckArgumentNull(writer);
         if (Target is not null)

src/Microsoft.OpenApi/Reader/Services/OpenApiRemoteReferenceCollector.cs

@@ -26,7 +26,14 @@ public IEnumerable<OpenApiReference> References
         /// <inheritdoc/>
         public override void Visit(IOpenApiReferenceHolder referenceHolder)
         {
-            AddExternalReferences(referenceHolder.Reference);
+            if (referenceHolder is IOpenApiReferenceHolder<OpenApiReference> { Reference: OpenApiReference reference })
+            {
+                AddExternalReferences(reference);
+            }
+            else if (referenceHolder is IOpenApiReferenceHolder<JsonSchemaReference> { Reference: JsonSchemaReference jsonSchemaReference })
+            {
+                AddExternalReferences(jsonSchemaReference);
+            }
         }
 
         /// <summary>

src/Microsoft.OpenApi/Services/OpenApiWalker.cs

@@ -1262,8 +1262,7 @@ private void Walk(string context, Action walk)
         /// </summary>
         private bool ProcessAsReference(IOpenApiReferenceHolder referenceableHolder, bool isComponent = false)
         {
-            var isReference = referenceableHolder.Reference != null &&
-                              (!isComponent || referenceableHolder.UnresolvedReference);
+            var isReference = !isComponent || referenceableHolder.UnresolvedReference;
             if (isReference)
             {
                 Walk(referenceableHolder);

src/Microsoft.OpenApi/Services/ReferenceHostDocumentSetter.cs

@@ -18,7 +18,14 @@ public ReferenceHostDocumentSetter(OpenApiDocument currentDocument)
         /// <inheritdoc/>
         public override void Visit(IOpenApiReferenceHolder referenceHolder)
         {
-            referenceHolder.Reference?.EnsureHostDocumentIsSet(_currentDocument);
+            if (referenceHolder is IOpenApiReferenceHolder<OpenApiReference> { Reference: OpenApiReference reference })
+            {
+                reference.EnsureHostDocumentIsSet(_currentDocument);
+            }
+            else if (referenceHolder is IOpenApiReferenceHolder<JsonSchemaReference> { Reference: JsonSchemaReference jsonSchemaReference })
+            {
+                jsonSchemaReference.EnsureHostDocumentIsSet(_currentDocument);
+            }
         }
     }
 }