feat(core): Add non-impactful change detection infrastructure

- Add ChangeImpact enum (BreakingPublicApi, BreakingInternalApi, NonBreaking, FormattingOnly)
- Add Visibility enum for symbol accessibility tracking
- Add SymbolKind enum for categorizing symbol types
- Update Change record with Impact, Visibility, and Caveats properties
- Add VisibilityExtractor to extract visibility from Roslyn syntax nodes
- Add ImpactClassifier to classify change impact based on visibility rules
- Add comprehensive unit tests (59 new tests)

Part of DESIGN-004: Non-Impactful Change Detection

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

Author: randlee

src/RoslynDiff.Core/Comparison/ImpactClassifier.cs

@@ -0,0 +1,149 @@
+using RoslynDiff.Core.Models;
+
+namespace RoslynDiff.Core.Comparison;
+
+/// <summary>
+/// Classifies the impact level of code changes based on visibility and change type.
+/// </summary>
+public static class ImpactClassifier
+{
+    /// <summary>
+    /// Classifies the impact of a change.
+    /// </summary>
+    /// <param name="changeType">The type of change (Added, Removed, Modified, Renamed, Moved).</param>
+    /// <param name="symbolKind">The kind of symbol being changed.</param>
+    /// <param name="visibility">The visibility of the symbol.</param>
+    /// <param name="isSignatureChange">Whether this is a signature change vs body-only change.</param>
+    /// <param name="isSameScopeMove">For moves, whether it's within the same containing type.</param>
+    /// <returns>A tuple of (impact level, list of caveats).</returns>
+    public static (ChangeImpact Impact, List<string> Caveats) Classify(
+        ChangeType changeType,
+        SymbolKind symbolKind,
+        Visibility visibility,
+        bool isSignatureChange = true,
+        bool isSameScopeMove = false)
+    {
+        var caveats = new List<string>();
+
+        // Renamed symbols
+        if (changeType == ChangeType.Renamed)
+        {
+            return ClassifyRename(symbolKind, visibility, caveats);
+        }
+
+        // Moved symbols
+        if (changeType == ChangeType.Moved)
+        {
+            return ClassifyMove(visibility, isSameScopeMove, caveats);
+        }
+
+        // Added/Removed/Modified
+        return ClassifyModification(changeType, visibility, isSignatureChange, caveats);
+    }
+
+    private static (ChangeImpact, List<string>) ClassifyRename(
+        SymbolKind symbolKind,
+        Visibility visibility,
+        List<string> caveats)
+    {
+        // Public API renames are breaking
+        if (VisibilityExtractor.IsPublicApi(visibility))
+        {
+            return (ChangeImpact.BreakingPublicApi, caveats);
+        }
+
+        // Internal API renames are breaking for internal consumers
+        if (VisibilityExtractor.IsInternalApi(visibility))
+        {
+            return (ChangeImpact.BreakingInternalApi, caveats);
+        }
+
+        // Parameter renames have a caveat about named arguments
+        if (symbolKind == SymbolKind.Parameter)
+        {
+            caveats.Add("Parameter rename may break callers using named arguments");
+        }
+
+        // Private member renames have a caveat about reflection/serialization
+        if (visibility == Visibility.Private && symbolKind is SymbolKind.Field or SymbolKind.Property or SymbolKind.Method)
+        {
+            caveats.Add("Private member rename may break reflection or serialization");
+        }
+
+        return (ChangeImpact.NonBreaking, caveats);
+    }
+
+    private static (ChangeImpact, List<string>) ClassifyMove(
+        Visibility visibility,
+        bool isSameScopeMove,
+        List<string> caveats)
+    {
+        // Same-scope moves are non-breaking (just reordering)
+        if (isSameScopeMove)
+        {
+            caveats.Add("Code reordering within same scope");
+            return (ChangeImpact.NonBreaking, caveats);
+        }
+
+        // Cross-scope moves follow visibility rules
+        if (VisibilityExtractor.IsPublicApi(visibility))
+        {
+            return (ChangeImpact.BreakingPublicApi, caveats);
+        }
+
+        if (VisibilityExtractor.IsInternalApi(visibility))
+        {
+            return (ChangeImpact.BreakingInternalApi, caveats);
+        }
+
+        return (ChangeImpact.NonBreaking, caveats);
+    }
+
+    private static (ChangeImpact, List<string>) ClassifyModification(
+        ChangeType changeType,
+        Visibility visibility,
+        bool isSignatureChange,
+        List<string> caveats)
+    {
+        // Body-only modifications are non-breaking
+        if (changeType == ChangeType.Modified && !isSignatureChange)
+        {
+            return (ChangeImpact.NonBreaking, caveats);
+        }
+
+        // Signature changes and additions/removals follow visibility rules
+        if (VisibilityExtractor.IsPublicApi(visibility))
+        {
+            return (ChangeImpact.BreakingPublicApi, caveats);
+        }
+
+        if (VisibilityExtractor.IsInternalApi(visibility))
+        {
+            return (ChangeImpact.BreakingInternalApi, caveats);
+        }
+
+        // Private changes are non-breaking
+        return (ChangeImpact.NonBreaking, caveats);
+    }
+
+    /// <summary>
+    /// Determines if a change should be considered formatting-only.
+    /// </summary>
+    public static bool IsFormattingOnly(string? oldContent, string? newContent)
+    {
+        if (oldContent == null || newContent == null)
+            return false;
+
+        // Normalize whitespace and compare
+        var normalizedOld = NormalizeWhitespace(oldContent);
+        var normalizedNew = NormalizeWhitespace(newContent);
+
+        return normalizedOld == normalizedNew;
+    }
+
+    private static string NormalizeWhitespace(string content)
+    {
+        // Remove all whitespace for comparison
+        return string.Concat(content.Where(c => !char.IsWhiteSpace(c)));
+    }
+}

