Use directly parsed ObjectList for ObjectList command

This fixes ObjectList for files without TypeTrees

Author: SkowronskiAndrew

Analyzer/Util/SerializedFileDetector.cs

@@ -604,12 +604,6 @@ private static void ParseExtendedMetadata(BinaryReader reader, SerializedFileInf
             }
             metadata.ObjectList = objectList;
 
-            // m_RefTypes (version >= 20) is not located immediately after m_Types.
-            // It appears at the end of the metadata section, after the object list,
-            // script type list, and externals list. We must skip those three sections.
-            if (version < SupportsRefObjectVersion)
-                return;
-
             // --- Skip the script type list ---
             // Per-entry layout (version >= 14, applies to all our versions):
             //   [int32 localSerializedFileIndex]
@@ -638,6 +632,11 @@ private static void ParseExtendedMetadata(BinaryReader reader, SerializedFileInf
                 BinaryFileHelper.ReadNullTermString(reader);          // pathName
             }
 
+            // m_RefTypes (version >= 20) is not located immediately after m_Types.
+            // It appears at the end of the metadata section
+            if (version < SupportsRefObjectVersion)
+                return;
+
             // --- SerializeReference type list (m_RefTypes, version >= 20) ---
             int refTypeCount = BinaryFileHelper.ReadInt32(reader, swap);
             metadata.SerializedReferenceTypeTreeCount = refTypeCount;

UnityDataTool.Tests/SerializedFileCommandTests.cs

@@ -293,6 +293,49 @@ public async Task ObjectList_SharedAssets_ContainsExpectedTypes()
         }
     }
 
+    [Test]
+    public async Task ObjectList_NoTypeTree_JsonFormat_OutputsExpectedValues()
+    {
+        var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "PlayerNoTypeTree", "level0");
+        using var sw = new StringWriter();
+        var currentOut = Console.Out;
+        try
+        {
+            Console.SetOut(sw);
+
+            Assert.AreEqual(0, await Program.Main(new string[] { "sf", "objectlist", path, "-f", "json" }));
+
+            var output = sw.ToString();
+            var jsonArray = JsonDocument.Parse(output).RootElement;
+            Assert.AreEqual(7, jsonArray.GetArrayLength());
+
+            // Spot-check a few entries by index
+            var first = jsonArray[0];
+            Assert.AreEqual(1,            first.GetProperty("id").GetInt64());
+            Assert.AreEqual(1,            first.GetProperty("typeId").GetInt32());
+            Assert.AreEqual("GameObject", first.GetProperty("typeName").GetString());
+            Assert.AreEqual(576,          first.GetProperty("offset").GetInt64());
+            Assert.AreEqual(63,           first.GetProperty("size").GetInt64());
+
+            var third = jsonArray[2];
+            Assert.AreEqual(3,                third.GetProperty("id").GetInt64());
+            Assert.AreEqual(104,              third.GetProperty("typeId").GetInt32());
+            Assert.AreEqual("RenderSettings", third.GetProperty("typeName").GetString());
+            Assert.AreEqual(720,              third.GetProperty("offset").GetInt64());
+
+            var last = jsonArray[6];
+            Assert.AreEqual(7,               last.GetProperty("id").GetInt64());
+            Assert.AreEqual(114,             last.GetProperty("typeId").GetInt32());
+            Assert.AreEqual("MonoBehaviour", last.GetProperty("typeName").GetString());
+            Assert.AreEqual(1200,            last.GetProperty("offset").GetInt64());
+            Assert.AreEqual(44,              last.GetProperty("size").GetInt64());
+        }
+        finally
+        {
+            Console.SetOut(currentOut);
+        }
+    }
+
     #endregion
 
     #region Header Tests

UnityDataTool/SerializedFileCommands.cs

