[#77] dump: detect missing TypeTrees up front instead of crashing

dump can never interpret a SerializedFile without TypeTrees, yet it handed
such files to the native loader, producing misleading version mismatch errors
and a raw SerializedFileOpenException with a stack trace (and, for archives,
no clean handling at all).

Detect missing TypeTrees before opening for both the direct-SerializedFile and
the Unity Archive paths, and print a clear message explaining dump cannot
process the file. This reuses the same SerializedFileDetector.IsMissingTypeTrees
check the analyzer uses.

With the dump path no longer relying on it, the now-unused GetOpenFailureHint
and MissingTypeTreesHint are removed from SerializedFileDetector.

Author: SkowronskiAndrew

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

@@ -655,16 +655,6 @@ public static bool TryParseMetadata(Stream stream, SerializedFileInfo headerInfo
         }
     }
 
-    /// <summary>
-    /// Explanation shown for SerializedFiles that have no TypeTrees. Such files can only be
-    /// opened when every type they use exactly matches the build of UnityFileSystemApi in use,
-    /// which is why the native loader reports misleading version mismatch errors (or crashes)
-    /// when that is not the case.
-    /// </summary>
-    public const string MissingTypeTreesHint =
-        "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.";
-
     /// <summary>
     /// 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
@@ -677,24 +667,6 @@ public static bool IsMissingTypeTrees(Stream stream)
             && !metadata.EnableTypeTree;
     }
 
-    /// <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).
-    /// </summary>
-    /// <param name="path">Real filesystem path to the file that failed to open.</param>
-    public static string GetOpenFailureHint(string path)
-    {
-        if (TryDetectSerializedFile(path, out var fileInfo) &&
-            TryParseMetadata(path, fileInfo, out var metadata, out _) &&
-            !metadata.EnableTypeTree)
-        {
-            return MissingTypeTreesHint;
-        }
-        return null;
-    }
-
     /// <summary>
     /// Parses the TypeTree and other arrays that are stored in the metadata,
     /// </summary>

UnityDataTool.Tests/DumpTests.cs

@@ -13,6 +13,8 @@ public class DumpTests
     private string m_SerializedFilePath;
     private string m_ResourceFilePath;
     private string m_MultiSerializedFileArchivePath;
+    private string m_NoTypeTreeSerializedFilePath;
+    private string m_NoTypeTreeArchivePath;
 
     [OneTimeSetUp]
     public void OneTimeSetup()
@@ -21,6 +23,8 @@ public void OneTimeSetup()
         m_SerializedFilePath = Path.Combine(m_TestDataFolder, "PlayerWithTypeTrees", "level0");
         m_ResourceFilePath = Path.Combine(m_TestDataFolder, "PlayerWithTypeTrees", "sharedassets0.assets.resS");
         m_MultiSerializedFileArchivePath = Path.Combine(m_TestDataFolder, "PlayerDataCompressed", "data.unity3d");
+        m_NoTypeTreeSerializedFilePath = Path.Combine(m_TestDataFolder, "PlayerNoTypeTree", "level0");
+        m_NoTypeTreeArchivePath = Path.Combine(m_TestDataFolder, "AssetBundleTypeTreeVariations", "AssetBundle-NoTypeTree", "small.bundle");
     }
 
     [Test]
@@ -207,4 +211,52 @@ public async Task Dump_Stdout_InvalidFileType_Fails()
 
         Assert.That(swErr.ToString(), Does.Contain("does not appear to be a valid Unity SerializedFile or Unity Archive"));
     }
+
+    [Test]
+    public async Task Dump_NoTypeTreeSerializedFile_ReportsMissingTypeTreesWithoutCrashing()
+    {
+        using var swOut = new StringWriter();
+        using var swErr = new StringWriter();
+        var currentOut = Console.Out;
+        var currentErr = Console.Error;
+        try
+        {
+            Console.SetOut(swOut);
+            Console.SetError(swErr);
+            Assert.AreNotEqual(0, await Program.Main(new string[] { "dump", m_NoTypeTreeSerializedFilePath, "--stdout" }));
+        }
+        finally
+        {
+            Console.SetOut(currentOut);
+            Console.SetError(currentErr);
+        }
+
+        var output = swOut.ToString() + swErr.ToString();
+        Assert.That(output, Does.Contain("has no TypeTrees"), "Expected a clear missing-TypeTrees message");
+        Assert.That(output, Does.Not.Contain("SerializedFileOpenException"), "Should not leak an exception/stack trace");
+    }
+
+    [Test]
+    public async Task Dump_NoTypeTreeArchive_ReportsMissingTypeTreesWithoutCrashing()
+    {
+        using var swOut = new StringWriter();
+        using var swErr = new StringWriter();
+        var currentOut = Console.Out;
+        var currentErr = Console.Error;
+        try
+        {
+            Console.SetOut(swOut);
+            Console.SetError(swErr);
+            Assert.AreNotEqual(0, await Program.Main(new string[] { "dump", m_NoTypeTreeArchivePath, "--stdout" }));
+        }
+        finally
+        {
+            Console.SetOut(currentOut);
+            Console.SetError(currentErr);
+        }
+
+        var output = swOut.ToString() + swErr.ToString();
+        Assert.That(output, Does.Contain("has no TypeTrees"), "Expected a clear missing-TypeTrees message");
+        Assert.That(output, Does.Not.Contain("SerializedFileOpenException"), "Should not leak an exception/stack trace");
+    }
 }