Further comments and manual adjustments

Author: SkowronskiAndrew

Analyzer/Util/SerializedFileDetector.cs

@@ -44,8 +44,11 @@ public class SerializedFileInfo
 public static class SerializedFileDetector
 {
     // Version boundaries for format changes
-    private const uint NewLayoutVersion = 9;           // kUnknown_9: Changed from [header][data][metadata] to [header][metadata][data]
-    private const uint LargeFilesSupportVersion = 22;  // kLargeFilesSupport: Changed to 64-bit header
+    // NOTE: This version is so old that it is extremely unlikely it will work with modern versions of Unity,
+    // we handle it just for the purpose of trying to report accurate information about the file.
+    private const uint NewLayoutVersion = 9;           // Changed from [header][data][metadata] to [header][metadata][data]
+
+    private const uint LargeFilesSupportVersion = 22;  // Changed to 64-bit header
 
     // Reasonable version range for SerializedFiles
     // Unity versions currently use values in the 20s-30s range
@@ -105,7 +108,7 @@ public static bool TryDetectSerializedFile(string filePath, out SerializedFileIn
 
             // Determine which interpretation gives us a valid version number
             uint version;
-            bool needsSwap;  // Whether header fields need byte swapping
+            bool needsSwap;  // Whether header fields need byte swapping (expected to be true when running on most modern systems, which are little-endian)
 
             if (versionLE >= MinVersion && versionLE <= MaxVersion)
             {
@@ -250,13 +253,8 @@ public static bool TryDetectSerializedFile(string filePath, out SerializedFileIn
             // Allow some tolerance for "stream files" which can have padding
             if (fileSize != ulong.MaxValue)
             {
-                // File size should not exceed actual file size by more than 1MB (arbitrary tolerance)
-                if (fileSize > (ulong)fileLength + 1024 * 1024)
-                    return false;
-
-                // File size should be reasonably close to actual size (within 10% or 1MB)
-                ulong tolerance = Math.Max(fileSize / 10, 1024 * 1024);
-                if ((ulong)fileLength > fileSize + tolerance)
+                // File size should not exceed actual file size by more than 1KB (arbitrary tolerance)
+                if (fileSize > (ulong)fileLength + 1024)
                     return false;
             }
 
@@ -305,9 +303,6 @@ private static ulong ReadUInt64(byte[] buffer, int offset, bool swap)
         return swap ? SwapUInt64(value) : value;
     }
 
-    /// <summary>
-    /// Swaps the byte order of a UInt32 value.
-    /// </summary>
     private static uint SwapUInt32(uint value)
     {
         return ((value & 0x000000FFU) << 24) |
@@ -316,9 +311,6 @@ private static uint SwapUInt32(uint value)
                ((value & 0xFF000000U) >> 24);
     }
 
-    /// <summary>
-    /// Swaps the byte order of a UInt64 value.
-    /// </summary>
     private static ulong SwapUInt64(ulong value)
     {
         return ((value & 0x00000000000000FFUL) << 56) |

Analyzer/Util/YamlSerializedFileDetector.cs

@@ -8,32 +8,17 @@ namespace UnityDataTools.Analyzer.Util;
 /// Utility for detecting YAML-format Unity SerializedFiles.
 ///
 /// Unity SerializedFiles can be stored in two formats:
-/// 1. Binary format (used in builds and by Unity Runtime) - detected by SerializedFileDetector
+/// 1. Binary format (produced by builds - read by Unity Runtime, also used for imported artifacts etc) - detected by SerializedFileDetector
 /// 2. YAML format (text format used in Editor for .asset, .prefab, .unity files) - detected by this class
 ///
-/// The YAML format is not supported by Unity Runtime and cannot be read by UnityDataTool,
-/// which only supports the binary format.
-///
 /// YAML SerializedFiles begin with the magic string "%YAML 1.1", optionally preceded by
 /// a UTF-8 BOM (byte order mark: 0xEF 0xBB 0xBF).
-///
-/// This implementation is based on Unity's SerializedFile.cpp::FinalizeInitRead() and
-/// IsSerializedFileTextFile() from Runtime/Serialize/SerializedFile.cpp (lines 101-117, 668-687).
 /// </summary>
 public static class YamlSerializedFileDetector
 {
-    // Magic string that identifies YAML-format SerializedFiles
     private const string UnityTextMagicString = "%YAML 1.1";
-
-    // UTF-8 BOM (Byte Order Mark): EF BB BF
     private static readonly byte[] Utf8Bom = new byte[] { 0xEF, 0xBB, 0xBF };
 
-    /// <summary>
-    /// Checks if a file is a YAML-format Unity SerializedFile by reading the magic string
-    /// at the beginning of the file.
-    /// </summary>
-    /// <param name="filePath">Path to the file to check</param>
-    /// <returns>True if the file starts with "%YAML 1.1" (optionally with UTF-8 BOM), false otherwise</returns>
     public static bool IsYamlSerializedFile(string filePath)
     {
         if (!File.Exists(filePath))
@@ -57,7 +42,6 @@ public static bool IsYamlSerializedFile(string filePath)
             if (bytesRead < magicLength)
                 return false;
 
-            // Check if file starts with UTF-8 BOM
             int offset = 0;
             if (bytesRead >= bomLength && HasUtf8Bom(buffer))
             {
@@ -78,9 +62,6 @@ public static bool IsYamlSerializedFile(string filePath)
         }
     }
 
-    /// <summary>
-    /// Checks if a byte array starts with UTF-8 BOM (0xEF 0xBB 0xBF).
-    /// </summary>
     private static bool HasUtf8Bom(byte[] buffer)
     {
         if (buffer.Length < Utf8Bom.Length)