Add YamlSerializerContext.CreateOptions for per-call option overrides (#138)

Add CreateOptions(Func<YamlSerializerOptions, YamlSerializerOptions>) to
YamlSerializerContext, enabling per-call option variations (e.g. different
SourceName per file) while reusing the same source-generated context.

Implementation:
- YamlSerializerContext.CreateOptions applies a 'with' transform and ensures
  TypeInfoResolver always points back to the context.
- YamlSerializer.ResolveTypeInfo now allows options that reference a context
  as TypeInfoResolver but are a different instance. It wraps the resolved
  YamlTypeInfo with YamlTypeInfoWithOptions so the caller's options (SourceName,
  WriteIndented, etc.) flow through to YamlReader/YamlWriter creation.
- YamlTypeInfoWithOptions delegates Read/Write to the inner type info but
  exposes the caller's options.

Author: fdcastel

src/SharpYaml.Tests/Serialization/YamlSerializerContextCreateOptionsTests.cs

@@ -0,0 +1,160 @@
+#nullable enable
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SharpYaml.Serialization;
+
+namespace SharpYaml.Tests.Serialization;
+
+[TestClass]
+public class YamlSerializerContextCreateOptionsTests
+{
+    [TestMethod]
+    public void CreateOptions_OverridesSourceName()
+    {
+        var context = new TestYamlSerializerContext();
+        var options = context.CreateOptions(o => o with { SourceName = "config.yaml" });
+
+        Assert.AreEqual("config.yaml", options.SourceName);
+        Assert.AreSame(context, options.TypeInfoResolver);
+    }
+
+    [TestMethod]
+    public void CreateOptions_PreservesTypeInfoResolver()
+    {
+        var context = new TestYamlSerializerContext();
+        var options = context.CreateOptions(o => o with { WriteIndented = false });
+
+        Assert.AreSame(context, options.TypeInfoResolver);
+        Assert.IsFalse(options.WriteIndented);
+    }
+
+    [TestMethod]
+    public void CreateOptions_OverwritesResolverIfDifferent()
+    {
+        var context1 = new TestYamlSerializerContext();
+        var context2 = new TestYamlSerializerContext();
+
+        // Even if configure tries to set a different resolver, CreateOptions overwrites it
+        var options = context1.CreateOptions(o => o with { TypeInfoResolver = context2 });
+
+        Assert.AreSame(context1, options.TypeInfoResolver);
+    }
+
+    [TestMethod]
+    public void CreateOptions_PreservesOriginalConverters()
+    {
+        var converter = new DummyConverter();
+        var baseOptions = new YamlSerializerOptions { Converters = [converter] };
+        var context = new TestYamlSerializerContext(baseOptions);
+
+        var options = context.CreateOptions(o => o with { SourceName = "test.yaml" });
+
+        Assert.AreEqual(1, options.Converters.Count);
+        Assert.AreSame(converter, options.Converters[0]);
+        Assert.AreEqual("test.yaml", options.SourceName);
+    }
+
+    [TestMethod]
+    public void CreateOptions_CanAddConverters()
+    {
+        var context = new TestYamlSerializerContext();
+        var newConverter = new DummyConverter();
+
+        var options = context.CreateOptions(o => o with
+        {
+            Converters = [newConverter],
+            SourceName = "extra.yaml"
+        });
+
+        Assert.AreEqual(1, options.Converters.Count);
+        Assert.AreSame(newConverter, options.Converters[0]);
+        Assert.AreEqual("extra.yaml", options.SourceName);
+        Assert.AreSame(context, options.TypeInfoResolver);
+    }
+
+    [TestMethod]
+    public void CreateOptions_CanOverrideMultipleProperties()
+    {
+        var context = new TestYamlSerializerContext();
+        var options = context.CreateOptions(o => o with
+        {
+            SourceName = "multi.yaml",
+            WriteIndented = false,
+            PropertyNameCaseInsensitive = true,
+            Schema = YamlSchemaKind.Extended,
+        });
+
+        Assert.AreEqual("multi.yaml", options.SourceName);
+        Assert.IsFalse(options.WriteIndented);
+        Assert.IsTrue(options.PropertyNameCaseInsensitive);
+        Assert.AreEqual(YamlSchemaKind.Extended, options.Schema);
+        Assert.AreSame(context, options.TypeInfoResolver);
+    }
+
+    [TestMethod]
+    public void CreateOptions_IdentityReturnsOptionsWithSameResolver()
+    {
+        var context = new TestYamlSerializerContext();
+        var options = context.CreateOptions(o => o);
+
+        // Identity transform preserves the resolver
+        Assert.AreSame(context, options.TypeInfoResolver);
+    }
+
+    [TestMethod]
+    public void CreateOptions_WorksWithOptionsBasedContext()
+    {
+        var baseOptions = new YamlSerializerOptions
+        {
+            SourceName = "original.yaml",
+            WriteIndented = false,
+        };
+        var context = new TestYamlSerializerContext(baseOptions);
+
+        // Override just SourceName, keep other base settings
+        var options = context.CreateOptions(o => o with { SourceName = "override.yaml" });
+
+        Assert.AreEqual("override.yaml", options.SourceName);
+        Assert.IsFalse(options.WriteIndented); // Preserved from base
+        Assert.AreSame(context, options.TypeInfoResolver);
+    }
+
+    [TestMethod]
+    public void CreateOptions_ResultCanBeUsedForDeserialization()
+    {
+        var context = new TestYamlSerializerContext();
+        var options = context.CreateOptions(o => o with { SourceName = "test-input.yaml" });
+
+        // Verify the options work for actual deserialization
+        var yaml = "first_name: hello\nAge: 42\n";
+        var result = YamlSerializer.Deserialize<GeneratedPerson>(yaml, options);
+
+        Assert.IsNotNull(result);
+        Assert.AreEqual("hello", result.FirstName);
+    }
+
+    [TestMethod]
+    public void CreateOptions_SourceNameAppearsInErrorMessages()
+    {
+        var context = new TestYamlSerializerContext();
+        var options = context.CreateOptions(o => o with { SourceName = "myfile.yaml" });
+
+        var yaml = "first_name: hello\nAge: not-a-number\n";
+        var ex = Assert.Throws<YamlException>(() =>
+            YamlSerializer.Deserialize<GeneratedPerson>(yaml, options));
+
+        StringAssert.Contains(ex.Message, "myfile.yaml");
+    }
+
+    private sealed class DummyConverter : YamlConverter<int>
+    {
+        public override int Read(YamlReader reader)
+        {
+            reader.Skip();
+            return 0;
+        }
+
+        public override void Write(YamlWriter writer, int value)
+            => writer.WriteScalar("0");
+    }
+}

