com.wallstop-studios.dxmessaging 2.2.0 → 3.0.1

package/Editor/Analyzers/BaseCallLogMessageParser.cs

@@ -0,0 +1,295 @@
+// The Unity Editor assembly that hosts this file does not enable nullable annotations; the
+// dotnet-test project that compiles a linked copy DOES (`<Nullable>enable</Nullable>`). Pin the
+// nullable state per-file so behavior is identical in both compilation contexts.
+#nullable disable
+namespace DxMessaging.Editor.Analyzers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Text.RegularExpressions;
+
+    /// <summary>
+    /// Single parsed diagnostic line emitted by the <c>MessageAwareComponentBaseCallAnalyzer</c>.
+    /// </summary>
+    /// <remarks>
+    /// Empty <see cref="MethodName"/> is the documented sentinel for DXMSG008 (which carries no
+    /// method name in its message format). Empty <see cref="FilePath"/> / zero <see cref="Line"/>
+    /// indicate the bare (Unity-prefix-less) form of the message.
+    /// </remarks>
+    public readonly struct ParsedEntry
+    {
+        public string DiagnosticId { get; }
+
+        public string TypeFullName { get; }
+
+        public string MethodName { get; }
+
+        public string FilePath { get; }
+
+        public int Line { get; }
+
+        public ParsedEntry(
+            string diagnosticId,
+            string typeFullName,
+            string methodName,
+            string filePath,
+            int line
+        )
+        {
+            DiagnosticId = diagnosticId;
+            TypeFullName = typeFullName;
+            MethodName = methodName;
+            FilePath = filePath;
+            Line = line;
+        }
+    }
+
+    /// <summary>
+    /// Per-type aggregate produced by <see cref="BaseCallLogMessageParser.Aggregate"/>.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="MissingBaseFor"/> is deduplicated and stored in deterministic ordinal-sorted order
+    /// via <see cref="SortedSet{T}"/>. <see cref="DiagnosticIds"/> uses ordinal comparison.
+    /// <see cref="FilePath"/> / <see cref="Line"/> hold the FIRST seen non-empty values so the
+    /// inspector overlay's "Open Script" jump remains stable across repeated parses.
+    /// </remarks>
+    public sealed class ParsedTypeReport
+    {
+        public string TypeFullName { get; set; }
+
+        public SortedSet<string> MissingBaseFor { get; } = new(StringComparer.Ordinal);
+
+        public HashSet<string> DiagnosticIds { get; } = new(StringComparer.Ordinal);
+
+        public string FilePath { get; set; }
+
+        public int Line { get; set; }
+    }
+
+    /// <summary>
+    /// Pure parser for the DXMSG006/DXMSG007/DXMSG008/DXMSG009/DXMSG010 console-log lines emitted
+    /// by the <c>MessageAwareComponentBaseCallAnalyzer</c>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class lives in the Editor assembly so the harvester can call it directly without
+    /// referencing the Roslyn-analyzer DLL (Unity excludes <c>RoslynAnalyzer</c>-labelled
+    /// assemblies from asmdef compile-time references).
+    /// </para>
+    /// <para>
+    /// The analyzer-tests project compiles its own copy of this file via a
+    /// <c>&lt;Compile Include="...\BaseCallLogMessageParser.cs" Link="..." /&gt;</c> so the
+    /// existing dotnet-test coverage continues to run.
+    /// </para>
+    /// <para>
+    /// The regexes are pinned to the analyzer's verbatim message-format strings. Whenever those
+    /// formats change, both this parser AND <c>BaseCallLogMessageParserTests</c> must be updated
+    /// in lockstep.
+    /// </para>
+    /// </remarks>
+    public static class BaseCallLogMessageParser
+    {
+        // Roslyn / Unity-style location prefix:  path(line,col): warning DXMSG006:
+        // We don't anchor to the diagnostic id here beyond the leading "DXMSG"; that lets the
+        // same prefix regex serve all five diagnostics (DXMSG006/007/008/009/010). The trailing
+        // `: ` is consumed so the diagnostic-specific regexes only see the message body.
+        private const RegexOptions SharedOptions =
+            RegexOptions.Compiled | RegexOptions.CultureInvariant;
+
+        private static readonly Regex PrefixRegex = new(
+            @"^(?<path>[^()\r\n]+?)\((?<line>\d+),(?<col>\d+)\)\s*:\s*(?:warning|error|info|hidden|message)\s+DXMSG0(?:0[6789]|10)\s*:\s*",
+            SharedOptions
+        );
+
+        // DXMSG006 format:
+        //   '{type}' overrides MessageAwareComponent.{method} but does not call base.{method}();
+        //   the messaging system may not function correctly on this component.
+        // The type name is captured from the first single-quoted token; the method from the first
+        // `MessageAwareComponent.{method}` occurrence (the format string repeats `{method}`).
+        // Body regexes anchor to the start of the body (^) so a Debug.Log payload that *contains*
+        // the analyzer's wording mid-string is not surfaced as a real DXMSG006/007/008. The prefix
+        // (when present) is stripped before this match, so ^ here is the start of the message body.
+        private static readonly Regex Dxmsg006Regex = new(
+            @"^'(?<type>[^']+)'\s+overrides\s+MessageAwareComponent\.(?<method>[A-Za-z_][A-Za-z0-9_]*)\s+but\s+does\s+not\s+call\s+base\.[A-Za-z_][A-Za-z0-9_]*\(\)\s*;\s*the\s+messaging\s+system\s+may\s+not\s+function\s+correctly\s+on\s+this\s+component\.",
+            SharedOptions
+        );
+
+        // DXMSG007 format:
+        //   '{type}' hides MessageAwareComponent.{method} with 'new'; replace with 'override' and
+        //   call base.{method}() so the messaging system continues to function.
+        private static readonly Regex Dxmsg007Regex = new(
+            @"^'(?<type>[^']+)'\s+hides\s+MessageAwareComponent\.(?<method>[A-Za-z_][A-Za-z0-9_]*)\s+with\s+'new'\s*;\s*replace\s+with\s+'override'\s+and\s+call\s+base\.[A-Za-z_][A-Za-z0-9_]*\(\)\s+so\s+the\s+messaging\s+system\s+continues\s+to\s+function\.",
+            SharedOptions
+        );
+
+        // DXMSG008 format:
+        //   '{type}' is excluded from the DxMessaging base-call check ({source}).
+        // No method name in the message; MethodName is returned as the empty string.
+        private static readonly Regex Dxmsg008Regex = new(
+            @"^'(?<type>[^']+)'\s+is\s+excluded\s+from\s+the\s+DxMessaging\s+base-call\s+check\s+\([^)]*\)\.",
+            SharedOptions
+        );
+
+        // DXMSG009 format:
+        //   '{type}' declares {method} without 'override' or 'new'; this implicitly hides
+        //   MessageAwareComponent.{method} (CS0114) and the messaging system will not function. ...
+        // We anchor on the head of the message and stop after the modifier-tokens phrase so future
+        // wording tweaks to the trailing remediation text don't break the parser.
+        private static readonly Regex Dxmsg009Regex = new(
+            @"^'(?<type>[^']+)'\s+declares\s+(?<method>[A-Za-z_][A-Za-z0-9_]*)\s+without\s+'override'\s+or\s+'new'",
+            SharedOptions
+        );
+
+        // DXMSG010 format:
+        //   '{type}' calls base.{method}() but the inherited override on '{broken}' does not
+        //   chain to MessageAwareComponent.{method}; the messaging system will not function
+        //   correctly on this component.
+        // We capture {type} (the class the user is editing), {method}, and the broken-ancestor
+        // FQN so the inspector overlay can mention "broken chain via {broken}" if desired.
+        private static readonly Regex Dxmsg010Regex = new(
+            @"^'(?<type>[^']+)'\s+calls\s+base\.(?<method>[A-Za-z_][A-Za-z0-9_]*)\(\)\s+but\s+the\s+inherited\s+override\s+on\s+'(?<broken>[^']+)'",
+            SharedOptions
+        );
+
+        /// <summary>
+        /// Parses one console log line. Returns <c>null</c> if the line is not a recognised
+        /// DXMSG006/DXMSG007/DXMSG008/DXMSG009/DXMSG010 message.
+        /// </summary>
+        /// <remarks>
+        /// Tolerates both the Roslyn-prefixed form (<c>Path(L,C): warning DXMSG006: ...</c>) and the
+        /// bare form (just the message body). The prefix's path/line are captured; the bare form
+        /// returns empty path / zero line.
+        /// </remarks>
+        public static ParsedEntry? ParseLine(string logLine)
+        {
+            if (string.IsNullOrWhiteSpace(logLine))
+            {
+                return null;
+            }
+
+            string filePath = string.Empty;
+            int line = 0;
+            string body = logLine;
+
+            Match prefixMatch = PrefixRegex.Match(logLine);
+            if (prefixMatch.Success)
+            {
+                filePath = prefixMatch.Groups["path"].Value;
+                if (
+                    !int.TryParse(
+                        prefixMatch.Groups["line"].Value,
+                        NumberStyles.Integer,
+                        CultureInfo.InvariantCulture,
+                        out line
+                    )
+                )
+                {
+                    line = 0;
+                }
+                body = logLine.Substring(prefixMatch.Length);
+            }
+
+            Match dxmsg006 = Dxmsg006Regex.Match(body);
+            if (dxmsg006.Success)
+            {
+                string type = dxmsg006.Groups["type"].Value;
+                string method = dxmsg006.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG006", type, method, filePath, line);
+                }
+            }
+
+            Match dxmsg007 = Dxmsg007Regex.Match(body);
+            if (dxmsg007.Success)
+            {
+                string type = dxmsg007.Groups["type"].Value;
+                string method = dxmsg007.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG007", type, method, filePath, line);
+                }
+            }
+
+            Match dxmsg008 = Dxmsg008Regex.Match(body);
+            if (dxmsg008.Success)
+            {
+                string type = dxmsg008.Groups["type"].Value;
+                if (!string.IsNullOrWhiteSpace(type))
+                {
+                    return new ParsedEntry("DXMSG008", type, string.Empty, filePath, line);
+                }
+            }
+
+            Match dxmsg009 = Dxmsg009Regex.Match(body);
+            if (dxmsg009.Success)
+            {
+                string type = dxmsg009.Groups["type"].Value;
+                string method = dxmsg009.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG009", type, method, filePath, line);
+                }
+            }
+
+            Match dxmsg010 = Dxmsg010Regex.Match(body);
+            if (dxmsg010.Success)
+            {
+                string type = dxmsg010.Groups["type"].Value;
+                string method = dxmsg010.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG010", type, method, filePath, line);
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Aggregates many log lines into a per-type report keyed by FQN. Deduplicates methods and
+        /// diagnostic ids ordinally; method names are stored in deterministic ordinal-sorted order.
+        /// Preserves first-occurrence for <see cref="ParsedTypeReport.FilePath"/> /
+        /// <see cref="ParsedTypeReport.Line"/>.
+        /// </summary>
+        public static Dictionary<string, ParsedTypeReport> Aggregate(IEnumerable<string> logLines)
+        {
+            Dictionary<string, ParsedTypeReport> result = new(StringComparer.Ordinal);
+            if (logLines == null)
+            {
+                return result;
+            }
+
+            foreach (string logLine in logLines)
+            {
+                ParsedEntry? parsed = ParseLine(logLine);
+                if (parsed is not ParsedEntry entry)
+                {
+                    continue;
+                }
+
+                if (!result.TryGetValue(entry.TypeFullName, out ParsedTypeReport report))
+                {
+                    report = new ParsedTypeReport { TypeFullName = entry.TypeFullName };
+                    result[entry.TypeFullName] = report;
+                }
+
+                report.DiagnosticIds.Add(entry.DiagnosticId);
+
+                if (!string.IsNullOrEmpty(entry.MethodName))
+                {
+                    report.MissingBaseFor.Add(entry.MethodName);
+                }
+
+                if (string.IsNullOrEmpty(report.FilePath) && !string.IsNullOrEmpty(entry.FilePath))
+                {
+                    report.FilePath = entry.FilePath;
+                    report.Line = entry.Line;
+                }
+            }
+
+            return result;
+        }
+    }
+}

