Refactor (#94)

CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs

@@ -0,0 +1,77 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class SystemConsoleShouldBeAvoidedAnalyzer : AnalyzerBase
+    {
+        public SystemConsoleShouldBeAvoidedAnalyzer()
+            : base(
+                $"Avoid calling `System.Console` where `{SymbolNames.CliFxConsoleInterface}` is available",
+                $"Use the provided `{SymbolNames.CliFxConsoleInterface}` abstraction instead of `System.Console` to ensure that the command can be tested in isolation.",
+                DiagnosticSeverity.Warning)
+        {
+        }
+
+        private MemberAccessExpressionSyntax? TryGetSystemConsoleMemberAccess(
+            SyntaxNodeAnalysisContext context,
+            SyntaxNode node)
+        {
+            var currentNode = node;
+
+            while (currentNode is MemberAccessExpressionSyntax memberAccess)
+            {
+                var symbol = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
+
+                if (symbol is not null && symbol.ContainingType.DisplayNameMatches("System.Console"))
+                {
+                    return memberAccess;
+                }
+
+                // Get inner expression, which may be another member access expression.
+                // Example: System.Console.Error
+                //          ~~~~~~~~~~~~~~          <- inner member access expression
+                //          --------------------    <- outer member access expression
+                currentNode = memberAccess.Expression;
+            }
+
+            return null;
+        }
+
+        private void Analyze(SyntaxNodeAnalysisContext context)
+        {
+            // Try to get a member access on System.Console in the current expression,
+            // or in any of its inner expressions.
+            var systemConsoleMemberAccess = TryGetSystemConsoleMemberAccess(context, context.Node);
+            if (systemConsoleMemberAccess is null)
+                return;
+
+            // Check if IConsole is available in scope as an alternative to System.Console
+            var isConsoleInterfaceAvailable = context.Node
+                .Ancestors()
+                .OfType<MethodDeclarationSyntax>()
+                .SelectMany(m => m.ParameterList.Parameters)
+                .Select(p => p.Type)
+                .Select(t => context.SemanticModel.GetSymbolInfo(t).Symbol)
+                .Where(s => s is not null)
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxConsoleInterface));
+
+            if (isConsoleInterfaceAvailable)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(systemConsoleMemberAccess.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.SimpleMemberAccessExpression);
+        }
+    }
+}