[#77] Detect missing TypeTrees up front in analyze and dump (#78)

Analyzing AssetBundles whose SerializedFiles have no TypeTrees handed the
files to the native loader, which emitted misleading "Invalid serialized
file version" errors and could crash the process with an access violation
(0xC0000005)

Fix is to detect missing TypeTrees before the native open and skip such files cleanly,

Fix applies to both dump and analyze commands.
Fix applies to Player data and other build types in addition to AssetBundles.

Author: SkowronskiAndrew

Analyzer/AnalyzerTool.cs

@@ -6,7 +6,6 @@
 using UnityDataTools.Analyzer.SQLite.Parsers;
 using UnityDataTools.Analyzer.SQLite.Writers;
 using UnityDataTools.Models;
-using UnityDataTools.BinaryFormat;
 using UnityDataTools.FileSystem;
 
 namespace UnityDataTools.Analyzer;
@@ -66,6 +65,7 @@ public int Analyze(AnalyzeOptions options)
         int countFailures = 0;
         int countSuccess = 0;
         int countIgnored = 0;
+        int countNoTypeTrees = 0;
         int i = 1;
         foreach (var (file, displayRoot) in files)
         {
@@ -82,15 +82,21 @@ public int Analyze(AnalyzeOptions options)
                         ReportProgress(relativePath, i, files.Count);
                         countSuccess++;
                     }
-                    catch (SerializedFileOpenException e)
+                    catch (SerializedFileOpenException e) when (e.MissingTypeTrees)
+                    {
+                        // The file has no TypeTrees and was rejected before opening. This is an
+                        // expected, distinct outcome — reported and counted separately so a large
+                        // run can tell these apart from genuine failures.
+                        EraseProgressLine();
+                        Console.Error.WriteLine($"Skipped (no TypeTrees): {relativePath}");
+                        countNoTypeTrees++;
+                    }
+                    catch (SerializedFileOpenException)
                     {
                         // Expected failure — the file content could not be parsed.
                         // Don't print a stack trace; it adds no value for this known failure mode.
                         EraseProgressLine();
                         Console.Error.WriteLine($"Failed to open: {relativePath}");
-                        var hint = SerializedFileDetector.GetOpenFailureHint(e.FilePath);
-                        if (hint != null)
-                            Console.Error.WriteLine(hint);
                         countFailures++;
                     }
                     catch (Exception e)
@@ -123,7 +129,7 @@ public int Analyze(AnalyzeOptions options)
         }
 
         Console.WriteLine();
-        Console.WriteLine($"Finalizing database. Successfully processed files: {countSuccess}, Failed files: {countFailures}, Ignored files: {countIgnored}");
+        Console.WriteLine($"Finalizing database. Successfully processed files: {countSuccess}, Failed files: {countFailures}, Files without TypeTrees: {countNoTypeTrees}, Ignored files: {countIgnored}");
 
         writer.End();
         foreach (var parser in parsers)

Analyzer/SQLite/Parsers/SerializedFileParser.cs

