Fix nested type fallback decompilation

Author: pardeike

.github/copilot-instructions.md

@@ -122,6 +122,7 @@ dotnet format DecompilerServer.sln
 - Cache decompiled C# source with line indexing
 - Support ranged retrieval without re-decompilation
 - Include proper headers/footers and maintain source document metadata
+- When decompiling nested types by name, prefer reflection names such as `Outer+Inner`; dotted names such as `Outer.Inner` can fail in ILSpy lookup paths even when the type exists in metadata.
 
 ### IL Handling
 - Use ICSharpCode.Decompiler.Disassembler for readable IL output

DecompilerServer.csproj

@@ -5,7 +5,7 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <Version>1.0.0</Version>
+    <Version>1.0.1</Version>
   </PropertyGroup>
 
   <ItemGroup>
@@ -16,6 +16,7 @@
 
   <ItemGroup>
     <Compile Remove="EmbeddedSourceTestLibrary/**" />
+    <Compile Remove="NestedNoSymbolsTestLibrary/**" />
     <Compile Remove="Tests/**" />
     <Compile Remove="TestLibrary/**" />
   </ItemGroup>

NestedNoSymbolsTestLibrary/NestedNoSymbolsTestLibrary.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <DebugType>none</DebugType>
+    <DebugSymbols>false</DebugSymbols>
+  </PropertyGroup>
+
+</Project>

NestedNoSymbolsTestLibrary/OuterContainer.cs

@@ -0,0 +1,12 @@
+namespace NestedNoSymbolsTestLibrary;
+
+public class OuterContainer
+{
+    public class NestedWorker
+    {
+        public int Compute(int value)
+        {
+            return value + 1;
+        }
+    }
+}

Services/DecompilerService.cs

@@ -189,7 +189,7 @@ private string DecompileEntity(IEntity entity)
             var decompiler = _contextManager.GetDecompiler();
             return entity switch
             {
-                ITypeDefinition type => decompiler.DecompileTypeAsString(type.FullTypeName),
+                ITypeDefinition type => DecompileType(type, decompiler),
                 IMethod method => DecompileMethod(method, decompiler),
                 IField field => DecompileField(field, decompiler),
                 IProperty property => DecompileProperty(property, decompiler),
@@ -199,6 +199,23 @@ private string DecompileEntity(IEntity entity)
         }
     }
 
+    private static string DecompileType(IType type, CSharpDecompiler decompiler)
+    {
+        return decompiler.DecompileTypeAsString(GetDecompilerTypeName(type));
+    }
+
+    private static FullTypeName GetDecompilerTypeName(IType type)
+    {
+        if (!string.IsNullOrWhiteSpace(type.ReflectionName))
+            return new FullTypeName(type.ReflectionName);
+
+        return type switch
+        {
+            ITypeDefinition typeDefinition => typeDefinition.FullTypeName,
+            _ => new FullTypeName(type.FullName)
+        };
+    }
+
     private static string StripHeader(string code)
     {
         var lines = code.Split('\n');
@@ -248,31 +265,31 @@ private string DecompileMethod(IMethod method, CSharpDecompiler decompiler)
         if (method.DeclaringType == null)
             return $"// Error: Method '{method.Name}' has no declaring type and cannot be decompiled";
 
-        return decompiler.DecompileTypeAsString(new ICSharpCode.Decompiler.TypeSystem.FullTypeName(method.DeclaringType.FullName));
+        return DecompileType(method.DeclaringType, decompiler);
     }
 
     private string DecompileField(IField field, CSharpDecompiler decompiler)
     {
         if (field.DeclaringType == null)
             return $"// Error: Field '{field.Name}' has no declaring type and cannot be decompiled";
 
-        return decompiler.DecompileTypeAsString(new ICSharpCode.Decompiler.TypeSystem.FullTypeName(field.DeclaringType.FullName));
+        return DecompileType(field.DeclaringType, decompiler);
     }
 
     private string DecompileProperty(IProperty property, CSharpDecompiler decompiler)
     {
         if (property.DeclaringType == null)
             return $"// Error: Property '{property.Name}' has no declaring type and cannot be decompiled";
 
-        return decompiler.DecompileTypeAsString(new ICSharpCode.Decompiler.TypeSystem.FullTypeName(property.DeclaringType.FullName));
+        return DecompileType(property.DeclaringType, decompiler);
     }
 
     private string DecompileEvent(IEvent evt, CSharpDecompiler decompiler)
     {
         if (evt.DeclaringType == null)
             return $"// Error: Event '{evt.Name}' has no declaring type and cannot be decompiled";
 
-        return decompiler.DecompileTypeAsString(new ICSharpCode.Decompiler.TypeSystem.FullTypeName(evt.DeclaringType.FullName));
+        return DecompileType(evt.DeclaringType, decompiler);
     }
 
     private string ComputeHash(string content)

Tests/DecompilationFunctionalityTests.cs

@@ -60,6 +60,34 @@ public void DecompileInterface_ShouldContainInterfaceDeclaration()
         Assert.Contains("InterfaceProperty", sourceCode);
     }
 
+    [Fact]
+    public void DecompileNestedTypeWithoutSymbols_ShouldUseFallbackDecompiler()
+    {
+        using var contextManager = new AssemblyContextManager();
+        var memberResolver = new MemberResolver(contextManager);
+        var decompilerService = new DecompilerService(contextManager, memberResolver);
+
+        var assemblyPath = typeof(global::NestedNoSymbolsTestLibrary.OuterContainer.NestedWorker).Assembly.Location;
+        contextManager.LoadAssemblyDirect(assemblyPath);
+
+        var nestedType = contextManager.GetAllTypes()
+            .Single(type => type.ReflectionName == "NestedNoSymbolsTestLibrary.OuterContainer+NestedWorker");
+
+        var typeDocument = decompilerService.DecompileMember(memberResolver.GenerateMemberId(nestedType));
+        var typeSource = string.Join("\n", typeDocument.Lines);
+
+        Assert.Equal(SourceKinds.Decompiled, typeDocument.SourceKind);
+        Assert.Contains("class NestedWorker", typeSource);
+
+        var method = nestedType.Methods.Single(m => m.Name == "Compute");
+        var methodDocument = decompilerService.DecompileMember(memberResolver.GenerateMemberId(method));
+        var methodSource = string.Join("\n", methodDocument.Lines);
+
+        Assert.Equal(SourceKinds.Decompiled, methodDocument.SourceKind);
+        Assert.Contains("class NestedWorker", methodSource);
+        Assert.Contains("Compute", methodSource);
+    }
+
     [Fact]
     public void DecompileDerivedClass_ShouldShowInheritance()
     {
@@ -177,4 +205,4 @@ public void ResponseFormatter_ProducesValidJsonForDecompilerResults()
         Assert.Contains("\"language\":\"C#\"", jsonResponse);
         Assert.Contains("\"totalLines\":", jsonResponse);
     }
-}
+}

Tests/Tests.csproj

@@ -29,6 +29,7 @@
   <ItemGroup>
     <ProjectReference Include="../DecompilerServer.csproj" />
     <ProjectReference Include="../EmbeddedSourceTestLibrary/EmbeddedSourceTestLibrary.csproj" />
+    <ProjectReference Include="../NestedNoSymbolsTestLibrary/NestedNoSymbolsTestLibrary.csproj" />
     <ProjectReference Include="../TestLibrary/TestLibrary.csproj" />
   </ItemGroup>