src/RoslynDiff.Core/Comparison/VisibilityExtractor.cs

@@ -0,0 +1,99 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using RoslynDiff.Core.Models;
+
+namespace RoslynDiff.Core.Comparison;
+
+/// <summary>
+/// Extracts visibility/accessibility information from Roslyn syntax nodes.
+/// </summary>
+public static class VisibilityExtractor
+{
+    /// <summary>
+    /// Extracts the visibility from a syntax node.
+    /// </summary>
+    public static Visibility Extract(SyntaxNode node)
+    {
+        return node switch
+        {
+            MemberDeclarationSyntax member => ExtractFromMember(member),
+            ParameterSyntax => Visibility.Local,
+            LocalDeclarationStatementSyntax => Visibility.Local,
+            VariableDeclaratorSyntax => Visibility.Local,
+            _ => Visibility.Private // Default for unknown nodes
+        };
+    }
+
+    /// <summary>
+    /// Extracts visibility from a member declaration.
+    /// </summary>
+    private static Visibility ExtractFromMember(MemberDeclarationSyntax member)
+    {
+        var modifiers = member.Modifiers;
+
+        bool hasPublic = modifiers.Any(SyntaxKind.PublicKeyword);
+        bool hasPrivate = modifiers.Any(SyntaxKind.PrivateKeyword);
+        bool hasProtected = modifiers.Any(SyntaxKind.ProtectedKeyword);
+        bool hasInternal = modifiers.Any(SyntaxKind.InternalKeyword);
+
+        // Check combinations first
+        if (hasProtected && hasInternal)
+            return Visibility.ProtectedInternal;
+        if (hasPrivate && hasProtected)
+            return Visibility.PrivateProtected;
+
+        // Single modifiers
+        if (hasPublic)
+            return Visibility.Public;
+        if (hasProtected)
+            return Visibility.Protected;
+        if (hasInternal)
+            return Visibility.Internal;
+        if (hasPrivate)
+            return Visibility.Private;
+
+        // Default visibility depends on containing context
+        return GetDefaultVisibility(member);
+    }
+
+    /// <summary>
+    /// Gets the default visibility when no explicit modifier is specified.
+    /// </summary>
+    private static Visibility GetDefaultVisibility(MemberDeclarationSyntax member)
+    {
+        // Top-level types default to internal
+        if (member is TypeDeclarationSyntax && member.Parent is CompilationUnitSyntax)
+            return Visibility.Internal;
+
+        // Interface members default to public (check BEFORE TypeDeclarationSyntax since interface IS a type)
+        if (member.Parent is InterfaceDeclarationSyntax)
+            return Visibility.Public;
+
+        // Nested types and members default to private
+        if (member.Parent is TypeDeclarationSyntax)
+            return Visibility.Private;
+
+        // Enum members are public
+        if (member is EnumMemberDeclarationSyntax)
+            return Visibility.Public;
+
+        return Visibility.Private;
+    }
+
+    /// <summary>
+    /// Determines if a visibility level is considered public API.
+    /// </summary>
+    public static bool IsPublicApi(Visibility visibility)
+    {
+        return visibility is Visibility.Public or Visibility.Protected or Visibility.ProtectedInternal;
+    }
+
+    /// <summary>
+    /// Determines if a visibility level is considered internal API.
+    /// </summary>
+    public static bool IsInternalApi(Visibility visibility)
+    {
+        return visibility is Visibility.Internal or Visibility.PrivateProtected;
+    }
+}