@@ -81,6 +81,7 @@ void ProcessFile(string file, string rootDirectory)
             if (ArchiveDetector.IsUnityArchive(file))
             {
                 bool archiveHadErrors = false;
+                bool archiveHadMissingTypeTrees = false;
                 using (UnityArchive archive = UnityFileSystem.MountArchive(file, "archive:" + Path.DirectorySeparatorChar))
                 {
                     if (archive == null)
@@ -100,6 +101,12 @@ void ProcessFile(string file, string rootDirectory)
                                 {
                                     m_Writer.WriteSerializedFile(node.Path, "archive:/" + node.Path, Path.GetDirectoryName(file));
                                 }
+                                catch (SerializedFileOpenException e) when (e.MissingTypeTrees)
+                                {
+                                    // The file has no TypeTrees and was rejected before opening. This is
+                                    // tracked separately so it isn't lumped with genuine processing errors.
+                                    archiveHadMissingTypeTrees = true;
+                                }
                                 catch (Exception e)
                                 {
                                     // the most likely exception here is Microsoft.Data.Sqlite.SqliteException,
@@ -124,10 +131,16 @@ void ProcessFile(string file, string rootDirectory)
                     }
                 }
 
+                // Genuine errors take precedence over missing TypeTrees when reporting the archive's outcome.
                 if (archiveHadErrors)
                 {
                     throw new Exception("One or more files in the archive failed to process");
                 }
+
+                if (archiveHadMissingTypeTrees)
+                {
+                    throw new SerializedFileOpenException(file, missingTypeTrees: true);
+                }
             }
             else
             {

Analyzer/SQLite/Writers/SerializedFileSQLiteWriter.cs

@@ -6,6 +6,7 @@
 using UnityDataTools.Analyzer.SQLite.Commands.SerializedFile;
 using UnityDataTools.Analyzer.SQLite.Handlers;
 using UnityDataTools.Analyzer.Util;
+using UnityDataTools.BinaryFormat;
 using UnityDataTools.FileSystem;
 using UnityDataTools.FileSystem.TypeTreeReaders;
 
@@ -116,6 +117,16 @@ public void EndAssetBundle()
 
     public void WriteSerializedFile(string relativePath, string fullPath, string containingFolder)
     {
+        // A file without TypeTrees can only be opened when its types exactly match this build of
+        // UnityFileSystemApi. Handing such a file to the native loader produces misleading version
+        // mismatch errors and can crash the process, so detect and reject it up front. The native
+        // VFS path here may be a real file or an entry inside a mounted archive.
+        using (var detectStream = new UnityFileStream(fullPath))
+        {
+            if (SerializedFileDetector.IsMissingTypeTrees(detectStream))
+                throw new SerializedFileOpenException(fullPath, missingTypeTrees: true);
+        }
+
         using var sf = UnityFileSystem.OpenSerializedFile(fullPath);
         using var reader = new UnityFileReader(fullPath, 64 * 1024 * 1024);
         using var pptrReader = new PPtrAndCrcProcessor(sf, reader, containingFolder, m_SkipCrc, AddReference);

TextDumper/TextDumperTool.cs

@@ -76,6 +76,9 @@ public int Dump(DumpOptions options)
 
     int DumpSerializedFile()
     {
+        if (ReportIfMissingTypeTrees(m_Options.Path, m_Options.Path))
+            return 1;
+
         try
         {
             if (m_Options.ToStdout)
@@ -93,23 +96,33 @@ int DumpSerializedFile()
         }
         catch (SerializedFileOpenException)
         {
-            var hint = SerializedFileDetector.GetOpenFailureHint(m_Options.Path);
-            if (hint != null)
-            {
-                Console.Error.WriteLine();
-                Console.Error.WriteLine(hint);
-            }
+            Console.Error.WriteLine($"Error: Failed to open serialized file: {m_Options.Path}");
             return 1;
         }
 
         return 0;
     }
 
+    // dump needs TypeTrees to interpret object data, so a SerializedFile without them cannot be dumped.
+    // Detecting this up front avoids handing the file to the native loader, which would otherwise emit
+    // misleading version mismatch errors or crash the process. Returns true (and prints a clear message)
+    // when the file has no TypeTrees. The path may be a real file or an entry in a mounted archive.
+    bool ReportIfMissingTypeTrees(string path, string displayName)
+    {
+        using var stream = new UnityFileStream(path);
+        if (!SerializedFileDetector.IsMissingTypeTrees(stream))
+            return false;
+
+        Console.Error.WriteLine($"Error: \"{displayName}\" has no TypeTrees. The dump command needs TypeTrees to interpret the serialized object data, so this file cannot be dumped.");
+        return true;
+    }
+
     // For convenience we also support directly dumping serialized files that are inside an archive,
     // so that it's not necessary to use `archive extract` if you only want to see values from the object serialization.
     int DumpArchive()
     {
         using var archive = UnityFileSystem.MountArchive(m_Options.Path, "/");
+        bool anyMissingTypeTrees = false;
 
         if (m_Options.ToStdout)
         {
@@ -139,6 +152,8 @@ int DumpArchive()
 
             var node2 = singleSerializedFile.Value;
             Console.Error.WriteLine($"Processing {node2.Path} {node2.Size} {node2.Flags}");
+            if (ReportIfMissingTypeTrees("/" + node2.Path, node2.Path))
+                return 1;
             m_Writer = Console.Out;
             OutputSerializedFile("/" + node2.Path);
             m_Writer.Flush();
@@ -151,14 +166,20 @@ int DumpArchive()
 
                 if (node.Flags.HasFlag(ArchiveNodeFlags.SerializedFile))
                 {
+                    if (ReportIfMissingTypeTrees("/" + node.Path, node.Path))
+                    {
+                        anyMissingTypeTrees = true;
+                        continue;
+                    }
+
                     using var writer = new StreamWriter(Path.Combine(m_Options.OutputPath, Path.GetFileName(node.Path) + ".txt"), false);
                     m_Writer = writer;
                     OutputSerializedFile("/" + node.Path);
                 }
             }
         }
 
-        return 0;
+        return anyMissingTypeTrees ? 1 : 0;
     }
 
     void OutputSerializedFile(string path)

UnityBinaryFormat/SerializedFileDetector.cs

@@ -303,16 +303,37 @@ public static bool TryDetectSerializedFile(string filePath, out SerializedFileIn
         try
         {
             using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+            return TryDetectSerializedFile(stream, out info);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Stream-based variant of <see cref="TryDetectSerializedFile(string, out SerializedFileInfo)"/>.
+    /// Reads from the current contents of <paramref name="stream"/> (seeking it to the start first),
+    /// allowing detection of files that are not directly on disk (e.g. inside a mounted archive).
+    /// </summary>
+    public static bool TryDetectSerializedFile(Stream stream, out SerializedFileInfo info)
+    {
+        info = null;
+
+        try
+        {
             long fileLength = stream.Length;
 
             // Quick rejection: file must be at least large enough for the legacy header
             if (fileLength < LegacyHeaderSize)
                 return false;
 
+            stream.Seek(0, SeekOrigin.Begin);
+
             // Read enough bytes to cover a modern header (48 bytes)
             // We'll determine which format to parse based on the version field
             byte[] headerBytes = new byte[ModernHeaderSize];
-            int bytesRead = stream.Read(headerBytes, 0, headerBytes.Length);
+            int bytesRead = stream.ReadAtLeast(headerBytes, ModernHeaderSize, throwOnEndOfStream: false);
 
             if (bytesRead < LegacyHeaderSize)
                 return false;
@@ -528,32 +549,71 @@ public static bool TryParseMetadata(string filePath, SerializedFileInfo headerIn
         metadata = null;
         errorMessage = null;
 
+        // The supported-version check depends only on the header, so do it before touching the file.
+        if (!IsMetadataVersionSupported(headerInfo.Version, out errorMessage))
+            return false;
+
+        try
+        {
+            using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+            return TryParseMetadata(stream, headerInfo, out metadata, out errorMessage);
+        }
+        catch
+        {
+            errorMessage = "An unexpected error occurred while opening the file.";
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Validates that the SerializedFile version is within the range whose metadata layout this
+    /// parser understands. Returns false with an explanatory message when it is not.
+    /// </summary>
+    private static bool IsMetadataVersionSupported(uint version, out string errorMessage)
+    {
         // Only support version >= 19 (Unity 2019.1). Older files have metadata format
         // differences we have not implemented.
-        if (headerInfo.Version < MinMetadataParseVersion)
+        if (version < MinMetadataParseVersion)
         {
-            errorMessage = $"Metadata parsing is not supported for SerializedFile version {headerInfo.Version}. " +
+            errorMessage = $"Metadata parsing is not supported for SerializedFile version {version}. " +
                            $"Version {MinMetadataParseVersion} (Unity 2019.1) or newer is required.";
             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)
+        if (version > MaxMetadataParseVersion)
         {
-            errorMessage = $"SerializedFile version {headerInfo.Version} is not supported. " +
+            errorMessage = $"SerializedFile version {version} is not supported. " +
                            $"UnityDataTool supports up to version {MaxMetadataParseVersion}. " +
                            $"Please use a newer version of UnityDataTool to read this file.";
             return false;
         }
 
+        errorMessage = null;
+        return true;
+    }
+
+    /// <summary>
+    /// Stream-based variant of <see cref="TryParseMetadata(string, SerializedFileInfo, out SerializedFileMetadata, out string)"/>.
+    /// When <paramref name="parseExtended"/> is false, only the leading metadata fields (Unity version,
+    /// target platform and EnableTypeTree) are read; the type/object/reference arrays are skipped. This
+    /// is the cheap path for callers that only need to know whether the file has TypeTrees.
+    /// </summary>
+    public static bool TryParseMetadata(Stream stream, SerializedFileInfo headerInfo, out SerializedFileMetadata metadata, out string errorMessage, bool parseExtended = true)
+    {
+        metadata = null;
+        errorMessage = null;
+
+        if (!IsMetadataVersionSupported(headerInfo.Version, out errorMessage))
+            return false;
+
         try
         {
             long metadataOffset = headerInfo.IsLegacyFormat ? LegacyHeaderSize : ModernHeaderSize;
             bool swap = headerInfo.Endianness == BigEndian;
 
-            using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
             stream.Seek(metadataOffset, SeekOrigin.Begin);
             using var reader = new BinaryReader(stream, System.Text.Encoding.ASCII, leaveOpen: true);
 
@@ -583,7 +643,8 @@ public static bool TryParseMetadata(string filePath, SerializedFileInfo headerIn
 
             // 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.
-            ParseExtendedMetadata(reader, headerInfo, swap, metadataOffset, metadata);
+            if (parseExtended)
+                ParseExtendedMetadata(reader, headerInfo, swap, metadataOffset, metadata);
 
             return true;
         }
@@ -595,22 +656,15 @@ public static bool TryParseMetadata(string filePath, SerializedFileInfo headerIn
     }
 
     /// <summary>
-    /// Returns a diagnostic hint explaining why a SerializedFile may have failed to open,
-    /// or null if no specific diagnosis is available.
-    /// Currently detects the common case of missing TypeTrees (player builds compiled
-    /// without type information, which the DLL reports as a generic unknown error).
+    /// Returns true when the stream is a SerializedFile we can positively confirm has no TypeTrees.
+    /// Returns false for files that have TypeTrees and for anything we cannot parse (so callers fall
+    /// back to the normal open path rather than skipping a file we simply did not understand).
     /// </summary>
-    /// <param name="path">Real filesystem path to the file that failed to open.</param>
-    public static string GetOpenFailureHint(string path)
+    public static bool IsMissingTypeTrees(Stream stream)
     {
-        if (TryDetectSerializedFile(path, out var fileInfo) &&
-            TryParseMetadata(path, fileInfo, out var metadata, out _) &&
-            !metadata.EnableTypeTree)
-        {
-            return "Note: This file does not have TypeTrees and can only be opened if all the " +
-                   "types it uses exactly match the types in the build of UnityFileSystemApi being used.";
-        }
-        return null;
+        return TryDetectSerializedFile(stream, out var fileInfo)
+            && TryParseMetadata(stream, fileInfo, out var metadata, out _, parseExtended: false)
+            && !metadata.EnableTypeTree;
     }
 
     /// <summary>