Avoid attempting to parse future versions

Author: SkowronskiAndrew

Analyzer.Tests/FileDetectionTests.cs

@@ -171,6 +171,35 @@ public void TryDetectSerializedFile_NonExistentFile_ReturnsFalse()
 
     #region SerializedFile Metadata Parsing Tests
 
+    [Test]
+    public void TryParseMetadata_VersionTooOld_ReturnsFalseWithMessage()
+    {
+        var headerInfo = new SerializedFileInfo { Version = 18 };
+
+        bool result = SerializedFileDetector.TryParseMetadata("irrelevant", headerInfo, out var metadata, out var errorMessage);
+
+        Assert.IsFalse(result);
+        Assert.IsNull(metadata);
+        Assert.IsNotNull(errorMessage);
+        Assert.That(errorMessage, Does.Contain("18"), "Error should mention the actual version");
+        Assert.That(errorMessage, Does.Contain("19"), "Error should mention the minimum supported version");
+    }
+
+    [Test]
+    public void TryParseMetadata_VersionTooNew_ReturnsFalseWithMessage()
+    {
+        var headerInfo = new SerializedFileInfo { Version = 24 };
+
+        bool result = SerializedFileDetector.TryParseMetadata("irrelevant", headerInfo, out var metadata, out var errorMessage);
+
+        Assert.IsFalse(result);
+        Assert.IsNull(metadata);
+        Assert.IsNotNull(errorMessage);
+        Assert.That(errorMessage, Does.Contain("24"), "Error should mention the actual version");
+        Assert.That(errorMessage, Does.Contain("23"), "Error should mention the maximum supported version");
+        Assert.That(errorMessage, Does.Contain("UnityDataTool"), "Error should mention UnityDataTool");
+    }
+
     [Test]
     public void TryParseMetadata_PlayerDataLevel0_ReturnsExpectedValues()
     {
@@ -211,7 +240,7 @@ public void TryParseMetadata_PlayerDataLevel0_ReturnsExpectedValues()
                 $"TypeTreeSerializedSize should be non-zero (persistentTypeID={entry.PersistentTypeID})");
             Assert.Greater(entry.PersistentTypeID, 0,
                 $"PersistentTypeID should be positive for native types (got {entry.PersistentTypeID})");
-            Assert.AreNotEqual(114, entry.PersistentTypeID,
+            Assert.That(entry.PersistentTypeID, Is.Not.EqualTo(114),
                 "No MonoBehaviour types expected in this scene");
             Assert.That(entry.ScriptTypeIndex, Is.EqualTo((short)-1),
                 $"ScriptTypeIndex should be -1 for native types (persistentTypeID={entry.PersistentTypeID})");
@@ -344,6 +373,43 @@ public void TryParseMetadata_V22PrefabWithSerializedReference_ReturnsExpectedTyp
         Assert.That(refType.AssemblyName, Is.EqualTo("Assembly-CSharp"));
     }
 
+    [Test]
+    public void TryParseMetadata_V23ExtractedMonoscriptBundle_ReturnsExpectedTypeTreeData()
+    {
+        // This is a v23 (kExtractedTypeTreeSupport) file where the TypeTree blobs have been
+        // extracted to a shared external store. The metadata records a non-zero TypeTreeContentHash
+        // as a cache key, but typeTreeSerializedSize == 0 and InlineTypeTree == false for every entry.
+        var testFile = Path.Combine(m_TestDataPath, "AssetBundleTypeTreeVariations", "v23_extracted",
+            "monoscriptbundle.serializedfile");
+
+        bool headerResult = SerializedFileDetector.TryDetectSerializedFile(testFile, out var headerInfo);
+        Assert.IsTrue(headerResult, "File should be detected as a valid SerializedFile");
+
+        bool result = SerializedFileDetector.TryParseMetadata(testFile, headerInfo, out var metadata, out var errorMessage);
+        Assert.IsTrue(result, $"Metadata parsing should succeed. Error: {errorMessage}");
+        Assert.IsNotNull(metadata);
+
+        // --- Initial metadata fields ---
+        Assert.IsTrue(metadata.EnableTypeTree, "EnableTypeTree should be true");
+
+        // --- Type counts ---
+        Assert.That(metadata.TypeTreeCount, Is.EqualTo(2), "Should have 2 regular type entries");
+        Assert.That(metadata.SerializedReferenceTypeTreeCount, Is.EqualTo(0), "Should have 0 SerializeReference type entries");
+        Assert.IsNotNull(metadata.TypeTrees, "TypeTrees array should be populated");
+        Assert.That(metadata.TypeTrees.Length, Is.EqualTo(2));
+
+        // --- All TypeTree blobs are extracted: non-zero content hash, zero size, not inline ---
+        foreach (var entry in metadata.TypeTrees)
+        {
+            Assert.IsFalse(entry.TypeTreeContentHash.IsZero,
+                $"TypeTreeContentHash should be non-zero for extracted v23 entry (persistentTypeID={entry.PersistentTypeID})");
+            Assert.That(entry.TypeTreeSerializedSize, Is.EqualTo(0u),
+                $"TypeTreeSerializedSize should be 0 for extracted entry (persistentTypeID={entry.PersistentTypeID})");
+            Assert.IsFalse(entry.InlineTypeTree,
+                $"InlineTypeTree should be false for extracted entry (persistentTypeID={entry.PersistentTypeID})");
+        }
+    }
+
     #endregion
 
     #region YAML SerializedFile Detection Tests

