feat(core): Integrate impact classification into SemanticComparer

Phase 2 of non-impactful change detection:

- Integrate VisibilityExtractor and ImpactClassifier into SemanticComparer
- Add impact, visibility, and caveats to renamed/moved changes
- Add IncludeNonImpactful and MinimumImpactLevel to DiffOptions
- Add impact breakdown stats to DiffStats (BreakingPublicApiCount, etc.)
- Add 5 integration tests for impact classification scenarios

Test: 849 tests pass (100%)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: randlee

src/RoslynDiff.Core/Comparison/SemanticComparer.cs

@@ -299,7 +299,7 @@ private void DetectRenames(
                 continue;
             }
 
-            // Create a Renamed change
+            // Create a Renamed change (without impact initially for classification)
             var renamedChange = new Change
             {
                 Type = ChangeType.Renamed,
@@ -312,6 +312,15 @@ private void DetectRenames(
                 NewContent = candidate.AddedChange.NewContent
             };
 
+            // Classify the impact of the rename
+            var (impact, visibility, caveats) = ClassifyChangeImpact(renamedChange, oldTree, newTree);
+            renamedChange = renamedChange with
+            {
+                Impact = impact,
+                Visibility = visibility,
+                Caveats = caveats
+            };
+
             replacements[candidate.RemovedChange] = renamedChange;
             matchedRemoved.Add(candidate.RemovedChange);
             matchedAdded.Add(candidate.AddedChange);
@@ -342,7 +351,7 @@ private void DetectMoves(
                 continue;
             }
 
-            // Create a Moved change
+            // Create a Moved change (without impact initially for classification)
             var movedChange = new Change
             {
                 Type = ChangeType.Moved,
@@ -354,9 +363,82 @@ private void DetectMoves(
                 NewContent = candidate.AddedChange.NewContent
             };
 
+            // Classify the impact of the move (same-parent moves are non-breaking)
+            var (impact, visibility, caveats) = ClassifyChangeImpact(
+                movedChange,
+                oldTree,
+                newTree,
+                isSameScopeMove: candidate.IsSameParent);
+            movedChange = movedChange with
+            {
+                Impact = impact,
+                Visibility = visibility,
+                Caveats = caveats
+            };
+
             replacements[candidate.RemovedChange] = movedChange;
             matchedRemoved.Add(candidate.RemovedChange);
             matchedAdded.Add(candidate.AddedChange);
         }
     }
+
+    /// <summary>
+    /// Maps a ChangeKind to the corresponding SymbolKind for impact classification.
+    /// </summary>
+    private static Models.SymbolKind MapToSymbolKind(ChangeKind changeKind)
+    {
+        return changeKind switch
+        {
+            ChangeKind.Namespace => Models.SymbolKind.Namespace,
+            ChangeKind.Class => Models.SymbolKind.Type,
+            ChangeKind.Method => Models.SymbolKind.Method,
+            ChangeKind.Property => Models.SymbolKind.Property,
+            ChangeKind.Field => Models.SymbolKind.Field,
+            ChangeKind.Statement => Models.SymbolKind.Local,
+            ChangeKind.Line => Models.SymbolKind.Unknown,
+            ChangeKind.File => Models.SymbolKind.Unknown,
+            _ => Models.SymbolKind.Unknown
+        };
+    }
+
+    /// <summary>
+    /// Classifies the impact of a change and returns updated Impact, Visibility, and Caveats.
+    /// </summary>
+    private static (ChangeImpact Impact, Visibility Visibility, IReadOnlyList<string>? Caveats) ClassifyChangeImpact(
+        Change change,
+        SyntaxTree? oldTree,
+        SyntaxTree? newTree,
+        bool isSameScopeMove = false)
+    {
+        // Try to get the syntax node for visibility extraction
+        SyntaxNode? node = null;
+
+        // For renames and moves, prefer the old location for visibility (original declaration)
+        if (oldTree is not null && change.OldLocation is not null)
+        {
+            node = SymbolMatcher.FindNodeAtLocation(oldTree, change.OldLocation);
+        }
+        else if (newTree is not null && change.NewLocation is not null)
+        {
+            node = SymbolMatcher.FindNodeAtLocation(newTree, change.NewLocation);
+        }
+
+        // Extract visibility (default to Private if no node found)
+        var visibility = node is not null
+            ? VisibilityExtractor.Extract(node)
+            : Visibility.Private;
+
+        // Map ChangeKind to SymbolKind
+        var symbolKind = MapToSymbolKind(change.Kind);
+
+        // Classify the impact
+        var (impact, caveats) = ImpactClassifier.Classify(
+            change.Type,
+            symbolKind,
+            visibility,
+            isSignatureChange: true, // Renames/moves are treated as signature changes
+            isSameScopeMove: isSameScopeMove);
+
+        return (impact, visibility, caveats.Count > 0 ? caveats : null);
+    }
 }