src/RoslynDiff.Core/Models/Change.cs

@@ -78,4 +78,30 @@ public record Change
     /// can have child changes representing modified methods, properties, or fields within it.
     /// </remarks>
     public IReadOnlyList<Change>? Children { get; init; }
+
+    /// <summary>
+    /// Gets the impact level of this change.
+    /// </summary>
+    /// <remarks>
+    /// Indicates whether this change affects public API, internal API, or is non-breaking.
+    /// </remarks>
+    public ChangeImpact Impact { get; init; }
+
+    /// <summary>
+    /// Gets the visibility/accessibility of the affected symbol.
+    /// </summary>
+    /// <remarks>
+    /// This is <c>null</c> for changes that don't involve symbols with visibility modifiers
+    /// (e.g., line-based diffs or certain statement-level changes).
+    /// </remarks>
+    public Visibility? Visibility { get; init; }
+
+    /// <summary>
+    /// Gets any caveats or warnings about the impact classification.
+    /// </summary>
+    /// <remarks>
+    /// Caveats provide additional context about the impact analysis, such as cases where
+    /// the impact might be understated or where further review is recommended.
+    /// </remarks>
+    public IReadOnlyList<string>? Caveats { get; init; }
 }

src/RoslynDiff.Core/Models/ChangeImpact.cs

@@ -0,0 +1,27 @@
+namespace RoslynDiff.Core.Models;
+
+/// <summary>
+/// Categorizes the impact level of a code change.
+/// </summary>
+public enum ChangeImpact
+{
+    /// <summary>
+    /// Changes to public API surface that could break external consumers.
+    /// </summary>
+    BreakingPublicApi,
+
+    /// <summary>
+    /// Changes to internal API surface that could break internal consumers.
+    /// </summary>
+    BreakingInternalApi,
+
+    /// <summary>
+    /// Changes that don't affect code execution or API contracts.
+    /// </summary>
+    NonBreaking,
+
+    /// <summary>
+    /// Whitespace-only or comment-only changes.
+    /// </summary>
+    FormattingOnly
+}

src/RoslynDiff.Core/Models/SymbolKind.cs

@@ -0,0 +1,77 @@
+namespace RoslynDiff.Core.Models;
+
+/// <summary>
+/// Specifies the kind of symbol being analyzed for impact classification.
+/// </summary>
+public enum SymbolKind
+{
+    /// <summary>
+    /// A namespace declaration.
+    /// </summary>
+    Namespace,
+
+    /// <summary>
+    /// A type declaration (class, struct, record, interface, enum).
+    /// </summary>
+    Type,
+
+    /// <summary>
+    /// A method or function declaration.
+    /// </summary>
+    Method,
+
+    /// <summary>
+    /// A property declaration.
+    /// </summary>
+    Property,
+
+    /// <summary>
+    /// A field declaration.
+    /// </summary>
+    Field,
+
+    /// <summary>
+    /// An event declaration.
+    /// </summary>
+    Event,
+
+    /// <summary>
+    /// A parameter in a method or constructor.
+    /// </summary>
+    Parameter,
+
+    /// <summary>
+    /// A local variable.
+    /// </summary>
+    Local,
+
+    /// <summary>
+    /// A constructor.
+    /// </summary>
+    Constructor,
+
+    /// <summary>
+    /// An indexer.
+    /// </summary>
+    Indexer,
+
+    /// <summary>
+    /// An operator overload.
+    /// </summary>
+    Operator,
+
+    /// <summary>
+    /// A delegate declaration.
+    /// </summary>
+    Delegate,
+
+    /// <summary>
+    /// An enum member.
+    /// </summary>
+    EnumMember,
+
+    /// <summary>
+    /// Unknown or unclassified symbol.
+    /// </summary>
+    Unknown
+}