src/SharpYaml.Tests/Serialization/YamlSerializerSourceGenerationTests.cs

@@ -1061,15 +1061,20 @@ public void GeneratedContextDefaultAppliesYamlSourceGenerationOptions()
     }
 
     [TestMethod]
-    public void GeneratedContextThrowsWhenOptionsInstanceDoesNotMatchContext()
+    public void GeneratedContextAllowsOptionsWithSameResolverButDifferentInstance()
     {
         var context = TestYamlSerializerContext.Default;
         var options = new YamlSerializerOptions
         {
             TypeInfoResolver = context,
+            SourceName = "override.yaml",
         };
 
-        _ = Assert.Throws<InvalidOperationException>(() => YamlSerializer.Serialize(new GeneratedPerson(), options));
+        // Options that reference a context as TypeInfoResolver but are a separate instance
+        // now work correctly — the context resolves type info and the caller's options
+        // are used for runtime behavior (e.g. SourceName).
+        var yaml = YamlSerializer.Serialize(new GeneratedPerson { FirstName = "Alice", Age = 30 }, options);
+        Assert.IsTrue(yaml.Contains("Alice", StringComparison.Ordinal));
     }
 
     [TestMethod]

src/SharpYaml/Serialization/YamlSerializerContext.cs

@@ -56,6 +56,42 @@ protected YamlSerializerContext(YamlSerializerOptions options)
     /// </remarks>
     public YamlSerializerOptions Options { get; }
 
