Add documents to PDB for types that have no methods with IL

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

@@ -208,6 +208,108 @@ private void ValidateReferencedAssembly(AssemblySymbol assembly, AssemblyReferen
             return null;
         }
 
+        public sealed override MultiDictionary<Cci.ITypeDefinition, Cci.DebugSourceDocument> GetTypeToDebugDocumentMap(EmitContext context)
+        {
+            var result = new MultiDictionary<Cci.ITypeDefinition, Cci.DebugSourceDocument>(Cci.SymbolEquivalentEqualityComparer.Instance);
+
+            var namespacesAndTypesToProcess = new Stack<NamespaceOrTypeSymbol>();
+            namespacesAndTypesToProcess.Push(SourceModule.GlobalNamespace);
+            while (namespacesAndTypesToProcess.Count > 0)
+            {
+                var symbol = namespacesAndTypesToProcess.Pop();
+
+                switch (symbol.Kind)
+                {
+                    case SymbolKind.Namespace:
+                        var location = GetSmallestSourceLocationOrNull(symbol);
+
+                        // filtering out synthesized symbols not having real source 
+                        // locations such as anonymous types, etc...
+                        if (location != null)
+                        {
+                            foreach (var member in symbol.GetMembers())
+                            {
+                                switch (member.Kind)
+                                {
+                                    case SymbolKind.Namespace:
+                                    case SymbolKind.NamedType:
+                                        namespacesAndTypesToProcess.Push((NamespaceOrTypeSymbol)member);
+                                        break;
+                                    default:
+                                        throw ExceptionUtilities.UnexpectedValue(member.Kind);
+                                }
+                            }
+                        }
+                        break;
+                    case SymbolKind.NamedType:
+                        var methodDocumentList = GetDocumentsForMethods(symbol, context, out var allMethodsHaveIL);
+
+                        // If all of the methods have IL then the document data we already have is enough, but if not
+                        // then we want to add document info for the type.
+                        if (!allMethodsHaveIL)
+                        {
+                            var typeDefinition = (Cci.ITypeDefinition)symbol.GetCciAdapter();
+
+                            foreach (var loc in symbol.Locations)
+                            {
+                                if (!loc.IsInSource)
+                                {
+                                    continue;
+                                }
+
+                                var span = loc.GetLineSpan();
+                                var debugDocument = DebugDocumentsBuilder.TryGetDebugDocument(span.Path, basePath: null);
+
+                                // We don't need to duplicate the data, if the method debug info would already contain this document
+                                if (debugDocument is not null && !methodDocumentList.Contains(debugDocument))
+                                {
+                                    result.Add(typeDefinition, debugDocument);
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(symbol.Kind);
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Gets a list of documents from the method definitions in this type, and also outputs whether there are
+        /// any methods that don't have document info (ie don't have any IL)
+        /// </summary>
+        private static HashSet<Cci.DebugSourceDocument> GetDocumentsForMethods(NamespaceOrTypeSymbol typeSymbol, EmitContext context, out bool allMethodsHaveIL)
+        {
+            var documentList = new HashSet<Cci.DebugSourceDocument>();
+
+            var typeDef = (Cci.ITypeDefinition)typeSymbol.GetCciAdapter();
+            var typeMethods = typeDef.GetMethods(context);
+
+            var foundMethodWithIL = false;
+            var foundMethodWithoutIL = false;
+            foreach (var method in typeMethods)
+            {
+                if (Cci.Extensions.HasBody(method) &&
+                    method.GetBody(context) is { } body &&
+                    !body.SequencePoints.IsEmpty)
+                {
+                    foundMethodWithIL = true;
+
+                    foreach (var point in body.SequencePoints)
+                    {
+                        documentList.Add(point.Document);
+                    }
+                }
+                else
+                {
+                    foundMethodWithoutIL = true;
+                }
+            }
+            allMethodsHaveIL = foundMethodWithIL && !foundMethodWithoutIL;
+            return documentList;
+        }
+
         public sealed override MultiDictionary<Cci.DebugSourceDocument, Cci.DefinitionWithLocation> GetSymbolToLocationMap()
         {
             var result = new MultiDictionary<Cci.DebugSourceDocument, Cci.DefinitionWithLocation>();

src/Compilers/CSharp/Test/Emit/PDB/CSharpPDBTestBase.cs

@@ -4,10 +4,16 @@
 
 #nullable disable
 
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Text;
 using System.Xml;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Debugging;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Test.Utilities;
@@ -67,5 +73,56 @@ public static bool CheckIfSpanWithinSequencePoints(TextSpan span, string source,
 
             return false;
         }
+
+        public static void TestTypeDocuments(string[] sources, params (string typeName, string documentName)[] expected)
+        {
+            var trees = sources.Select((s, i) => SyntaxFactory.ParseSyntaxTree(s, path: $"{i + 1}.cs", encoding: Encoding.UTF8)).ToArray();
+            var compilation = CreateCompilation(trees, options: TestOptions.DebugDll);
+
+            var pdbStream = new MemoryStream();
+            var pe = compilation.EmitToArray(EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb), pdbStream: pdbStream);
+            pdbStream.Position = 0;
+
+            var metadata = ModuleMetadata.CreateFromImage(pe);
+            var metadataReader = metadata.GetMetadataReader();
+
+            var provider = MetadataReaderProvider.FromPortablePdbStream(pdbStream);
+            var pdbReader = provider.GetMetadataReader();
+
+            var actual = from handle in pdbReader.CustomDebugInformation
+                         let entry = pdbReader.GetCustomDebugInformation(handle)
+                         where pdbReader.GetGuid(entry.Kind).Equals(PortableCustomDebugInfoKinds.TypeDocument)
+                         select (typeName: GetTypeName(entry.Parent), documentName: GetDocumentNames(entry.Value));
+
+            AssertEx.Equal(expected, actual, itemSeparator: ", ", itemInspector: i => $"(\"{i.typeName}\", \"{i.documentName}\")");
+
+            string GetTypeName(EntityHandle handle)
+            {
+                var typeHandle = (TypeDefinitionHandle)handle;
+                var type = metadataReader.GetTypeDefinition(typeHandle);
+                return metadataReader.GetString(type.Name);
+            }
+
+            string GetDocumentNames(BlobHandle value)
+            {
+                var result = new List<string>();
+
+                var reader = pdbReader.GetBlobReader(value);
+                while (reader.RemainingBytes > 0)
+                {
+                    var documentRow = reader.ReadCompressedInteger();
+                    if (documentRow > 0)
+                    {
+                        var doc = pdbReader.GetDocument(MetadataTokens.DocumentHandle(documentRow));
+                        result.Add(pdbReader.GetString(doc.Name));
+                    }
+                }
+
+                // Order can be different in net472 vs net5 :(
+                result.Sort();
+
+                return string.Join(", ", result);
+            }
+        }
     }
 }