@@ -33,24 +33,39 @@ public static int HandleExternalRefs(FileInfo filename, OutputFormat format)
 
     public static int HandleObjectList(FileInfo filename, OutputFormat format)
     {
-        if (!ValidateSerializedFile(filename.FullName, out _))
+        // The object list is read directly from the parsed metadata rather than via UnityFileSystemApi.
+        //
+        // Advantages: works for any modern SerializedFile (version >= 19), including Player builds
+        // that were compiled without TypeTrees — files that UnityFileSystemApi cannot open at all.
+        //
+        // Trade-offs: type names come from TypeIdRegistry rather than the file's embedded TypeTree,
+        // so uncommon types not covered by the registry are displayed as a numeric TypeId. Files
+        // older than version 19 (Unity 2019.1) are not supported by the metadata parser.
+        //
+        // These trade-offs are minor compared to the benefit of handling the common no-TypeTree case,
+        // so there is no need to keep the UnityFileSystemApi code path.
+        if (!ValidateSerializedFile(filename.FullName, out var fileInfo))
             return 1;
 
-        try
+        if (!SerializedFileDetector.TryParseMetadata(filename.FullName, fileInfo, out var metadata, out var errorMessage))
         {
-            using var sf = UnityFileSystem.OpenSerializedFile(filename.FullName);
-            if (format == OutputFormat.Json)
-                OutputObjectListJson(sf);
-            else
-                OutputObjectListText(sf);
-            return 0;
+            Console.Error.WriteLine($"Error: Failed to parse object list for: {filename.FullName}");
+            Console.Error.WriteLine(errorMessage);
+            return 1;
         }
-        catch (Exception err) when (err is NotSupportedException || err is FileFormatException)
+
+        if (metadata.ObjectList == null)
         {
-            Console.Error.WriteLine($"Error opening SerializedFile: {filename.FullName}");
-            Console.Error.WriteLine(err.Message);
+            Console.Error.WriteLine($"Error: Object list could not be parsed for: {filename.FullName}");
             return 1;
         }
+
+        if (format == OutputFormat.Json)
+            OutputObjectListJson(metadata.ObjectList);
+        else
+            OutputObjectListText(metadata.ObjectList);
+
+        return 0;
     }
 
     public static int HandleHeader(FileInfo filename, OutputFormat format)
@@ -167,36 +182,27 @@ private static void OutputExternalRefsJson(SerializedFile sf)
         Console.WriteLine(json);
     }
 
-    private static void OutputObjectListText(SerializedFile sf)
+    private static void OutputObjectListText(ObjectInfo[] objects)
     {
-        var objects = sf.Objects;
-
-        // Print header
         Console.WriteLine($"{"Id",-20} {"Type",-40} {"Offset",-15} {"Size",-15}");
         Console.WriteLine(new string('-', 90));
 
         foreach (var obj in objects)
-        {
-            string typeName = GetTypeName(sf, obj);
-            Console.WriteLine($"{obj.Id,-20} {typeName,-40} {obj.Offset,-15} {obj.Size,-15}");
-        }
+            Console.WriteLine($"{obj.Id,-20} {TypeIdRegistry.GetTypeName(obj.TypeId),-40} {obj.Offset,-15} {obj.Size,-15}");
     }
 
-    private static void OutputObjectListJson(SerializedFile sf)
+    private static void OutputObjectListJson(ObjectInfo[] objects)
     {
-        var objects = sf.Objects;
-        var jsonArray = new object[objects.Count];
+        var jsonArray = new object[objects.Length];
 
-        for (int i = 0; i < objects.Count; i++)
+        for (int i = 0; i < objects.Length; i++)
         {
             var obj = objects[i];
-            string typeName = GetTypeName(sf, obj);
-
             jsonArray[i] = new
             {
                 id = obj.Id,
                 typeId = obj.TypeId,
-                typeName = typeName,
+                typeName = TypeIdRegistry.GetTypeName(obj.TypeId),
                 offset = obj.Offset,
                 size = obj.Size
             };
@@ -206,21 +212,6 @@ private static void OutputObjectListJson(SerializedFile sf)
         Console.WriteLine(json);
     }
 
-    private static string GetTypeName(SerializedFile sf, ObjectInfo obj)
-    {
-        try
-        {
-            // Try to get type name from TypeTree first (most accurate)
-            var root = sf.GetTypeTreeRoot(obj.Id);
-            return root.Type;
-        }
-        catch
-        {
-            // Fall back to registry if TypeTree is not available
-            return TypeIdRegistry.GetTypeName(obj.TypeId);
-        }
-    }
-
     private static void OutputHeaderText(SerializedFileInfo info)
     {
         Console.WriteLine($"{"Version",-20} {info.Version}");