Fix additional LineId dupe scenarios (#12361)

* Fix more dupe LineId scenarios

* cleanup

* cleanup

* cleanup

* Update tools/apiview/parsers/csharp-api-parser/CSharpAPIParser/TreeToken/CodeFileBuilder.cs

Co-authored-by: Copilot <[email protected]>

* fail fast with dupes

---------

Co-authored-by: Copilot <[email protected]>

Author: christothes

tools/apiview/parsers/csharp-api-parser/CSharpAPIParser/TreeToken/CodeFileBuilder.cs

@@ -9,7 +9,6 @@
 using System.Collections.Immutable;
 using System.ComponentModel;
 using ApiView;
-using System.Diagnostics.CodeAnalysis;
 
 namespace CSharpAPIParser.TreeToken
 {
@@ -107,6 +106,7 @@ public CodeFile Build(IAssemblySymbol assemblySymbol, bool runAnalysis, List<Dep
             }
 
             codeFile.Diagnostics = analyzer.Results.ToArray();
+            VerifyCodeFile(codeFile);
             return codeFile;
         }
 
@@ -140,7 +140,7 @@ public static void BuildInternalsVisibleToAttributes(List<ReviewLine> reviewLine
                             param = firstComma > 0 ? param?[..(int)firstComma] : param;
                             reviewLines.Add(new ReviewLine()
                             {
-                                LineId = attribute.AttributeClass?.Name,
+                                LineId = attribute.AttributeClass?.Name + "_" + param,
                                 Tokens = [
                                     ReviewToken.CreateStringLiteralToken(param)
                                 ]
@@ -174,7 +174,7 @@ public static void BuildDependencies(List<ReviewLine> reviewLines, List<Dependen
                     versionToken.SkipDiff = true;
                     var dependencyLine = new ReviewLine()
                     {
-                        LineId = dependency.Name,
+                        LineId = dependency.Name + versionToken.Value,
                         Tokens = [
                             ReviewToken.CreateStringLiteralToken(dependency.Name, false),
                             versionToken
@@ -871,5 +871,43 @@ string GetLineId(ISymbol member)
             };
             return value;
         }
+
+        /// <summary>
+        /// Verifies that all LineId values in the codeFile's ReviewLines collection are unique.
+        /// </summary>
+        /// <param name="codeFile">The CodeFile to verify.</param>
+        /// <exception cref="InvalidOperationException">Thrown when duplicate LineId values are found.</exception>
+        private static void VerifyCodeFile(CodeFile codeFile)
+        {
+            var lineIds = new HashSet<string>();
+            var duplicates = new List<string>();
+
+            void CheckLineIds(IEnumerable<ReviewLine> lines)
+            {
+                foreach (var line in lines)
+                {
+                    if (!string.IsNullOrEmpty(line.LineId))
+                    {
+                        if (!lineIds.Add(line.LineId))
+                        {
+                            duplicates.Add(line.LineId);
+                        }
+                    }
+
+                    if (line.Children != null && line.Children.Count > 0)
+                    {
+                        CheckLineIds(line.Children);
+                    }
+                }
+            }
+
+            CheckLineIds(codeFile.ReviewLines);
+
+            if (duplicates.Count > 0)
+            {
+                throw new InvalidOperationException(
+                    $"Duplicate LineId values found: {string.Join(", ", duplicates.Distinct())}");
+            }
+        }
     }
 }

tools/apiview/parsers/csharp-api-parser/CSharpAPIParserTests/CodeFileTests.cs

@@ -6,6 +6,7 @@
 using System.Text.Json.Serialization;
 using APIView.Model.V2;
 using Microsoft.CodeAnalysis;
+using System.CommandLine.Parsing;
 
 
 namespace CSharpAPIParserTests
@@ -310,7 +311,7 @@ private int CountAttributeRelatedToProperty(List<ReviewLine> lines)
 
             foreach (var line in lines)
             {
-                if (line.LineId != null && line.LineId.StartsWith("System.FlagsAttribute.") && !string.IsNullOrEmpty(line.RelatedToLine))
+                if (line.LineId != null && line.LineId.StartsWith("System.FlagsAttribute().") && !string.IsNullOrEmpty(line.RelatedToLine))
                 {
                     count++;
                 }
@@ -406,5 +407,81 @@ public void VerifySkippedAttributes()
             Assert.False(isRequiresUnreferencedCodePresent);
             Assert.False(isRequiresDynamicCode);
         }
+
+        [Fact]
+        public void VerifyCodeFileBuilderThrowsOnDuplicateLineIdsInBuildProcess()
+        {
+            // This test verifies that CodeFileBuilder.Build() properly throws InvalidOperationException
+            // when duplicate LineIds are generated during the build process. We simulate this by
+            // creating a custom SymbolOrderProvider that returns duplicate members.
+            
+            var sourceCode = @"
+using System;
+
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public void Method1() { }
+        public void Method2() { }
+        public int Property1 { get; set; }
+    }
+}";
+
+            // Create a syntax tree from the source
+            var syntaxTree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(sourceCode);
+            
+            // Create a compilation with the syntax tree
+            var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(
+                "TestAssembly",
+                new[] { syntaxTree },
+                new[] { 
+                    MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
+                    MetadataReference.CreateFromFile(typeof(Console).Assembly.Location)
+                },
+                new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+            // Get the assembly symbol
+            var assemblySymbol = compilation.Assembly;
+            
+            // Create the builder with a custom SymbolOrderProvider that duplicates members
+            var builder = new CSharpAPIParser.TreeToken.CodeFileBuilder();
+            builder.SymbolOrderProvider = new DuplicatingSymbolOrderProvider();
+            
+            // The Build method should throw InvalidOperationException when it calls VerifyCodeFile
+            // because the DuplicatingSymbolOrderProvider causes duplicate LineIds to be generated
+            var exception = Assert.Throws<InvalidOperationException>(() => 
+                builder.Build(assemblySymbol, false, null));
+            
+            Assert.Contains("Duplicate LineId values found", exception.Message);
+        }
+
+        // Custom SymbolOrderProvider that returns members twice to simulate duplicate LineIds
+        private class DuplicatingSymbolOrderProvider : ICodeFileBuilderSymbolOrderProvider
+        {
+            public IEnumerable<INamespaceSymbol> OrderNamespaces(IEnumerable<INamespaceSymbol> namespaces)
+            {
+                return namespaces;
+            }
+
+            public IEnumerable<T> OrderTypes<T>(IEnumerable<T> symbols) where T : ITypeSymbol
+            {
+                return symbols;
+            }
+
+            public IEnumerable<ISymbol> OrderMembers(IEnumerable<ISymbol> members)
+            {
+                // Return each member twice to create duplicate LineIds
+                var membersList = members.ToList();
+                foreach (var member in membersList)
+                {
+                    yield return member;
+                }
+                foreach (var member in membersList)
+                {
+                    yield return member;
+                }
+            }
+        }
     }
 }