Analyzer/Util/SerializedFileDetector.cs

@@ -211,6 +211,10 @@ public static class SerializedFileDetector
     // Older files have format differences that we do not attempt to support.
     private const uint MinMetadataParseVersion = 19;
 
+    // Maximum version for metadata section parsing (kExtractedTypeTreeSupport = 23, Unity 6000.4).
+    // Files newer than this version may have an unknown format and cannot be parsed safely.
+    private const uint MaxMetadataParseVersion = 23;
+
     // Reasonable version range for SerializedFiles
     // Unity versions currently use values in the 20s-30s range
     private const uint MinVersion = 1;
@@ -485,6 +489,17 @@ public static bool TryParseMetadata(string filePath, SerializedFileInfo headerIn
             return false;
         }
 
+        // Reject versions beyond the highest known format. Future Unity versions may change the
+        // metadata layout in ways that would cause incorrect results or a parse failure.
+        // A newer version of UnityDataTool is required to read these files.
+        if (headerInfo.Version > MaxMetadataParseVersion)
+        {
+            errorMessage = $"SerializedFile version {headerInfo.Version} is not supported. " +
+                           $"UnityDataTool supports up to version {MaxMetadataParseVersion}. " +
+                           $"Please use a newer version of UnityDataTool to read this file.";
+            return false;
+        }
+
         try
         {
             long metadataOffset = headerInfo.IsLegacyFormat ? LegacyHeaderSize : ModernHeaderSize;
@@ -518,9 +533,9 @@ public static bool TryParseMetadata(string filePath, SerializedFileInfo headerIn
                 EnableTypeTree = enableTypeTree,
             };
 
-            // Parse the TypeTree section. Protected by its own try/catch so that any
+            // Parse the rest of the metadata section. Protected by its own try/catch so that any
             // failure there still returns a partially-populated metadata struct.
-            ParseTypeTreeMetadata(reader, headerInfo, swap, metadataOffset, metadata);
+            ParseExtendedMetadata(reader, headerInfo, swap, metadataOffset, metadata);
 
             return true;
         }
@@ -532,19 +547,9 @@ public static bool TryParseMetadata(string filePath, SerializedFileInfo headerIn
     }
 
     /// <summary>
-    /// Parses the TypeTree section of the metadata, populating the type-list fields of
-    /// <paramref name="metadata"/>. Any parse failure is silently caught so the caller
-    /// always receives at least the three initial metadata fields.
-    ///
-    /// Layout after the three initial fields:
-    ///   [int32  typeCount]
-    ///   [SerializedType * typeCount]   -- regular object types (m_Types)
-    ///
-    /// Then, after the object list, script type list, and externals list, for version >= 20:
-    ///   [int32  refTypeCount]
-    ///   [RefSerializedType * refTypeCount]  -- SerializeReference types (m_RefTypes)
+    /// Parses the TypeTree and other arrays that are stored in the metadata,
     /// </summary>
-    private static void ParseTypeTreeMetadata(BinaryReader reader, SerializedFileInfo headerInfo,
+    private static void ParseExtendedMetadata(BinaryReader reader, SerializedFileInfo headerInfo,
         bool swap, long metadataOffset, SerializedFileMetadata metadata)
     {
         try