+    /// <summary>
+    /// Creates a new <see cref="YamlSerializerOptions"/> based on this context's options
+    /// with the specified overrides applied, while preserving the <see cref="YamlSerializerOptions.TypeInfoResolver"/>.
+    /// </summary>
+    /// <param name="configure">A function that applies overrides to a copy of this context's options using the <c>with</c> expression.</param>
+    /// <returns>A new options instance with the configured overrides and this context as the resolver.</returns>
+    /// <remarks>
+    /// <para>
+    /// This is useful when you need per-call option variations (such as a different
+    /// <see cref="YamlSerializerOptions.SourceName"/> for each file) while reusing the
+    /// same source-generated context.
+    /// </para>
+    /// <para>
+    /// The returned options always has <see cref="YamlSerializerOptions.TypeInfoResolver"/> set to this context.
+    /// Any <see cref="YamlSerializerOptions.TypeInfoResolver"/> value set by <paramref name="configure"/> is overwritten.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// var options = context.CreateOptions(o =&gt; o with { SourceName = "config.yaml" });
+    /// var result = YamlSerializer.Deserialize&lt;Config&gt;(yaml, options);
+    /// </code>
+    /// </example>
+    /// <exception cref="ArgumentNullException"><paramref name="configure"/> is <see langword="null"/>.</exception>
+    public YamlSerializerOptions CreateOptions(Func<YamlSerializerOptions, YamlSerializerOptions> configure)
+    {
+        ArgumentGuard.ThrowIfNull(configure);
+        var modified = configure(Options);
+        if (ReferenceEquals(modified.TypeInfoResolver, this))
+        {
+            return modified;
+        }
+
+        return modified with { TypeInfoResolver = this };
+    }
+
     /// <inheritdoc />
     public abstract YamlTypeInfo? GetTypeInfo(Type type, YamlSerializerOptions options);
 }

src/SharpYaml/YamlSerializer.cs

@@ -1070,9 +1070,15 @@ private static YamlTypeInfo ResolveTypeInfo(YamlSerializerOptions options, Type
     {
         if (options.TypeInfoResolver is YamlSerializerContext context && !ReferenceEquals(options, context.Options))
         {
-            throw new InvalidOperationException(
-                $"The provided {nameof(YamlSerializerOptions)} instance does not match the options associated with the source-generated context '{context.GetType()}'. " +
-                $"Use the overloads that accept a {nameof(YamlSerializerContext)} or a {nameof(YamlTypeInfo)} directly.");
+            // Options were created from context.CreateOptions(); resolve type info from the context
+            // but use the caller's options for runtime behavior (SourceName, WriteIndented, etc.).
+            var contextTypeInfo = context.GetTypeInfo(requestedType, context.Options);
+            if (contextTypeInfo is not null)
+            {
+                return new YamlTypeInfoWithOptions(contextTypeInfo, options);
+            }
+
+            throw new InvalidOperationException($"No generated metadata is available for '{requestedType}' on context '{context.GetType()}'.");
         }
 
         var typeInfo = options.TypeInfoResolver?.GetTypeInfo(requestedType, options);

src/SharpYaml/YamlTypeInfo.cs

@@ -99,3 +99,21 @@ public override void Write(YamlWriter writer, object? value)
     }
 }
 
+/// <summary>
+/// Wraps a <see cref="YamlTypeInfo"/> to use a different <see cref="YamlSerializerOptions"/>.
+/// </summary>
+internal sealed class YamlTypeInfoWithOptions : YamlTypeInfo
+{
+    private readonly YamlTypeInfo _inner;
+
+    internal YamlTypeInfoWithOptions(YamlTypeInfo inner, YamlSerializerOptions options)
+        : base(inner.Type, options)
+    {
+        _inner = inner;
+    }
+
+    public override void Write(YamlWriter writer, object? value) => _inner.Write(writer, value);
+
+    public override object? ReadAsObject(YamlReader reader) => _inner.ReadAsObject(reader);
+}
+