package/Editor/Analyzers/BaseCallLogMessageParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a17c13ebe9604cee9bfa08d2517a3fad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Analyzers/BaseCallReportAggregator.cs

@@ -0,0 +1,308 @@
+// The Unity Editor assembly that hosts this file does not enable nullable annotations; the
+// dotnet-test project that compiles a linked copy DOES (`<Nullable>enable</Nullable>`). Pin the
+// nullable state per-file so behavior is identical in both compilation contexts.
+#nullable disable
+namespace DxMessaging.Editor.Analyzers
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Pure-BCL data-transfer object for an aggregated per-FQN report row. Mirrors the public
+    /// shape of <see cref="BaseCallReportEntry"/> but uses property-style PascalCase fields so it
+    /// does not depend on Unity's <c>JsonUtility</c> serialization conventions and is safely
+    /// constructible from <c>dotnet test</c>.
+    /// </summary>
+    /// <remarks>
+    /// The harvester wraps every DTO in a <see cref="BaseCallReportEntry"/> (with the lowercase
+    /// Unity-serialisable field names) before the snapshot crosses into Editor code. Keep this
+    /// shape in lock-step with that wrapper -- fields added here must also flow through to the
+    /// Unity-facing entry or the inspector overlay won't see them.
+    /// </remarks>
+    public sealed class BaseCallReportEntryDto
+    {
+        /// <summary>Fully-qualified name of the offending type (dot-form for nested types).</summary>
+        public string TypeName;
+
+        /// <summary>Method names whose overrides are missing the corresponding <c>base.*()</c> call.</summary>
+        public readonly SortedSet<string> MissingBaseFor = new(StringComparer.Ordinal);
+
+        /// <summary>Diagnostic IDs that contributed to this entry (e.g., DXMSG006/007/008/009).</summary>
+        public readonly HashSet<string> DiagnosticIds = new(StringComparer.Ordinal);
+
+        /// <summary>Source file path (best-effort) for "Open Script" actions in the inspector overlay.</summary>
+        public string FilePath;
+
+        /// <summary>1-based line number of the first relevant diagnostic, when known.</summary>
+        public int Line;
+    }
+
+    /// <summary>
+    /// Pure (Unity-API-free) aggregator for the per-assembly merge + retirement logic at the heart
+    /// of <see cref="DxMessagingConsoleHarvester"/>. Extracted so the merge contract is covered by
+    /// <c>dotnet test</c> via the linked-source pattern (see
+    /// <c>WallstopStudios.DxMessaging.SourceGenerators.Tests.csproj</c>).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The harvester must own two pieces of cross-call state to do its job correctly:
+    /// </para>
+    /// <list type="number">
+    /// <item><description><c>typesByAssembly</c>: which FQNs each compiled assembly has reported.
+    /// When an assembly recompiles WITHOUT reporting a previously-seen FQN, that FQN is retired
+    /// -- the user fixed the offending base call.</description></item>
+    /// <item><description><c>mergedReports</c>: the per-FQN union of every assembly's latest
+    /// report. The final snapshot merges this with whatever the LogEntries scan yielded.</description></item>
+    /// </list>
+    /// <para>
+    /// Both maps mutate in lock-step inside <see cref="ApplyAssemblyReports"/>. Because retirement
+    /// crosses assembly boundaries (an FQN may live in two assemblies; only when neither still
+    /// reports it does it disappear from <c>mergedReports</c>), the bookkeeping is the most
+    /// failure-prone slice of the harvester. Keeping it pure makes it test-driven.
+    /// </para>
+    /// </remarks>
+    public static class BaseCallReportAggregator
+    {
+        /// <summary>
+        /// Apply a single assembly's freshly-parsed report batch. Replaces that assembly's prior
+        /// FQN attribution wholesale (so types the user fixed disappear) and rebuilds the merged
+        /// per-FQN map by unioning every assembly's latest reports.
+        /// </summary>
+        /// <param name="assemblyKey">Stable identifier for the source assembly (typically the
+        /// assembly path Unity passes via <c>CompilationPipeline.assemblyCompilationFinished</c>).</param>
+        /// <param name="latestReportsForAssembly">Reports parsed from this assembly's most recent
+        /// compilation. May be empty -- that case is the retirement path (every FQN this assembly
+        /// previously reported is dropped).</param>
+        /// <param name="typesByAssembly">Per-assembly FQN bookkeeping. Mutated in place.</param>
+        /// <param name="mergedReports">Per-FQN union across every assembly. Mutated in place;
+        /// rebuilt from scratch on every call so retirement Just Works regardless of which
+        /// assembly drops its claim.</param>
+        public static void ApplyAssemblyReports(
+            string assemblyKey,
+            IReadOnlyDictionary<string, ParsedTypeReport> latestReportsForAssembly,
+            Dictionary<string, HashSet<string>> typesByAssembly,
+            Dictionary<string, ParsedTypeReport> mergedReports
+        )
+        {
+            if (string.IsNullOrEmpty(assemblyKey))
+            {
+                throw new ArgumentException("Assembly key must be non-empty.", nameof(assemblyKey));
+            }
+            if (typesByAssembly is null)
+            {
+                throw new ArgumentNullException(nameof(typesByAssembly));
+            }
+            if (mergedReports is null)
+            {
+                throw new ArgumentNullException(nameof(mergedReports));
+            }
+
+            // 1. Replace this assembly's FQN set with the latest batch. Types absent from the new
+            //    batch are dropped from the assembly's row; that's the per-assembly retirement.
+            if (!typesByAssembly.TryGetValue(assemblyKey, out HashSet<string> typeSet))
+            {
+                typeSet = new HashSet<string>(StringComparer.Ordinal);
+                typesByAssembly[assemblyKey] = typeSet;
+            }
+            typeSet.Clear();
+            if (latestReportsForAssembly is not null)
+            {
+                foreach (string fqn in latestReportsForAssembly.Keys)
+                {
+                    if (!string.IsNullOrEmpty(fqn))
+                    {
+                        typeSet.Add(fqn);
+                    }
+                }
+            }
+
+            // 2. Rebuild mergedReports from the per-assembly view. We can't simply remove "the
+            //    types this assembly retired" because another assembly may still report them; the
+            //    only correct algorithm is to start fresh from typesByAssembly + the freshest
+            //    payload for each (assembly, FQN) pair.
+            //
+            //    Per-FQN merge semantics:
+            //    - Method list: union, deduplicated ordinally, stored in deterministic
+            //      ordinal-sorted order.
+            //    - Diagnostic IDs: union via HashSet.
+            //    - File path / line: first non-empty wins (stable across recompiles).
+            Dictionary<string, ParsedTypeReport> rebuilt = new(StringComparer.Ordinal);
+            foreach (KeyValuePair<string, HashSet<string>> assemblyEntry in typesByAssembly)
+            {
+                string thisAssemblyKey = assemblyEntry.Key;
+                HashSet<string> fqns = assemblyEntry.Value;
+                if (fqns is null || fqns.Count == 0)
+                {
+                    continue;
+                }
+
+                // For the assembly we just updated, prefer the freshly-parsed payload. For other
+                // assemblies, we need the previous merge to still carry their data; but that
+                // information is only retrievable from the OUTGOING mergedReports, so we read it
+                // before clearing.
+                IReadOnlyDictionary<string, ParsedTypeReport> source = string.Equals(
+                    thisAssemblyKey,
+                    assemblyKey,
+                    StringComparison.OrdinalIgnoreCase
+                )
+                    ? latestReportsForAssembly
+                    : mergedReports;
+                if (source is null)
+                {
+                    continue;
+                }
+
+                foreach (string fqn in fqns)
+                {
+                    if (!source.TryGetValue(fqn, out ParsedTypeReport contribution))
+                    {
+                        continue;
+                    }
+                    if (contribution is null)
+                    {
+                        continue;
+                    }
+
+                    if (!rebuilt.TryGetValue(fqn, out ParsedTypeReport existing))
+                    {
+                        // Defensive copy so future ApplyAssemblyReports calls don't mutate state
+                        // that callers may still hold a reference to.
+                        existing = new ParsedTypeReport
+                        {
+                            TypeFullName = contribution.TypeFullName,
+                            FilePath = contribution.FilePath,
+                            Line = contribution.Line,
+                        };
+                        foreach (string method in contribution.MissingBaseFor)
+                        {
+                            if (!string.IsNullOrEmpty(method))
+                            {
+                                existing.MissingBaseFor.Add(method);
+                            }
+                        }
+                        foreach (string id in contribution.DiagnosticIds)
+                        {
+                            existing.DiagnosticIds.Add(id);
+                        }
+                        rebuilt[fqn] = existing;
+                        continue;
+                    }
+
+                    foreach (string method in contribution.MissingBaseFor)
+                    {
+                        if (!string.IsNullOrEmpty(method))
+                        {
+                            existing.MissingBaseFor.Add(method);
+                        }
+                    }
+                    foreach (string id in contribution.DiagnosticIds)
+                    {
+                        existing.DiagnosticIds.Add(id);
+                    }
+                    if (
+                        string.IsNullOrEmpty(existing.FilePath)
+                        && !string.IsNullOrEmpty(contribution.FilePath)
+                    )
+                    {
+                        existing.FilePath = contribution.FilePath;
+                        existing.Line = contribution.Line;
+                    }
+                }
+            }
+
+            mergedReports.Clear();
+            foreach (KeyValuePair<string, ParsedTypeReport> kvp in rebuilt)
+            {
+                mergedReports[kvp.Key] = kvp.Value;
+            }
+        }
+
+        /// <summary>
+        /// Builds the final flat snapshot for the inspector overlay by unioning the LogEntries
+        /// scan with the per-assembly merged reports. Both inputs are read-only; the result is a
+        /// fresh dictionary the caller owns.
+        /// </summary>
+        /// <param name="logEntriesReports">Reports harvested from <c>UnityEditor.LogEntries</c>.
+        /// May be empty (Unity 2021 path) or null (LogEntries reflection unavailable).</param>
+        /// <param name="mergedReports">Per-FQN merged view of every assembly's latest reports
+        /// produced by <see cref="ApplyAssemblyReports"/>. May be empty when no compilation
+        /// callbacks have fired yet.</param>
+        public static Dictionary<string, BaseCallReportEntryDto> BuildSnapshot(
+            IReadOnlyDictionary<string, ParsedTypeReport> logEntriesReports,
+            IReadOnlyDictionary<string, ParsedTypeReport> mergedReports
+        )
+        {
+            Dictionary<string, BaseCallReportEntryDto> snapshot = new(StringComparer.Ordinal);
+
+            if (logEntriesReports is not null)
+            {
+                foreach (KeyValuePair<string, ParsedTypeReport> kvp in logEntriesReports)
+                {
+                    AddOrMerge(snapshot, kvp.Key, kvp.Value);
+                }
+            }
+
+            if (mergedReports is not null)
+            {
+                foreach (KeyValuePair<string, ParsedTypeReport> kvp in mergedReports)
+                {
+                    AddOrMerge(snapshot, kvp.Key, kvp.Value);
+                }
+            }
+
+            return snapshot;
+        }
+
+        private static void AddOrMerge(
+            Dictionary<string, BaseCallReportEntryDto> snapshot,
+            string fqn,
+            ParsedTypeReport report
+        )
+        {
+            if (string.IsNullOrEmpty(fqn) || report is null)
+            {
+                return;
+            }
+
+            if (!snapshot.TryGetValue(fqn, out BaseCallReportEntryDto existing))
+            {
+                existing = new BaseCallReportEntryDto { TypeName = fqn };
+                snapshot[fqn] = existing;
+            }
+            if (string.IsNullOrEmpty(existing.TypeName))
+            {
+                existing.TypeName = fqn;
+            }
+
+            foreach (string method in report.MissingBaseFor)
+            {
+                if (!string.IsNullOrEmpty(method))
+                {
+                    // Dedupe across the dual-source merge: LogEntries and CompilerMessage may
+                    // both surface the same `<type>.<method>` pair on Unity 2022+, where both
+                    // pipes are wired. MissingBaseFor is a SortedSet<string>, so duplicates are
+                    // removed and HelpBox output remains stable via deterministic ordinal sorting.
+                    existing.MissingBaseFor.Add(method);
+                }
+            }
+
+            foreach (string id in report.DiagnosticIds)
+            {
+                if (!string.IsNullOrEmpty(id))
+                {
+                    // HashSet dedupes repeated IDs surfaced by the dual-source merge
+                    // (LogEntries + CompilerMessage on Unity 2022+).
+                    existing.DiagnosticIds.Add(id);
+                }
+            }
+
+            // First seen file/line wins so "Open Script" jumps to a stable location across
+            // rebuilds; which is what the user's eye lands on first in the console.
+            if (string.IsNullOrEmpty(existing.FilePath) && !string.IsNullOrEmpty(report.FilePath))
+            {
+                existing.FilePath = report.FilePath;
+                existing.Line = report.Line;
+            }
+        }
+    }
+}

package/Editor/Analyzers/BaseCallReportAggregator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f94fb4275c724821995abe36ce51046a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: