Enhance nullable reference type support and clean up code across multiple files

- Added nullable attributes for compatibility with netstandard2.0
- Updated method signatures to use nullable reference types
- Refactored code to improve clarity and remove unnecessary variables
- Suppressed specific warnings in project files for generated code

Author: glucaci

src/Yamlify.SourceGenerator/NullableAttributes.cs

@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// These attributes are defined here because netstandard2.0 doesn't include them.
+// The compiler will use these definitions for nullable flow analysis.
+
+#if NETSTANDARD2_0
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Specifies that when a method returns <see cref="ReturnValue"/>,
+/// the parameter will not be null even if the corresponding type allows it.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+internal sealed class NotNullWhenAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes the attribute with the specified return value condition.
+    /// </summary>
+    /// <param name="returnValue">
+    /// The return value condition. If the method returns this value,
+    /// the associated parameter will not be null.
+    /// </param>
+    public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+    /// <summary>
+    /// Gets the return value condition.
+    /// </summary>
+    public bool ReturnValue { get; }
+}
+
+#endif

src/Yamlify.SourceGenerator/YamlSourceGenerator.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using Microsoft.CodeAnalysis;
@@ -498,15 +499,14 @@ private static void GenerateReadMethod(StringBuilder sb, TypeToGenerate type, IR
 
         // Check if this type is polymorphic (from [YamlSerializable] or [YamlPolymorphic] attributes)
         var polyInfo = GetPolymorphicInfoForType(type);
-        var isPolymorphicBase = polyInfo is not null && polyInfo.DerivedTypes.Count > 0;
-        if (isPolymorphicBase && (type.Symbol.IsAbstract || type.Symbol.TypeKind == TypeKind.Interface))
+        if (polyInfo is { DerivedTypes.Count: > 0 } && (type.Symbol.IsAbstract || type.Symbol.TypeKind == TypeKind.Interface))
         {
             // Generate polymorphic read - dispatch to correct derived type based on discriminator
             GeneratePolymorphicRead(sb, type, polyInfo, allTypes, fullTypeName);
             sb.AppendLine("        }");
             return;
         }
-        else if (isPolymorphicBase)
+        else if (polyInfo is { DerivedTypes.Count: > 0 })
         {
             // Non-abstract base type with derived types - still needs polymorphic dispatch
             // but must also handle the case where the base type itself is serialized
@@ -2678,7 +2678,7 @@ private static string ToKebabCase(string name)
         return null;
     }
 
-    private static bool IsListOrArray(ITypeSymbol type, out ITypeSymbol? elementType, out bool isHashSet)
+    private static bool IsListOrArray(ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType, out bool isHashSet)
     {
         elementType = null;
         isHashSet = false;
@@ -2714,7 +2714,7 @@ private static bool IsListOrArray(ITypeSymbol type, out ITypeSymbol? elementType
         return false;
     }
 
-    private static bool IsDictionary(ITypeSymbol type, out ITypeSymbol? keyType, out ITypeSymbol? valueType)
+    private static bool IsDictionary(ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? keyType, [NotNullWhen(true)] out ITypeSymbol? valueType)
     {
         keyType = null;
         valueType = null;

src/Yamlify.SourceGenerator/Yamlify.SourceGenerator.csproj

@@ -4,12 +4,16 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <LangVersion>12.0</LangVersion>
     <Nullable>enable</Nullable>
+    <WarningsAsErrors>$(WarningsAsErrors);nullable</WarningsAsErrors>
     <ImplicitUsings>disable</ImplicitUsings>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     <IsRoslynComponent>true</IsRoslynComponent>
 
     <!-- Package metadata - not published separately, bundled with Yamlify -->
     <IsPackable>false</IsPackable>
+    
+    <!-- Suppress analyzer release tracking warning (bundled with main package) -->
+    <NoWarn>$(NoWarn);RS2008</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>

src/Yamlify/Core/Utf8YamlReader.Helpers.cs

@@ -393,14 +393,12 @@ private bool HasTabsInIndentation()
         // Check for tabs before content while still in the indentation zone
         // Tabs are only invalid if they appear at positions that would affect indentation
         int pos = _lineStart;
-        bool foundNonTabWhitespace = false;
 
         while (pos < _consumed && pos < _buffer.Length)
         {
             byte b = _buffer[pos];
             if (b == Space)
             {
-                foundNonTabWhitespace = true;
                 pos++;
             }
             else if (b == Tab)

src/Yamlify/Core/Utf8YamlReader.Parsing.cs

@@ -1714,12 +1714,9 @@ private bool ParseFlowMappingValue()
         _consumed++; // Skip :
         SkipSpaces();
 
-        _parsingFlowMappingValue = true; // Track that we're parsing a value in flow mapping
-        
         // For node-level API, don't emit Value token - parse the value content directly
         if (_consumed >= _buffer.Length)
         {
-            _parsingFlowMappingValue = false;
             throw new YamlException("Unexpected end of input in flow mapping", Position);
         }
 
@@ -1732,7 +1729,6 @@ private bool ParseFlowMappingValue()
             _valueSpan = default;
             _tokenType = YamlTokenType.Scalar;
             _scalarStyle = ScalarStyle.Plain;
-            _parsingFlowMappingValue = false;
             return true;
         }
 
@@ -1744,7 +1740,6 @@ private bool ParseFlowMappingValue()
             _valueSpan = default;
             _tokenType = YamlTokenType.Scalar;
             _scalarStyle = ScalarStyle.Plain;
-            _parsingFlowMappingValue = false;
             return true;
         }
 
@@ -1760,7 +1755,6 @@ private bool ParseFlowMappingValue()
             _ => ParsePlainScalar()
         };
 
-        _parsingFlowMappingValue = false;
         return result;
     }
 

src/Yamlify/Core/Utf8YamlReader.Tokens.cs

@@ -204,8 +204,11 @@ public void Invalidate()
 internal ref struct TokenBuffer
 {
     // Inline storage for common cases (8 tokens = ~320 bytes)
+    // These fields are accessed via Unsafe.Add from _token0
+#pragma warning disable CS0169
     private RawToken _token0, _token1, _token2, _token3;
     private RawToken _token4, _token5, _token6, _token7;
+#pragma warning restore CS0169
 
     // Overflow storage for rare complex cases
     private RawToken[]? _overflow;
@@ -388,8 +391,11 @@ private void SetInline(int index, RawToken value)
 internal ref struct SimpleKeyStack
 {
     // Inline storage (8 levels covers most real-world cases)
+    // These fields are accessed via Unsafe.Add from _key0
+#pragma warning disable CS0169
     private SimpleKeyInfo _key0, _key1, _key2, _key3;
     private SimpleKeyInfo _key4, _key5, _key6, _key7;
+#pragma warning restore CS0169
 
     // Overflow for deeply nested flows
     private SimpleKeyInfo[]? _overflow;
@@ -499,10 +505,13 @@ internal struct TagHandleStorage
     private const int MaxHandles = 4;
 
     // Inline storage for handles (fixed-size arrays)
+    // These fields are accessed via Unsafe.Add from _handle0
+#pragma warning disable CS0169, CS0649
     private TagHandleEntry _handle0;
     private TagHandleEntry _handle1;
     private TagHandleEntry _handle2;
     private TagHandleEntry _handle3;
+#pragma warning restore CS0169, CS0649
 
     private int _count;
 

src/Yamlify/Core/Utf8YamlReader.cs

@@ -49,7 +49,6 @@ public ref partial struct Utf8YamlReader
     private bool _expectingMappingValue; // True after parsing a mapping key, expecting value
     private bool _hadValueOnLine; // True if we parsed a complete key:value on the current line
     private int _lastValueLine; // Line number where _hadValueOnLine was set
-    private bool _parsingFlowMappingValue; // True when parsing value after : in flow mapping
     private bool _crossedLineBreakInFlow; // True when SkipFlowWhitespaceAndComments crossed a line break
     private bool _onDocumentStartLine; // True when content follows --- on the same line
 

src/Yamlify/Core/Utf8YamlWriter.cs

@@ -21,7 +21,6 @@ public sealed class Utf8YamlWriter : IDisposable
     private readonly bool _ownsOutput;
 
     private int _currentDepth;
-    private int _pendingIndent;
     private bool _needsNewLine;
     private bool _inFlowContext;
     private bool _afterPropertyName; // True if we just wrote a property name and need a value
@@ -59,7 +58,6 @@ public Utf8YamlWriter(IBufferWriter<byte> output, YamlWriterOptions? options = n
         _options = options ?? YamlWriterOptions.Default;
         _ownsOutput = false;
         _currentDepth = 0;
-        _pendingIndent = 0;
         _needsNewLine = false;
         _inFlowContext = false;
         _afterPropertyName = false;
@@ -539,7 +537,6 @@ public void Flush()
     public void Reset()
     {
         _currentDepth = 0;
-        _pendingIndent = 0;
         _needsNewLine = false;
         _inFlowContext = false;
         _afterPropertyName = false;
@@ -687,6 +684,7 @@ private void WriteScalarValue(ReadOnlySpan<char> value)
         if (needsQuoting)
         {
             WriteRaw((byte)'\'');
+            Span<byte> charBuffer = stackalloc byte[4];
             foreach (char c in value)
             {
                 if (c == '\'')
@@ -695,7 +693,6 @@ private void WriteScalarValue(ReadOnlySpan<char> value)
                 }
                 else
                 {
-                    Span<byte> charBuffer = stackalloc byte[4];
                     var chars = new ReadOnlySpan<char>(in c);
                     int byteCount = Encoding.UTF8.GetBytes(chars, charBuffer);
                     WriteRaw(charBuffer[..byteCount]);

src/Yamlify/Serialization/YamlSerializer.cs

@@ -1,5 +1,4 @@
 using System.Buffers;
-using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using Yamlify.Core;
 
@@ -420,8 +419,7 @@ public static async Task SerializeAsync<TValue>(
     /// <param name="reader">The reader to read from.</param>
     /// <param name="typeInfo">The source-generated type info for the target type.</param>
     /// <returns>A <typeparamref name="TValue"/> representation of the YAML value.</returns>
-    [return: MaybeNull]
-    public static TValue Deserialize<TValue>(ref Utf8YamlReader reader, YamlTypeInfo<TValue> typeInfo)
+    public static TValue? Deserialize<TValue>(ref Utf8YamlReader reader, YamlTypeInfo<TValue> typeInfo)
     {
         ArgumentNullException.ThrowIfNull(typeInfo);
         return DeserializeCore(ref reader, typeInfo);
@@ -440,8 +438,7 @@ public static TValue Deserialize<TValue>(ref Utf8YamlReader reader, YamlTypeInfo
     /// <exception cref="InvalidOperationException">
     /// Thrown when no TypeInfoResolver is configured on <see cref="YamlSerializerOptions.Default"/>.
     /// </exception>
-    [return: MaybeNull]
-    public static TValue Deserialize<TValue>(Stream stream)
+    public static TValue? Deserialize<TValue>(Stream stream)
     {
         ArgumentNullException.ThrowIfNull(stream);
         var options = YamlSerializerOptions.Default;
@@ -457,8 +454,7 @@ public static TValue Deserialize<TValue>(Stream stream)
     /// <param name="stream">The stream to read from.</param>
     /// <param name="typeInfo">The source-generated type info for the target type.</param>
     /// <returns>A <typeparamref name="TValue"/> representation of the YAML value.</returns>
-    [return: MaybeNull]
-    public static TValue Deserialize<TValue>(Stream stream, YamlTypeInfo<TValue> typeInfo)
+    public static TValue? Deserialize<TValue>(Stream stream, YamlTypeInfo<TValue> typeInfo)
     {
         ArgumentNullException.ThrowIfNull(stream);
         ArgumentNullException.ThrowIfNull(typeInfo);
@@ -478,8 +474,7 @@ public static TValue Deserialize<TValue>(Stream stream, YamlTypeInfo<TValue> typ
     /// <exception cref="InvalidOperationException">
     /// Thrown when no TypeInfoResolver is configured on the options.
     /// </exception>
-    [return: MaybeNull]
-    public static TValue Deserialize<TValue>(Stream stream, YamlSerializerOptions options)
+    public static TValue? Deserialize<TValue>(Stream stream, YamlSerializerOptions options)
     {
         ArgumentNullException.ThrowIfNull(stream);
         ArgumentNullException.ThrowIfNull(options);
@@ -498,8 +493,7 @@ public static TValue Deserialize<TValue>(Stream stream, YamlSerializerOptions op
     /// <exception cref="InvalidOperationException">
     /// Thrown when no TypeInfoResolver is configured on <see cref="YamlSerializerOptions.Default"/>.
     /// </exception>
-    [return: MaybeNull]
-    public static async ValueTask<TValue> DeserializeAsync<TValue>(
+    public static async ValueTask<TValue?> DeserializeAsync<TValue>(
         Stream stream,
         CancellationToken cancellationToken = default)
     {
@@ -518,8 +512,7 @@ public static async ValueTask<TValue> DeserializeAsync<TValue>(
     /// <param name="typeInfo">The source-generated type info for the target type.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
     /// <returns>A <typeparamref name="TValue"/> representation of the YAML value.</returns>
-    [return: MaybeNull]
-    public static async ValueTask<TValue> DeserializeAsync<TValue>(
+    public static async ValueTask<TValue?> DeserializeAsync<TValue>(
         Stream stream, 
         YamlTypeInfo<TValue> typeInfo,
         CancellationToken cancellationToken = default)

src/Yamlify/Yamlify.csproj

@@ -5,6 +5,7 @@
     <LangVersion>preview</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <WarningsAsErrors>$(WarningsAsErrors);nullable</WarningsAsErrors>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 
     <!-- AOT compatibility -->