src/RoslynDiff.Core/Comparison/SymbolMatcher.cs

@@ -247,7 +247,7 @@ private static string GetParameterTypesSignature(ParameterListSyntax? parameterL
     /// <summary>
     /// Finds a syntax node at a given location in a tree.
     /// </summary>
-    private static SyntaxNode? FindNodeAtLocation(SyntaxTree tree, SourceLocation? location)
+    internal static SyntaxNode? FindNodeAtLocation(SyntaxTree tree, SourceLocation? location)
     {
         if (location is null)
             return null;

src/RoslynDiff.Core/Models/DiffOptions.cs

@@ -47,4 +47,26 @@ public record DiffOptions
     /// This is used for display purposes and to determine the file type for automatic mode selection.
     /// </remarks>
     public string? NewPath { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether non-impactful changes should be included in results.
+    /// </summary>
+    /// <remarks>
+    /// When <c>true</c>, all changes are included regardless of impact level.
+    /// When <c>false</c>, non-breaking and formatting-only changes are filtered out.
+    /// Default is <c>true</c> for the core library; output formatters may apply their own filtering.
+    /// </remarks>
+    public bool IncludeNonImpactful { get; init; } = true;
+
+    /// <summary>
+    /// Gets the minimum impact level to include in results.
+    /// </summary>
+    /// <remarks>
+    /// Only changes with an impact level at or above this threshold are included.
+    /// The hierarchy from most to least impactful is:
+    /// <see cref="ChangeImpact.BreakingPublicApi"/> > <see cref="ChangeImpact.BreakingInternalApi"/>
+    /// > <see cref="ChangeImpact.NonBreaking"/> > <see cref="ChangeImpact.FormattingOnly"/>.
+    /// Default includes all changes.
+    /// </remarks>
+    public ChangeImpact MinimumImpactLevel { get; init; } = ChangeImpact.FormattingOnly;
 }

src/RoslynDiff.Core/Models/DiffResult.cs

@@ -85,6 +85,41 @@ public record DiffStats
     /// Gets the number of renamed symbols or elements.
     /// </summary>
     public int Renames { get; init; }
+
+    // Impact breakdown statistics
+
+    /// <summary>
+    /// Gets the number of breaking public API changes.
+    /// </summary>
+    public int BreakingPublicApiCount { get; init; }
+
+    /// <summary>
+    /// Gets the number of breaking internal API changes.
+    /// </summary>
+    public int BreakingInternalApiCount { get; init; }
+
+    /// <summary>
+    /// Gets the number of non-breaking changes.
+    /// </summary>
+    public int NonBreakingCount { get; init; }
+
+    /// <summary>
+    /// Gets the number of formatting-only changes.
+    /// </summary>
+    public int FormattingOnlyCount { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether there are any breaking changes (public or internal API).
+    /// </summary>
+    public bool HasBreakingChanges => BreakingPublicApiCount > 0 || BreakingInternalApiCount > 0;
+
+    /// <summary>
+    /// Gets a value indicating whether the changes require review.
+    /// </summary>
+    /// <remarks>
+    /// Returns <c>true</c> if there are any changes that are not purely formatting-only.
+    /// </remarks>
+    public bool RequiresReview => BreakingPublicApiCount > 0 || BreakingInternalApiCount > 0 || NonBreakingCount > 0;
 }
 
 /// <summary>

tests/RoslynDiff.Core.Tests/SemanticComparerTests.cs

@@ -554,4 +554,166 @@ public void AddedMethod()
     }
 
     #endregion
+
+    #region Impact Classification
+
+    [Fact]
+    public void EnhanceWithSemantics_PublicMethodRenamed_ClassifiesAsBreakingPublicApi()
+    {
+        var oldCode = """
+            namespace Test;
+            public class Calculator
+            {
+                public int OldMethod(int a, int b) => a + b;
+            }
+            """;
+        var newCode = """
+            namespace Test;
+            public class Calculator
+            {
+                public int NewMethod(int a, int b) => a + b;
+            }
+            """;
+        var options = new DiffOptions();
+
+        var syntaxChanges = _syntaxComparer.CompareSource(oldCode, newCode, options);
+        var result = _semanticComparer.EnhanceWithSemantics(syntaxChanges, oldCode, newCode, options);
+
+        var allChanges = FlattenAllChanges(result);
+        var renamed = allChanges.FirstOrDefault(c => c.Type == ChangeType.Renamed && c.Kind == ChangeKind.Method);
+
+        renamed.Should().NotBeNull();
+        renamed!.Impact.Should().Be(ChangeImpact.BreakingPublicApi);
+        renamed.Visibility.Should().Be(Visibility.Public);
+        renamed.Caveats.Should().BeNullOrEmpty();
+    }
+
+    [Fact]
+    public void EnhanceWithSemantics_PrivateMethodRenamed_ClassifiesAsNonBreaking()
+    {
+        var oldCode = """
+            namespace Test;
+            public class Calculator
+            {
+                private int OldPrivateMethod(int a, int b) => a + b;
+            }
+            """;
+        var newCode = """
+            namespace Test;
+            public class Calculator
+            {
+                private int NewPrivateMethod(int a, int b) => a + b;
+            }
+            """;
+        var options = new DiffOptions();
+
+        var syntaxChanges = _syntaxComparer.CompareSource(oldCode, newCode, options);
+        var result = _semanticComparer.EnhanceWithSemantics(syntaxChanges, oldCode, newCode, options);
+
+        var allChanges = FlattenAllChanges(result);
+        var renamed = allChanges.FirstOrDefault(c => c.Type == ChangeType.Renamed && c.Kind == ChangeKind.Method);
+
+        renamed.Should().NotBeNull();
+        renamed!.Impact.Should().Be(ChangeImpact.NonBreaking);
+        renamed.Visibility.Should().Be(Visibility.Private);
+        renamed.Caveats.Should().NotBeNull();
+        renamed.Caveats.Should().Contain(c => c.Contains("reflection") || c.Contains("serialization"));
+    }
+
+    [Fact]
+    public void EnhanceWithSemantics_InternalMethodRenamed_ClassifiesAsBreakingInternalApi()
+    {
+        var oldCode = """
+            namespace Test;
+            internal class Calculator
+            {
+                internal int OldMethod(int a, int b) => a + b;
+            }
+            """;
+        var newCode = """
+            namespace Test;
+            internal class Calculator
+            {
+                internal int NewMethod(int a, int b) => a + b;
+            }
+            """;
+        var options = new DiffOptions();
+
+        var syntaxChanges = _syntaxComparer.CompareSource(oldCode, newCode, options);
+        var result = _semanticComparer.EnhanceWithSemantics(syntaxChanges, oldCode, newCode, options);
+
+        var allChanges = FlattenAllChanges(result);
+        var renamed = allChanges.FirstOrDefault(c => c.Type == ChangeType.Renamed && c.Kind == ChangeKind.Method);
+
+        renamed.Should().NotBeNull();
+        renamed!.Impact.Should().Be(ChangeImpact.BreakingInternalApi);
+        renamed.Visibility.Should().Be(Visibility.Internal);
+    }
+
+    [Fact]
+    public void EnhanceWithSemantics_MethodMovedWithinSameClass_ClassifiesAsNonBreaking()
+    {
+        var oldCode = """
+            namespace Test;
+            public class Calculator
+            {
+                public int Add(int a, int b) => a + b;
+                public int Multiply(int a, int b) => a * b;
+            }
+            """;
+        // Same class, just reordered
+        var newCode = """
+            namespace Test;
+            public class Calculator
+            {
+                public int Multiply(int a, int b) => a * b;
+                public int Add(int a, int b) => a + b;
+            }
+            """;
+        var options = new DiffOptions();
+
+        var syntaxChanges = _syntaxComparer.CompareSource(oldCode, newCode, options);
+        var result = _semanticComparer.EnhanceWithSemantics(syntaxChanges, oldCode, newCode, options);
+
+        var allChanges = FlattenAllChanges(result);
+
+        // Reordering within the same class should produce either no changes or Moved with NonBreaking
+        var moved = allChanges.FirstOrDefault(c => c.Type == ChangeType.Moved);
+        if (moved is not null)
+        {
+            moved.Impact.Should().Be(ChangeImpact.NonBreaking);
+        }
+    }
+
+    [Fact]
+    public void EnhanceWithSemantics_PublicClassRenamed_ClassifiesAsBreakingPublicApi()
+    {
+        var oldCode = """
+            namespace Test;
+            public class OldClassName
+            {
+                public int Value { get; set; }
+            }
+            """;
+        var newCode = """
+            namespace Test;
+            public class NewClassName
+            {
+                public int Value { get; set; }
+            }
+            """;
+        var options = new DiffOptions();
+
+        var syntaxChanges = _syntaxComparer.CompareSource(oldCode, newCode, options);
+        var result = _semanticComparer.EnhanceWithSemantics(syntaxChanges, oldCode, newCode, options);
+
+        var allChanges = FlattenAllChanges(result);
+        var renamed = allChanges.FirstOrDefault(c => c.Type == ChangeType.Renamed && c.Kind == ChangeKind.Class);
+
+        renamed.Should().NotBeNull();
+        renamed!.Impact.Should().Be(ChangeImpact.BreakingPublicApi);
+        renamed.Visibility.Should().Be(Visibility.Public);
+    }
+
+    #endregion
 }